Metadorius · ChrisLv-CN · Aug 8, 2023 · Aug 12, 2023 · Sep 8, 2023 · Sep 8, 2023
diff --git a/AircraftClass.h b/AircraftClass.h
@@ -61,14 +61,14 @@ class NOVTABLE AircraftClass : public FootClass, public IFlyControl
 public:
 
 	AircraftTypeClass* Type;
-	bool unknown_bool_6C8;
+	bool LoseAmmo; // flag for Mission_Attack mission_statue == 1 == AIR_ATT_PICK_ATTACK_LOCATION
 	bool HasPassengers;	//parachutes
 	bool IsKamikaze; // when crashing down, duh
 	BuildingClass* DockNowHeadingTo;
 	bool unknown_bool_6D0;
 	bool unknown_bool_6D1;
-	bool unknown_bool_6D2;
-	char unknown_char_6D3;
-	bool unknown_bool_6D4;
+	bool IsLocked;
+	bool ParadropsLeft;
+	bool IsCarrayall;
 	bool unknown_bool_6D5;
 };
diff --git a/AircraftTrackerClass.h b/AircraftTrackerClass.h
@@ -0,0 +1,49 @@
+/*
+	AircraftTrackerClass
+*/
+
+#pragma once
+
+#include <GeneralDefinitions.h>
+#include <ArrayClasses.h>
+#include <TechnoClass.h>
+#include <CellClass.h>
+
+/**
+ * The game use this array when searching for and damaging air techno,
+ * when warhead explosion or greatest threat.
+ * JumpjetLoco, RocketLoco and FlyLoco will Add or Remove or Update this list.
+ *
+ */
+class AircraftTrackerClass
+{
+public:
+	static constexpr constant_ptr<AircraftTrackerClass, 0x887888u> const Instance{};
+
+	//Destructor
+	~AircraftTrackerClass() RX;
+
+	void Add_Entry(TechnoClass* pAircraft)
+		{ JMP_THIS(0x4134A0); }
+
+	void Remove_Entry(TechnoClass* pAircraft)
+		{ JMP_THIS(0x4135D0); }
+
+	void Update_Entry(TechnoClass* pAircraft, CellStruct lastCell, CellStruct curretCell)
+		{ JMP_THIS(0x4138C0); }
+
+	int Search_Entry(CellClass* pCell, int cellSpread)
+		{ JMP_THIS(0x412B40); }
+
+protected:
+	//Constructor
+	AircraftTrackerClass() {}	//don't need this
+
+	//===========================================================================
+	//===== Properties ==========================================================
+	//===========================================================================
+
+public:
+	DECLARE_PROPERTY(DynamicVectorClass<TechnoClass*>, Technos); // All Techno in air
+	DECLARE_PROPERTY(DynamicVectorClass<TechnoClass*>, Current); // Searching for
+};
diff --git a/BasicStructures.h b/BasicStructures.h
@@ -41,9 +41,26 @@ struct ColorStruct
 
 	inline explicit operator WORD() const;
 
+	operator bool()
+	{
+		return R != 0 || G != 0 || B != 0;
+	}
+
 	BYTE R, G, B;
 };
 
+// Helper
+namespace Colors
+{
+	static ColorStruct Empty{ 0, 0, 0 };
+	static ColorStruct Red{ 252, 0, 0 };
+	static ColorStruct Green{ 0, 252, 0 };
+	static ColorStruct Blue{ 0, 0, 252 };
+	static ColorStruct Yellow{ 252, 212, 0 };
+	static ColorStruct White{ 252, 252, 252 };
+	static ColorStruct Black{ 3, 3, 3 };
+}
+
 struct BytePalette {
 	ColorStruct Entries[256];
 
@@ -155,6 +172,11 @@ struct RandomStruct
 struct RectangleStruct
 {
 	int X, Y, Width, Height;
+
+	bool IsEmpty()
+	{
+		return X == 0 && Y == 0 && Width == 0 && Height == 0;
+	}
 };
 
 struct LTRBStruct
@@ -163,4 +185,4 @@ struct LTRBStruct
 	int Top;
 	int Right;
 	int Bottom;
-};
+};
diff --git a/BombListClass.h b/BombListClass.h
@@ -31,7 +31,7 @@ class BombListClass
 	void RemoveDetector(TechnoClass *Detector)
 		{ JMP_THIS(0x4390D0); }
 
