Update

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;
-};
+};

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)
 	{

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:
@@ -192,6 +217,15 @@ class NOVTABLE CellClass : public AbstractClass
 		return buffer;
 	}
 
+	// pass
+	bool IsClearToMove(SpeedType speedType, bool ignoreInfantry, bool ignoreVehicles, ZoneType zone, MovementZone movementZone, int level, bool isBridge)
+		{ 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, ContainsBridge());
+	}
+
 	void ActivateVeins()
 		{ JMP_THIS(0x486920); }
 
@@ -291,6 +325,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;

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:

DisplayClass.h

@@ -4,13 +4,21 @@
 
 class CCINIClass;
 class ObjectTypeClass;
+class BuildingTypeClass;
 
 class NOVTABLE DisplayClass : public MapClass
 {
 public:
 	//Static
 	static constexpr constant_ptr<DisplayClass, 0x87F7E8u> const Instance{};
 
+	static constexpr reference<CellStruct, 0x88095Cu> const Display_ZoneCell{};
+	static constexpr reference<CellStruct, 0x880960u> const Display_ZoneOffset{};
+	static constexpr reference<CellStruct*, 0x880964u> const Display_CurrentFoundation_Data{};
+	static constexpr reference<bool, 0x880968u> const Display_PassedProximityCheck{};
+	static constexpr reference<BuildingTypeClass*, 0x880990u> const Display_PendingObject{};
+	static constexpr reference<int, 0x880994u> const Display_PendingHouse{};
+
 	//WIP: DisplayClass::TacticalClass goes HERE
 
 	bool ProcessClickCoords(Point2D *src, CellStruct *XYdst, CoordStruct *XYZdst, ObjectClass **Target, BYTE *a5, BYTE *a6)
@@ -65,6 +73,17 @@ class NOVTABLE DisplayClass : public MapClass
 		return outBuffer;
 	}
 
+	bool Passes_Proximity_Check(BuildingTypeClass* pPendingObject, int houseIndex, CellStruct* foundation, CellStruct* center)
+		{ JMP_THIS(0x4A8EB0); }
+
+	bool Passes_Proximity_Check()
+	{
+		CellStruct zoneCell = Display_ZoneCell.get();
+		CellStruct zoneOffset = Display_ZoneOffset.get();
+		CellStruct center = zoneCell + zoneOffset;
+		return Passes_Proximity_Check(Display_PendingObject.get(), Display_PendingHouse.get(), Display_CurrentFoundation_Data.get(), &center);
+	}
+
 	/* marks or unmarks the cells pointed to by CurrentFoundationData as containing a building */
 	void MarkFoundation(CellStruct * BaseCell, bool Mark)
 		{ JMP_THIS(0x4A95A0); }

EBolt.h

@@ -5,7 +5,9 @@
 #pragma once
 
 #include <GeneralDefinitions.h>
+#include <ArrayClasses.h>
 
+class TechnoClass;
 class UnitClass;
 
 class EBolt

Facing.h

@@ -25,7 +25,7 @@ class FacingClass
 		DesiredFacing.SetDir(dir);
 	}
 
-	explicit FacingClass(const FacingClass& another) noexcept
+	FacingClass(const FacingClass& another) noexcept
 		: DesiredFacing { another.DesiredFacing }
 		, StartFacing { another.StartFacing }
 		, RotationTimer { another.RotationTimer }
@@ -132,8 +132,8 @@ class FacingClass
 
 public:
 
-	DirStruct DesiredFacing;
+	DirStruct DesiredFacing;  // target facing
 	DirStruct StartFacing; // The starting direction from which to calcuate the rotation.
-	CDTimerClass RotationTimer;
-	DirStruct ROT;
+	CDTimerClass RotationTimer; // counts rotation steps
+	DirStruct ROT; // Rate of Turn. INI Value * 256
 };

HouseClass.h

@@ -11,6 +11,7 @@
 #include <ScenarioClass.h>
 #include <SessionClass.h>
 #include <SideClass.h>
