コード例 #1
0
 public AssignmentTroopObjectInitializer(ITroopObject existingTroopObject, TroopBattleGroup group, AttackMode mode, Formula formula)
 {
     this.existingTroopObject = existingTroopObject;
     this.group   = group;
     this.mode    = mode;
     this.formula = formula;
 }
コード例 #2
0
        public virtual BattleStats LoadStats(IBaseBattleStats stats, ICity city, TroopBattleGroup group)
        {
            var calculator = new BattleStatsModCalculator(stats);

            foreach (var effect in city.Technologies.GetAllEffects())
            {
                if (effect.Id == EffectCode.UnitStatMod)
                {
                    if (!UnitStatModCheck(stats, @group, (string)effect.Value[3]))
                    {
                        continue;
                    }

                    switch ((string)effect.Value[0])
                    {
                    case "Atk":
                        calculator.Atk.AddMod((string)effect.Value[1], (int)effect.Value[2]);
                        break;

                    case "Splash":
                        calculator.Splash.AddMod((string)effect.Value[1], (int)effect.Value[2]);
                        break;

                    case "Spd":
                        calculator.Spd.AddMod((string)effect.Value[1], (int)effect.Value[2]);
                        break;

                    case "Stl":
                        calculator.Stl.AddMod((string)effect.Value[1], (int)effect.Value[2]);
                        break;

                    case "Rng":
                        calculator.Rng.AddMod((string)effect.Value[1], (int)effect.Value[2]);
                        break;

                    case "Carry":
                        calculator.Carry.AddMod((string)effect.Value[1], (int)effect.Value[2]);
                        break;

                    case "MaxHp":
                        calculator.MaxHp.AddMod((string)effect.Value[1], (int)effect.Value[2]);
                        break;
                    }
                }
                else if (effect.Id == EffectCode.ACallToArmMod && group == TroopBattleGroup.Local)
                {
                    var bonus = (int)effect.Value[0] * Math.Min(city.Resource.Labor.Value, (int)effect.Value[1]) /
                                ((int)effect.Value[1]);
                    calculator.Atk.AddMod("CALL_TO_ARM_BONUS", 100 + bonus);
                }
            }

            return(calculator.GetStats());
        }
コード例 #3
0
 public CityTroopObjectInitializer(uint cityId,
                                   ISimpleStub simpleStub,
                                   TroopBattleGroup group,
                                   AttackMode mode,
                                   IGameObjectLocator gameObjectLocator,
                                   Formula formula,
                                   Procedure procedure,
                                   IWorld world)
 {
     this.cityId            = cityId;
     this.simpleStub        = simpleStub;
     this.group             = group;
     this.mode              = mode;
     this.gameObjectLocator = gameObjectLocator;
     this.formula           = formula;
     this.procedure         = procedure;
     this.world             = world;
 }
コード例 #4
0
        /// <summary>
        ///     Must call begin/end update on the troop stub that owns this template
        /// </summary>
        public void LoadStats(TroopBattleGroup group)
        {
            stats = new Dictionary <ushort, BattleStats>();

            foreach (var formation in stub)
            {
                foreach (var type in formation.Keys)
                {
                    if (stats.ContainsKey(type))
                    {
                        continue;
                    }

                    BattleStats stat = battleFormulas.LoadStats(type,
                                                                stub.City.Template[type].Lvl,
                                                                stub.City,
                                                                group);
                    stats.Add(type, stat);
                }
            }

            stub.FireUnitUpdated();
        }
コード例 #5
0
 public virtual BattleStats LoadStats(ushort type, byte lvl, ICity city, TroopBattleGroup group)
 {
     return(LoadStats(unitFactory.GetUnitStats(type, lvl).Battle, city, group));
 }
コード例 #6
0
        public virtual bool UnitStatModCheck(IBaseBattleStats stats, TroopBattleGroup group, string value)
        {
            string[] conditions = value.Split('=', '|');
            int      success    = 0;

            for (int i = 0; i < conditions.Length / 2; ++i)
            {
                switch (conditions[i * 2])
                {
                case "ArmorEqual":
                    if (stats.Armor == (ArmorType)Enum.Parse(typeof(ArmorType), conditions[i * 2 + 1], true))
                    {
                        ++success;
                    }
                    break;

                case "ArmorNotEqual":
                    if (stats.Armor != (ArmorType)Enum.Parse(typeof(ArmorType), conditions[i * 2 + 1], true))
                    {
                        ++success;
                    }
                    break;

                case "ArmorClassEqual":
                    if (stats.ArmorClass == (ArmorClass)Enum.Parse(typeof(ArmorClass), conditions[i * 2 + 1], true))
                    {
                        ++success;
                    }
                    break;

                case "WeaponEqual":
                    if (stats.Weapon == (WeaponType)Enum.Parse(typeof(WeaponType), conditions[i * 2 + 1], true))
                    {
                        ++success;
                    }
                    break;

                case "WeaponClassEqual":
                    if (stats.WeaponClass ==
                        (WeaponClass)Enum.Parse(typeof(WeaponClass), conditions[i * 2 + 1], true))
                    {
                        ++success;
                    }
                    break;

                case "GroupEqual":
                    switch ((TroopBattleGroup)Enum.Parse(typeof(TroopBattleGroup), conditions[i * 2 + 1], true))
                    {
                    case TroopBattleGroup.Defense:
                        if (group == TroopBattleGroup.Local || group == TroopBattleGroup.Defense)
                        {
                            ++success;
                        }
                        break;

                    case TroopBattleGroup.Attack:
                        if (group == TroopBattleGroup.Attack)
                        {
                            ++success;
                        }
                        break;

                    case TroopBattleGroup.Local:
                        if (group == TroopBattleGroup.Local)
                        {
                            ++success;
                        }
                        break;
                    }
                    break;

                case "TypeEqual":
                    if (stats.Type == ushort.Parse(conditions[i * 2 + 1]))
                    {
                        ++success;
                    }
                    break;
                }
            }
            return(success == conditions.Length / 2);
        }
コード例 #7
0
 public ITroopObjectInitializer CreateAssignmentTroopObjectInitializer(ITroopObject existingTroopObject, TroopBattleGroup @group, AttackMode mode)
 {
     return(new AssignmentTroopObjectInitializer(existingTroopObject, @group, mode, kernel.Get <Formula>()));
 }
コード例 #8
0
 public ITroopObjectInitializer CreateCityTroopObjectInitializer(uint cityId, ISimpleStub simpleStub, TroopBattleGroup @group, AttackMode mode)
 {
     return(new CityTroopObjectInitializer(cityId, simpleStub, @group, mode, kernel.Get <IGameObjectLocator>(), kernel.Get <Formula>(), kernel.Get <Procedure>(), kernel.Get <IWorld>()));
 }