-	void PointerGotInvalid(AbstractClass* pInvalid)
+	void Detach(TechnoClass* pOwner)
 		{ JMP_THIS(0x439150); }
 
 protected:

diff --git a/BuildingClass.h b/BuildingClass.h
@@ -255,8 +255,8 @@ class NOVTABLE BuildingClass : public TechnoClass
 	BuildingTypeClass* Type;
 	FactoryClass* Factory;
 	CDTimerClass C4Timer;
-	int BState;
-	int QueueBState;
+	BStateType BState;
+	BStateType QueueBState;
 	DWORD OwnerCountryIndex;
 	InfantryClass* C4AppliedBy;
 	DWORD unknown_544;

diff --git a/BulletClass.h b/BulletClass.h
@@ -127,14 +127,14 @@ class NOVTABLE BulletClass : public ObjectClass
 
 	BulletTypeClass* Type;
 	TechnoClass* Owner;
-	bool unknown_B4;
+	bool IsInaccurate;
 	BulletData Data;
 	bool Bright;
 	DWORD unknown_E4;
 	BulletVelocity Velocity;
 	DWORD unknown_100;
-	bool unknown_104;
-	DWORD unknown_108;
+	bool CourseLocked;
+	int CourseLockedDuration;
 	AbstractClass* Target;
 	int Speed;
 	int InheritedColor;

diff --git a/CCINIClass.h b/CCINIClass.h
@@ -338,6 +338,11 @@ class CCINIClass : public INIClass
 	static constexpr reference<CCINIClass, 0x887208u> const INI_UIMD{};
 	static constexpr reference<CCINIClass, 0x8870C0u> const INI_RA2MD{};
 
