Example #1
0
        public static void Cast(ICast cast, BattleUnitsStack caster, params BattleUnitsStack[] targets)
        {
            caster.state = State.MadeMove;

            caster.GetLastEffect()?.BeforeCast(cast, caster, targets);
            foreach (var target in targets)
            {
                target.GetLastEffect()?.BeforeCast(cast, caster, targets);
            }

            if (cast is ISingleCast)
            {
                if (targets.Length != 1)
                {
                    throw new GameException($"Invalid number of targets: {targets.Length} (Cast {cast.type})");
                }
                ((ISingleCast)cast).Cast(caster, targets[0]);
            }

            caster.GetLastEffect()?.AfterCast(cast, caster, targets);
            foreach (var target in targets)
            {
                target.GetLastEffect()?.AfterCast(cast, caster, targets);
            }

            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine($"{cast.type} casted!");
            Console.ResetColor();
        }
Example #2
0
        private void ToAwaitingScale(BattleUnitsStack stack)
        {
            double initiativeRandom = -currentMainScale.GetPriority(stack) % 1;

            currentMainScale.Remove(stack);
            currentAwaitingScale.Enqueue(stack, stack.metaUnit.initiative + initiativeRandom);
        }
Example #3
0
        public BattleUnitsStack(BattleUnitsStack otherStack)
        {
            unitsType      = otherStack.unitsType;
            totalHitPoints = otherStack.totalHitPoints;
            state          = otherStack.state;
            fightedBack    = otherStack.fightedBack;
            initHitPoints  = otherStack.initHitPoints;
            _metaUnit      = new BattleUnit(otherStack.metaUnit);

            foreach (IModifier mod in otherStack.Modifiers.Keys)
            {
                Modifiers.Add(mod, (double)otherStack.Modifiers[mod]);
            }
            foreach (BaseEffect effect in otherStack.Effects.Keys)
            {
                AddEffect(effect, double.PositiveInfinity);
            }
            GetLastEffect()?.Init();

            foreach (var cast in otherStack.Casts)
            {
                Casts.Add(cast);
            }
            parentArmy = otherStack.parentArmy;
        }
Example #4
0
 public void AddStack(BattleUnitsStack newUnitsStack)
 {
     if (_unitsStackList.Count == MAXSIZE)
     {
         throw new ArmyOverflowException($"Trying to add too many stacks to BattleArmy.\nBattleArmy.MAXSIZE is {MAXSIZE}");
     }
     _unitsStackList.Add(new BattleUnitsStack(newUnitsStack));
 }
Example #5
0
 public BattleArmy(Army otherArmy)
 {
     otherArmy.unitsStackList.ForEach((currentStack) => {
         var newStack        = new BattleUnitsStack(currentStack);
         newStack.parentArmy = this;
         _unitsStackList.Add(newStack);
     });
 }
Example #6
0
 public void Surrender(BattleUnitsStack stack)
 {
     if (stack.parentArmy == firstPlayerArmy)
     {
         winner = secondPlayerArmy;
     }
     else if (stack.parentArmy == secondPlayerArmy)
     {
         winner = firstPlayerArmy;
     }
 }
Example #7
0
 public BattleArmy(IEnumerable <BattleUnitsStack> otherUnitsStackList)
 {
     foreach (BattleUnitsStack currentStack in otherUnitsStackList)
     {
         if (_unitsStackList.Count == MAXSIZE)
         {
             throw new ArmyOverflowException($"Trying to make battle army of [{string.Join(", ", otherUnitsStackList)}]\nBattleArmy.MAXSIZE = {MAXSIZE}");
         }
         var newStack = new BattleUnitsStack(currentStack);
         newStack.parentArmy = this;
         _unitsStackList.Add(newStack);
     }
 }
Example #8
0
 public BattleArmy(params UnitsStack[] otherUnitsStackList)
 {
     if (otherUnitsStackList.Length > MAXSIZE)
     {
         throw new ArmyOverflowException($"Trying to make battle army of [{string.Join<UnitsStack>(", ", otherUnitsStackList)}]\nBattleArmy.MAXSIZE = {MAXSIZE}");
     }
     foreach (UnitsStack currentStack in otherUnitsStackList)
     {
         var newStack = new BattleUnitsStack(currentStack);
         newStack.parentArmy = this;
         _unitsStackList.Add(newStack);
     }
 }
Example #9
0
        private void ChangeInitiative(BattleUnitsStack stack, double newValue)
        {
            if (currentMainScale.Contains(stack))
            {
                currentMainScale.UpdatePriority(stack, -newValue + currentMainScale.GetPriority(stack) % 1);
            }
            if (currentAwaitingScale.Contains(stack))
            {
                currentAwaitingScale.UpdatePriority(stack, newValue + currentAwaitingScale.GetPriority(stack) % 1);
            }
            if (nextMainScale.Contains(stack))
            {
                nextMainScale.UpdatePriority(stack, -newValue + nextMainScale.GetPriority(stack) % 1);
            }

            if (!(currentMainScale.Contains(stack) || currentAwaitingScale.Contains(stack) || nextMainScale.Contains(stack)))
            {
                throw new InitiativeException("Trying to change initiative of stack which is not in scale");
            }
        }
