[Minor] Extended ExtendedAircraftMissions (#1654)

- Aircraft will now be able to use waypoints.
- When a `guard` command (`[G]` by default) is issued, the aircraft will
search for targets around the current location and return immediately
when target is not found, target is destroyed or ammos are depleted.
- If the target is destroyed but ammos are not depleted yet, it will
also return because the aircraft's command is one-time.
- When an `attack move` command (`[Ctrl]+[Shift]`) is issued, the
aircraft will move towards the destination and search for nearby targets
on the route for attack. Once ammo is depleted or the destination is
reached, it will return.
- If the automatically selected target is destroyed but ammo is not
depleted yet during the process, the aircraft will continue flying to
the destination.
- In addition, the actions of aircraft are also changed.
- `ExtendedAircraftMissions.SmoothMoving` controls whether the aircraft
will return to the airport when the distance to the destination is less
than half of `SlowdownDistance` or its turning radius.
- `ExtendedAircraftMissions.EarlyDescend` controls whether the aircraft
not have to fly directly above the airport before starting to descend
when the distance between the aircraft and the landing point is less
than `SlowdownDistance` (also work for aircraft spawned by aircraft
carriers).
- `ExtendedAircraftMissions.RearApproach` controls whether the aircraft
should start landing at the airport from the opposite direction of
`LandingDir`.

In `rulesmd.ini`:
```ini
[General]
ExtendedAircraftMissions=false         ; boolean

[SOMEAIRCRAFT]                         ; AircraftType
ExtendedAircraftMissions.SmoothMoving=  ; boolean, default to [General] -> ExtendedAircraftMissions
ExtendedAircraftMissions.EarlyDescend=  ; boolean, default to [General] -> ExtendedAircraftMissions
ExtendedAircraftMissions.RearApproach=  ; boolean, default to [General] -> ExtendedAircraftMissions
```

---


![landing](https://github.com/user-attachments/assets/859012d5-4131-4708-b539-cefb1f62da37)

Author: CrimRecya

docs/Fixed-or-Improved-Logics.md

@@ -275,16 +275,24 @@ FiringForceScatter=true   ; boolean
 ### Extended Aircraft Missions
 
 - Aircraft will now be able to use waypoints.
-- Aircraft can fly at a certain speed as much as possible, when the distance to the destination is less than half of `SlowdownDistance` or 8 cell distances divided by `ROT`, it will return to the airport. And now aircraft not have to fly directly above the airport before starting to descend.
 - When a `guard` command (`[G]` by default) is issued, the aircraft will search for targets around the current location and return immediately when target is not found, target is destroyed or ammos are depleted.
   - If the target is destroyed but ammos are not depleted yet, it will also return because the aircraft's command is one-time.
 - When an `attack move` command (`[Ctrl]+[Shift]`) is issued, the aircraft will move towards the destination and search for nearby targets on the route for attack. Once ammo is depleted or the destination is reached, it will return.
   - If the automatically selected target is destroyed but ammo is not depleted yet during the process, the aircraft will continue flying to the destination.
+- In addition, the actions of aircraft are also changed.
+  - `ExtendedAircraftMissions.SmoothMoving` controls whether the aircraft will return to the airport when the distance to the destination is less than half of `SlowdownDistance` or its turning radius.
+  - `ExtendedAircraftMissions.EarlyDescend` controls whether the aircraft not have to fly directly above the airport before starting to descend when the distance between the aircraft and the landing point is less than `SlowdownDistance` (also work for aircraft spawned by aircraft carriers).
+  - `ExtendedAircraftMissions.RearApproach` controls whether the aircraft should start landing at the airport from the opposite direction of `LandingDir`.
 
 In `rulesmd.ini`:
 ```ini
 [General]
-ExtendedAircraftMissions=false  ; boolean
+ExtendedAircraftMissions=false         ; boolean
+
+[SOMEAIRCRAFT]                         ; AircraftType
+ExtendedAircraftMissions.SmoothMoving=  ; boolean, default to [General] -> ExtendedAircraftMissions
+ExtendedAircraftMissions.EarlyDescend=  ; boolean, default to [General] -> ExtendedAircraftMissions
+ExtendedAircraftMissions.RearApproach=  ; boolean, default to [General] -> ExtendedAircraftMissions
 ```
 
 ### Fixed spawn distance & spawn height for airstrike / SpyPlane aircraft

src/Ext/Aircraft/Hooks.cpp

@@ -298,21 +298,27 @@ DEFINE_HOOK(0x414C0B, AircraftClass_ChronoSparkleDelay, 0x5)
 
 DEFINE_HOOK(0x4CF31C, FlyLocomotionClass_FlightUpdate_LandingDir, 0x9)
 {
-	enum { SkipGameCode = 0x4CF351 };
+	enum { SkipGameCode = 0x4CF3D0, SetSecondaryFacing = 0x4CF351 };
 
-	GET(FootClass**, pLinkedToPtr, ESI);
+	GET(FootClass** const, pFootPtr, ESI);
+	GET_STACK(IFlyControl* const, iFly, STACK_OFFSET(0x48, -0x38));
 	REF_STACK(unsigned int, dir, STACK_OFFSET(0x48, 0x8));
 
-	auto const pLinkedTo = *pLinkedToPtr;
+	const auto pFoot = *pFootPtr;
 	dir = 0;
 
-	if (pLinkedTo->CurrentMission == Mission::Enter || pLinkedTo->GetMapCoords() == CellClass::Coord2Cell(pLinkedTo->Locomotor->Destination()))
-	{
-		if (auto const pAircraft = abstract_cast<AircraftClass*, true>(pLinkedTo))
-			dir = DirStruct(AircraftExt::GetLandingDir(pAircraft)).Raw;
-	}
+	if (!iFly)
+		return SetSecondaryFacing;
 
-	return SkipGameCode;
+	if (iFly->Is_Locked())
+		return SkipGameCode;
+
+	if (const auto pAircraft = abstract_cast<AircraftClass*, true>(pFoot))
+		dir = DirStruct(AircraftExt::GetLandingDir(pAircraft)).Raw;
+	else
+		dir = (iFly->Landing_Direction() << 13);
+
+	return SetSecondaryFacing;
 }
 
 namespace SeparateAircraftTemp
@@ -329,11 +335,10 @@ DEFINE_HOOK(0x446F57, BuildingClass_GrandOpening_PoseDir_SetContext, 0x6)
 	return 0;
 }
 
-DirType _fastcall AircraftClass_PoseDir_Wrapper(AircraftClass* pThis)
+DirType __fastcall AircraftClass_PoseDir_Wrapper(AircraftClass* pThis)
 {
 	return AircraftExt::GetLandingDir(pThis, SeparateAircraftTemp::pBuilding);
 }
-
 DEFINE_FUNCTION_JUMP(CALL, 0x446F67, AircraftClass_PoseDir_Wrapper); // BuildingClass_GrandOpening
 
 DEFINE_HOOK(0x443FC7, BuildingClass_ExitObject_PoseDir1, 0x8)
@@ -352,7 +357,10 @@ DEFINE_HOOK(0x44402E, BuildingClass_ExitObject_PoseDir2, 0x5)
 	GET(AircraftClass*, pAircraft, EBP);
 
 	auto dir = DirStruct(AircraftExt::GetLandingDir(pAircraft, pThis));
-	// pAircraft->PrimaryFacing.SetCurrent(dir);
+
+	if (RulesExt::Global()->ExtendedAircraftMissions)
+		pAircraft->PrimaryFacing.SetCurrent(dir);
+
 	pAircraft->SecondaryFacing.SetCurrent(dir);
 
 	return 0;
@@ -399,23 +407,31 @@ DEFINE_HOOK(0x416A0A, AircraftClass_Mission_Move_SmoothMoving, 0x5)
 	GET(AircraftClass* const, pThis, ESI);
 	GET(CoordStruct* const, pCoords, EAX);
 
-	if (!RulesExt::Global()->ExtendedAircraftMissions)
+	if (pThis->Team || pThis->Airstrike || pThis->Spawned)
 		return 0;
 
 	const auto pType = pThis->Type;
 
-	if (!pType->AirportBound || pThis->Team || pThis->Airstrike || pThis->Spawned)
+	if (!pType->AirportBound)
+		return 0;
+
+	const auto extendedMissions = RulesExt::Global()->ExtendedAircraftMissions;
+
+	if (!TechnoTypeExt::ExtMap.Find(pType)->ExtendedAircraftMissions_SmoothMoving.Get(extendedMissions))
 		return 0;
 
 	const int distance = Game::F2I(Point2D { pCoords->X, pCoords->Y }.DistanceFrom(Point2D { pThis->Location.X, pThis->Location.Y }));
 
 	// When the horizontal distance between the aircraft and its destination is greater than half of its deceleration distance
 	// or its turning radius, continue to move forward, otherwise return to airbase or execute the next planning waypoint
-	if (distance > std::max((pType->SlowdownDistance >> 1), (2048 / pType->ROT)))
+	const auto rotRadian = std::abs(pThis->PrimaryFacing.ROT.Raw * (Math::TwoPi / 65536)); // GetRadian<65536>() is an incorrect method
+	const auto turningRadius = rotRadian > 1e-10 ? static_cast<int>(pType->Speed / rotRadian) : 0;
+
+	if (distance > std::max((pType->SlowdownDistance / 2), turningRadius))
 		return (R->Origin() == 0x4168C7 ? ContinueMoving1 : ContinueMoving2);
 
 	// Try next planning waypoint first, then return to air base if it does not exist or cannot be taken
-	if (!pThis->TryNextPlanningTokenNode())
+	if (!extendedMissions || !pThis->TryNextPlanningTokenNode())
 		pThis->EnterIdleMode(false, true);
 
 	return EnterIdleAndReturn;
@@ -436,14 +452,142 @@ DEFINE_HOOK(0x4DDD66, FootClass_IsLandZoneClear_ReplaceHardcode, 0x6) // To avoi
 	return SkipGameCode;
 }
 