+	// get the fileName
+	static constexpr reference<BYTE[], 0x826260u> const INI_Rules_FileName{};
+	static constexpr reference<BYTE[], 0x82621Cu> const INI_AI_FileName{};
+	static constexpr reference<BYTE[], 0x826254u> const INI_Art_FileName{};
+
 	//non-static
 	CCINIClass() : INIClass(false)
 	{

diff --git a/CellClass.h b/CellClass.h
@@ -24,6 +24,31 @@ class TagClass;
 class TiberiumClass;
 class PixelFXClass;
 
+enum class TileType : unsigned int
+{
+	Unknown = 0,
+	Tunnel = 0x484AB0,
+	Water = 0x485060,
+	Blank = 0x486380,
+	Ramp = 0x4863A0,
+	Cliff = 0x4863D0,
+	Shore = 0x4865B0,
+	Wet = 0x4865D0,
+	MiscPave = 0x486650,
+	Pave = 0x486670,
+	DirtRoad = 0x486690,
+	PavedRoad = 0x4866D0,
+	PavedRoadEnd = 0x4866F0,
+	PavedRoadSlope = 0x486710,
+	Median = 0x486730,
+	Bridge = 0x486750,
+	WoodBridge = 0x486770,
+	ClearToSandLAT = 0x486790,
+	Green = 0x4867B0,
+	NotWater = 0x4867E0,
+	DestroyableCliff = 0x486900
+};
+
 class NOVTABLE CellClass : public AbstractClass
 {
 public:
@@ -178,6 +203,9 @@ class NOVTABLE CellClass : public AbstractClass
 	void SetMapCoords(const CoordStruct& coords)
 		{ JMP_THIS(0x485240); }
 
+	int GetFloorHeightAdjust() const
+		{ JMP_THIS(0x485080); }
+
 	int GetFloorHeight(Point2D const& subcoords) const
 		{ JMP_THIS(0x47B3A0); }
 
@@ -192,6 +220,15 @@ class NOVTABLE CellClass : public AbstractClass
 		return buffer;
 	}
 
+	// pass
+	bool IsClearToMove(SpeedType speedType, bool ignoreInfantry, bool ignoreVehicles, ZoneType zone, MovementZone movementZone, int level, bool alt)
+		{ JMP_THIS(0x4834A0); }
+
+	bool IsClearToMove(SpeedType speedType, MovementZone movementZone, bool ignoreInfantry = false, bool ignoreVehicles = false, int level = -1)
+	{
+		return IsClearToMove(speedType, ignoreInfantry, ignoreInfantry, ZoneType::None, movementZone, level, (bool)(this->Flags & CellFlags::CenterRevealed));
+	}
-	// pass
-	bool IsClearToMove(SpeedType speedType, bool ignoreInfantry, bool ignoreVehicles, ZoneType zone, MovementZone movementZone, int level, bool alt)
-		{ JMP_THIS(0x4834A0); }
-
-	bool IsClearToMove(SpeedType speedType, MovementZone movementZone, bool ignoreInfantry = false, bool ignoreVehicles = false, int level = -1)
-	{
-		return IsClearToMove(speedType, ignoreInfantry, ignoreInfantry, ZoneType::None, movementZone, level, (bool)(this->Flags & CellFlags::CenterRevealed));
-	}
+	// pass
+	bool IsClearToMove(SpeedType speedType, bool ignoreInfantry, bool ignoreVehicles, ZoneType zone, MovementZone movementZone, int level, bool alt)
+		{ JMP_THIS(0x4834A0); }
+
+	bool IsClearToMove(SpeedType speedType, MovementZone movementZone, bool ignoreInfantry = false, bool ignoreVehicles = false, int level = -1)
+	{
+		return IsClearToMove(speedType, ignoreInfantry, ignoreVehicles, ZoneType::None, movementZone, level, (bool)(this->Flags & CellFlags::CenterRevealed));
+	}
-	// pass
-	bool IsClearToMove(SpeedType speedType, bool ignoreInfantry, bool ignoreVehicles, ZoneType zone, MovementZone movementZone, int level, bool alt)
-		{ JMP_THIS(0x4834A0); }
-
-	bool IsClearToMove(SpeedType speedType, MovementZone movementZone, bool ignoreInfantry = false, bool ignoreVehicles = false, int level = -1)
-	{
-		return IsClearToMove(speedType, ignoreInfantry, ignoreInfantry, ZoneType::None, movementZone, level, (bool)(this->Flags & CellFlags::CenterRevealed));
-	}
+	// pass
+	bool IsClearToMove(SpeedType speedType, bool ignoreInfantry, bool ignoreVehicles, ZoneType zone, MovementZone movementZone, int level, bool alt)
+		{ JMP_THIS(0x4834A0); }
+
+	bool IsClearToMove(SpeedType speedType, MovementZone movementZone, bool ignoreInfantry = false, bool ignoreVehicles = false, int level = -1)
+	{
+		return IsClearToMove(speedType, ignoreInfantry, ignoreVehicles, ZoneType::None, movementZone, level, (bool)(this->Flags & CellFlags::CenterRevealed));
+	}
+
 	void ActivateVeins()
 		{ JMP_THIS(0x486920); }
 
@@ -250,8 +287,8 @@ class NOVTABLE CellClass : public AbstractClass
 
 	// helper
 	bool ContainsBridge() const
-	{ 
-		return static_cast<bool>(this->Flags & CellFlags::BridgeHead); 
+	{
+		return static_cast<bool>(this->Flags & CellFlags::BridgeHead);
 	}
 	bool ContainsBridgeEx() const
 	{
@@ -291,6 +328,31 @@ class NOVTABLE CellClass : public AbstractClass
 	ISTILE(NotWater, 0x4867E0);
 	ISTILE(DestroyableCliff, 0x486900);
 
+	TileType GetTileType()
+	{
+		if (Tile_Is_Tunnel()) return TileType::Tunnel;
+		if (Tile_Is_Water()) return TileType::Water;
+		if (Tile_Is_Blank()) return TileType::Blank;
+		if (Tile_Is_Ramp()) return TileType::Ramp;
+		if (Tile_Is_Cliff()) return TileType::Cliff;
+		if (Tile_Is_Shore()) return TileType::Shore;
+		if (Tile_Is_Wet()) return TileType::Wet;
+		if (Tile_Is_MiscPave()) return TileType::MiscPave;
+		if (Tile_Is_Pave()) return TileType::Pave;
+		if (Tile_Is_DirtRoad()) return TileType::DirtRoad;
+		if (Tile_Is_PavedRoad()) return TileType::PavedRoad;
+		if (Tile_Is_PavedRoadEnd()) return TileType::PavedRoadEnd;
+		if (Tile_Is_PavedRoadSlope()) return TileType::PavedRoadSlope;
+		if (Tile_Is_Median()) return TileType::Median;
+		if (Tile_Is_Bridge()) return TileType::Bridge;
+		if (Tile_Is_WoodBridge()) return TileType::WoodBridge;
+		if (Tile_Is_ClearToSandLAT()) return TileType::ClearToSandLAT;
+		if (Tile_Is_Green()) return TileType::Green;
+		if (Tile_Is_NotWater()) return TileType::NotWater;
+		if (Tile_Is_DestroyableCliff()) return TileType::DestroyableCliff;
+		return TileType::Unknown;
+	}
+
 	static CoordStruct Cell2Coord(const CellStruct &cell, int z = 0)
 	{
 		CoordStruct ret;

diff --git a/Dir.h b/Dir.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #include <bit>
 
@@ -11,8 +11,8 @@ enum class DirType : unsigned char;
 struct DirStruct
 {
 public:
-	explicit DirStruct() noexcept : Raw { 0 } { }
-	explicit DirStruct(int raw) noexcept : Raw { static_cast<unsigned short>(raw) } { }
+	explicit DirStruct() noexcept : Raw{ 0 } { }
+	explicit DirStruct(int raw) noexcept : Raw{ static_cast<unsigned short>(raw) } { }
 	explicit DirStruct(double rad) noexcept { SetRadian<65536>(rad); }
 	explicit DirStruct(const DirType dir) noexcept { SetDir(dir); }
 	explicit DirStruct(const noinit_t&) noexcept { }
@@ -52,6 +52,25 @@ struct DirStruct
 		Raw = static_cast<unsigned short>(TranslateFixedPoint<Bits, 16>(value, offset));
 	}
 
+	// untemplate
+	short GetValue(const size_t Bits = 16)
+	{
+		if (Bits > 0 && Bits <= 16)
+		{
+			return (short)(TranslateFixedPoint(16, Bits, (size_t)(this->Raw), 0));
+		}
+		return 0;
+	}
+
+	// untemplate
+	void SetValue(short value, size_t Bits = 16, size_t offset = 0)
+	{
+		if (Bits > 0 && Bits <= 16)
+		{
+			Raw = static_cast<unsigned short>(TranslateFixedPoint(16, Bits, (size_t)value, offset));
+		}
+	}
+
 	template<size_t Count>
 	constexpr size_t GetFacing(size_t offset = 0) const
 	{
@@ -95,6 +114,31 @@ struct DirStruct
 		SetValue<Bits>(value & Max);
 	}
 
+	// untemplate
+	double GetRadian(size_t Bits = 16)
+	{
+		if (Bits > 0 && Bits <= 16)
+		{
+			int Max = (1 << (int)Bits) - 1;
+
+			int value = Max / 4 - this->GetValue(Bits);
+			return -value * -(Math::TwoPi / Max);
+		}
+		return 0;
+	}
+
+	// untemplate
+	void SetRadian(double rad, size_t Bits = 16)
+	{
+		if (Bits > 0 && Bits <= 16)
+		{
+			int Max = (1 << (int)Bits) - 1;
+
+			int value = (int)(rad * (Max / Math::TwoPi));
+			this->SetValue((short)(Max / 4 - value), Bits);
+		}
+	}
+
 private:
 	template<size_t BitsFrom, size_t BitsTo>
 	constexpr static size_t TranslateFixedPoint(size_t value, size_t offset = 0)
@@ -110,6 +154,27 @@ struct DirStruct
 			return value & MaskOut;
 	}
 
+	// untemplate
+	constexpr static size_t TranslateFixedPoint(size_t bitsFrom, size_t bitsTo, size_t value, size_t offset = 0)
+	{
+		size_t MaskIn = (1u << (int)bitsFrom) - 1;
+		size_t MaskOut = (1u << (int)bitsTo) - 1;
+
+		if (bitsFrom > bitsTo)
+		{
+			// converting down
+			return (((((value & MaskIn) >> (int)(bitsFrom - bitsTo - 1)) + 1) >> 1) + offset) & MaskOut;
+		}
+		else if (bitsFrom < bitsTo)
+		{
+			// converting up
+			return (((value - offset) & MaskIn) << (int)(bitsTo - bitsFrom)) & MaskOut;
+		}
+		else
+		{
+			return value & MaskOut;
+		}
+	}
 public:
 	unsigned short Raw;
 private:

diff --git a/DiskLaserClass.h b/DiskLaserClass.h
@@ -39,7 +39,7 @@ class NOVTABLE DiskLaserClass : public AbstractClass
 	void Fire(TechnoClass* pOwner, TechnoClass* pTarget, WeaponTypeClass* pWeapon, int nDamage)
 		{ JMP_THIS(0x4A71A0); }
 
-	void PointerGotInvalid(AbstractClass* pInvalid)
+	void Detach(TechnoClass* pTecno)
 		{ JMP_THIS(0x4A7900); }
 
 	//Constructor