コード例 #1
0
        public void ExecuteAbilityOnUnit(IAbilityDefinition ability, IUnit unit)
        {
            if (!CanExecuteAbilityOnUnit(ability, unit))
            {
                throw new InvalidOperationException("CanExecuterAbilityOnUnit must return true on the arguments");
            }

            foreach (var command in ability.CommandRequests)
            {
                var firstValidHandler = AbilityHandlers.First(
                    handler => handler.CanHandleCommandOnUnit(command, unit)
                    );

                firstValidHandler.HandleCommandOnUnit(command, unit);
            }

            if (ability.ConsumesMovement)
            {
                unit.CurrentMovement = 0;
            }

            if (ability.DestroysUnit)
            {
                unit.Destroy();
            }

            Signals.ActivatedAbility.OnNext(new Tuple <IUnit, IAbilityDefinition>(unit, ability));
        }
コード例 #2
0
        public void StartExecution_AndUnitCanExecuteFirstFortifyAbility_AbilityExecuted()
        {
            var abilities = new IAbilityDefinition[] {
                BuildAbility(true),
                BuildAbility(
                    false,
                    new AbilityCommandRequest()
                {
                    Type = AbilityCommandType.GainFreeTech
                }
                    ),
                BuildAbility(
                    true,
                    new AbilityCommandRequest()
                {
                    Type = AbilityCommandType.Fortify
                },
                    new AbilityCommandRequest()
                {
                    Type = AbilityCommandType.ClearVegetation
                }
                    ),
                BuildAbility(
                    true,
                    new AbilityCommandRequest()
                {
                    Type = AbilityCommandType.Fortify
                }
                    )
            };

            var unit = BuildUnit(abilities);

            var unitCommand = Container.Resolve <FortifyUnitCommand>();

            unitCommand.UnitToFortify = unit;

            unitCommand.StartExecution();

            MockAbilityExecuter.Verify(
                executer => executer.ExecuteAbilityOnUnit(It.IsAny <IAbilityDefinition>(), unit),
                Times.Once, "ExecuteAbilityOnUnit called an unexpected number of times"
                );

            MockAbilityExecuter.Verify(
                executer => executer.ExecuteAbilityOnUnit(abilities[2], unit),
                Times.Once, "abilities[2] not executed as expected"
                );
        }
コード例 #3
0
        public bool CanExecuteAbilityOnUnit(IAbilityDefinition ability, IUnit unit)
        {
            if (ability.RequiresMovement && unit.CurrentMovement <= 0)
            {
                return(false);
            }

            foreach (var command in ability.CommandRequests)
            {
                if (!AbilityHandlers.Any(handler => handler.CanHandleCommandOnUnit(command, unit)))
                {
                    return(false);
                }
            }

            return(true);
        }
コード例 #4
0
 public bool IsAbilityResearchedForCiv(IAbilityDefinition ability, ICivilization civilization)
 {
     return(GetResearchedAbilities(civilization).Contains(ability));
 }