-DEFINE_HOOK(0x4CF408, FlyLocomotionClass_FlightUpdate_SetFlightLevel, 0x6) // Make aircraft not have to fly directly above the airport before starting to descend
+DEFINE_HOOK(0x4CF190, FlyLocomotionClass_FlightUpdate_SetPrimaryFacing, 0x6) // Make aircraft not to fly directly to the airport before starting to land
 {
-	enum { SkipGameCode = 0x4CF40E };
+	enum { SkipGameCode = 0x4CF29A };
+
+	GET(IFlyControl* const, iFly, EAX);
+
+	if (!iFly || !iFly->Is_Locked())
+	{
+		GET(FootClass** const, pFootPtr, ESI);
+		GET(const int, distance, EBX);
+
+		const auto pFoot = *pFootPtr;
+		const auto pAircraft = abstract_cast<AircraftClass*, true>(pFoot);
+
+		// Rewrite vanilla implement
+		if (!pAircraft || !TechnoTypeExt::ExtMap.Find(pAircraft->Type)->ExtendedAircraftMissions_RearApproach.Get(RulesExt::Global()->ExtendedAircraftMissions))
+		{
+			REF_STACK(const CoordStruct, destination, STACK_OFFSET(0x48, 0x8));
+
+			const auto footCoords = pFoot->GetCoords();
+			const auto desired = DirStruct(Math::atan2(footCoords.Y - destination.Y, destination.X - footCoords.X));
+
+			if (!iFly || !iFly->Is_Strafe() || distance > 768 // I don't know why it's 3 cells' length, but its vanilla, keep it
+				|| std::abs(static_cast<short>(static_cast<short>(desired.Raw) - static_cast<short>(pFoot->PrimaryFacing.Current().Raw))) >= 8192)
+			{
+				pFoot->PrimaryFacing.SetDesired(desired);
+			}
+		}
+		else
+		{
+			// No const because it also need to be used by SecondaryFacing
+			REF_STACK(CoordStruct, destination, STACK_OFFSET(0x48, 0x8));
+
+			const auto footCoords = pAircraft->GetCoords();
+			const auto landingDir = DirStruct(AircraftExt::GetLandingDir(pAircraft));
+
+			// Try to land from the rear
+			if (pAircraft->Destination && (pAircraft->DockNowHeadingTo == pAircraft->Destination || pAircraft->SpawnOwner == pAircraft->Destination))
+			{
+				const auto pType = pAircraft->Type;
 
-	GET(FlyLocomotionClass* const, pThis, EBP);
-	GET(TechnoTypeClass* const, pType, EAX);
+				// Like smooth moving
+				const auto rotRadian = std::abs(pAircraft->PrimaryFacing.ROT.Raw * (Math::TwoPi / 65536));
+				const auto turningRadius = rotRadian > 1e-10 ? static_cast<int>(pType->Speed / rotRadian) : 0;
+
+				// diameter = 2 * radius
+				const auto cellCounts = Math::max((pType->SlowdownDistance / 256), (turningRadius / 128));
+
+				// The direction of the airport
+				const auto currentDir = DirStruct(Math::atan2(footCoords.Y - destination.Y, destination.X - footCoords.X));
+
+				// Included angle's raw
+				const auto difference = static_cast<short>(static_cast<short>(currentDir.Raw) - static_cast<short>(landingDir.Raw));
+
+				// Land from this direction of the airport
+				const auto landingFace = landingDir.GetFacing<8>(4);
+				auto cellOffset = Unsorted::AdjacentCoord[landingFace];
+
+				// When the direction is opposite, moving to the side first, then automatically shorten based on the current distance
+				if (std::abs(difference) >= 12288) // 12288 -> 3/16 * 65536 (1/8 < 3/16 < 1/4, so the landing can begin at the appropriate location)
+					cellOffset = (cellOffset + Unsorted::AdjacentCoord[((difference > 0) ? (landingFace + 2) : (landingFace - 2)) & 7]) * cellCounts;
+				else // 724 -> 512√2
+					cellOffset *= Math::min(cellCounts, ((landingFace & 1) ? (distance / 724) : (distance / 512)));
+
+				// On the way back, increase the offset value of the destination so that it looks like a real airplane
+				destination.X += cellOffset.X;
+				destination.Y += cellOffset.Y;
+			}
+
+			if (footCoords.Y != destination.Y && footCoords.X != destination.X)
+				pAircraft->PrimaryFacing.SetDesired(DirStruct(Math::atan2(footCoords.Y - destination.Y, destination.X - footCoords.X)));
+			else
+				pAircraft->PrimaryFacing.SetDesired(landingDir);
+		}
+	}
+
+	return SkipGameCode;
+}
+
+DEFINE_HOOK(0x4CF3D0, FlyLocomotionClass_FlightUpdate_SetFlightLevel, 0x7) // Make aircraft not have to fly directly above the airport before starting to descend
+{
+	GET(FootClass** const, pFootPtr, ESI);
+
+	const auto pAircraft = abstract_cast<AircraftClass*, true>(*pFootPtr);
+
+	if (!pAircraft)
+		return 0;
+
+	const auto pType = pAircraft->Type;
+
+	// Ares hook
+	if (pType->HunterSeeker)
+		return 0;
+
+	if (!TechnoTypeExt::ExtMap.Find(pType)->ExtendedAircraftMissions_EarlyDescend.Get(RulesExt::Global()->ExtendedAircraftMissions))
+		return 0;
+
+	enum { SkipGameCode = 0x4CF4D2 };
+
+	GET_STACK(FlyLocomotionClass* const, pThis, STACK_OFFSET(0x48, -0x28));
+	GET(const int, distance, EBX);
+
+	// Restore skipped code
+	R->EBP(pThis);
+
+	// Same as vanilla
+	if (pThis->IsElevating && distance < 768)
+	{
+		// Fast descent
+		const auto floorHeight = MapClass::Instance.GetCellFloorHeight(pThis->MovingDestination);
+		pThis->FlightLevel = pThis->MovingDestination.Z - floorHeight;
+
+		// Bug fix
+		if (MapClass::Instance.GetCellAt(pAircraft->Location)->ContainsBridge() && pThis->FlightLevel >= CellClass::BridgeHeight)
+			pThis->FlightLevel -= CellClass::BridgeHeight;
+
+		return SkipGameCode;
+	}
+
+	const auto flightLevel = pType->GetFlightLevel();
+
+	// Check returning actions
+	if (distance < pType->SlowdownDistance && pAircraft->Destination
+		&& (pAircraft->DockNowHeadingTo == pAircraft->Destination || pAircraft->SpawnOwner == pAircraft->Destination))
+	{
+		// Slow descent
+		const auto floorHeight = MapClass::Instance.GetCellFloorHeight(pThis->MovingDestination);
+		const auto destinationHeight = pThis->MovingDestination.Z - floorHeight + 1;
+		pThis->FlightLevel = static_cast<int>((flightLevel - destinationHeight) * (static_cast<double>(distance) / pType->SlowdownDistance)) + destinationHeight;
+	}
+	else
+	{
+		// Horizontal flight
+		pThis->FlightLevel = flightLevel;
+	}
 
-	R->ECX(RulesExt::Global()->ExtendedAircraftMissions && pThis->LinkedTo->CurrentMission == Mission::Enter || pType->IsDropship);
 	return SkipGameCode;
 }
 