Example #10
0
        private void ToNextRound(BattleUnitsStack stack)
        {
            Random rnd = new Random();
            double initiativeRandom = 0;

            if (currentMainScale.Contains(stack))
            {
                initiativeRandom = currentMainScale.GetPriority(stack) % 1;
                currentMainScale.Remove(stack);
            }
            else if (currentAwaitingScale.Contains(stack))
            {
                initiativeRandom = -currentAwaitingScale.GetPriority(stack) % 1;
                currentAwaitingScale.Remove(stack);
            }

            if (!nextMainScale.Contains(stack))
            {
                nextMainScale.Enqueue(stack, -(stack.unitsType.initiative + (initiativeRandom == 0 ? rnd.NextDouble() / 100 : initiativeRandom)));
            }
        }
Example #11
0
        public static void PureAttack(BattleUnitsStack attackingStack, BattleUnitsStack defendingStack)
        {
            Unit attackingUnit = attackingStack.metaUnit;
            Unit defendingUnit = defendingStack.metaUnit;

            (uint minDamage, uint maxDamage)finalDamage;

            if (attackingUnit.attack > defendingUnit.defence)
            {
                finalDamage.minDamage = (uint)Math.Ceiling(attackingStack.unitsCount * attackingUnit.damage.minDamage * (1 + 0.05 * (attackingUnit.attack - defendingUnit.defence)));
                finalDamage.maxDamage = (uint)Math.Ceiling(attackingStack.unitsCount * attackingUnit.damage.maxDamage * (1 + 0.05 * (attackingUnit.attack - defendingUnit.defence)));
            }
            else
            {
                finalDamage.minDamage = (uint)Math.Ceiling(attackingStack.unitsCount * attackingUnit.damage.minDamage / (1 + 0.05 * (defendingUnit.defence - attackingUnit.attack)));
                finalDamage.maxDamage = (uint)Math.Ceiling(attackingStack.unitsCount * attackingUnit.damage.maxDamage / (1 + 0.05 * (defendingUnit.defence - attackingUnit.attack)));
            }

            var random = new Random();

            defendingStack.Damage((uint)random.Next((int)finalDamage.minDamage, (int)finalDamage.maxDamage));
        }
Example #12
0
        public static void Attack(BattleUnitsStack attackingStack, BattleUnitsStack defendingStack)
        {
            attackingStack.state = State.MadeMove;

            attackingStack.GetLastEffect()?.BeforeAttack(attackingStack, defendingStack);
            defendingStack.GetLastEffect()?.BeforeAttack(attackingStack, defendingStack);

            PureAttack(attackingStack, defendingStack);

            attackingStack.GetLastEffect()?.AfterAttack(attackingStack, defendingStack);
            defendingStack.GetLastEffect()?.AfterAttack(attackingStack, defendingStack);

            attackingStack.GetLastEffect()?.BeforeFightBack(attackingStack, defendingStack);
            defendingStack.GetLastEffect()?.BeforeFightBack(attackingStack, defendingStack);

            if (!defendingStack.fightedBack)
            {
                defendingStack.fightedBack = true;
                PureAttack(defendingStack, attackingStack);
            }

            attackingStack.GetLastEffect()?.AfterFightBack(attackingStack, defendingStack);
            defendingStack.GetLastEffect()?.AfterFightBack(attackingStack, defendingStack);
        }
Example #13
0
 public EndGameInterface(Battle _battle, BattleUnitsStack _surrenderedStack = null)
 {
     surrenderedStack = _surrenderedStack;
     battle           = _battle;
 }
Example #14
0
 public abstract void AfterFightBack(BattleUnitsStack attacker, BattleUnitsStack target);
Example #15
0
 public static void Defend(BattleUnitsStack defendingStack)
 {
     defendingStack.state = State.Defending;
     defendingStack.AddModifier(MDefense.Instance, 1);
 }
Example #16
0
 public static void Wait(BattleUnitsStack waitingStack)
 {
     waitingStack.state = State.Awaiting;
 }
Example #17
0
 public abstract void AfterCast(ICast cast, BattleUnitsStack caster, params BattleUnitsStack[] targets);
Example #18
0
 public void RemoveStack(BattleUnitsStack stackToRemove)
 {
     _unitsStackList.Remove(stackToRemove);
 }
Example #19
0
 public CastInterface(Battle _battle, BattleUnitsStack _stack)
 {
     battle = _battle;
     stack  = _stack;
 }
Example #20
0
 // attacker - стек, который изначально атаковал
 // target - стек, который дает сдачу
 public abstract void BeforeFightBack(BattleUnitsStack attacker, BattleUnitsStack target);
Example #21
0
 public UnitsStack(BattleUnitsStack otherStack)
 {
     unitsType  = otherStack.unitsType;
     unitsCount = otherStack.unitsCount;
 }