CreateUnit refactoring / improvements

- Move parsing to separate class, pass a pointer to TechnoExt::CreateUnit function instead of large amount of parameters
- Fix an issue where CreateUnit.AIMission did not get correctly used
- Add CreateUnit.RequireOwner which aborts creation of unit if there is no owner set or the house has been defeated

Author: Starkku

Phobos.vcxproj

@@ -18,6 +18,7 @@
     </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="src\New\Type\Affiliated\CreateUnitTypeClass.cpp" />
     <ClCompile Include="src\Blowfish\blowfish.cpp" />
     <ClCompile Include="src\Blowfish\Hooks.Blowfish.cpp" />
     <ClCompile Include="src\Ext\Cell\Body.cpp" />
@@ -195,6 +196,7 @@
     <ClCompile Include="YRpp\StaticInits.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="src\New\Type\Affiliated\CreateUnitTypeClass.h" />
     <ClInclude Include="src\Blowfish\blowfish.h" />
     <ClInclude Include="src\Ext\Cell\Body.h" />
     <ClInclude Include="src\New\Entity\AttachEffectClass.h" />

docs/New-or-Enhanced-Logics.md

@@ -455,7 +455,7 @@ Shield.InheritStateOnReplace=false          ; boolean
 ![image](_static/images/animToUnit.gif)
 
 - Animations can now create (or "convert" to) any unit (vehicles, aircraft and infantry) when they end via `CreateUnit`. This offers more settings than `MakeInfantry` does for infantry.
