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"); } }