[Highly Customized] Jumpjet Climbing Logic Enhancement (Phobos-developers#1318)

In vanilla game, the jumpjet unit would stop horizontal movement as it
rose to a relatively high altitude. Here are two options to change this.
- You can now let the jumpjets increase their height earlier by set
`JumpjetClimbPredictHeight` to true or simply let them skip the stop
check by set `JumpjetClimbWithoutCutOut` to true.

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

---------

Co-authored-by: Coronia <[email protected]>

Author: CrimRecya

CREDITS.md

@@ -537,6 +537,7 @@ This page lists all the individual contributions to the project by their author.
   - Restore turret recoil effect
   - Fix an issue that `FireAngle` was not taken into account when drawing barrel in `TurretShadow`
   - Fix an issue that barrel anim data will be incorrectly overwritten by turret anim data if the techno's section exists in the map file
+  - Jumpjet Climbing Logic Enhancement
 - **Ollerus**:
   - Build limit group enhancement
   - Customizable rocker amplitude

docs/Fixed-or-Improved-Logics.md

@@ -1287,6 +1287,19 @@ IronCurtain.ExtraTintIntensity=0.0  ; floating point value
 ForceShield.ExtraTintIntensity=0.0  ; floating point value
 ```
 
+### Jumpjet climbing logic enhancement
+
+- You can now let the jumpjets increase their height earlier by set `JumpjetClimbPredictHeight` to true. The jumpjet will raise its height 5 cells in advance, instead of only raising its height when encountering cliffs or buildings in front of it.
+- You can also let them simply skip the stop check by set `JumpjetClimbWithoutCutOut` to true. The jumpjet will not stop moving horizontally when encountering cliffs or buildings in front of it, but will continue to move forward while raising its altitude.
+  - When `JumpjetClimbPredictHeight` is enabled, if the height raised five grids in advance is still not enough to cross cliffs or buildings, it will stop and move horizontally as before, unless `JumpjetClimbWithoutCutOut` is also enabled.
+
+In `rulesmd.ini`:
+```ini
+[General]
+JumpjetClimbPredictHeight=false  ; boolean
+JumpjetClimbWithoutCutOut=false  ; boolean
+```
+
 ### Jumpjet rotating on crashing toggle
 
 - Jumpjet that is going to crash starts to change its facing uncontrollably, this can now be turned off.

docs/Whats-New.md

@@ -432,6 +432,7 @@ New:
 - Reverse engineer warhead (by CrimRecya)
 - AI base construction modification (by CrimRecya)
 - Restore turret recoil effect (by CrimRecya)
+- Jumpjet Climbing Logic Enhancement (by CrimRecya)
 
 Vanilla fixes:
 - Fixed sidebar not updating queued unit numbers when adding or removing units when the production is on hold (by CrimRecya)

src/Ext/Rules/Body.cpp

@@ -224,6 +224,9 @@ void RulesExt::ExtData::LoadBeforeTypeData(RulesClass* pThis, CCINIClass* pINI)
 	this->DefaultInfantrySelectBox.Read(exINI, GameStrings::AudioVisual, "DefaultInfantrySelectBox");
 	this->DefaultUnitSelectBox.Read(exINI, GameStrings::AudioVisual, "DefaultUnitSelectBox");
 
+	this->JumpjetClimbPredictHeight.Read(exINI, GameStrings::General, "JumpjetClimbPredictHeight");
+	this->JumpjetClimbWithoutCutOut.Read(exINI, GameStrings::General, "JumpjetClimbWithoutCutOut");
+
 	this->DamageOwnerMultiplier.Read(exINI, GameStrings::CombatDamage, "DamageOwnerMultiplier");
 	this->DamageAlliesMultiplier.Read(exINI, GameStrings::CombatDamage, "DamageAlliesMultiplier");
 	this->DamageEnemiesMultiplier.Read(exINI, GameStrings::CombatDamage, "DamageEnemiesMultiplier");
@@ -501,6 +504,8 @@ void RulesExt::ExtData::Serialize(T& Stm)
 		.Process(this->DropPodTrailer)
 		.Process(this->DropPodDefaultTrailer)
 		.Process(this->PodImage)
+		.Process(this->JumpjetClimbPredictHeight)
+		.Process(this->JumpjetClimbWithoutCutOut)
 		.Process(this->DamageOwnerMultiplier)
 		.Process(this->DamageAlliesMultiplier)
 		.Process(this->DamageEnemiesMultiplier)

src/Ext/Rules/Body.h

@@ -173,6 +173,9 @@ class RulesExt
 		Valueable<AnimTypeClass*> Promote_VeteranAnimation;
 		Valueable<AnimTypeClass*> Promote_EliteAnimation;
 
+		Valueable<bool> JumpjetClimbPredictHeight;
+		Valueable<bool> JumpjetClimbWithoutCutOut;
+
 		Valueable<double> DamageOwnerMultiplier;
 		Valueable<double> DamageAlliesMultiplier;
 		Valueable<double> DamageEnemiesMultiplier;
@@ -389,6 +392,8 @@ class RulesExt
 			, DropPodTrailer { }
 			, DropPodDefaultTrailer { }
 			, PodImage { }
+			, JumpjetClimbPredictHeight { false }
+			, JumpjetClimbWithoutCutOut { false }
 			, DamageOwnerMultiplier { 1.0 }
 			, DamageAlliesMultiplier { 1.0 }
 			, DamageEnemiesMultiplier { 1.0 }

src/Ext/Unit/Hooks.Jumpjet.cpp

@@ -1,10 +1,10 @@
 #include <JumpjetLocomotionClass.h>
 #include <UnitClass.h>
+#include <BuildingClass.h>
+
 #include <Utilities/Macro.h>
 #include <Ext/Techno/Body.h>
-#include <Ext/TechnoType/Body.h>
 #include <Ext/WeaponType/Body.h>
-#include <Ext/Techno/Body.h>
 
 // Misc jumpjet facing, turning, drawing fix -- Author: Trsdy
 // Jumpjets stuck at FireError::FACING because Jumpjet has its own facing just for JumpjetTurnRate
@@ -222,3 +222,159 @@ void __stdcall JumpjetLocomotionClass_Unlimbo(ILocomotion* pThis)
 }
 
 DEFINE_FUNCTION_JUMP(VTABLE, 0x7ECDB8, JumpjetLocomotionClass_Unlimbo)
+
+// Let the jumpjet increase their height earlier or simply skip the stop check
+namespace JumpjetRushHelpers
+{
+	bool Skip = false;
+	int GetJumpjetHeightWithOccupyTechno(const CellClass* pCell); // Replace sub_485080
+	int JumpjetLocomotionPredictHeight(JumpjetLocomotionClass* pThis); // Replace sub_54D820
+}
+
+int JumpjetRushHelpers::GetJumpjetHeightWithOccupyTechno(const CellClass* pCell)
+{
+	if (const auto pBuilding = pCell->GetBuilding())
+	{
+		auto dim2 = CoordStruct::Empty;
+		pBuilding->Type->Dimension2(&dim2);
+		return dim2.Z;
+	}
+
+	int height = 0;
+
+	if (pCell->FindTechnoNearestTo(Point2D::Empty, false))
+		height += 85; // Vanilla
+
+	if (pCell->ContainsBridge())
+		height += CellClass::BridgeHeight;
+
+	return height;
+}
+
+int JumpjetRushHelpers::JumpjetLocomotionPredictHeight(JumpjetLocomotionClass* pThis)
+{
+	const auto pFoot = pThis->LinkedTo;
+	const auto pLocation = &pFoot->Location;
+
+	constexpr int shift = 8; // >> shift -> / Unsorted::LeptonsPerCell
+	constexpr auto point2Cell = [](const Point2D& point) -> CellStruct
+	{
+		return CellStruct { static_cast<short>(point.X >> shift), static_cast<short>(point.Y >> shift) };
+	};
+	auto getJumpjetHeight = [](const CellClass* const pCell, const Point2D& point) -> int
+	{
+		return pCell->GetFloorHeight(Point2D { point.X, point.Y }) + JumpjetRushHelpers::GetJumpjetHeightWithOccupyTechno(pCell);
+	};
+
+	// Initialize
+	auto curCoord = Point2D { pLocation->X, pLocation->Y };
+	const CellClass* pCurCell = MapClass::Instance.GetCellAt(point2Cell(curCoord));
+	int maxHeight = getJumpjetHeight(pCurCell, curCoord);
+
+	// If is moving
+	if (pThis->CurrentSpeed > 0.0)
+	{
+		// Prepare for prediction
+		auto lastCoord = Point2D::Empty;
+		const int checkLength = (pThis->LocomotionFacing.IsRotating() || !pFoot->Destination)
+			? Unsorted::LeptonsPerCell
+			: Math::min((Unsorted::LeptonsPerCell * 5), pFoot->DistanceFrom(pFoot->Destination)); // Predict the distance of 5 cells ahead
+		const double angle = -pThis->LocomotionFacing.Current().GetRadian<65536>();
+		const auto checkCoord = Point2D { static_cast<int>(checkLength * Math::cos(angle) + 0.5), static_cast<int>(checkLength * Math::sin(angle) + 0.5) };
+		const int largeStep = Math::max(std::abs(checkCoord.X), std::abs(checkCoord.Y));
+		const int checkSteps = (largeStep > Unsorted::LeptonsPerCell) ? (largeStep / Unsorted::LeptonsPerCell + 1) : 1;
+		const auto stepCoord = Point2D { (checkCoord.X / checkSteps), (checkCoord.Y / checkSteps) };
+
+		auto getSideHeight = [](const CellClass* const pCell) -> int
+		{
+			return (pCell->Level * Unsorted::LevelHeight) + JumpjetRushHelpers::GetJumpjetHeightWithOccupyTechno(pCell);
+		};
+		auto getAntiAliasingCell = [&stepCoord, &checkCoord](const Point2D& curCoord, const Point2D& lastCoord) -> CellClass*
+		{
+			// Check if it is a diagonal relationship
+			if ((curCoord.X >> shift) == (lastCoord.X >> shift) || (curCoord.Y >> shift) == (lastCoord.Y >> shift))
+				return nullptr;
+
+			constexpr int mask = 0xFF; // & mask -> % Unsorted::LeptonsPerCell
+			bool lastX = false;
+
+			// Calculate the bias of the previous cell
+			if (std::abs(stepCoord.X) > std::abs(stepCoord.Y))
+			{
+				const int offsetX = curCoord.X & mask;
+				const int deltaX = (stepCoord.X > 0) ? offsetX : (offsetX - Unsorted::LeptonsPerCell);
+				const int projectedY = curCoord.Y - deltaX * checkCoord.Y / checkCoord.X;
+				lastX = (projectedY ^ curCoord.Y) >> shift == 0;
+			}
+			else
+			{
+				const int offsetY = curCoord.Y & mask;
+				const int deltaY = (stepCoord.Y > 0) ? offsetY : (offsetY - Unsorted::LeptonsPerCell);
+				const int projectedX = curCoord.X - deltaY * checkCoord.X / checkCoord.Y;
+				lastX = (projectedX ^ curCoord.X) >> shift != 0;
+			}
+
+			// Get cell
+			return MapClass::Instance.TryGetCellAt(lastX
+				? CellStruct { static_cast<short>(lastCoord.X >> shift), static_cast<short>(curCoord.Y >> shift) }
+				: CellStruct { static_cast<short>(curCoord.X >> shift), static_cast<short>(lastCoord.Y >> shift) });
+		};
+		auto checkStepHeight = [&maxHeight, &curCoord, &lastCoord, &pCurCell, &stepCoord,
+			&getJumpjetHeight, &getAntiAliasingCell, &getSideHeight]() -> bool
+		{
+			// Check forward
+			lastCoord = curCoord;
+			curCoord += stepCoord;
+			pCurCell = MapClass::Instance.TryGetCellAt(point2Cell(curCoord));
+
+			if (!pCurCell)
+				return false;
+
+			maxHeight = Math::max(maxHeight, getJumpjetHeight(pCurCell, curCoord));
+
+			// "Anti-Aliasing"
+			if (const auto pCheckCell = getAntiAliasingCell(curCoord, lastCoord))
+				maxHeight = Math::max(maxHeight, getSideHeight(pCheckCell));
+
+			return true;
+		};
+
+		// Predict height
+		if (checkStepHeight())
+		{
+			// The forward cell is not so high, keep moving
+			if ((pLocation->Z - maxHeight) >= pFoot->GetTechnoType()->JumpjetHeight)
+				JumpjetRushHelpers::Skip = true;
+
+			// Check further
+			for (int i = 1; i < checkSteps && checkStepHeight(); ++i);
+		}
+	}
+
+	return maxHeight;
+}
+
+DEFINE_HOOK(0x54D827, JumpjetLocomotionClass_sub_54D820_PredictHeight, 0x8)
+{
+	enum { SkipVanillaCalculate = 0x54D928 };
+
+	GET(JumpjetLocomotionClass*, pThis, ESI);
+
+	if (!RulesExt::Global()->JumpjetClimbPredictHeight)
+		return 0;
+
+	R->EAX(JumpjetRushHelpers::JumpjetLocomotionPredictHeight(pThis));
+	return SkipVanillaCalculate;
+}
+
+DEFINE_HOOK(0x54D4C0, JumpjetLocomotionClass_sub_54D0F0_NoStuck, 0x6)
+{
+	enum { SkipCheckStop = 0x54D52F };
+
+	if (JumpjetRushHelpers::Skip)
+		JumpjetRushHelpers::Skip = false;
+	else if (!RulesExt::Global()->JumpjetClimbWithoutCutOut)
+		return 0;
+
+	return SkipCheckStop;
+}