[New feature]Tiberium eater logic (#1619)

- Re-impl from  PR #1111
- Units can convert the ore underneath them into cash in real time, like
GDI's EPIC unit MARV in Command & Conquer 3 Kane's Wrath, when
`TiberiumEater.TransDelay` is 0 or larger.
- 当 `TiberiumEater.TransDelay`
大于等于0时，单位将可以实时将矿石转换为资金，就像《命令与征服3：凯恩之怒》中GDI史诗载具MARV那样。
- `TiberiumEater.TransDelay` specifies the interval in game frames
between two mining "processes".
- `TiberiumEater.TransDelay` 指定两次转换之间的间隔帧数。
- `TiberiumEater.CellN` set a list of cells that'll process tiberium
eating, where `N` is 0-based and the values are offset related to the
TechnoType's current cell. If not set, only the ores on the TechnoType's
current cell will be eaten.
- `TiberiumEater.CellN`
设置一系列将要被转换矿石的格子偏移量，N为从0开始的整数，实际坐标基于单位当前所处的格子。若不设定，则只有单位当前所处的格子中的矿石会被转换。
- `TiberiumEater.AmountPerCell` controls how many "bails" of ore can be
mined at each cell at once.
- `TiberiumEater.AmountPerCell` 控制每次在每格内转换多少数量的矿石。
- By default, ore mined this way is worth the same as if it was
harvested and refined the normal way. This can be adjusted with
`TiberiumEater.CashMultiplier`.
- 默认情况下，以这种方式转换矿石获得的资金量与正常的矿车采收倒入矿石精炼厂获得的资金相同。这可以通过
`TiberiumEater.CashMultiplier` 来进行调整。
- `TiberiumEater.Display=true` will create a flying text displaying the
total cash amount received each mining process.
`TiberiumEater.Display.Houses` controlls who can see this text.
- `TiberiumEater.Display=true` 将会显示转换后获得的金额。
`TiberiumEater.Display.Houses` 控制谁可以看见显示的金额。
- An animation will be played at each interval at each mined cell. If
`TiberiumEater.Anims` contains 8 entries, then an entry will be picked
according to unit facing. Otherwise, an entry will be chosen at random.
- 转换时可以播放动画。如果 `TiberiumEater.Anims`
包含8个动画，那么将会根据单位的朝向进行选择；其他情况下，将会随机选择动画。
- `TiberiumEater.Anims.TiberiumN`, if set, will override
`TiberiumEater.Anims` when mining corresponding tiberium type.
- `TiberiumEater.Anims.TiberiumN` 若设置，则在处理对应矿石类型的时候将覆盖
`TiberiumEater.Anims` 的值.
- If `TiberiumEater.AnimMove=true`, the animations will move with the
unit.
- 如果 `TiberiumEater.AnimMove=true` ，动画将会跟随单位移动。

In `rulesmd.ini`:
```ini
[SOMETECHNO]                       ; InfantryType, UnitType or AircraftType
TiberiumEater.TransDelay=-1       ; integer
TiberiumEater.CashMultiplier=1.0  ; float
TiberiumEater.AmountPerCell=0     ; integer
TiberiumEater.CellN=              ; x, y , use cell as unit, multiple values mean that they are effective in multiple cells at the same time
TiberiumEater.Display=true        ; boolean
TiberiumEater.Display.Houses=all  ; AffectedHouse enumeration
TiberiumEater.Anims=              ; list of animations
TiberiumEater.Anims.Tiberium0=    ; List of AnimationTypes
TiberiumEater.Anims.Tiberium1=    ; List of AnimationTypes
TiberiumEater.Anims.Tiberium2=    ; List of AnimationTypes
TiberiumEater.Anims.Tiberium3=    ; List of AnimationTypes
TiberiumEater.AnimMove=true       ; boolean
```

---------

Co-authored-by: 九千天华 <1065703286@qq.com>
Co-authored-by: Coronia <2217891145@qq.com>

Author: 3 people

CREDITS.md

@@ -387,6 +387,7 @@ This page lists all the individual contributions to the project by their author.
   - Fix the bug that buildings will always be tinted as airstrike owner
   - Fix the bug that `AllowAirstrike=no` cannot completely prevent air strikes from being launched against it
   - Fix the bug that infantry ignored `Passengers` and `SizeLimit` when entering buildings
+  - Tiberium eater logic
 - **Apollo** - Translucent SHP drawing patches
 - **ststl**:
   - Customizable `ShowTimer` priority of superweapons

Phobos.vcxproj

@@ -28,6 +28,7 @@
     <ClCompile Include="src\Ext\Unit\Hooks.Sinking.cpp" />
     <ClCompile Include="src\Misc\Hooks.AlphaImage.cpp" />
     <ClCompile Include="src\New\Entity\AttachEffectClass.cpp" />
+    <ClCompile Include="src\New\Type\Affiliated\TiberiumEaterTypeClass.cpp" />
     <ClCompile Include="src\New\Type\AttachEffectTypeClass.cpp" />
     <ClCompile Include="src\Commands\Commands.cpp" />
     <ClCompile Include="src\Commands\DamageDisplay.cpp" />
@@ -197,6 +198,7 @@
     <ClInclude Include="src\Blowfish\blowfish.h" />
     <ClInclude Include="src\Ext\Cell\Body.h" />
     <ClInclude Include="src\New\Entity\AttachEffectClass.h" />
+    <ClInclude Include="src\New\Type\Affiliated\TiberiumEaterTypeClass.h" />
     <ClInclude Include="src\New\Type\AttachEffectTypeClass.h" />
     <ClInclude Include="src\Commands\FrameByFrame.h" />
     <ClInclude Include="src\Commands\FrameStep.h" />

docs/New-or-Enhanced-Logics.md

@@ -1724,6 +1724,35 @@ IsVoiceCreatedGlobal=false   ; boolean
 VoiceCreated=                ; Sound entry
 ```
 
+### Tiberium eater
+
+- TechnoTypes can convert the ores underneath them into credits in real time, like GDI's MARV in Command & Conquer 3 Kane's Wrath.
+- `TiberiumEater.TransDelay` specifies the interval frames between two eating processes, 0 means eat in every frame. When it's below 0, the logic will be turned off for this TechnoType.
+- `TiberiumEater.CellN` set a list of cells that'll process tiberium eating, where `N` is 0-based and the values are offset related to the TechnoType's current cell. If not set, only the ores on the TechnoType's current cell will be eaten.
+- `TiberiumEater.AmountPerCell` controls the amount of ores that can be eaten at each cell at once. No limit when it's below 0.
+- By default, ores mined in this way worth the same as regular harvesting. This can be adjusted by `TiberiumEater.CashMultiplier`.
+- `TiberiumEater.Display`, if set to true, will create a flying text to display the total credits received in each eating process. `TiberiumEater.Display.Houses` determines which houses can see the credits display.
+- An animation will be played at each mined cell in an eating process. If `TiberiumEater.Anims` contains 8 entries, entry from position matching the TechnoType's current facing will be chosen. Otherwise, an entry will be chosen randomly.
+  - `TiberiumEater.Anims.TiberiumN`, if set, will override `TiberiumEater.Anims` when eating corresponding tiberium type.
+  - If `TiberiumEater.AnimMove` set to true, the animations will move with the TechnoType.
+
+In `rulesmd.ini`:
+```ini
+[SOMETECHNO]                      ; InfantryType, VehicleType or AircraftType
+TiberiumEater.TransDelay=-1       ; integer
+TiberiumEater.CellN=              ; X,Y - cell offset
+TiberiumEater.CashMultiplier=1.0  ; floating point value
+TiberiumEater.AmountPerCell=0     ; integer
+TiberiumEater.Display=true        ; boolean
+TiberiumEater.Display.Houses=all  ; AffectedHouse enumeration
+TiberiumEater.Anims=              ; List of AnimationTypes
+TiberiumEater.Anims.Tiberium0=    ; List of AnimationTypes
+TiberiumEater.Anims.Tiberium1=    ; List of AnimationTypes
+TiberiumEater.Anims.Tiberium2=    ; List of AnimationTypes
+TiberiumEater.Anims.Tiberium3=    ; List of AnimationTypes
+TiberiumEater.AnimMove=true       ; boolean
+```
+
 ### Weapons fired on warping in / out
 
 - It is now possible to add weapons that are fired on a teleporting TechnoType when it warps in or out. They are at the same time as the appropriate animations (`WarpIn` / `WarpOut`) are displayed.

docs/Whats-New.md

@@ -374,6 +374,7 @@ New:
 - [Make harvesters do addtional scan after unload](Fixed-or-Improved-Logics.md#make-harvesters-do-addtional-scan-after-unload) (by TaranDahl)
 - [Passenger-based insignias](Fixed-or-Improved-Logics.md#customizable-veterancy-insignias) (by Ollerus)
 - [Use `InsigniaType` to set the properties of insignia in a batch](Miscellanous.md#insignia-type) (by Ollerus)
+- [Tiberium eater logic](New-or-Enhanced-Logics.md#tiberium-eater) (by NetsuNegi)
 
 Vanilla fixes:
 - Fixed sidebar not updating queued unit numbers when adding or removing units when the production is on hold (by CrimRecya)

src/Ext/Techno/Body.Update.cpp

@@ -3,6 +3,7 @@
 
 #include <SpawnManagerClass.h>
 #include <ParticleSystemClass.h>
+#include <Conversions.h>
 
 #include <Ext/Anim/Body.h>
 #include <Ext/Bullet/Body.h>
@@ -338,6 +339,97 @@ void TechnoExt::ExtData::EatPassengers()
 	}
 }
 
+void TechnoExt::ExtData::UpdateTiberiumEater()
+{
+	const auto pEaterType = this->TypeExtData->TiberiumEaterType.get();
+
+	if (!pEaterType)
+		return;
+
+	const int transDelay = pEaterType->TransDelay;
+
+	if (transDelay && this->TiberiumEater_Timer.InProgress())
+		return;
+
+	const auto pThis = this->OwnerObject();
+	const auto pOwner = pThis->Owner;
+	bool active = false;
+	const bool displayCash = pEaterType->Display && pThis->IsClearlyVisibleTo(HouseClass::CurrentPlayer);
+	int facing = pThis->PrimaryFacing.Current().GetFacing<8>();
+
+	if (facing >= 7)
+		facing = 0;
+	else
+		facing++;
+
+	const int cellCount = static_cast<int>(pEaterType->Cells.size());
+
+	for (int idx = 0; idx < cellCount; idx++)
+	{
+		const auto& cellOffset = pEaterType->Cells[idx];
+		const auto pos = TechnoExt::GetFLHAbsoluteCoords(pThis, CoordStruct { cellOffset.X, cellOffset.Y, 0 }, false);
+		const auto pCell = MapClass::Instance.TryGetCellAt(pos);
+
+		if (!pCell)
+			continue;
+
+		if (const int contained = pCell->GetContainedTiberiumValue())
+		{
+			const int tiberiumIdx = pCell->GetContainedTiberiumIndex();
+			const int tiberiumValue = TiberiumClass::Array[tiberiumIdx]->Value;
+			const int tiberiumAmount = static_cast<int>(static_cast<double>(contained) / tiberiumValue);
+			const int amount = pEaterType->AmountPerCell > 0 ? std::min(pEaterType->AmountPerCell.Get(), tiberiumAmount) : tiberiumAmount;
+			pCell->ReduceTiberium(amount);
+			const float multiplier = pEaterType->CashMultiplier * (1.0f + pOwner->NumOrePurifiers * RulesClass::Instance->PurifierBonus);
+			const int value = static_cast<int>(std::round(amount * tiberiumValue * multiplier));
+			pOwner->TransactMoney(value);
+			active = true;
+
+			if (displayCash)
+			{
+				auto cellCoords = pCell->GetCoords();
+				cellCoords.Z = std::max(pThis->Location.Z, cellCoords.Z);
+				FlyingStrings::AddMoneyString(value, pOwner, pEaterType->DisplayToHouse, cellCoords, pEaterType->DisplayOffset);
+			}
+
+			const auto& anims = pEaterType->Anims_Tiberiums[tiberiumIdx].GetElements(pEaterType->Anims);
+			const int animCount = static_cast<int>(anims.size());
+
+			if (animCount == 0)
+				continue;
+
+			AnimTypeClass* pAnimType = nullptr;
+
+			switch (animCount)
+			{
+			case 1:
+				pAnimType = anims[0];
+				break;
+
+			case 8:
+				pAnimType = anims[facing];
+				break;
+
+			default:
+				pAnimType = anims[ScenarioClass::Instance->Random.RandomRanged(0, animCount - 1)];
+				break;
+			}
+
+			if (pAnimType)
+			{
+				const auto pAnim = GameCreate<AnimClass>(pAnimType, pos);
+				AnimExt::SetAnimOwnerHouseKind(pAnim, pThis->Owner, nullptr, false, true);
+
+				if (pEaterType->AnimMove)
+					pAnim->SetOwnerObject(pThis);
+			}
+		}
+	}
+
+	if (active && transDelay)
+		this->TiberiumEater_Timer.Start(pEaterType->TransDelay);
+}
+
 void TechnoExt::ExtData::UpdateShield()
 {
 	auto const pTypeExt = this->TypeExtData;

src/Ext/Techno/Body.cpp

@@ -589,6 +589,7 @@ void TechnoExt::ExtData::Serialize(T& Stm)
 		.Process(this->IsBeingChronoSphered)
 		.Process(this->KeepTargetOnMove)
 		.Process(this->LastSensorsMapCoords)
+		.Process(this->TiberiumEater_Timer)
 		.Process(this->AirstrikeTargetingMe)
 		;
 }

src/Ext/Techno/Body.h

@@ -67,6 +67,7 @@ class TechnoExt
 		bool IsBeingChronoSphered;             // Set to true on units currently being ChronoSphered, does not apply to Ares-ChronoSphere'd buildings or Chrono reinforcements.
 		bool KeepTargetOnMove;
 		CellStruct LastSensorsMapCoords;
+		CDTimerClass TiberiumEater_Timer;
 
 		AirstrikeClass* AirstrikeTargetingMe;
 
@@ -112,6 +113,7 @@ class TechnoExt
 			, IsBeingChronoSphered { false }
 			, KeepTargetOnMove { false }
 			, LastSensorsMapCoords { CellStruct::Empty }
+			, TiberiumEater_Timer {}
 			, AirstrikeTargetingMe { nullptr }
 		{ }
 
@@ -121,6 +123,7 @@ class TechnoExt
 		bool CheckDeathConditions(bool isInLimbo = false);
 		void DepletedAmmoActions();
 		void EatPassengers();
+		void UpdateTiberiumEater();
 		void UpdateShield();
 		void UpdateOnTunnelEnter();
 		void UpdateOnTunnelExit();

src/Ext/Techno/Hooks.cpp

@@ -37,6 +37,7 @@ DEFINE_HOOK(0x4DA54E, FootClass_AI, 0x6)
 		pExt->UpdateTypeData_Foot();
 
 	pExt->UpdateWarpInDelay();
+	pExt->UpdateTiberiumEater();
 
 	return 0;
 }

src/Ext/TechnoType/Body.cpp

@@ -753,6 +753,20 @@ void TechnoTypeExt::ExtData::LoadFromINIFile(CCINIClass* const pINI)
 			this->PassengerDeletionType->LoadFromINI(pINI, pSection);
 	}
 
+	Nullable<int> transDelay;
+	transDelay.Read(exINI, pSection, "TiberiumEater.TransDelay");
+
+	if (transDelay.Get(-1) >= 0 && !this->TiberiumEaterType)
+		this->TiberiumEaterType = std::make_unique<TiberiumEaterTypeClass>();
+
+	if (this->TiberiumEaterType)
+	{
+		if (transDelay.isset() && transDelay.Get() < 0)
+			this->TiberiumEaterType.reset();
+		else
+			this->TiberiumEaterType->LoadFromINI(pINI, pSection);
+	}
+
 	Nullable<bool> isInterceptor;
 	isInterceptor.Read(exINI, pSection, "Interceptor");
 
@@ -996,6 +1010,8 @@ void TechnoTypeExt::ExtData::Serialize(T& Stm)
 		.Process(this->LandingDir)
 		.Process(this->DroppodType)
 
+		.Process(this->TiberiumEaterType)
+
 		.Process(this->Convert_HumanToComputer)
 		.Process(this->Convert_ComputerToHuman)
 

src/Ext/TechnoType/Body.h

@@ -13,6 +13,7 @@
 #include <New/Type/DigitalDisplayTypeClass.h>
 #include <New/Type/SelectBoxTypeClass.h>
 #include <New/Type/Affiliated/DroppodTypeClass.h>
+#include <New/Type/Affiliated/TiberiumEaterTypeClass.h>
 
 class Matrix3D;
 class ParticleSystemTypeClass;
@@ -62,6 +63,7 @@ class TechnoTypeExt
 		Valueable<ShieldTypeClass*> ShieldType;
 		std::unique_ptr<PassengerDeletionTypeClass> PassengerDeletionType;
 		std::unique_ptr<DroppodTypeClass> DroppodType;
+		std::unique_ptr<TiberiumEaterTypeClass> TiberiumEaterType;
 
 		Nullable<float> HarvesterDumpAmount;
 
@@ -556,6 +558,7 @@ class TechnoTypeExt
 			, SpawnHeight {}
 			, LandingDir {}
 			, DroppodType {}
+			, TiberiumEaterType {}
 
 			, Convert_HumanToComputer { }
 			, Convert_ComputerToHuman { }

src/New/Type/Affiliated/TiberiumEaterTypeClass.cpp

@@ -0,0 +1,80 @@
+#include "TiberiumEaterTypeClass.h"
+
+#include <Utilities/SavegameDef.h>
+#include <Utilities/TemplateDef.h>
+
+void TiberiumEaterTypeClass::LoadFromINI(CCINIClass* pINI, const char* pSection)
+{
+	INI_EX exINI(pINI);
+	char tempBuffer[32];
+
+	this->TransDelay.Read(exINI, pSection, "TiberiumEater.TransDelay");
+	this->CashMultiplier.Read(exINI, pSection, "TiberiumEater.CashMultiplier");
+	this->AmountPerCell.Read(exINI, pSection, "TiberiumEater.AmountPerCell");
+
+	for (size_t idx = 0; ; ++idx)
+	{
+		Nullable<Vector2D<int>> cell;
+		_snprintf_s(tempBuffer, sizeof(tempBuffer), "TiberiumEater.Cell%d", idx);
+		cell.Read(exINI, pSection, tempBuffer);
+
+		if (idx >= this->Cells.size())
+		{
+			if (!cell.isset())
+				break;
+
+			this->Cells.emplace_back(cell.Get().X * Unsorted::LeptonsPerCell, cell.Get().Y * Unsorted::LeptonsPerCell);
+		}
+		else
+		{
+			if (!cell.isset())
+				continue;
+
+			this->Cells[idx] = Vector2D<int> { cell.Get().X * Unsorted::LeptonsPerCell, cell.Get().Y * Unsorted::LeptonsPerCell };
+		}
+	}
+
+	this->Display.Read(exINI, pSection, "TiberiumEater.Display");
+	this->DisplayToHouse.Read(exINI, pSection, "TiberiumEater.DisplayToHouse");
+	this->DisplayOffset.Read(exINI, pSection, "TiberiumEater.DisplayOffset");
+	this->Anims.Read(exINI, pSection, "TiberiumEater.Anims");
+
+	for (size_t idx = 0; idx < 4; ++idx)
+	{
+		_snprintf_s(tempBuffer, sizeof(tempBuffer), "TiberiumEater.Anims.Tiberium%d", idx);
+		this->Anims_Tiberiums[idx].Read(exINI, pSection, tempBuffer);
+	}
+
+	this->AnimMove.Read(exINI, pSection, "TiberiumEater.AnimMove");
+}
+
+template <class T>
+bool TiberiumEaterTypeClass::Serialize(T& stm)
+{
+	return stm
+		.Process(this->TransDelay)
+		.Process(this->CashMultiplier)
+		.Process(this->AmountPerCell)
+		.Process(this->Cells)
+		.Process(this->Display)
+		.Process(this->DisplayToHouse)
+		.Process(this->DisplayOffset)
+		.Process(this->Anims)
+		.Process(this->Anims_Tiberiums)
+		.Process(this->AnimMove)
+		.Success();
+}
+
+#pragma region(save/load)
+
+bool TiberiumEaterTypeClass::Load(PhobosStreamReader& stm, bool registerForChange)
+{
+	return this->Serialize(stm);
+}
+
+bool TiberiumEaterTypeClass::Save(PhobosStreamWriter& stm) const
+{
+	return const_cast<TiberiumEaterTypeClass*>(this)->Serialize(stm);
+}
+
+#pragma endregion

src/New/Type/Affiliated/TiberiumEaterTypeClass.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <Utilities/Constructs.h>
+#include <Utilities/Enum.h>
+#include <Utilities/Template.h>
+
+class TiberiumEaterTypeClass
+{
+public:
+	Valueable<int> TransDelay { -1 };
+	Valueable<float>  CashMultiplier { 1.0 };
+	Valueable<int> AmountPerCell { 0 };
+	std::vector<Vector2D<int>> Cells { std::vector<Vector2D<int>>(1) };
+	Valueable<bool> Display { true };
+	Valueable<AffectedHouse> DisplayToHouse { AffectedHouse::All };
+	Valueable<Point2D> DisplayOffset { Point2D::Empty };
+	ValueableVector<AnimTypeClass*> Anims {};
+	NullableVector<AnimTypeClass*> Anims_Tiberiums[4] {};
+	Valueable<bool> AnimMove { true };
+
+	TiberiumEaterTypeClass() = default;
+
+	void LoadFromINI(CCINIClass* pINI, const char* pSection);
+	bool Load(PhobosStreamReader& stm, bool registerForChange);
+	bool Save(PhobosStreamWriter& stm) const;
+
+private:
+
+	template <typename T>
+	bool Serialize(T& stm);
+};