@lazyglobal off.

global function steering_locked {
    parameter epsilon is 0.1.
    local rate_epsilon is epsilon * 0.1.
    local angle_good is abs(steeringmanager:pitcherror) < epsilon and abs(steeringmanager:yawerror) < epsilon.
    local rate_good is abs(ship:angularvel:x) < rate_epsilon and abs(ship:angularvel:y) < rate_epsilon.
    return rate_good and angle_good.
}

global function launch_azimuth {
    // from https://www.orbiterwiki.org/wiki/Launch_Azimuth
    parameter target_inclination, target_alt.

    local inertial_hdg is arcsin(cos(target_inclination) / cos(ship:latitude)).
    local orbit_vel is sqrt(ship:body:mu / (target_alt + ship:body:radius)).
    local body_vel is 2 * constant:pi * ship:body:radius / ship:body:rotationperiod.
    local vxrot is orbit_vel * sin(inertial_hdg) - body_vel * cos(ship:latitude).
    local vyrot is orbit_vel * cos(inertial_hdg).
    return arctan(vxrot / vyrot).
}

global function ap_prograde {
    local nd is node(time:seconds + eta:apoapsis, 0, 0, 1).
    add(nd).
    local target_hdg is rotatefromto(ship:prograde:forevector, nd:burnvector) * ship:prograde.
    remove(nd).
    return target_hdg.
}

global function obt_altitude {
    if eta:apoapsis > eta:periapsis {
        local since_ap is ship:obt:period - eta:apoapsis.
        if since_ap < eta:periapsis {
            return ship:obt:periapsis.
        } else {
            return ship:obt:apoapsis.
        }
    } else {
        local since_pe is ship:obt:period - eta:periapsis.
        if since_pe < eta:apoapsis {
            ship:obt:apoapsis.
        } else {
            ship:obt:periapsis.
        }
    }
}

global function target_lan {
    parameter target_lan, epsilon is 0.1.
    local current_lan is mod(earth:rotationangle - ship:longitude - 90 + 360, 360).

    local lan_diff is mod(current_lan - target_lan + 360, 360).

    local target is time:now - 60 * (lan_diff / 4).
    warpto(target - 10).
    wait until time:now > target.
}

global function circular_vel {
    parameter obt_alt is ship:altitude.
    return sqrt(ship:body:mu / (obt_alt + ship:body:radius)).
}

global function orbital_vel {
    parameter obt_alt.
    return sqrt(ship:body:mu * (2 / (obt_alt + ship:body:radius) - 1 / ship:obt:semimajoraxis)).
}

global function circularization_dv {
    return circular_vel(ship:obt:apoapsis) - orbital_vel(ship:obt:apoapsis).
}

global function burn_time {
    parameter dv, engine.

    local thrust is engine:possiblethrust.
    local exhaust_vel is thrust / engine:maxmassflow.
    local initial_mass is ship:mass.

    return initial_mass * exhaust_vel * (1 - CONSTANT:E ^ (0 - dv / exhaust_vel)) / thrust.
}

global function hohmann_transfer_time {
    parameter b, pe, ap.
    local r1 is pe + b:radius.
    local r2 is ap + b:radius.
    return constant:pi * sqrt((r1+r2)*(r1+r2)*(r1+r2)/(8*b:mu)).
}

global function hohmann_transfer_dv {
    parameter b, pe, ap.
    local r1 is pe + b:radius.
    local r2 is ap + b:radius.
    return sqrt(b:mu/r1)*(sqrt(2*r2/(r1 + r2)) - 1).
}

global function predicted_ap {
    local vel is ship:velocity:orbit:mag.
    local rp is ship:altitude + ship:obt:body:radius.
    local a is rp / 2 - ship:obt:body:mu/(vel*vel).
    return (2*a - rp) - ship:obt:body:radius.
}