declare function WaitForEngineStart{
	wait until AnyEngineActive().
}

declare function GetDrag{
	parameter lg.
	return ship:sensors:acc:mag + lg.
}

declare function GetDragDir{
	parameter lg, dir.
	return vDot(ship:sensors:acc, dir) + lg.
}

declare function AnyEngineActive{
	list engines in egs.
	for eng in egs{
		if eng:ignition {
			return true.
		}
	}
	return false.
}

declare function GetIsp{
	LIST ENGINES IN egs.
	declare local totalThrust is ship:maxThrust.
	local sum is 0.
	local weights is 0.
	for eng in egs{
		if eng:IGNITION and not eng:flameout{
			local w is  eng:AVAILABLETHRUST / totalThrust.
			local ispW is eng:isp * w.
			set sum to sum + ispW.
			set weights to weights + w.
		}
	}
	return sum / weights.
}

declare function GetIspForStage{
	parameter eS, p is 0.
	LIST ENGINES IN egs.
	local totalThrust is GetThrustOfStage(eS, p).
	if totalThrust = 0{
		return 0.
	}
	local sum is 0.
	local weights is 0.
	for eng in egs{
		if eng:stage = eS {
			local w is eng:POSSIBLETHRUSTAT(p) / totalThrust.
			local ispW is eng:ispat(p) * w.
			set sum to sum + ispW.
			set weights to weights + w.
		}
	}
	return sum / weights.
}

declare function GetMaxMassFlow{
	LIST ENGINES IN egs.
	local sum is 0.
	for eng in egs{
		if eng:IGNITION and not eng:flameout{
			set sum to sum + eng:maxmassflow.
		}
	}
	return sum.
}

declare function GetMaxMassFlowForStage{
	parameter eS.
	LIST ENGINES IN egs.
	local sum is 0.
	for eng in egs{
		if eng:stage = eS {
			set sum to sum + eng:maxmassflow.
		}
	}
	return sum.
}

declare function CalculateSuicideBurnDuration{
	parameter isp.
	return CalculateBurnDuration(verticalSpeed, isp, ship:mass, GetMaxMassFlow() * 1000).
}

declare function CalculateBurnDuration{
	parameter dv, burnIsp, iM, mF.

	if burnIsp = 0 {
		return 0.
	}
	set dv to abs(dv).
	local exp is -dv / (burnIsp * constant:g0).
	local mR is constant:e ^ (-exp).
	local fM is iM / mR.
	local f is iM - fM.

	if mF <= 0{
		return 0.
	}

	return f / mF.
}

declare function CalculateSuicideBurnAltitude
{
	parameter vS, lg, cAlt is 0.0, drag is 0.0.

	local vertAcc is CalculateAverageDecceleration(lg, drag).
	local burnAltitude is ((vS^2) / (2 * (vertAcc))).
	return burnAltitude + cAlt.
}

declare function CalculateAverageDecceleration{
	parameter lg.
	parameter d is 0.
	local maxVertAcc is (ship:availablethrust / ship:mass) - lg.

	return maxVertAcc + d.
}

declare function GetLocalGravity{
	parameter curAltitude is -1.
	
	if curAltitude = -1 {
		set curAltitude to altitude.
	}
	return body:mu / (curAltitude + body:radius)^2.
}

declare function CalculateTimeToImpact{
	parameter vS, cAlt, cG, tAlt is 0.0.

	if cG <= 0 or cAlt <= 0{
		return 0.0.
	}

	set vS to abs(vS).
	local g is cG.
	local hRel is cAlt - tAlt.
	local disc is ((vS^2) + (2 * g * hRel)).
	return (vS + sqrt(disc)) / g.
}

function CalculateMultiStageBurnDuration{
	parameter dv.
	if ship:STAGEDELTAV(ship:stagenum):current >= dv {
		return CalculateBurnDuration(dv, GetIsp(), ship:mass, GetMaxMassFlow()).
	}else{
		local bT is 0.
		local remDv is dv.
		from {local s is ship:stagenum. } until s = -1 step { set s to s-1.} do {
			if remDv <= 0 {
				return bT.
			}
			local cdv is ship:stagedeltav(s):current.
			local cmass is GetMassOfStage(s).
			local cflow is GetMaxMassFlowForStage(s).
			local cisp is GetIspForStage(s).
			local sdv is 0.
			if cdv >= remDv {
				set sdv to remDv.
			}else{
				set sdv to cdv.
			}
			set bT to bT + CalculateBurnDuration(sdv, cisp, cmass, cflow).
			set remDv to remDv - cdv.
		}
		return bT.
	}
}

function GetThrustOfStage {
	parameter st, p is 0.

	local tTh is 0.
	LIST ENGINES IN egs.
	for eng in egs{
		if eng:stage = st {
			set tTh to tTh + eng:POSSIBLETHRUSTAT(p).
		}
	}
	return tTh.
}

function GetMassOfStage {
	parameter st.

	local sum is 0.
	LIST PARTS IN allP.
	for p in allP {
		if p:stage <= st and p:DECOUPLEDIN < st {
			set sum to sum + p:mass.
		}
	}
	return sum.
}