+#include <SuperWeaponTypeClass.h>
 #include <UnitClass.h>
 #include <UnitTypeClass.h>
 
@@ -504,6 +505,8 @@ class NOVTABLE HouseClass : public AbstractClass, public IHouse, public IPublicH
 
 	SuperClass* FindSuperWeapon(SuperWeaponType type) const;
 
+	SuperClass* FindSuperWeapon(SuperWeaponTypeClass* type) const;
+
 	// I don't want to talk about these
 	// read the code <_<
 

Kamikaze.h

@@ -13,7 +13,7 @@ class Kamikaze {
 public:
 	struct KamikazeControl {
 		AircraftClass* Item;
-		CellClass* Cell;
+		AbstractClass* Cell; // Change to AbstractClass for Mission homing TechnoClass
 	};
 
 	static constexpr reference<Kamikaze, 0xABC5F8u> const Instance{};

MessageListClass.h

@@ -83,10 +83,12 @@ class MessageListClass
 	void PrintMessage(const wchar_t* pMessage, int durationFrames = 0x96, int nColorSchemeIndex = ColorScheme::White, bool bSilent = false)
 		{ this->AddMessage(nullptr, 0, pMessage, nColorSchemeIndex, static_cast<TextPrintType>(0x4046), durationFrames, bSilent); }
 
+	void PrintMessage(const wchar_t* pLabel, const wchar_t* pMessage, int durationFrames = 0x96, int nColorSchemeIndex = ColorScheme::White, bool bSilent = false)
+		{ this->AddMessage(pLabel, 0, pMessage, nColorSchemeIndex, static_cast<TextPrintType>(0x4046), static_cast<int>(durationFrames), bSilent); }
+
 	void PrintMessage(const wchar_t* pMessage, double durationMinutes, int nColorSchemeIndex = ColorScheme::White, bool bSilent = false)
 		{ this->AddMessage(nullptr, 0, pMessage, nColorSchemeIndex, static_cast<TextPrintType>(0x4046), static_cast<int>(durationMinutes * 900), bSilent); }
 
-
 	TextLabelClass* MessageList;
 	Point2D MessagePos;
 	int MaxMessageCount;

ObjectClass.h

@@ -8,6 +8,7 @@
 #include <Audio.h>
 #include <ObjectTypeClass.h>
 #include <TagClass.h>
+#include <RulesClass.h>
 
 #include <Helpers/Template.h>
 
@@ -265,6 +266,16 @@ class NOVTABLE ObjectClass : public AbstractClass
 		return ret;
 	}
 
+	DamageState TakeDamage(int damage, WarheadTypeClass* pWH, bool crewed, bool ignoreDefenses = true, ObjectClass* pAttacker = nullptr, HouseClass* pAttackingHouse = nullptr)
+	{
+		return ReceiveDamage(&damage, 0, pWH, pAttacker, ignoreDefenses, !crewed, pAttackingHouse);
+	}
+
+	DamageState TakeDamage(int damage, bool crewed, bool ignoreDefenses = true, ObjectClass* pAttacker = nullptr, HouseClass* pAttackingHouse = nullptr)
+	{
+		return TakeDamage(damage, RulesClass::Instance->C4Warhead, crewed, ignoreDefenses, pAttacker, pAttackingHouse);
+	}
+
 	//Constructor NEVER CALL IT DIRECTLY
 	/*ObjectClass()  noexcept
 		{ JMP_THIS(0x5F3900); }*/

SpawnManagerClass.h

@@ -102,7 +102,7 @@ class NOVTABLE SpawnManagerClass : public AbstractClass
 	DynamicVectorClass<SpawnNode*> SpawnedNodes;
 	CDTimerClass UpdateTimer;
 	CDTimerClass SpawnTimer;
-	AbstractClass* Target;
-	AbstractClass* NewTarget;
+	AbstractClass* Destination; // SpawnMissile's destination
+	AbstractClass* Target; // Spwan plane's target
 	SpawnManagerStatus Status;
 };