private void PrintCombatobject(ICombatObject co)
{
if (co is AttackCombatUnit)
{
var unit = co as AttackCombatUnit;
Append("Team[Atk] Unit[" + co.Id + "] Formation[" + unit.Formation + "] Type[" +
unitFactory.GetName(unit.Type, 1) + "] HP[" + unit.Hp + "]");
}
else if (co is DefenseCombatUnit)
{
var unit = co as DefenseCombatUnit;
Append("Team[Def] Unit[" + co.Id + "] Formation[" + unit.Formation + "] Type[" +
unitFactory.GetName(unit.Type, 1) + "] HP[" + unit.Hp + "]");
}
else if (co is CombatStructure)
{
var cs = co as CombatStructure;
Append("Team[Def] Structure[" + co.Id + "] Type[" +
structureCsvFactory.GetName(cs.Structure.Type, cs.Structure.Lvl) + "] HP[" + cs.Hp +
"]");
}
else if (co is BarbarianTribeCombatUnit)
{
var unit = co as BarbarianTribeCombatUnit;
Append("Team[Def] Unit[" + co.Id + "] Type[" +
unitFactory.GetName(unit.Type, 1) + "] HP[" + unit.Hp + "]");
}
}
private void MainBattleOnUnitKilled(IBattleManager battle,
BattleManager.BattleSide combatObjectSide,
ICombatGroup combatGroup,
ICombatObject combatObject,
int count)
{
IStronghold stronghold;
if (!gameObjectLocator.TryGetObjects(strongholdId, out stronghold))
{
throw new Exception("Stronghold not found");
}
var defensiveMeter = battle.GetProperty <decimal>("defense_stronghold_meter");
var offensiveMeter = battle.GetProperty <decimal>("offense_stronghold_meter");
if (combatObjectSide == BattleManager.BattleSide.Attack)
{
offensiveMeter -= combatObject.Stats.NormalizedCost * count;
}
else
{
defensiveMeter -= combatObject.Stats.NormalizedCost * count;
}
battle.SetProperty("defense_stronghold_meter", defensiveMeter);
battle.SetProperty("offense_stronghold_meter", offensiveMeter);
}
private void BattleActionAttacked(IBattleManager battle,
BattleManager.BattleSide attackingside,
ICombatGroup attackerGroup,
ICombatObject attacker,
ICombatGroup targetGroup,
ICombatObject target,
decimal damage,
int attackerCount,
int targetCount)
{
// Check if the unit being attacked belongs to us
if (targetGroup.Id != combatGroup.Id)
{
return;
}
// Check to see if player should retreat
var remainingUnitCount = troopStub.TotalCount;
// Don't return if we haven't fulfilled the minimum rounds or not below the threshold
if (target.RoundsParticipated < Config.battle_retreat_min_rounds || remainingUnitCount == 0 ||
remainingUnitCount > troopStub.RetreatCount)
{
return;
}
battle.Remove(combatGroup,
attackingside == BattleManager.BattleSide.Attack
? BattleManager.BattleSide.Defense
: BattleManager.BattleSide.Attack,
ReportState.Retreating);
}
public virtual Resource GetRewardResource(ICombatObject attacker, ICombatObject defender)
{
// calculate total carry, if 10 units with 10 carry, which should be 100
int totalCarry = attacker.Stats.Carry * attacker.Count;
// if carry is 100 and % is 5, then count = 5;
int lootPerRound = attacker.LootPerRound();
int count = Math.Max(1, totalCarry * lootPerRound / 100);
// spaceleft is the maxcarry.
var spaceLeft = new Resource(totalCarry / 1,
totalCarry / 2,
totalCarry / Config.battle_loot_resource_iron_ratio,
totalCarry / 1,
totalCarry / Config.battle_loot_resource_labor_ratio);
// maxcarry minus current resource is the empty space left.
spaceLeft.Subtract(attacker.Loot);
// returning lesser value between the count and the empty space.
return(new Resource(Math.Min(count / 1, spaceLeft.Crop),
Math.Min(count / 2, spaceLeft.Gold),
Math.Min(count / Config.battle_loot_resource_iron_ratio, spaceLeft.Iron),
Math.Min(count / 1, spaceLeft.Wood)));
}
private void BattleActionAttacked(IBattleManager battle,
BattleManager.BattleSide attackingside,
ICombatGroup attackerGroup,
ICombatObject attacker,
ICombatGroup targetGroup,
ICombatObject target,
decimal damage,
int attackerCount,
int targetCount)
{
if (target.ClassType == BattleClass.Structure && attackingside == BattleManager.BattleSide.Attack && target.IsDead)
{
if (objectTypeFactory.IsObjectType("BattleNoStaminaReduction", target.Type))
{
return;
}
if (objectTypeFactory.IsObjectType("BattleNoStaminaReductionEarlyLevels", target.Type) && target.Lvl < 5)
{
return;
}
Stamina = BattleFormulas.GetStaminaStructureDestroyed(Stamina, target);
}
}
public virtual decimal GetAttackScore(ICombatObject attacker, ICombatObject target, uint round)
{
decimal attackBonus = attacker.AttackBonus(target);
decimal modifier = (decimal)GetDmgModifier(attacker, target, round);
return(modifier * (1 + attackBonus));
}
private void BattleUnitKilled(IBattleManager battle,
BattleManager.BattleSide objSide,
ICombatGroup combatGroup,
ICombatObject obj)
{
Append("**************Removing****************");
PrintCombatobject(obj);
}
public void GiveDefendersRewards(ICombatObject attacker, int defensePoints, Resource loot)
{
if (!loot.Empty)
{
barbarianTribe.BeginUpdate();
barbarianTribe.Resource.Add(loot);
barbarianTribe.EndUpdate();
}
}
public virtual short GetStaminaStructureDestroyed(short stamina, ICombatObject combatStructure)
{
if (combatStructure.Stats.Base.Armor != ArmorType.Building3)
{
return(stamina);
}
return(Math.Max((short)0, (short)(stamina - Config.battle_stamina_destroyed_deduction)));
}
private void BattleSkippedAttacker(IBattleManager battle,
BattleManager.BattleSide objSide,
ICombatGroup combatGroup,
ICombatObject obj)
{
Append("***************Skipping***************");
PrintCombatobject(obj);
Append("**************************************\n");
}
private bool NextObjectFromList(uint round,
IList <ICombatGroup> combatGroups,
out ICombatObject outObj,
out ICombatGroup outGroup)
{
if (combatGroups.Count == 0)
{
outGroup = null;
outObj = null;
return(false);
}
int startGroupIdx = random.Next(combatGroups.Count);
// Find any objects that are still in the current round
for (var combatGroupIdx = 0; combatGroupIdx < combatGroups.Count; combatGroupIdx++)
{
var combatGroup = combatGroups[(startGroupIdx + combatGroupIdx) % combatGroups.Count];
int startObjIdx = random.Next(combatGroup.Count);
for (var combatObjIdx = 0; combatObjIdx < combatGroup.Count; combatObjIdx++)
{
outObj = combatGroup[(startObjIdx + combatObjIdx) % combatGroup.Count];
if (outObj.IsWaitingToJoinBattle || outObj.HasAttacked(round))
{
continue;
}
// We've found an object thats still in the current round
// so we're done
outGroup = combatGroup;
return(true);
}
}
// No object in the current round, get a random object from the group we got above
// We loop incase the group is empty then it continues onto the next one
for (var combatGroupIdx = 0; combatGroupIdx < combatGroups.Count; combatGroupIdx++)
{
var combatGroup = combatGroups[(startGroupIdx + combatGroupIdx) % combatGroups.Count];
if (combatGroup.Count == 0)
{
continue;
}
outGroup = combatGroup;
outObj = combatGroup[random.Next(combatGroup.Count)];
return(false);
}
outGroup = null;
outObj = null;
return(false);
}
private void BattleManagerOnGroupUnitRemoved(IBattleManager battle,
BattleManager.BattleSide combatObjectSide,
ICombatGroup combatGroup,
ICombatObject combatObject)
{
var packet = CreatePacket(battle, Command.BattleGroupUnitRemoved);
packet.AddUInt32(combatGroup.Id);
packet.AddUInt32(combatObject.Id);
channel.Post(channelName, packet);
}
public override bool InRange(ICombatObject obj)
{
if (obj.ClassType == BattleClass.Unit)
{
return(tileLocator.IsOverlapping(obj.Location(), obj.Size, obj.AttackRadius(),
Structure.PrimaryPosition, Structure.Size, Structure.Stats.Base.Radius));
}
throw new Exception(string.Format("Why is a structure trying to kill a unit of type {0}?",
obj.GetType().FullName));
}
public virtual decimal GetAttackerDmgToDefender(ICombatObject attacker, ICombatObject target, uint round)
{
decimal atk = attacker.Stats.Atk;
decimal rawDmg = (atk * attacker.Count);
decimal attackBonus = attacker.AttackBonus(target);
decimal defenseBonus = target.DefenseBonus(attacker);
decimal modifier = (decimal)GetDmgModifier(attacker, target, round);
rawDmg = modifier * rawDmg * (1 + attackBonus) / (1 + defenseBonus);
return(rawDmg > ushort.MaxValue ? ushort.MaxValue : rawDmg);
}
public void GiveDefendersRewards(ICombatObject attacker, int defensePoints, Resource loot)
{
if (stronghold.Tribe != null && defensePoints > 0)
{
stronghold.Tribe.DefensePoint += defensePoints;
}
if (defensePoints > 0)
{
attacker.ReceiveReward(defensePoints, null);
}
}
public void AttackBonus_WhenValueIs101_ShouldReturn100(ushort targetType, ICombatObject target, StubCityCombatObject cityCombatObject)
{
List <Effect> effects = new List <Effect>
{
new Effect {
Value = new object[] { (int)targetType, 101 }
},
};
target.Type.Returns(targetType);
cityCombatObject.City.Technologies.GetEffects(EffectCode.AttackBonus).Returns(effects);
cityCombatObject.AttackBonus(target).Should().Be(1m);
}
public void GetNumberOfHits_WhenObjectIsNotSplashEvery200(ICombatObject attacker, ICombatList defenderCombatList)
{
var objectTypeFactory = Substitute.For <IObjectTypeFactory>();
var fixture = FixtureHelper.Create();
fixture.Register(() => objectTypeFactory);
var battleFormulas = fixture.Create <BattleFormulas>();
objectTypeFactory.IsObjectType(string.Empty, 0).ReturnsForAnyArgs(false);
attacker.Stats.Splash.Returns((byte)2);
defenderCombatList.UpkeepExcludingWaitingToJoinBattle.Returns(800);
battleFormulas.GetNumberOfHits(attacker, defenderCombatList).Should().Be(2);
}
private void WriteResult(ICombatObject obj)
{
sw.Write("{0},{1},{2},{3},{4},{5},{6},{7},{8}",
obj.DmgDealt,
obj.DmgRecv,
obj.HitDealt,
obj.HitRecv,
obj.MaxDmgDealt,
obj.MinDmgDealt == ushort.MaxValue ? 0 : obj.MinDmgDealt,
obj.MaxDmgRecv,
obj.MinDmgRecv == ushort.MaxValue ? 0 : obj.MinDmgRecv,
obj.Count);
}
public void RemoveLoot(IBattleManager battleManager, int attackIndex, ICombatObject attacker, ICombatObject defender, out Resource actualLoot)
{
if (attackIndex != 0)
{
actualLoot = new Resource();
return;
}
var loot = battleFormulas.GetRewardResource(attacker, defender);
barbarianTribe.BeginUpdate();
barbarianTribe.Resource.Subtract(loot, out actualLoot);
barbarianTribe.EndUpdate();
}
private void BmUnitRemoved2(IBattleManager battle,
BattleManager.BattleSide objSide,
ICombatGroup group,
ICombatObject obj)
{
deadObject = obj;
if (obj is AttackCombatUnit)
{
if (sw != null)
{
WriteResult(obj);
}
}
}
private void BattleUnitKilled(IBattleManager battle,
BattleManager.BattleSide objSide,
ICombatGroup group,
ICombatObject obj)
{
deadObject = obj;
if (obj is DefenseCombatUnit)
{
if (sw != null)
{
WriteResult(obj);
}
}
}
/// <summary>
/// Gives alignment points when a structure is destroyed.
/// </summary>
private void BattleUnitKilled(IBattleManager battle,
BattleManager.BattleSide objSide,
ICombatGroup combatGroup,
ICombatObject obj)
{
// Keep track of our buildings destroyed HP
if (objSide != BattleManager.BattleSide.Defense || obj.ClassType != BattleClass.Structure)
{
return;
}
destroyedHp += (uint)obj.Stats.MaxHp;
AddAlignmentPoint(battle.Attackers, battle.Defenders, Config.battle_stamina_destroyed_deduction);
}
public void RemoveLoot(IBattleManager battleManager, int attackIndex, ICombatObject attacker, ICombatObject defender, out Resource actualLoot)
{
if (attackIndex != 0 || battleManager.Round < Config.battle_loot_begin_round)
{
actualLoot = new Resource();
return;
}
var loot = battleFormulas.GetRewardResource(attacker, defender);
city.BeginUpdate();
city.Resource.Subtract(loot, formula.HiddenResource(city, true), out actualLoot);
city.EndUpdate();
}
public override bool InRange(ICombatObject obj)
{
switch (obj.ClassType)
{
case BattleClass.Unit:
return(true);
case BattleClass.Structure:
return(tileLocator.IsOverlapping(Location(), Size, AttackRadius(),
obj.Location(), obj.Size, obj.AttackRadius()));
default:
throw new Exception(string.Format("Why is an attack combat unit trying to kill a unit of type {0}?", obj.GetType().FullName));
}
}
private void BattleActionAttacked(IBattleManager battle,
BattleManager.BattleSide attackingSide,
ICombatGroup attackerGroup,
ICombatObject source,
ICombatGroup defenderGroup,
ICombatObject target,
decimal damage,
int attackerCount,
int targetCount)
{
Append("*************Attacking****************");
PrintCombatobject(source);
PrintCombatobject(target);
//Append("**************************************\n");
}
public void GiveDefendersRewards(ICombatObject attacker, int defensePoints, Resource loot)
{
// Any loot being added to the defender is loot dropped by the attacker
// so give back to original city
if (!loot.Empty)
{
city.BeginUpdate();
city.Resource.Add(loot);
city.EndUpdate();
}
if (defensePoints > 0)
{
attacker.ReceiveReward(defensePoints, null);
}
}
/// <summary>
/// Writes an object that is leaving the battle without reporting on the other objects in the group
/// </summary>
public void WriteExitingObject(ICombatGroup group, bool isAttacker, ICombatObject combatObject)
{
WriteBeginReport();
uint reportedGroupId;
bool alreadySnapped = ReportedGroups.TryGetValue(group, out reportedGroupId);
if (!alreadySnapped)
{
reportedGroupId = battleReportWriter.SnapGroup(ReportId, group, ReportState.Staying, isAttacker);
ReportedGroups[group] = reportedGroupId;
}
battleReportWriter.SnapCombatObject(reportedGroupId, combatObject);
}
public void GetAttackScore_ShouldCalculateCorrectScore(
[FrozenMock] UnitModFactory unitModFactory,
ICombatObject attacker,
ICombatObject target,
BattleFormulas battleFormulas)
{
attacker.AttackBonus(target).Returns(0.2m);
attacker.Stats.Base.Weapon.Returns(WeaponType.Bow);
target.Stats.Base.Armor.Returns(ArmorType.Machine);
attacker.Type.Returns <ushort>(1);
target.Type.Returns <ushort>(2);
unitModFactory.GetModifier(1, 2).Returns(1.25);
var score = battleFormulas.GetAttackScore(attacker, target, 1);
score.Should().Be(1.5m);
}
private void BattleSkippedAttacker(IBattleManager battle,
BattleManager.BattleSide objSide,
ICombatGroup combatGroup,
ICombatObject source)
{
// Don't inform client for objs that simply never attack
if (source.Stats.Atk == 0)
{
return;
}
var packet = CreatePacket(battle, Command.BattleSkipped);
packet.AddUInt32(combatGroup.Id);
packet.AddUInt32(source.Id);
channel.Post(channelName, packet);
}
private void BattleActionAttacked(IBattleManager battleManager,
BattleManager.BattleSide attackingSide,
ICombatGroup attackerGroup,
ICombatObject source,
ICombatGroup targetGroup,
ICombatObject target,
decimal damage,
int attackerCount,
int targetCount)
{
ICity city;
if (!gameObjectLocator.TryGetObjects(cityId, out city))
{
return;
}
var cityCombatTarget = target as CityCombatObject;
// Check if we should retreat a unit
if (cityCombatTarget == null || attackingSide == BattleManager.BattleSide.Defense ||
cityCombatTarget.TroopStub.Station != city || cityCombatTarget.TroopStub.TotalCount <= 0 ||
cityCombatTarget.TroopStub.TotalCount > cityCombatTarget.TroopStub.RetreatCount)
{
return;
}
ITroopStub stub = cityCombatTarget.TroopStub;
// Remove the object from the battle
city.Battle.Remove(targetGroup, BattleManager.BattleSide.Defense, ReportState.Retreating);
stub.BeginUpdate();
stub.State = TroopState.Stationed;
stub.EndUpdate();
// Send the defender back to their city
var troopInitializer = troopInitializerFactory.CreateStationedTroopObjectInitializer(stub);
var retreatChainAction = actionFactory.CreateRetreatChainAction(stub.City.Id, troopInitializer);
var result = stub.City.Worker.DoPassive(stub.City, retreatChainAction, true);
if (result != Error.Ok)
{
throw new Exception("Unexpected failure when retreating a unit from city");
}
}