@@ -461,13 +605,26 @@ DEFINE_HOOK(0x41A96C, AircraftClass_Mission_AreaGuard, 0x6)
 
 		if (pThis->TargetAndEstimateDamage(coords, ThreatType::Area))
 			pThis->QueueMission(Mission::Attack, false);
+		else if (pThis->Destination && pThis->Destination != pThis->DockNowHeadingTo)
+			pThis->EnterIdleMode(false, true);
 
 		return SkipGameCode;
 	}
 
 	return 0;
 }
 
+// Sleep: return to airbase if in incorrect sleep status
+int __fastcall AircraftClass_Mission_Sleep(AircraftClass* pThis)
+{
+	if (!pThis->Destination || pThis->Destination == pThis->DockNowHeadingTo)
+		return 450; // Vanilla MissionClass_Mission_Sleep value
+
+	pThis->EnterIdleMode(false, true);
+	return 1;
+}
+DEFINE_FUNCTION_JUMP(VTABLE, 0x7E24A8, AircraftClass_Mission_Sleep)
+
 // AttackMove: return when no ammo or arrived destination
 bool __fastcall AircraftTypeClass_CanAttackMove(AircraftTypeClass* pThis)
 {
@@ -582,12 +739,9 @@ DEFINE_HOOK(0x4C7403, EventClass_Execute_AircraftAreaGuard, 0x6)
 
 	GET(TechnoClass* const, pTechno, EDI);
 
-	if (RulesExt::Global()->ExtendedAircraftMissions && pTechno->WhatAmI() == AbstractType::Aircraft)
+	if (RulesExt::Global()->ExtendedAircraftMissions
+		&& pTechno->WhatAmI() == AbstractType::Aircraft)
 	{
-		// If we're on dock reloading but have ammo, untether from dock and try to scan for targets.
-		if (pTechno->CurrentMission == Mission::Sleep && pTechno->Ammo)
-			pTechno->SendToEachLink(RadioCommand::NotifyUnlink);
-
 		// Skip assigning destination / target here.
 		return SkipGameCode;
 	}
@@ -603,9 +757,12 @@ DEFINE_HOOK(0x4C72F2, EventClass_Execute_AircraftAreaGuard_Untether, 0x6)
 	GET(EventClass* const, pThis, ESI);
 	GET(TechnoClass* const, pTechno, EDI);
 
-	if (RulesExt::Global()->ExtendedAircraftMissions && pTechno->WhatAmI() == AbstractType::Aircraft
-		&& pThis->MegaMission.Mission == (char)Mission::Area_Guard)
+	if (RulesExt::Global()->ExtendedAircraftMissions
+		&& pTechno->WhatAmI() == AbstractType::Aircraft
+		&& pThis->MegaMission.Mission == (char)Mission::Area_Guard
+		&& (pTechno->CurrentMission != Mission::Sleep || !pTechno->Ammo))
 	{
+		// If we're on dock reloading but have ammo, untether from dock and try to scan for targets.
 		return SkipGameCode;
 	}
 

src/Ext/TechnoType/Body.cpp

@@ -638,12 +638,16 @@ void TechnoTypeExt::ExtData::LoadFromINIFile(CCINIClass* const pINI)
 	this->Overload_ParticleSys.Read(exINI, pSection, "Overload.ParticleSys");
 	this->Overload_ParticleSysCount.Read(exINI, pSection, "Overload.ParticleSysCount");
 
-	this->FallingDownDamage.Read(exINI, pSection, "FallingDownDamage");
-	this->FallingDownDamage_Water.Read(exINI, pSection, "FallingDownDamage.Water");
-
 	this->Harvester_CanGuardArea.Read(exINI, pSection, "Harvester.CanGuardArea");
 	this->HarvesterScanAfterUnload.Read(exINI, pSection, "HarvesterScanAfterUnload");
 
+	this->ExtendedAircraftMissions_SmoothMoving.Read(exINI, pSection, "ExtendedAircraftMissions.SmoothMoving");
+	this->ExtendedAircraftMissions_EarlyDescend.Read(exINI, pSection, "ExtendedAircraftMissions.EarlyDescend");
+	this->ExtendedAircraftMissions_RearApproach.Read(exINI, pSection, "ExtendedAircraftMissions.RearApproach");
+
+	this->FallingDownDamage.Read(exINI, pSection, "FallingDownDamage");
+	this->FallingDownDamage_Water.Read(exINI, pSection, "FallingDownDamage.Water");
+
 	this->FiringForceScatter.Read(exINI, pSection, "FiringForceScatter");
 
 	// Ares 0.2
@@ -1215,6 +1219,10 @@ void TechnoTypeExt::ExtData::Serialize(T& Stm)
 		.Process(this->Harvester_CanGuardArea)
 		.Process(this->HarvesterScanAfterUnload)
 
+		.Process(this->ExtendedAircraftMissions_SmoothMoving)
+		.Process(this->ExtendedAircraftMissions_EarlyDescend)
+		.Process(this->ExtendedAircraftMissions_RearApproach)
+
 		.Process(this->FallingDownDamage)
 		.Process(this->FallingDownDamage_Water)
 

src/Ext/TechnoType/Body.h

@@ -359,6 +359,10 @@ class TechnoTypeExt
 		Valueable<bool> Harvester_CanGuardArea;
 		Nullable<bool> HarvesterScanAfterUnload;
 
+		Nullable<bool> ExtendedAircraftMissions_SmoothMoving;
+		Nullable<bool> ExtendedAircraftMissions_EarlyDescend;
+		Nullable<bool> ExtendedAircraftMissions_RearApproach;
+
 		Valueable<double> FallingDownDamage;
 		Nullable<double> FallingDownDamage_Water;
 
@@ -678,6 +682,10 @@ class TechnoTypeExt
 			, Harvester_CanGuardArea { false }
 			, HarvesterScanAfterUnload {}
 
+			, ExtendedAircraftMissions_SmoothMoving {}
+			, ExtendedAircraftMissions_EarlyDescend {}
+			, ExtendedAircraftMissions_RearApproach {}
+
 			, FallingDownDamage { 1.0 }
 			, FallingDownDamage_Water {}
 

src/Misc/Hooks.BugFixes.cpp

@@ -1153,7 +1153,7 @@ DEFINE_HOOK(0x73ED66, UnitClass_Mission_Harvest_PathfindingFix, 0x5)
 
 #pragma region StopEventFix
 
-DEFINE_JUMP(LJMP, 0x4C756B, 0x4C757D); // Skip cell under bridge check
+DEFINE_JUMP(LJMP, 0x4C752A, 0x4C757D); // Skip cell under bridge check
 
 DEFINE_HOOK(0x4C75DA, EventClass_RespondToEvent_Stop, 0x6)
 {