-  - `CreateUnit.Owner` determines which house will own the created unit. This only works as expected if the animation has owner set.
+  - `CreateUnit.Owner` determines which house will own the created unit. This only works as expected if the animation has owner set. If there is no owner or the owner house has been defeated, the created unit will be owned by first house from Civilian side unless `CreateUnit.RequireOwner` is set to true in which case no unit will be created.
     - Vehicle [destroy animations](Fixed-or-Improved-Logics.md#destroy-animations), animations from Warhead `AnimList/SplashList` and map trigger action `41 Play Anim At` will have the owner set correctly.
     - `CreateUnit.RemapAnim`, if set to true, will cause the animation to be drawn in unit palette and remappable to owner's team color.
   - `CreateUnit.Mission` determines the initial mission of the created unit. This can be overridden for AI players by setting `CreateUnit.AIMission`.
@@ -473,6 +473,7 @@ In `artmd.ini`:
 [SOMEANIM]                             ; AnimationType
 CreateUnit=                            ; TechnoType
 CreateUnit.Owner=Victim                ; Owner house kind, Invoker/Killer/Victim/Civilian/Special/Neutral/Random
+CreateUnit.RequireOwner=false          ; boolean
 CreateUnit.RemapAnim=false             ; boolean
 CreateUnit.Mission=Guard               ; MissionType
 CreateUnit.AIMission=                  ; MissionType

src/Ext/Anim/Body.cpp

@@ -70,7 +70,7 @@ bool AnimExt::SetAnimOwnerHouseKind(AnimClass* pAnim, HouseClass* pInvoker, Hous
 {
 	auto const pTypeExt = AnimTypeExt::ExtMap.Find(pAnim->Type);
 	bool makeInf = pAnim->Type->MakeInfantry > -1;
-	bool createUnit = pTypeExt->CreateUnit.Get();
+	bool createUnit = pTypeExt->CreateUnitType != nullptr;
 	auto ownerKind = OwnerHouseKind::Default;
 	HouseClass* pDefaultOwner = nullptr;
 
@@ -83,7 +83,7 @@ bool AnimExt::SetAnimOwnerHouseKind(AnimClass* pAnim, HouseClass* pInvoker, Hous
 		ownerKind = pTypeExt->MakeInfantryOwner;
 
 	if (createUnit)
-		ownerKind = pTypeExt->CreateUnit_Owner;
+		ownerKind = pTypeExt->CreateUnitType->Owner;
 
 	auto newOwner = HouseExt::GetHouseKind(ownerKind, true, pDefaultOwner, pInvoker, pVictim);
 
@@ -96,7 +96,7 @@ bool AnimExt::SetAnimOwnerHouseKind(AnimClass* pAnim, HouseClass* pInvoker, Hous
 			isRemappable = true;
 
 		if (createUnit)
-			isRemappable = pTypeExt->CreateUnit_RemapAnim;
+			isRemappable = pTypeExt->CreateUnitType->RemapAnim;
 
 		if (isRemappable && !newOwner->Defeated)
 			pAnim->LightConvert = ColorScheme::Array[newOwner->ColorSchemeIndex]->LightConvert;

src/Ext/Anim/Hooks.AnimCreateUnit.cpp

@@ -45,7 +45,7 @@ DEFINE_HOOK(0x4226F0, AnimClass_CTOR_CreateUnit_MarkOccupationBits, 0x6)
 
 	auto const pTypeExt = AnimTypeExt::ExtMap.Find(pThis->Type);
 
-	if (pTypeExt->CreateUnit.Get())
+	if (pTypeExt->CreateUnitType)
 		pThis->MarkAllOccupationBits(pThis->GetCell()->GetCoordsWithBridge());
 
 	return 0; //return (pThis->Type->MakeInfantry != -1) ? 0x423BD6 : 0x423C03;
@@ -57,31 +57,26 @@ DEFINE_HOOK(0x424932, AnimClass_AI_CreateUnit_ActualEffects, 0x6)
 
 	auto const pTypeExt = AnimTypeExt::ExtMap.Find(pThis->Type);
 
-	if (auto const pUnitType = pTypeExt->CreateUnit.Get())
+	if (auto const pCreateUnit = pTypeExt->CreateUnitType.get())
 	{
+		auto const pUnitType = pCreateUnit->Type;
 		auto const pExt = AnimExt::ExtMap.Find(pThis);
 		pThis->UnmarkAllOccupationBits(pThis->GetCell()->GetCoordsWithBridge());
 
-		auto facing = pTypeExt->CreateUnit_RandomFacing
-			? static_cast<DirType>(ScenarioClass::Instance->Random.RandomRanged(0, 255)) : pTypeExt->CreateUnit_Facing;
+		auto facing = pCreateUnit->RandomFacing
+			? static_cast<DirType>(ScenarioClass::Instance->Random.RandomRanged(0, 255)) : pCreateUnit->Facing;
 
-		auto const primaryFacing = pTypeExt->CreateUnit_InheritDeathFacings && pExt->FromDeathUnit ? pExt->DeathUnitFacing : facing;
+		auto const primaryFacing = pCreateUnit->InheritDeathFacings && pExt->FromDeathUnit ? pExt->DeathUnitFacing : facing;
 		DirType* secondaryFacing = nullptr;
-		Mission* missionAI = nullptr;
 
-		if (pUnitType->WhatAmI() == AbstractType::UnitType && pUnitType->Turret && pExt->FromDeathUnit && pExt->DeathUnitHasTurret && pTypeExt->CreateUnit_InheritTurretFacings)
+		if (pUnitType->WhatAmI() == AbstractType::UnitType && pUnitType->Turret && pExt->FromDeathUnit && pExt->DeathUnitHasTurret && pCreateUnit->InheritTurretFacings)
 		{
 			auto dir = pExt->DeathUnitTurretFacing.GetDir();
 			secondaryFacing = &dir;
-			Debug::Log("CreateUnit: Using stored turret facing %d\n", pExt->DeathUnitTurretFacing.GetFacing<256>());
+			Debug::Log("CreateUnit: Using stored turret facing %d from anim [%s]\n", pExt->DeathUnitTurretFacing.GetFacing<256>(), pThis->Type->get_ID());
 		}
 
-		if (pTypeExt->CreateUnit_AIMission.isset())
-			missionAI = &pTypeExt->CreateUnit_AIMission;
-
-		TechnoTypeExt::CreateUnit(pUnitType, pThis->Location, primaryFacing, secondaryFacing, pThis->Owner, pExt->Invoker, pExt->InvokerHouse,
-			pTypeExt->CreateUnit_SpawnAnim, pTypeExt->CreateUnit_SpawnHeight, pTypeExt->CreateUnit_AlwaysSpawnOnGround, pTypeExt->CreateUnit_ConsiderPathfinding,
-			pTypeExt->CreateUnit_SpawnParachutedInAir, pTypeExt->CreateUnit_Mission, missionAI);
+		TechnoTypeExt::CreateUnit(pCreateUnit, primaryFacing, secondaryFacing, pThis->Location, pThis->Owner, pExt->Invoker, pExt->InvokerHouse);
 	}
 
 	return (pThis->Type->MakeInfantry != -1) ? 0x42493E : 0x424B31;

src/Ext/AnimType/Body.cpp

@@ -61,15 +61,18 @@ void AnimTypeExt::ProcessDestroyAnims(UnitClass* pThis, TechnoClass* pKiller)
 			pAnimExt->SetInvoker(pThis);
 			pAnimExt->FromDeathUnit = true;
 
-			if (pAnimTypeExt->CreateUnit_InheritDeathFacings.Get())
-				pAnimExt->DeathUnitFacing = facing;
-
-			if (pAnimTypeExt->CreateUnit_InheritTurretFacings.Get())
+			if (auto const pCreateUnit = pAnimTypeExt->CreateUnitType.get())
 			{
-				if (pThis->HasTurret())
+				if (pCreateUnit->InheritDeathFacings)
+					pAnimExt->DeathUnitFacing = facing;
+
+				if (pCreateUnit->InheritTurretFacings)
 				{
-					pAnimExt->DeathUnitHasTurret = true;
-					pAnimExt->DeathUnitTurretFacing = pThis->SecondaryFacing.Current();
+					if (pThis->HasTurret())
+					{
+						pAnimExt->DeathUnitHasTurret = true;
+						pAnimExt->DeathUnitTurretFacing = pThis->SecondaryFacing.Current();
+					}
 				}
 			}
 		}
@@ -83,20 +86,6 @@ void AnimTypeExt::ExtData::LoadFromINIFile(CCINIClass* pINI)
 	INI_EX exINI(pINI);
 
 	this->Palette.LoadFromINI(pINI, pID, "CustomPalette");
-	this->CreateUnit.Read(exINI, pID, "CreateUnit");
-	this->CreateUnit_Facing.Read(exINI, pID, "CreateUnit.Facing");
-	this->CreateUnit_InheritDeathFacings.Read(exINI, pID, "CreateUnit.InheritFacings");
-	this->CreateUnit_InheritTurretFacings.Read(exINI, pID, "CreateUnit.InheritTurretFacings");
-	this->CreateUnit_RemapAnim.Read(exINI, pID, "CreateUnit.RemapAnim");
-	this->CreateUnit_Mission.Read(exINI, pID, "CreateUnit.Mission");
-	this->CreateUnit_AIMission.Read(exINI, pID, "CreateUnit.AIMission");
-	this->CreateUnit_Owner.Read(exINI, pID, "CreateUnit.Owner");
-	this->CreateUnit_RandomFacing.Read(exINI, pID, "CreateUnit.RandomFacing");
-	this->CreateUnit_AlwaysSpawnOnGround.Read(exINI, pID, "CreateUnit.AlwaysSpawnOnGround");
-	this->CreateUnit_SpawnParachutedInAir.Read(exINI, pID, "CreateUnit.SpawnParachutedInAir");
-	this->CreateUnit_ConsiderPathfinding.Read(exINI, pID, "CreateUnit.ConsiderPathfinding");
-	this->CreateUnit_SpawnAnim.Read(exINI, pID, "CreateUnit.SpawnAnim");
-	this->CreateUnit_SpawnHeight.Read(exINI, pID, "CreateUnit.SpawnHeight");
 	this->XDrawOffset.Read(exINI, pID, "XDrawOffset");
 	this->HideIfNoOre_Threshold.Read(exINI, pID, "HideIfNoOre.Threshold");
 	this->Layer_UseObjectLayer.Read(exINI, pID, "Layer.UseObjectLayer");
@@ -130,27 +119,30 @@ void AnimTypeExt::ExtData::LoadFromINIFile(CCINIClass* pINI)
 	this->LargeFireAnims.Read(exINI, pID, "LargeFireAnims");
 	this->LargeFireChances.Read(exINI, pID, "LargeFireChances");
 	this->LargeFireDistances.Read(exINI, pID, "LargeFireDistances");
+
+	// Parasitic types
+	Nullable<TechnoTypeClass*> createUnit;
+	createUnit.Read(exINI, pID, "CreateUnit");
+
+	if (createUnit)
+	{
+		if (this->CreateUnitType == nullptr)
+			this->CreateUnitType = std::make_unique<CreateUnitTypeClass>();
+
+		this->CreateUnitType->LoadFromINI(pINI, pID);
+	}
+	else if (createUnit.isset())
+	{
+		this->CreateUnitType.reset();
+	}
 }
 
 template <typename T>
 void AnimTypeExt::ExtData::Serialize(T& Stm)
 {
 	Stm
 		.Process(this->Palette)
-		.Process(this->CreateUnit)
-		.Process(this->CreateUnit_Facing)
-		.Process(this->CreateUnit_InheritDeathFacings)
-		.Process(this->CreateUnit_RemapAnim)
-		.Process(this->CreateUnit_Mission)
-		.Process(this->CreateUnit_AIMission)
-		.Process(this->CreateUnit_InheritTurretFacings)
-		.Process(this->CreateUnit_Owner)
-		.Process(this->CreateUnit_RandomFacing)
-		.Process(this->CreateUnit_AlwaysSpawnOnGround)
-		.Process(this->CreateUnit_SpawnParachutedInAir)
-		.Process(this->CreateUnit_ConsiderPathfinding)
-		.Process(this->CreateUnit_SpawnAnim)
-		.Process(this->CreateUnit_SpawnHeight)
+		.Process(this->CreateUnitType)
 		.Process(this->XDrawOffset)
 		.Process(this->HideIfNoOre_Threshold)
 		.Process(this->Layer_UseObjectLayer)

src/Ext/AnimType/Body.h

@@ -2,10 +2,12 @@
 
 #include <AnimTypeClass.h>
 
+#include <New/Type/Affiliated//CreateUnitTypeClass.h>
 #include <Utilities/Container.h>
 #include <Utilities/Enum.h>
 #include <Utilities/Constructs.h>
 #include <Utilities/Template.h>
+
 class AnimTypeExt
 {
 public:
@@ -18,20 +20,7 @@ class AnimTypeExt
 	{
 	public:
 		CustomPalette Palette;
-		Valueable<TechnoTypeClass*> CreateUnit;
-		Valueable<DirType> CreateUnit_Facing;
-		Valueable<bool> CreateUnit_InheritDeathFacings;
-		Valueable<bool> CreateUnit_InheritTurretFacings;
-		Valueable<bool> CreateUnit_RemapAnim;
-		Valueable<bool> CreateUnit_RandomFacing;
-		Valueable<Mission> CreateUnit_Mission;
-		Nullable<Mission> CreateUnit_AIMission;
-		Valueable<OwnerHouseKind> CreateUnit_Owner;
-		Valueable<bool> CreateUnit_AlwaysSpawnOnGround;
-		Valueable<bool> CreateUnit_SpawnParachutedInAir;
-		Valueable<bool> CreateUnit_ConsiderPathfinding;
-		Valueable<AnimTypeClass*> CreateUnit_SpawnAnim;
-		Valueable<int> CreateUnit_SpawnHeight;
+		std::unique_ptr<CreateUnitTypeClass> CreateUnitType;
 		Valueable<int> XDrawOffset;
 		Valueable<int> HideIfNoOre_Threshold;
 		Nullable<bool> Layer_UseObjectLayer;
@@ -68,19 +57,7 @@ class AnimTypeExt
 
 		ExtData(AnimTypeClass* OwnerObject) : Extension<AnimTypeClass>(OwnerObject)
 			, Palette { CustomPalette::PaletteMode::Temperate }
-			, CreateUnit_Facing { DirType::North }
-			, CreateUnit_RandomFacing { true }
-			, CreateUnit_InheritDeathFacings { false }
-			, CreateUnit_InheritTurretFacings { false }
-			, CreateUnit_RemapAnim { false }
-			, CreateUnit_Mission { Mission::Guard }
-			, CreateUnit_AIMission {}
-			, CreateUnit_Owner { OwnerHouseKind::Victim }
-			, CreateUnit_AlwaysSpawnOnGround { false }
-			, CreateUnit_SpawnParachutedInAir { false }
-			, CreateUnit_ConsiderPathfinding { false }
-			, CreateUnit_SpawnAnim {}
-			, CreateUnit_SpawnHeight { -1 }
+			, CreateUnitType { nullptr }
 			, XDrawOffset { 0 }
 			, HideIfNoOre_Threshold { 0 }
 			, Layer_UseObjectLayer {}

src/Ext/TechnoType/Body.cpp

@@ -114,16 +114,24 @@ TechnoTypeClass* TechnoTypeExt::GetTechnoType(ObjectTypeClass* pType)
 	return nullptr;
 }
 
-TechnoClass* TechnoTypeExt::CreateUnit(TechnoTypeClass* pType, CoordStruct location, DirType facing, DirType* secondaryFacing, HouseClass* pOwner, TechnoClass* pInvoker, HouseClass* pInvokerHouse,
-	AnimTypeClass* pSpawnAnimType, int spawnHeight, bool alwaysOnGround, bool checkPathfinding, bool parachuteIfInAir, Mission mission, Mission* missionAI)
+TechnoClass* TechnoTypeExt::CreateUnit(CreateUnitTypeClass* pCreateUnit, DirType facing, DirType* secondaryFacing,
+	CoordStruct location, HouseClass* pOwner, TechnoClass* pInvoker, HouseClass* pInvokerHouse)
 {
+	auto const pType = pCreateUnit->Type;
 	auto const rtti = pType->WhatAmI();
 
 	if (rtti == AbstractType::BuildingType)
 		return nullptr;
 
-	HouseClass* decidedOwner = pOwner && !pOwner->Defeated
-		? pOwner : HouseClass::FindCivilianSide();
+	HouseClass* decidedOwner = pOwner;
+
+	if (!pOwner || pOwner->Defeated)
+	{
+		if (pCreateUnit->RequireOwner)
+			return nullptr;
+
+		decidedOwner = HouseClass::FindCivilianSide();
+	}
 
 	auto pCell = MapClass::Instance.TryGetCellAt(location);
 	auto const speedType = rtti != AbstractType::AircraftType ? pType->SpeedType : SpeedType::Wheel;
@@ -133,7 +141,7 @@ TechnoClass* TechnoTypeExt::CreateUnit(TechnoTypeClass* pType, CoordStruct locat
 	int baseHeight = location.Z;
 	bool inAir = location.Z >= Unsorted::CellHeight * 2;
 
-	if (checkPathfinding && (!pCell || !pCell->IsClearToMove(speedType, false, false, -1, mZone, -1, isBridge)))
+	if (pCreateUnit->ConsiderPathfinding && (!pCell || !pCell->IsClearToMove(speedType, false, false, -1, mZone, -1, isBridge)))
 	{
 		auto nCell = MapClass::Instance.NearByLocation(CellClass::Coord2Cell(location), speedType, -1, mZone,
 			isBridge, 1, 1, true, false, false, isBridge, CellStruct::Empty, false, false);
@@ -151,11 +159,11 @@ TechnoClass* TechnoTypeExt::CreateUnit(TechnoTypeClass* pType, CoordStruct locat
 	{
 		isBridge = allowBridges && pCell->ContainsBridge();
 		int bridgeZ = isBridge ? CellClass::BridgeHeight : 0;
-		int zCoord = alwaysOnGround ? INT32_MIN : baseHeight;
+		int zCoord = pCreateUnit->AlwaysSpawnOnGround ? INT32_MIN : baseHeight;
 		int cellFloorHeight = MapClass::Instance.GetCellFloorHeight(location) + bridgeZ;
 
-		if (!alwaysOnGround && spawnHeight >= 0)
-			location.Z = cellFloorHeight + spawnHeight;
+		if (!pCreateUnit->AlwaysSpawnOnGround && pCreateUnit->SpawnHeight >= 0)
+			location.Z = cellFloorHeight + pCreateUnit->SpawnHeight;
 		else
 			location.Z = Math::max(cellFloorHeight, zCoord);
 
@@ -165,12 +173,12 @@ TechnoClass* TechnoTypeExt::CreateUnit(TechnoTypeClass* pType, CoordStruct locat
 			bool parachuted = false;
 			pTechno->OnBridge = isBridge;
 
-			if (rtti != AbstractType::AircraftType && parachuteIfInAir && !alwaysOnGround && inAir)
+			if (rtti != AbstractType::AircraftType && pCreateUnit->SpawnParachutedInAir && !pCreateUnit->AlwaysSpawnOnGround && inAir)
 			{
 				parachuted = true;
 				success = pTechno->SpawnParachuted(location);
 			}
-			else if (!pCell->GetBuilding() || !checkPathfinding)
+			else if (!pCell->GetBuilding() || !pCreateUnit->ConsiderPathfinding)
 			{
 				++Unsorted::ScenarioInit;
 				success = pTechno->Unlimbo(location, facing);
@@ -186,16 +194,16 @@ TechnoClass* TechnoTypeExt::CreateUnit(TechnoTypeClass* pType, CoordStruct locat
 				if (secondaryFacing)
 					pTechno->SecondaryFacing.SetCurrent(DirStruct(*secondaryFacing));
 
-				if (pSpawnAnimType)
+				if (pCreateUnit->SpawnAnim)
 				{
-					auto const pAnim = GameCreate<AnimClass>(pSpawnAnimType, location);
+					auto const pAnim = GameCreate<AnimClass>(pCreateUnit->SpawnAnim, location);
 					AnimExt::SetAnimOwnerHouseKind(pAnim, pInvokerHouse, nullptr, false, true);
 					AnimExt::ExtMap.Find(pAnim)->SetInvoker(pInvoker, pInvokerHouse);
 				}
 
 				if (!pTechno->InLimbo)
 				{
-					if (!alwaysOnGround)
+					if (!pCreateUnit->AlwaysSpawnOnGround)
 					{
 						inAir = pTechno->IsInAir();
 						if (auto const pFlyLoco = locomotion_cast<FlyLocomotionClass*>(pTechno->Locomotor))
@@ -235,12 +243,12 @@ TechnoClass* TechnoTypeExt::CreateUnit(TechnoTypeClass* pType, CoordStruct locat
 						}
 					}
 
-					auto newMission = mission;
+					auto newMission = pCreateUnit->UnitMission;
 
-					if (!decidedOwner->IsControlledByHuman() && missionAI)
-						newMission = *missionAI;
+					if (!decidedOwner->IsControlledByHuman() && pCreateUnit->AIUnitMission.isset())
+						newMission = pCreateUnit->AIUnitMission;
 
-					pTechno->QueueMission(mission, false);
+					pTechno->QueueMission(newMission, false);
 				}
 
 				if (!decidedOwner->Type->MultiplayPassive)

src/Ext/TechnoType/Body.h

@@ -14,6 +14,7 @@
 #include <New/Type/SelectBoxTypeClass.h>
 #include <New/Type/Affiliated/DroppodTypeClass.h>
 #include <New/Type/Affiliated/TiberiumEaterTypeClass.h>
+#include <New/Type/Affiliated/CreateUnitTypeClass.h>
 
 class Matrix3D;
 class ParticleSystemTypeClass;
@@ -698,9 +699,8 @@ class TechnoTypeExt
 	static void ApplyTurretOffset(TechnoTypeClass* pType, Matrix3D* mtx, double factor = 1.0);
 	static TechnoTypeClass* GetTechnoType(ObjectTypeClass* pType);
 
-	static TechnoClass* CreateUnit(TechnoTypeClass* pType, CoordStruct location, DirType facing, DirType* secondaryFacing, HouseClass* pOwner,
-		TechnoClass* pInvoker = nullptr, HouseClass* pInvokerHouse = nullptr, AnimTypeClass* pSpawnAnimType = nullptr, int spawnHeight = -1,
-		bool alwaysOnGround = false, bool checkPathfinding = false, bool parachuteIfInAir = false, Mission mission = Mission::Guard, Mission* missionAI = nullptr);
+	static TechnoClass* CreateUnit(CreateUnitTypeClass* pCreateUnit, DirType facing, DirType* secondaryFacing,
+	CoordStruct location, HouseClass* pOwner, TechnoClass* pInvoker, HouseClass* pInvokerHouse);
 
 	// Ares 0.A
 	static const char* GetSelectionGroupID(ObjectTypeClass* pType);