public static void MoveArmyToTarget(UnitSystem.Army army, IMoveTarget target)
{
if (target != null)
{
OrdersManager.inst.MoveTo(army, target);
}
}
private static IMoveTarget GetNextTarget(Vector3 pos, float range)
{
IMoveTarget nextViking = GetNextViking(pos, range);
if (nextViking != null)
{
return(nextViking);
}
return(null);
}
public static void Prefix(UnitSystem.Army army)
{
if (originalPos.ContainsKey(army))
{
IMoveTarget target = army.moveTarget;
RemoveAssignment(target);
originalPos.Remove(army);
}
if (enemyAssignments.ContainsKey(army))
{
enemyAssignments.Remove(army);
}
}
private static bool LessThanMinimumAssignment(IMoveTarget target)
{
if (target != null && enemyAssignments.ContainsKey(target))
{
int points = enemyAssignments[target];
if ((target is SiegeMonster && points < ogreMinPoints) ||
(target is UnitSystem.Army && points < vikingMinPoints))
{
return(true);
}
}
return(false);
}
// Reassigns some allied soldiers in order to redistribute them.
private static void TryReassignAllArmy()
{
int armiesCount = UnitSystem.inst.ArmyCount();
for (int i = 0; i < armiesCount; i++)
{
UnitSystem.Army army = UnitSystem.inst.GetAmry(i);
IMoveTarget target = army.moveTarget;
Vector3 armyPos = army.GetPos();
bool alliedSoldier = army.TeamID() == 0 && army.armyType == UnitSystem.ArmyType.Default;
bool valid = !army.IsInvalid();
// Only valid allied soldiers can be reassigned.
if (!alliedSoldier || !valid)
{
continue;
}
IMoveTarget newTarget = GetTargetForArmy(army, settings.patrolRadius.Value);
// If the current target enemy is not a viking, disabled through settings, or invalid (dying or getting
// on a boat), always reassign.
bool targetIsViking = target != null && enemyAssignments.ContainsKey(target);
if (!targetIsViking || !TargetTypeEnabled(target) || TargetTypeInvalid(target))
{
MoveArmyToTarget(army, newTarget);
}
else if (target != null && target is UnitSystem.Army)
{
if (newTarget is UnitSystem.Army && !AtMinimumAssignment(target) &&
LessThanMinimumAssignment(newTarget))
{
MoveArmyToTarget(army, newTarget);
}
else if (newTarget is SiegeMonster && LessThanMinimumAssignment(newTarget))
{
// Ogres are always prioritized by always pulling soldiers away from viking squads.
MoveArmyToTarget(army, newTarget);
}
}
else if (target != null && target is SiegeMonster)
{
if (!AtMinimumAssignment(target) && LessThanMinimumAssignment(newTarget))
{
MoveArmyToTarget(army, newTarget);
}
}
}
}
private static void RemoveAssignment(IMoveTarget target)
{
if (target != null && enemyAssignments.ContainsKey(target))
{
if (target is SiegeMonster)
{
enemyAssignments[target] -= ogreAssignPoints;
}
else if (target is UnitSystem.Army)
{
enemyAssignments[target] -= vikingAssignPoints;
}
}
}
private static bool TargetTypeInvalid(IMoveTarget target)
{
UnitSystem.Army army = target as UnitSystem.Army;
SiegeMonster ogre = target as SiegeMonster;
if (ogre != null)
{
return(ogre.IsInvalid());
}
if (army != null)
{
return(army.IsInvalid());
}
return(true);
}
private static void RecordAssignment(IMoveTarget target)
{
// By adding a smaller number to every assignment to an ogre, the mod will try to assign more soldiers to
// it.
if (target != null && enemyAssignments.ContainsKey(target))
{
if (target is SiegeMonster)
{
enemyAssignments[target] += ogreAssignPoints;
}
else if (target is UnitSystem.Army)
{
enemyAssignments[target] += vikingAssignPoints;
}
}
}
private static int PointsToSoldiers(IMoveTarget target)
{
if (target != null && enemyAssignments.ContainsKey(target))
{
int points = enemyAssignments[target];
if (target is SiegeMonster)
{
return((points - ogreStartPoints) / ogreAssignPoints);
}
else if (target is UnitSystem.Army)
{
return((points - vikingStartPoints) / vikingAssignPoints);
}
}
return(-1);
}
public static void Prefix(IMoveableUnit moveableUnit, IMoveTarget moveTarget)
{
UnitSystem.Army army = moveableUnit as UnitSystem.Army;
if (army != null && army.TeamID() == 0 && army.armyType == UnitSystem.ArmyType.Default &&
!army.IsInvalid())
{
if (moveTarget != null && !(moveTarget is SiegeMonster) && !(moveTarget is UnitSystem.Army) &&
VikingInvasion())
{
originalPos[army] = moveTarget.GetPos();
}
string armyType = army.armyType.ToString();
RemoveAssignment(army.moveTarget);
RecordAssignment(moveTarget);
}
}
public static void Postfix(General __instance)
{
UnitSystem.Army army = __instance.army;
if (!settings.enabled.Value || army.TeamID() != 0 || army.armyType != UnitSystem.ArmyType.Default ||
army.IsInvalid())
{
return;
}
if (VikingInvasion())
{
try
{
if (!army.moving && ArmyIdle(army))
{
if (!originalPos.ContainsKey(army))
{
// At the beginning of an invasion, record the soldier squad's original position so it
// can be returned at the end.
originalPos[army] = army.GetPos();
}
AssignTargetToArmyAndMove(army, settings.patrolRadius.Value);
}
}
catch {}
}
else
{
if (originalPos.ContainsKey(army))
{
// At the end of a viking invasion, move all soldiers back to their original position.
IMoveTarget target = World.inst.GetCellData(originalPos[army]);
if (target != null)
{
OrdersManager.inst.MoveTo(army, target);
}
originalPos.Remove(army);
}
}
}
private static IMoveTarget GetNextViking(Vector3 pos, float range)
{
// Refer to SiegeMonster::ClosestMonster and UnitSystem::GetClosestDamageable.
float rangeSquared = range * range;
float currentClosestDistance = float.MaxValue;
int currentLowestAssigned = int.MaxValue;
IMoveTarget nextViking = null;
foreach (IMoveTarget viking in enemyAssignments.Keys)
{
UnitSystem.Army army = viking as UnitSystem.Army;
SiegeMonster ogre = viking as SiegeMonster;
if ((army == null && ogre == null) ||
(army != null && (army.IsInvalid() || !OnSameLandmass(pos, army.GetPos()))) ||
(ogre != null && (ogre.IsInvalid() || !OnSameLandmass(pos, ogre.GetPos()))) ||
!TargetTypeEnabled(viking))
{
continue;
}
// Select the closest viking squad or ogre with the least points to obey the assignment and distribution
// rules.
int assigned = enemyAssignments[viking];
float distanceSquared = Mathff.DistSqrdXZ(pos, viking.GetPos());
if (distanceSquared > rangeSquared || assigned > currentLowestAssigned)
{
continue;
}
if (nextViking == null || assigned < currentLowestAssigned ||
(distanceSquared < currentClosestDistance && assigned == currentLowestAssigned))
{
nextViking = viking;
currentClosestDistance = distanceSquared;
currentLowestAssigned = assigned;
}
}
return(nextViking);
}
private static bool TargetTypeEnabled(IMoveTarget target)
{
UnitSystem.Army army = target as UnitSystem.Army;
SiegeMonster ogre = target as SiegeMonster;
if (ogre != null)
{
return(settings.ogres.Value);
}
if (army != null)
{
if (army.armyType == UnitSystem.ArmyType.Default)
{
return(settings.defaultViking.Value);
}
if (army.armyType == UnitSystem.ArmyType.Thief)
{
return(settings.thieves.Value);
}
}
return(false);
}
private static IMoveTarget GetTargetForArmy(UnitSystem.Army army, float range)
{
if (!originalPos.ContainsKey(army))
{
return(null);
}
// Soldiers will patrol a radius around its starting point specified by range.
IMoveTarget target = null;
target = GetNextTarget(originalPos[army], range);
if (target == null)
{
// If there are no more targets, return the soldier squad to its original position if it's not already
// there.
if (originalPos[army] != army.GetPos())
{
target = World.inst.GetCellData(originalPos[army]);
}
}
return(target);
}
private static bool ArmyIdle(UnitSystem.Army army)
{
IMoveTarget target = army.moveTarget;
return(target == null || (!(target is SiegeMonster) && !(target is UnitSystem.Army)));
}
static void Postfix(TroopTransportShip __instance, IMoveTarget target, List <IMoveableUnit> ___loadTarget)
{
if (__instance.TeamID() != 0 || target == null || target.TeamID() == 0 || target.TeamID() == -1)
{
// Not an allied ship, no target, target is allied, or target is environment.
// Refer to UnitSystem::UpdatePathing for determining if target is an enemy.
return;
}
// Check if ship has archers.
bool shipHasArchers = false;
// Refer to TroopTransportShip::UpdateArmyPosition.
for (int i = 0; i < ___loadTarget.Count(); i++)
{
UnitSystem.Army army = ___loadTarget[i] as UnitSystem.Army;
if (army != null)
{
bool isArcher = army.armyType == UnitSystem.ArmyType.Archer;
if (isArcher)
{
shipHasArchers = true;
break;
}
}
}
if (shipHasArchers)
{
IMoveTarget archersTarget = null;
if (target is SiegeMonster)
{
SiegeMonster ogre = (SiegeMonster)target;
bool ogreTargettable = !ogre.IsInvalid();
bool ogreDead = ogre.IsDead();
if (ogreTargettable)
{
// Ogre is on land.
archersTarget = target;
}
else if (!ogreTargettable && !ogreDead)
{
// Ogre is on a ship. Assumption is that the closest ship is the ship it's on.
Vector3 pos = ogre.GetPos();
// Refer to ProjectileDefense::GetTarget
IProjectileHitable closestShip = ShipSystem.inst.GetClosestShipToAttack(pos, 1, 1f);
ShipBase shipBase = closestShip as ShipBase;
if (shipBase != null)
{
archersTarget = shipBase.GetComponentInParent <TroopTransportShip>();
}
}
}
else if (target is TroopTransportShip || target is IProjectileHitable)
{
archersTarget = target;
}
// Set archer target.
if (archersTarget != null)
{
for (int i = 0; i < ___loadTarget.Count(); i++)
{
UnitSystem.Army army = ___loadTarget[i] as UnitSystem.Army;
if (army != null)
{
bool isArcher = army.armyType == UnitSystem.ArmyType.Archer;
if (isArcher)
{
army.moveTarget = archersTarget;
}
}
}
}
}
}
