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);
}
}
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);
}
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);
}
public void AddAccess(ICombatGroup group, BattleManager.BattleSide battleSide)
{
battleReportWriter.SnapBattleAccess(battle.BattleId,
group.Owner,
group.TroopId,
group.Id,
battleSide == BattleManager.BattleSide.Attack);
}
public void AddAccess(BattleOwner owner, BattleManager.BattleSide battleSide)
{
battleReportWriter.SnapBattleAccess(battle.BattleId,
owner,
0,
0,
battleSide == BattleManager.BattleSide.Attack);
}
private void BattleUnitKilled(IBattleManager battle,
BattleManager.BattleSide objSide,
ICombatGroup combatGroup,
ICombatObject obj)
{
Append("**************Removing****************");
PrintCombatobject(obj);
}
private void BattleSkippedAttacker(IBattleManager battle,
BattleManager.BattleSide objSide,
ICombatGroup combatGroup,
ICombatObject obj)
{
Append("***************Skipping***************");
PrintCombatobject(obj);
Append("**************************************\n");
}
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);
}
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);
}
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");
}
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");
}
}
public void TestReduceStaminaWhenStructureDestroyed(BattleManager.BattleSide attackingSide,
BattleClass targetClassType,
bool targetIsDead,
bool isNoReductionType,
int expectedStamina)
{
var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
var target = Substitute.For <ICombatObject>();
target.Type.Returns((ushort)100);
target.ClassType.Returns(targetClassType);
target.IsDead.Returns(targetIsDead);
var objectTypeFactory = Substitute.For <IObjectTypeFactory>();
objectTypeFactory.IsObjectType("BattleNoStaminaReduction", 100).Returns(isNoReductionType);
fixture.Register(() => objectTypeFactory);
var battleFormulas = Substitute.For <IBattleFormulas>();
battleFormulas.GetStaminaStructureDestroyed(10, target).Returns((short)7);
fixture.Register(() => battleFormulas);
var battleManager = fixture.Freeze <IBattleManager>();
var staminaMonitor = fixture.Create <StaminaMonitor>();
staminaMonitor.Stamina = 10;
battleManager.ActionAttacked += Raise.Event <BattleManager.OnAttack>(battleManager,
attackingSide,
Substitute.For <ICombatGroup>(),
Substitute.For <ICombatObject>(),
Substitute.For <ICombatGroup>(),
target,
20m,
1,
1);
staminaMonitor.Stamina.Should().Be((short)expectedStamina);
}
private void BattleActionAttacked(IBattleManager battle,
BattleManager.BattleSide attackingSide,
ICombatGroup attackerGroup,
ICombatObject source,
ICombatGroup targetGroup,
ICombatObject target,
decimal damage,
int attackerCount,
int targetCount)
{
var packet = CreatePacket(battle, Command.BattleAttack);
packet.AddByte((byte)attackingSide);
packet.AddUInt32(attackerGroup.Id);
packet.AddUInt32(source.Id);
packet.AddUInt32(targetGroup.Id);
packet.AddUInt32(target.Id);
packet.AddFloat((float)damage);
packet.AddInt32(attackerCount);
packet.AddInt32(targetCount);
channel.Post(channelName, packet);
}
private void BattleOnActionAttacked(IBattleManager battle,
BattleManager.BattleSide attackingSide,
ICombatGroup attackerGroup,
ICombatObject attacker,
ICombatGroup targetGroup,
ICombatObject target,
decimal damage,
int attackerCount,
int targetCount)
{
if (attackingSide != BattleManager.BattleSide.Attack || attackerGroup.Owner.Type != BattleOwnerType.City)
{
return;
}
ICity attackingCity;
if (!gameObjectLocator.TryGetObjects(attackerGroup.Owner.Id, out attackingCity))
{
throw new Exception("Attacker city not found");
}
if (!attackingCity.Owner.IsInTribe)
{
return;
}
var tribeId = attackingCity.Owner.Tribesman.Tribe.Id;
if (tribeDamageDealt.ContainsKey(tribeId))
{
tribeDamageDealt[tribeId] += damage;
}
else
{
tribeDamageDealt[tribeId] = damage;
}
}
public void AddTribeToBattle(ITribe tribe, BattleManager.BattleSide side)
{
battleReportWriter.SnapTribeToBattle(battle.BattleId, tribe.Id, side == BattleManager.BattleSide.Attack);
}
private void BattleActionAttacked(IBattleManager battle,
BattleManager.BattleSide attackingSide,
ICombatGroup attackerGroup,
ICombatObject attacker,
ICombatGroup targetGroup,
ICombatObject target,
decimal damage,
int attackerCount,
int targetCount)
{
ICity city;
ITroopObject troopObject;
if (!gameObjectLocator.TryGetObjects(cityId, troopObjectId, out city, out troopObject))
{
throw new ArgumentException();
}
if (attackerGroup.Id == groupId && target.ClassType == BattleClass.Structure && target is ICombatStructure &&
target.IsDead)
{
// if our troop knocked down a building, we get the bonus.
bonus.Add(structureCsvFactory.GetCost(target.Type, target.Lvl) / 2);
IStructure structure = ((ICombatStructure)target).Structure;
object value;
if (structure.Properties.TryGet("Crop", out value))
{
if (value is int)
{
bonus.Crop += (int)value;
}
}
if (structure.Properties.TryGet("Gold", out value))
{
if (value is int)
{
bonus.Gold += (int)value;
}
}
if (structure.Properties.TryGet("Iron", out value))
{
if (value is int)
{
bonus.Iron += (int)value;
}
}
if (structure.Properties.TryGet("Wood", out value))
{
if (value is int)
{
bonus.Wood += (int)value;
}
}
if (structure.Properties.TryGet("Labor", out value))
{
if (value is int)
{
bonus.Labor += (int)value;
}
}
dbManager.Save(this);
}
}
public void NextObject_WhenCalled_CorrectAttackerIsReturned(int randomness, int attackerUpkeep, int defenderUpkeep, BattleManager.BattleSide side)
{
var random = Substitute.For <IBattleRandom>();
random.Next(Arg.Any <int>()).Returns(randomness);
BattleOrder battleOrder = new BattleOrder(random);
ICombatObject outCombatObject;
ICombatGroup outCombatGroup;
BattleManager.BattleSide foundInGroup;
var attackerObject = CreateCombatObject(0);
var attackerGroup = CreateGroup(attackerObject);
var attackerList = CreateList(attackerUpkeep, attackerGroup);
var defenderObject = CreateCombatObject(0);
var defenderGroup = CreateGroup(defenderObject);
var defenderList = CreateList(defenderUpkeep, defenderGroup);
var result = battleOrder.NextObject(0, attackerList, defenderList, out outCombatObject, out outCombatGroup, out foundInGroup);
result.Should().Be(true);
outCombatObject.Should().Be(side == BattleManager.BattleSide.Attack ? attackerObject : defenderObject);
foundInGroup.Should().Be(side);
random.Received(1).Next(defenderUpkeep + attackerUpkeep);
}
/// <summary>
/// Returns the next object from the primary group that should attack.
/// If primary group has no one able to attack, it will look into the secondary group instead.
/// </summary>
/// <returns>True if got an object from the current round. False if had to look into next round.</returns>
public bool NextObject(uint round,
ICombatList attacker,
ICombatList defender,
out ICombatObject outCombatObject,
out ICombatGroup outCombatGroup,
out BattleManager.BattleSide foundInGroup)
{
var attackerUpkeep = attacker.UpkeepNotParticipatedInRound(round);
var defenderUpkeep = defender.UpkeepNotParticipatedInRound(round);
if (attackerUpkeep == 0 && defenderUpkeep == 0)
{
attackerUpkeep = attacker.UpkeepNotParticipatedInRound(round + 1);
defenderUpkeep = defender.UpkeepNotParticipatedInRound(round + 1);
}
BattleManager.BattleSide sideAttack = random.Next(attackerUpkeep + defenderUpkeep) < attackerUpkeep
? BattleManager.BattleSide.Attack
: BattleManager.BattleSide.Defense;
var offensiveCombatList = sideAttack == BattleManager.BattleSide.Attack ? attacker : defender;
var defensiveCombatList = sideAttack == BattleManager.BattleSide.Attack ? defender : attacker;
var offensiveSide = sideAttack;
var defensiveSide = sideAttack == BattleManager.BattleSide.Attack
? BattleManager.BattleSide.Defense
: BattleManager.BattleSide.Attack;
// Look into offenside combat list first
ICombatObject outCombatObjectAttacker;
ICombatGroup outCombatGroupAttacker;
if (NextObjectFromList(round, offensiveCombatList, out outCombatObjectAttacker, out outCombatGroupAttacker))
{
foundInGroup = offensiveSide;
outCombatGroup = outCombatGroupAttacker;
outCombatObject = outCombatObjectAttacker;
return(true);
}
// Couldnt find in the attacker so look in defense
ICombatObject outCombatObjectDefender;
ICombatGroup outCombatGroupDefender;
if (NextObjectFromList(round, defensiveCombatList, out outCombatObjectDefender, out outCombatGroupDefender))
{
foundInGroup = defensiveSide;
outCombatGroup = outCombatGroupDefender;
outCombatObject = outCombatObjectDefender;
return(true);
}
// Okay looks like both sides are done for this round. If we had an attacker
// then we return that, otherwise go to the defender
if (outCombatObjectAttacker != null)
{
foundInGroup = offensiveSide;
outCombatGroup = outCombatGroupAttacker;
outCombatObject = outCombatObjectAttacker;
}
else if (outCombatObjectDefender != null)
{
foundInGroup = defensiveSide;
outCombatGroup = outCombatGroupDefender;
outCombatObject = outCombatObjectDefender;
}
// If this happens then it means there is no one in the battle or the battle is prolly over
else
{
outCombatGroup = null;
outCombatObject = null;
foundInGroup = offensiveSide;
return(true);
}
return(false);
}
