public void TestContributeNormal(
ICity city,
ICanDo canDo,
IStructure structure,
[FrozenMock] Formula formula,
Fixture fixture)
{
var cityResources = new LazyResource(1000, 1000, 1000, 1000, 1000);
var resource = new Resource(100, 20, 50, 80, 1);
var capacity = new Resource(500, 500, 500, 500, 5);
formula.GetContributeCapacity(structure).Returns(capacity);
Resource contributedResources = null;
city.Owner.Tribesman.Tribe.Contribute(123, Arg.Is <Resource>(contributed => contributed.CompareTo(resource) == 0))
.Returns(Error.Ok)
.AndDoes(callInfo =>
{
contributedResources = new Resource(callInfo.Arg <Resource>());
});
city.Id.Returns <uint>(1);
city.Resource.Returns(cityResources);
structure.GroupId.Returns <uint>(1);
structure.ObjectId.Returns <uint>(100);
structure.City.Returns(city);
city.Owner.IsInTribe.Returns(true);
city.Owner.PlayerId.Returns <uint>(123);
var locator = new GameObjectLocatorStub(city, city.Owner.Tribesman.Tribe, structure);
var action = new TribeContributeActiveAction(1, 100, resource, locator, formula, new LockerStub(locator))
{
WorkerObject = canDo,
IsDone = false
};
// Execute/Verify
action.Execute().Should().Be(Error.Ok);
cityResources.Crop.Value.Should().Be(900);
cityResources.Gold.Value.Should().Be(980);
cityResources.Iron.Value.Should().Be(950);
cityResources.Wood.Value.Should().Be(920);
cityResources.Labor.Value.Should().Be(999);
action.Callback(null);
contributedResources.Should().NotBeNull("Should have contributed resources");
contributedResources.Crop.Should().Be(100);
contributedResources.Gold.Should().Be(20);
contributedResources.Iron.Should().Be(50);
contributedResources.Wood.Should().Be(80);
contributedResources.Labor.Should().Be(1);
}
public void TestIgnoresTribesThatLeave()
{
var tribe1 = new Mock <ITribe>();
tribe1.SetupGet(p => p.Id).Returns(201);
var tribe2 = new Mock <ITribe>();
tribe2.SetupGet(p => p.Id).Returns(202);
var city1 = new Mock <ICity>();
city1.SetupGet(p => p.Id).Returns(101);
city1.SetupGet(p => p.Owner.IsInTribe).Returns(true);
city1.SetupGet(p => p.Owner.Tribesman.Tribe.Id).Returns(201);
var city2 = new Mock <ICity>();
city2.SetupGet(p => p.Id).Returns(102);
city2.SetupGet(p => p.Owner.IsInTribe).Returns(true);
city2.SetupGet(p => p.Owner.Tribesman.Tribe.Id).Returns(202);
var gateGroup = new Mock <CombatGroup>();
gateGroup.SetupGet(p => p.Id).Returns(1);
gateGroup.SetupGet(p => p.Owner).Returns(new BattleOwner(BattleOwnerType.Stronghold, 300));
var attackGroup1 = new Mock <CombatGroup>();
attackGroup1.SetupGet(p => p.Id).Returns(2);
attackGroup1.SetupGet(p => p.Owner).Returns(new BattleOwner(BattleOwnerType.City, 101));
var attackGroup2 = new Mock <CombatGroup>();
attackGroup2.SetupGet(p => p.Id).Returns(3);
attackGroup2.SetupGet(p => p.Owner).Returns(new BattleOwner(BattleOwnerType.City, 102));
var battle = new Mock <IBattleManager>();
var attackers = new Mock <ICombatList>();
attackers.Setup(p => p.GetEnumerator())
.Returns(() => new List <ICombatGroup> {
attackGroup1.Object
}.GetEnumerator());
battle.SetupGet(m => m.Attackers).Returns(attackers.Object);
var stronghold = new Mock <IStronghold>();
stronghold.SetupGet(p => p.ObjectId).Returns(300);
stronghold.SetupGet(p => p.GateBattle).Returns(battle.Object);
stronghold.SetupProperty(p => p.GateOpenTo);
IGameObjectLocator locator = new GameObjectLocatorStub(stronghold.Object,
city1.Object,
city2.Object,
tribe1.Object,
tribe2.Object);
var strongholdBattleProcedure = new Mock <StrongholdBattleProcedure>();
strongholdBattleProcedure.Setup(m => m.AddStrongholdGateToBattle(battle.Object, stronghold.Object))
.Returns(gateGroup.Object);
var action = new StrongholdGateBattlePassiveAction(300,
strongholdBattleProcedure.Object,
new LockerStub(locator),
locator,
new Mock <IDbManager>().Object,
new Mock <Formula>().Object,
new Mock <IWorld>().Object);
// Execute action to set it up
action.Execute().Should().Be(Error.Ok);
// Fire attack a few times
battle.Raise(m => m.ActionAttacked += null,
battle.Object,
BattleManager.BattleSide.Attack,
attackGroup2.Object,
new Mock <ICombatObject>().Object,
gateGroup.Object,
new Mock <ICombatObject>().Object,
31m,
1,
1);
battle.Raise(m => m.ActionAttacked += null,
battle.Object,
BattleManager.BattleSide.Attack,
attackGroup1.Object,
new Mock <ICombatObject>().Object,
gateGroup.Object,
new Mock <ICombatObject>().Object,
35m,
1,
1);
battle.Raise(m => m.ActionAttacked += null,
battle.Object,
BattleManager.BattleSide.Attack,
attackGroup2.Object,
new Mock <ICombatObject>().Object,
gateGroup.Object,
new Mock <ICombatObject>().Object,
5m,
1,
1);
// Attack from defense which should be totally ignored
battle.Raise(m => m.ActionAttacked += null,
battle.Object,
BattleManager.BattleSide.Defense,
gateGroup.Object,
new Mock <ICombatObject>().Object,
attackGroup1.Object,
new Mock <ICombatObject>().Object,
5000m,
1,
1);
// Send event that gate is dead
battle.Raise(m => m.GroupKilled += null, battle.Object, gateGroup.Object);
// Assert
stronghold.Object.GateOpenTo.Should().NotBeNull();
stronghold.Object.GateOpenTo.Id.Should().Be(201);
}
public void UserCancelled_WhenUserHasDifferentTechnologies_ShouldRefundCorrectAmount(
UserCancelledTestData testData,
[FrozenMock] Formula formula,
[FrozenMock] UnitFactory unitFactory,
[Frozen] IWorld world,
ICity city,
IStructure structure,
ITechnologyManager technologyManager)
{
ushort trainedCount = 0;
formula.GetInstantTrainCount(structure).ReturnsForAnyArgs(testData.InstantTrainCount);
formula.GetXForYTotal(technologyManager, testData.TrainCount).Returns(testData.TotalCount);
formula.GetXForYPaidFor(technologyManager, testData.InstantTrainCount + testData.CompletedTraining).Returns(testData.TotalPaidFor);
formula.UnitTrainCost(city, 100, 0).Returns(testData.CostPerUnit);
formula.GetActionCancelResource(DateTime.MinValue, null)
.ReturnsForAnyArgs(c => c.Arg <Resource>());
city.DefaultTroop.When(m => m.AddUnit(FormationType.Normal, 100, Arg.Any <ushort>()))
.Do(args =>
{
trainedCount += (ushort)args[2];
});
city.Resource.HasEnough(testData.TotalCost).ReturnsForAnyArgs(true);
city.Id.Returns <uint>(1);
structure.City.Returns(city);
structure.Technologies.Returns(technologyManager);
IStructure outStructure;
ICity outCity;
city.TryGetStructure(10, out outStructure).Returns(args =>
{
args[1] = structure;
return(true);
});
world.TryGetObjects(1, 10, out outCity, out outStructure).Returns(args =>
{
args[2] = city;
args[3] = structure;
return(true);
});
var gameObjectLocator = new GameObjectLocatorStub(city);
var locker = new LockerStub(gameObjectLocator);
var action = new UnitTrainActiveAction(1, 10, 100, testData.TrainCount, unitFactory, locker, world, formula);
action.WorkerObject = Substitute.For <ICanDo>();
action.Execute();
action.ActionCount.Should().Be(testData.ExpectedQueuedCount);
city.Resource.Received(1).Subtract(testData.TotalCost);
for (var i = 0; i < testData.CompletedTraining; i++)
{
action.Callback(null);
}
action.UserCancelled();
city.Resource.Received(1).Add(testData.ExpectedRefundAmount);
trainedCount.Should().Be(testData.ExpectedCityReceivedCount);
}
