const CUnit* owner,

const CUnit* /*collidee*/,

const float3& pos,

const float4& spd,

const SyncedFloat3& rightdir,

const SyncedFloat3& updir,

const SyncedFloat3& frontdir,

const float3& goalDir,

float groundHeight,

float wantedHeight,

float maxRudder,

float /*maxYaw*/,

float goalDotRight,

float goalDotFront,

bool /*avoidCollision*/,

bool isAttacking

) {

float rudder = 0.0f;

const float minGroundHeight = std::min(groundHeight + 15.0f, wantedHeight) * (1.0f + isAttacking);

const float maxRudderSpeedf = std::max(0.01f, maxRudder * spd.w * (1.0f + isAttacking));

const float minHeightMult = (pos.y >= minGroundHeight);

rudder -= (1.0f * minHeightMult * (goalDotRight < -maxRudderSpeedf) );

rudder += (1.0f * minHeightMult * (goalDotRight > maxRudderSpeedf) );

rudder += (1.0f * minHeightMult * (goalDotRight / maxRudderSpeedf) * (rudder == 0.0f));

// we have to choose a direction in case our target is almost straight behind us

rudder += (1.0f * minHeightMult * ((goalDotRight < 0.0f)? -0.01f: 0.01f) * (math::fabs(rudder) < 0.01f && goalDotFront < 0.0f));

return rudder;

const CUnit* owner,

const CUnit* /*collidee*/,

const float3& pos,

const float4& spd,

const SyncedFloat3& rightdir,

const SyncedFloat3& updir,

const SyncedFloat3& frontdir,

const float3& goalDir,

float groundHeight,

float wantedHeight,

float maxAileron,

float maxBank,

float goalDotRight,

float goalDotFront,

bool /*avoidCollision*/,

bool isAttacking

) {

float aileron = 0.0f;

// ailerons function less effectively at low (forward) speed

const float maxAileronSpeedf = std::max(0.01f, maxAileron * spd.w);

const float maxAileronSpeedf2 = std::max(0.01f, maxAileronSpeedf * 4.0f);

if (isAttacking) {

const float minPredictedHeight = pos.y + spd.y * 60.0f * math::fabs(frontdir.y) + std::min(0.0f, updir.y * 1.0f) * (GAME_SPEED * 5);

const float maxPredictedHeight = groundHeight + 60.0f + math::fabs(rightdir.y) * (GAME_SPEED * 5);

const float minSpeedMult = (spd.w > 0.45f && minPredictedHeight > maxPredictedHeight);

const float goalBankDif = goalDotRight + rightdir.y * 0.2f;

aileron += (1.0f * ( minSpeedMult) * (goalBankDif > maxAileronSpeedf2) );

aileron -= (1.0f * ( minSpeedMult) * (goalBankDif < -maxAileronSpeedf2) );

aileron += (1.0f * ( minSpeedMult) * (goalBankDif / maxAileronSpeedf2) * (aileron == 0.0f));

aileron += (1.0f * (1.0f - minSpeedMult) * (rightdir.y > 0.0f) * (rightdir.y > maxAileronSpeedf || frontdir.y < -0.7f));

aileron += (1.0f * (1.0f - minSpeedMult) * (aileron == 0.0f) * (rightdir.y > 0.0f) * (rightdir.y / maxAileronSpeedf ));

aileron -= (1.0f * (1.0f - minSpeedMult) * (rightdir.y < 0.0f) * (rightdir.y < -maxAileronSpeedf || frontdir.y < -0.7f));

aileron += (1.0f * (1.0f - minSpeedMult) * (aileron == 0.0f) * (rightdir.y < 0.0f) * (rightdir.y / maxAileronSpeedf ));

} else {

const float minPredictedHeight = pos.y + spd.y * 10.0f;

const float maxPredictedHeight = groundHeight + wantedHeight * 0.6f;

const float absRightDirY = math::fabs(rightdir.y);

const float goalBankDif = goalDotRight + rightdir.y * 0.5f;

const float relBankMult = (absRightDirY < maxBank && maxAileronSpeedf2 > 0.0f);

const float minSpeedMult = (spd.w > 1.5f && minPredictedHeight > maxPredictedHeight);

const float clampedBank = 1.0f;

// using this directly does not function well at higher pitch-angles, interplay with GetElevatorDeflection

// const float clampedBankAbs = math::fabs(Clamp(absRightDirY - maxBank, -1.0f, 1.0f));

// const float clampedBank = std::max(clampedBankAbs, 0.3f);

aileron -= (clampedBank * minSpeedMult * (goalBankDif < -maxAileronSpeedf2 && rightdir.y < maxBank));

aileron += (clampedBank * minSpeedMult * (goalBankDif > maxAileronSpeedf2 && rightdir.y > -maxBank));

/// NB: these ignore maxBank

aileron += (1.0f * minSpeedMult * (aileron == 0.0f) * ( relBankMult) * (goalBankDif / maxAileronSpeedf2));

aileron -= (1.0f * minSpeedMult * (aileron == 0.0f) * (1.0f - relBankMult) * (rightdir.y < 0.0f && goalBankDif < 0.0f));

aileron += (1.0f * minSpeedMult * (aileron == 0.0f) * (1.0f - relBankMult) * (rightdir.y > 0.0f && goalBankDif > 0.0f));

// if right wing too high, roll right (cw)

// if right wing too low, roll left (ccw)

aileron += std::copysign(1.0f, float(rightdir.y)) * (1.0f - minSpeedMult) * (absRightDirY > maxAileronSpeedf);

}

return aileron;

const CUnit* owner,

const CUnit* collidee,

const float3& pos,

const float4& spd,

const SyncedFloat3& rightdir,

const SyncedFloat3& updir,

const SyncedFloat3& frontdir,

const float3& goalDir,

const float3& yprInputLocks,

const float3& maxBodyAngles, // .x := maxYaw, .y := maxPitch, .z := maxBank

const float3& maxCtrlAngles, // .x := maxRudder, .y := maxElevator, .z := maxAileron

const float3* prvCtrlAngles,

float groundHeight,

float wantedHeight,

float goalDotRight,

float goalDotFront,

bool avoidCollision,

bool isAttacking

) {

float3 ctrlAngles;

// yaw (rudder), pitch (elevator), roll (aileron)

ctrlAngles.x = (yprInputLocks.x != 0.0f)? GetRudderDeflection (owner, collidee, pos, spd, rightdir, updir, frontdir, goalDir, groundHeight, wantedHeight, maxCtrlAngles.x, maxBodyAngles.x, goalDotRight, goalDotFront, avoidCollision, isAttacking): 0.0f;

ctrlAngles.y = (yprInputLocks.y != 0.0f)? GetElevatorDeflection(owner, collidee, pos, spd, rightdir, updir, frontdir, goalDir, groundHeight, wantedHeight, maxCtrlAngles.y, maxBodyAngles.y, goalDotRight, goalDotFront, avoidCollision, isAttacking): 0.0f;

ctrlAngles.z = (yprInputLocks.z != 0.0f)? GetAileronDeflection (owner, collidee, pos, spd, rightdir, updir, frontdir, goalDir, groundHeight, wantedHeight, maxCtrlAngles.z, maxBodyAngles.z, goalDotRight, goalDotFront, avoidCollision, isAttacking): 0.0f;

// let the previous control angles have some authority

return (ctrlAngles * 0.6f + prvCtrlAngles[0] * 0.3f + prvCtrlAngles[1] * 0.1f);

const SyncedFloat3& frontdir,

const SyncedFloat3& rightdir,

const float4& spd,

float turnRadius,

float groundDist

) {

// do not start looping if already banked

if (math::fabs(rightdir.y) > 0.05f)

return CStrafeAirMoveType::MANEUVER_FLY_STRAIGHT;

if (groundDist > TurnRadius(turnRadius, spd.w)) {

if (math::fabs(frontdir.y) <= 0.2f && gsRNG.NextFloat() > 0.3f)

return CStrafeAirMoveType::MANEUVER_IMMELMAN_INV;

} else {

if (frontdir.y > -0.2f && gsRNG.NextFloat() > 0.7f)

return CStrafeAirMoveType::MANEUVER_IMMELMAN;

}

return CStrafeAirMoveType::MANEUVER_FLY_STRAIGHT;

{

maneuverBlockTime = GAME_SPEED * 3;

// creg

if (owner == nullptr)

return;

assert(owner->unitDef != nullptr);

isFighter = owner->unitDef->IsFighterAirUnit();

loopbackAttack = owner->unitDef->canLoopbackAttack && isFighter;

wingAngle = owner->unitDef->wingAngle;

crashDrag = 1.0f - owner->unitDef->crashDrag;

frontToSpeed = owner->unitDef->frontToSpeed;

speedToFront = owner->unitDef->speedToFront;

myGravity = math::fabs(owner->unitDef->myGravity);

maxBank = owner->unitDef->maxBank;

maxPitch = owner->unitDef->maxPitch;

turnRadius = owner->unitDef->turnRadius;

wantedHeight =

(owner->unitDef->wantedHeight * 1.5f) +

((gsRNG.NextFloat() - 0.3f) * 15.0f * (isFighter? 2.0f: 1.0f));

orgWantedHeight = wantedHeight;

maxAileron = owner->unitDef->maxAileron;

maxElevator = owner->unitDef->maxElevator;

maxRudder = owner->unitDef->maxRudder;

attackSafetyDistance = 0.0f;

maxRudder *= (0.99f + gsRNG.NextFloat() * 0.02f);

maxElevator *= (0.99f + gsRNG.NextFloat() * 0.02f);

maxAileron *= (0.99f + gsRNG.NextFloat() * 0.02f);

accRate *= (0.99f + gsRNG.NextFloat() * 0.02f);

// magic constant ensures the same (0.25) average as urand() * urand()

crashAileron = 1.0f - Square(gsRNG.NextFloat() * 0.8660254037844386f);

crashAileron *= ((gsRNG.NextInt(2) == 1)? -1.0f: 1.0f);

crashElevator = gsRNG.NextFloat();

crashRudder = gsRNG.NextFloat() - 0.5f;

SetMaxSpeed(maxSpeedDef);

{

const float3 lastPos = owner->pos;

const float4 lastSpd = owner->speed;

AAirMoveType::Update();

// need to additionally check that we are not crashing,

// otherwise we might fall through the map when stunned

// (the kill-on-impact code is not reached in that case)

if ((owner->IsStunned() && !owner->IsCrashing()) || owner->beingBuilt) {

UpdateAirPhysics({0.0f * lastRudderPos[0], lastElevatorPos[0], lastAileronPos[0], 0.0f}, ZeroVector);

return (HandleCollisions(collide && !owner->beingBuilt && (aircraftState != AIRCRAFT_TAKEOFF)));

}

if (aircraftState != AIRCRAFT_CRASHING) {

if (owner->UnderFirstPersonControl()) {

SetState(AIRCRAFT_FLYING);

const CPlayer* fpsPlayer = owner->fpsControlPlayer;

const FPSUnitController& fpsCon = fpsPlayer->fpsController;

float aileron = 0.0f;

float elevator = 0.0f;

elevator -= (1.0f * fpsCon.forward);

elevator += (1.0f * fpsCon.back );

aileron += (1.0f * fpsCon.right );

aileron -= (1.0f * fpsCon.left );

UpdateAirPhysics({0.0f, elevator, aileron, 1.0f}, owner->frontdir);

maneuverState = MANEUVER_FLY_STRAIGHT;

return (HandleCollisions(collide && !owner->beingBuilt && (aircraftState != AIRCRAFT_TAKEOFF)));

}

}

switch (aircraftState) {

case AIRCRAFT_FLYING: {

const CCommandQueue& cmdQue = owner->commandAI->commandQue;

const bool isAttacking = (!cmdQue.empty() && (cmdQue.front()).GetID() == CMD_ATTACK);

const bool keepAttacking = ((owner->curTarget.type == Target_Unit && !owner->curTarget.unit->isDead) || owner->curTarget.type == Target_Pos);

/*

{

if (isAttacking && keepAttacking) {

switch (owner->curTarget.type) {

case Target_None: { } break;

case Target_Unit: { SetGoal(owner->curTarget.unit->pos); } break;

case Target_Pos: { SetGoal(owner->curTarget.groundPos); } break;

case Target_Intercept: { } break;

}

const bool goalInFront = ((goalPos - lastPos).dot(owner->frontdir) > 0.0f);

const bool goalInRange = (goalPos.SqDistance(lastPos) < Square(owner->maxRange * 4.0f));

// NOTE: UpdateAttack changes goalPos

if (maneuverState != MANEUVER_FLY_STRAIGHT) {

UpdateManeuver();

} else if (goalInFront && goalInRange) {

UpdateAttack();

} else {

if (UpdateFlying(wantedHeight, 1.0f) && !goalInFront && loopbackAttack) {

// once yaw and roll are unblocked, semi-randomly decide to turn or loop

const SyncedFloat3& rightdir = owner->rightdir;

const SyncedFloat3& frontdir = owner->frontdir;

const float altitude = CGround::GetHeightAboveWater(owner->pos.x, owner->pos.z) - lastPos.y;

if ((maneuverState = SelectLoopBackManeuver(frontdir, rightdir, lastSpd, turnRadius, altitude)) == MANEUVER_IMMELMAN_INV)

maneuverSubState = 0;

}

}

} else {

UpdateFlying(wantedHeight, 1.0f);

}

}

} break;

case AIRCRAFT_LANDED:

UpdateLanded();

break;

case AIRCRAFT_LANDING:

UpdateLanding();

break;

case AIRCRAFT_CRASHING: {

// NOTE: the crashing-state can only be set (and unset) by scripts

UpdateAirPhysics({crashRudder, crashElevator, crashAileron, 0.0f}, owner->frontdir);

if ((CGround::GetHeightAboveWater(owner->pos.x, owner->pos.z) + 5.0f + owner->radius) > owner->pos.y)

owner->ForcedKillUnit(nullptr, true, false);

amtEmitCrashTrailFuncs[crashExpGenID != -1u](owner, crashExpGenID);

} break;

case AIRCRAFT_TAKEOFF:

UpdateTakeOff();

break;

default:

break;

}

if (lastSpd == ZeroVector && owner->speed != ZeroVector) { owner->script->StartMoving(false); }

if (lastSpd != ZeroVector && owner->speed == ZeroVector) { owner->script->StopMoving(); }

return (HandleCollisions(collide && !owner->beingBuilt && (aircraftState != AIRCRAFT_TAKEOFF)));

const float3& pos = owner->pos;

#ifdef DEBUG_AIRCRAFT

switch (collisionState) {

case COLLISION_NEARBY: {

const int g = geometricObjects->AddLine(pos, lastCollidee->pos, 10, 1, 1);

geometricObjects->SetColor(g, 0.2f, 1, 0.2f, 0.6f);

} break;

case COLLISION_DIRECT: {

const int g = geometricObjects->AddLine(pos, lastCollidee->pos, 10, 1, 1);

if (owner->frontdir.dot(lastCollidee->midPos + lastCollidee->speed * 20.0f - owner->midPos - spd * 20.0f) < 0) {

geometricObjects->SetColor(g, 1, 0.2f, 0.2f, 0.6f);

} else {

geometricObjects->SetColor(g, 1, 1, 0.2f, 0.6f);

}

} break;

default: {

} break;

}

#endif

if (pos != oldPos) {

oldPos = pos;

bool hitBuilding = false;

// check for collisions if not being built or not taking off

if (checkCollisions) {

// copy on purpose, since the below can call Lua

QuadFieldQuery qfQuery;

quadField.GetUnitsExact(qfQuery, pos, owner->radius + 6);

for (CUnit* unit: *qfQuery.units) {

const bool unloadingUnit = ( unit->unloadingTransportId == owner->id);

const bool unloadingOwner = (owner->unloadingTransportId == unit->id);

const bool loadingUnit = ( unit->id == owner->loadingTransportId);

const bool loadingOwner = (owner->id == unit->loadingTransportId);

if (unloadingUnit)

unit->unloadingTransportId = -1;

if (unloadingOwner)

owner->unloadingTransportId = -1;

if (loadingUnit || loadingOwner || unit == owner->transporter || unit->transporter != nullptr)

continue;

const float sqDist = (pos - unit->pos).SqLength();

const float totRad = owner->radius + unit->radius;

if (sqDist <= 0.1f || sqDist >= (totRad * totRad))

continue;

if (unloadingUnit) {

unit->unloadingTransportId = owner->id;

continue;

}

if (unloadingOwner) {

owner->unloadingTransportId = unit->id;

continue;

}

const float dist = math::sqrt(sqDist);

const float3 dif = (pos - unit->pos).Normalize();

if (unit->immobile) {

const float damage = ((unit->speed - owner->speed) * 0.1f).SqLength();

owner->Move(-dif * (dist - totRad), true);

owner->SetVelocity(owner->speed * 0.99f);

if (modInfo.allowUnitCollisionDamage) {

owner->DoDamage(DamageArray(damage), ZeroVector, nullptr, -CSolidObject::DAMAGE_COLLISION_OBJECT, -1);

unit->DoDamage(DamageArray(damage), ZeroVector, nullptr, -CSolidObject::DAMAGE_COLLISION_OBJECT, -1);

}

hitBuilding = true;

} else {

const float part = owner->mass / (owner->mass + unit->mass);

const float damage = ((unit->speed - owner->speed) * 0.1f).SqLength();

owner->Move(-dif * (dist - totRad) * (1 - part), true);

owner->SetVelocity(owner->speed * 0.99f);

if (!unit->UsingScriptMoveType())

unit->Move(dif * (dist - totRad) * (part), true);

if (modInfo.allowUnitCollisionDamage) {

owner->DoDamage(DamageArray(damage), ZeroVector, nullptr, -CSolidObject::DAMAGE_COLLISION_OBJECT, -1);

unit->DoDamage(DamageArray(damage), ZeroVector, nullptr, -CSolidObject::DAMAGE_COLLISION_OBJECT, -1);

}

}

}

// update speed.w

owner->SetSpeed(owner->speed);

}

if (hitBuilding && owner->IsCrashing()) {

// if crashing and we hit a building, die right now

// rather than waiting until we are close enough to

// the ground

owner->ForcedKillUnit(nullptr, true, false);

return true;

}

if (pos.x < 0.0f) {

owner->Move( RgtVector * 1.5f, true);

} else if (pos.x > float3::maxxpos) {

owner->Move(-RgtVector * 1.5f, true);

}

if (pos.z < 0.0f) {

owner->Move( FwdVector * 1.5f, true);

} else if (pos.z > float3::maxzpos) {

owner->Move(-FwdVector * 1.5f, true);

}

return true;

}

return false;

{

// note: NOT AAirMoveType::SlowUpdate

AMoveType::SlowUpdate();

{

const float speedf = owner->speed.w;

switch (maneuverState) {

case MANEUVER_IMMELMAN: {

float aileron = 0.0f;

float elevator = 1.0f * (math::fabs(owner->rightdir.y) < maxAileron * 3.0f * speedf || owner->updir.y < 0.0f);

aileron += (1.0f * (owner->updir.y > 0.0f) * (owner->rightdir.y > maxAileron * speedf));

aileron -= (1.0f * (owner->updir.y > 0.0f) * (owner->rightdir.y < -maxAileron * speedf));

UpdateAirPhysics({0.0f, elevator, aileron, 1.0f}, owner->frontdir);

if ((owner->updir.y < 0.0f && owner->frontdir.y < 0.0f) || speedf < 0.8f)

maneuverState = MANEUVER_FLY_STRAIGHT;

// [?] some seem to report that the "unlimited altitude" thing is because of these maneuvers

if ((owner->pos.y - CGround::GetApproximateHeight(owner->pos.x, owner->pos.z)) > (wantedHeight * 4.0f))

maneuverState = MANEUVER_FLY_STRAIGHT;

} break;

case MANEUVER_IMMELMAN_INV: {

// inverted Immelman

float aileron = 0.0f;

float elevator = 0.0f;

aileron -= (1.0f * (maneuverSubState == 0) * (owner->rightdir.y >= 0.0f));

aileron += (1.0f * (maneuverSubState == 0) * (owner->rightdir.y < 0.0f));

if (owner->frontdir.y < -0.7f)

maneuverSubState = 1;

if (maneuverSubState == 1 || owner->updir.y < 0.0f)

elevator = 1.0f;

UpdateAirPhysics({0.0f, elevator, aileron, 1.0f}, owner->frontdir);

if ((owner->updir.y > 0.0f && owner->frontdir.y > 0.0f && maneuverSubState == 1) || speedf < 0.2f)

maneuverState = MANEUVER_FLY_STRAIGHT;

} break;

default: {

UpdateAirPhysics({0.0f, 0.0f, 0.0f, 1.0f}, owner->frontdir);

maneuverState = MANEUVER_FLY_STRAIGHT;

} break;

}

{

if (!isFighter) {

UpdateFlying(wantedHeight, 1.0f);

return;

}

const float3& pos = owner->pos;

const float4& spd = owner->speed;

const SyncedFloat3& rightdir = owner->rightdir;

const SyncedFloat3& frontdir = owner->frontdir;

const SyncedFloat3& updir = owner->updir;

if (spd.w < 0.01f) {

UpdateAirPhysics({0.0f, 0.0f, 0.0f, 1.0f}, owner->frontdir);

return;

}

if (((gs->frameNum + owner->id) & 3) == 0)

CheckForCollision();

float3 rightDir2D = rightdir;

const float3 difGoalPos = (goalPos - oldGoalPos) * SQUARE_SIZE;

oldGoalPos = goalPos;

goalPos += difGoalPos;

const float gHeightAW = CGround::GetHeightAboveWater(pos.x, pos.z);

const float goalDist = pos.distance(goalPos);

const float3 goalDir = (goalDist > 0.0f)?

(goalPos - pos) / goalDist:

ZeroVector;

// if goal too close, stop dive and resume flying at normal desired height

// to avoid colliding with target, evade blast, friendly and enemy fire, etc.

if (goalDist < attackSafetyDistance) {

UpdateFlying(wantedHeight, 1.0f);

return;

}

float goalDotRight = goalDir.dot(rightDir2D.Normalize2D());

const float goalDotFront = goalDir.dot(frontdir);

const float goalDotFront01 = goalDotFront * 0.5f + 0.501f; // [0,1]

if (goalDotFront01 != 0.0f)

goalDotRight /= goalDotFront01;

{

const float3 maxBodyAngles = {0.0f, maxPitch, maxBank};

const float3 maxCtrlAngles = {maxRudder, maxElevator, maxAileron};

const float3 prvCtrlAngles[2] = {{lastRudderPos[0], lastElevatorPos[0], lastAileronPos[0]}, {lastRudderPos[1], lastElevatorPos[1], lastAileronPos[1]}};

const float3& curCtrlAngles = GetControlSurfaceAngles(owner, lastCollidee, pos, spd, rightdir, updir, frontdir, goalDir, OnesVector, maxBodyAngles, maxCtrlAngles, prvCtrlAngles, gHeightAW, wantedHeight, goalDotRight, goalDotFront, false && collisionState == COLLISION_DIRECT, true);

const CUnit* attackee = owner->curTarget.unit;

// limit thrust when in range of (air) target and directly behind it

const float rangeLim = goalDist / owner->maxRange;

const float angleLim = 1.0f - goalDotFront * 0.7f;

const float thrustLim = ((attackee == nullptr) || attackee->unitDef->IsGroundUnit())? 1.0f: std::min(1.0f, rangeLim + angleLim);

UpdateAirPhysics({curCtrlAngles.x, curCtrlAngles.y, curCtrlAngles.z, thrustLim}, frontdir);

}

{

const float3& pos = owner->pos;

const float4& spd = owner->speed;

const SyncedFloat3& rightdir = owner->rightdir;

const SyncedFloat3& frontdir = owner->frontdir;

const SyncedFloat3& updir = owner->updir;

// NOTE:

// turnRadius is often way too small, but cannot calculate one

// because we have no turnRate (and unitDef->turnRate can be 0)

// --> would lead to infinite circling without adjusting goal

const float3 goalVec = goalPos - pos;

const float goalDist2D = std::max(0.001f, goalVec.Length2D());

// const float goalDist3D = std::max(0.001f, goalVec.Length());

const float3 goalDir2D = goalVec / goalDist2D;

// const float3 goalDir3D = goalVec / goalDist3D;

const float3 rightDir2D = (rightdir * XZVector).Normalize2D();

if (((gs->frameNum + owner->id) & 3) == 0)

CheckForCollision();

// RHS is needed for moving targets (when called by UpdateAttack)

// yaw and roll have to be unconditionally unblocked after a certain

// time or aircraft can fly straight forever e.g. if their target is

// another chasing aircraft

const bool allowUnlockYawRoll = (goalDist2D >= TurnRadius(turnRadius, spd.w) || goalVec.dot(owner->frontdir) > 0.0f);

const bool forceUnlockYawRoll = ((gs->frameNum - owner->lastFireWeapon) >= maneuverBlockTime);

// do not check if the plane can be submerged here,

// since it'll cause ground collisions later on (?)

const float groundHeight = amtGetGroundHeightFuncs[5 * UseSmoothMesh()](pos.x, pos.z);

// If goal-distance is half turn radius then turn if

// goal-position is not in front within a ~45 degree

// arc.

// If goal-position is behind us and goal-distance is

// less than our turning radius, turn the other way.

// These conditions prevent becoming stuck in a small

// circle around goal-position.

const float nearGoal = ((goalDist2D < turnRadius * 0.5f && goalDir2D.dot(frontdir) < 0.7f) || (goalDist2D < turnRadius && goalDir2D.dot(frontdir) < -0.1f));

const float turnFlip = ((!owner->UnderFirstPersonControl() || owner->fpsControlPlayer->fpsController.mouse2) * -2.0f + 1.0f);

// if nearGoal=0, multiply by 1

// if nearGoal=1, multiply by turnFlip

const float goalDotFront = goalDir2D.dot(frontdir);

const float goalDotRight = goalDir2D.dot(rightDir2D) * ((1.0f - nearGoal) + (nearGoal * turnFlip));

#if 0

// try to steer (yaw) away from nearby aircraft in front of us

if (lastCollidee != nullptr) {

const float3 collideeVec = lastCollidee->pos - pos;

const float collideeDist = collideeVec.Length();

const float relativeDist = (collideeDist > 0.0f)?

std::max(1200.0f, goalDist2D) / collideeDist * 0.036f:

0.0f;

const float3 collideeDir = (collideeDist > 0.0f)?

(collideeVec / collideeDist):

ZeroVector;

goalDotRight -= (collideeDir.dot(rightdir) * relativeDist * std::max(0.0f, collideeDir.dot(frontdir)));

}

#endif

const float3 yprInputLocks = (XZVector * float(allowUnlockYawRoll || forceUnlockYawRoll)) + UpVector;

const float3 maxBodyAngles = {0.0f, maxPitch, maxBank};

const float3 maxCtrlAngles = {maxRudder, maxElevator, maxAileron};

const float3 prvCtrlAngles[2] = {{lastRudderPos[0], lastElevatorPos[0], lastAileronPos[0]}, {lastRudderPos[1], lastElevatorPos[1], lastAileronPos[1]}};

const float3& curCtrlAngles = GetControlSurfaceAngles(owner, lastCollidee, pos, spd, rightdir, updir, frontdir, goalDir2D, yprInputLocks, maxBodyAngles, maxCtrlAngles, prvCtrlAngles, groundHeight, wantedHeight, goalDotRight, goalDotFront, false && collisionState == COLLISION_DIRECT, false);

UpdateAirPhysics({curCtrlAngles, wantedThrottle}, owner->frontdir);

return (allowUnlockYawRoll || forceUnlockYawRoll);

const float nxtHeight = curHeight + vertSpeed * 20.0f;

const float tgtHeight = wtdHeight * 1.02f;

return (Sign<float>(nxtHeight < tgtHeight));

{

const float3& pos = owner->pos;

const float4& spd = owner->speed;

wantedHeight = orgWantedHeight;

SyncedFloat3& rightdir = owner->rightdir;

SyncedFloat3& frontdir = owner->frontdir;

SyncedFloat3& updir = owner->updir;

const float3 goalDir = (goalPos - pos).Normalize();

const float yawWeight = maxRudder * spd.y;

const float dirWeight = Clamp(goalDir.dot(rightdir), -1.0f, 1.0f);

// this tends to alternate between -1 and +1 when goalDir and rightdir are ~orthogonal

// const float yawSign = Sign(goalDir.dot(rightdir));

const float currentHeight = pos.y - amtGetGroundHeightFuncs[canSubmerge](pos.x, pos.z);

const float minAccHeight = wantedHeight * 0.4f;

frontdir += (rightdir * dirWeight * yawWeight);

frontdir.Normalize();

rightdir = frontdir.cross(updir);

owner->SetVelocity(spd + (UpVector * accRate * GetVTOLAccelerationSign(currentHeight, wantedHeight, spd.y)));

owner->SetVelocity(spd + (owner->frontdir * accRate * (currentHeight > minAccHeight)));

// initiate forward motion before reaching wantedHeight

// normally aircraft start taking off from the ground below wantedHeight,

// but state can also change to LANDING via StopMoving and then again to

// TAKEOFF (via StartMoving) while still in mid-air

if (currentHeight > wantedHeight || spd.SqLength2D() >= Square(maxWantedSpeed * 0.8f))

SetState(AIRCRAFT_FLYING);

owner->SetVelocityAndSpeed(spd * invDrag);

owner->Move(spd, true);

owner->SetHeadingFromDirection();

owner->UpdateMidAndAimPos();

{

const float3 pos = owner->pos;

SyncedFloat3& rightdir = owner->rightdir;

SyncedFloat3& frontdir = owner->frontdir;

SyncedFloat3& updir = owner->updir;

if (!HaveLandingPos()) {

reservedLandingPos = FindLandingPos(pos + frontdir * BrakingDistance(maxSpeed, decRate));

// if spot is valid, mark it on the blocking-map

// so other aircraft can not claim the same spot

if (HaveLandingPos()) {

wantedHeight = 0.0f;

owner->Move(reservedLandingPos, false);

owner->Block();

owner->Move(pos, false);

// Block updates the blocking-map position (mapPos)

// via GroundBlockingObjectMap (which calculates it

// from object->pos) and UnBlock always uses mapPos

// --> we cannot block in one part of the map *and*

// unblock in another

// owner->UnBlock();

} else {

goalPos.ClampInBounds();

UpdateFlying(wantedHeight, 1.0f);

return;

}

}

SetGoal(reservedLandingPos);

UpdateLandingHeight(wantedHeight);

const float3 reservedLandingPosDir = reservedLandingPos - pos;

const float3 brakeSpot = pos + frontdir * BrakingDistance(owner->speed.Length2D(), decRate);

if (brakeSpot.SqDistance2D(reservedLandingPos) > landRadiusSq) {

// If we're not going to land inside the landRadius, keep flying.

const float tempWantedHeight = wantedHeight;

UpdateFlying(wantedHeight = orgWantedHeight, 1.0f);

wantedHeight = tempWantedHeight;

return;

}

updir -= ((rightdir * 0.02f) * (rightdir.y < -0.01f));

updir += ((rightdir * 0.02f) * (rightdir.y > 0.01f));

frontdir += ((updir * 0.02f) * (frontdir.y < -0.01f));

frontdir -= ((updir * 0.02f) * (frontdir.y > 0.01f));

frontdir += ((rightdir * 0.02f) * (rightdir.dot(reservedLandingPosDir) > 0.01f));

frontdir -= ((rightdir * 0.02f) * (rightdir.dot(reservedLandingPosDir) < -0.01f));

{

//A Mangled UpdateAirPhysics

float4& spd = owner->speed;

float frontSpeed = spd.dot2D(frontdir);

if (frontSpeed > 0.0f) {

//Slow down before vertical landing

owner->SetVelocity(frontdir * (spd.Length2D() * invDrag - decRate));

//Calculate again for next check

frontSpeed = spd.dot2D(frontdir);

}

if (frontSpeed < 0.0f)

owner->SetVelocityAndSpeed(UpVector * owner->speed);

const float landPosDistXZ = reservedLandingPosDir.Length2D() + 0.1f;

const float landPosDistY = reservedLandingPosDir.y;

const float curSpeedXZ = spd.Length2D();