Esempio n. 1
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            foreach (BasicCard card in targets)
            {
                card.AddBuff(new BuffDebuff()
                {
                    Name                 = "Deafened",
                    Buff                 = false,
                    Origin               = $"({inst.GetCardTurn().Signature})",
                    Description          = "15% less defense.",
                    DefensePercentDebuff = 0.15,
                    Strikes              = 2
                });

                List <int> rolls = RandomGen.RollDice(3, 8);
                await MessageHandler.DiceThrow(inst.Location, "3d8", rolls);

                var damage = 0;
                foreach (int roll in rolls)
                {
                    damage += roll;
                }

                damage = inst.GetCardTurn().ApplyDamageBuffs(damage);
                var damages = card.TakeDamage(damage);

                await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} deafens {card.Signature} with a sharp note and strike them with their sword! {card.DamageTakenString(damages)}");
            }

            inst.GetCardTurn().Actions--;
        }
Esempio n. 2
0
        public static async Task SkipTurn(CombatInstance inst, BasicCard player)
        {
            player.IsTurn = false;
            await player.TurnTick();

            await NextTurn(inst);
        }
Esempio n. 3
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            foreach (BasicCard card in targets)
            {
                List <int> rolls = RandomGen.RollDice(7, 8);
                await MessageHandler.DiceThrow(inst.Location, "7d8", rolls);

                int damage = 0;

                foreach (int roll in rolls)
                {
                    damage += roll;
                }

                damage = inst.GetCardTurn().ApplyDamageBuffs(damage);
                var damages = card.TakeDamage(damage);

                card.AddBuff(new BuffDebuff()
                {
                    Name             = "Bleeding",
                    Buff             = false,
                    Origin           = $"({inst.GetCardTurn().Signature})",
                    Description      = "3 damage every turn.",
                    DamagePerTurn    = 3,
                    DPRAlternateText = " bleeding damage.",
                    Turns            = 2
                });

                await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} bites {card.Signature}, causing them to bleed. {card.DamageTakenString(damages)}");
            }

            inst.GetCardTurn().Actions--;
        }
Esempio n. 4
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            foreach (BasicCard card in targets)
            {
                List <int> damRolls = RandomGen.RollDice(4, 6);
                await MessageHandler.DiceThrow(inst.Location, "4d6", damRolls);

                List <int> shield = RandomGen.RollDice(1, 2);
                await MessageHandler.DiceThrow(inst.Location, "1d2", shield);

                var damage = 0;
                foreach (int roll in damRolls)
                {
                    damage += roll;
                }

                damage = inst.GetCardTurn().ApplyDamageBuffs(damage);
                var damages = card.TakeDamage(damage);

                inst.GetCardTurn().AddBuff(new BuffDebuff()
                {
                    Name        = "Poof",
                    Buff        = true,
                    Origin      = $"({inst.GetCardTurn().Signature})",
                    Description = $"{shield[0]} light shielding.",
                    ShieldOnly  = true,
                    LightShield = shield[0]
                });

                await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} poofs out! They gain {shield[0]} light shield(s) and {card.DamageTakenString(damages)}");
            }

            inst.GetCardTurn().Actions--;
        }
Esempio n. 5
0
        public override async Task MoveEffect(CombatInstance inst)
        {
            List <int> rolls = RandomGen.RollDice(4, 15, true);
            await MessageHandler.DiceThrow(inst.Location, "4d15!", rolls);

            int damage = 0;

            foreach (int roll in rolls)
            {
                damage += roll;
            }

            damage = inst.GetCardTurn().ApplyDamageBuffs(damage);
            string str      = "";
            var    totalDam = 0;

            List <BasicCard> targets = inst.GetAOEEnemyTargets();

            foreach (BasicCard card in targets)
            {
                var tempDam = card.TakeDamage(damage);
                totalDam += tempDam[0];
                str      += $"\n{card.DamageTakenString(tempDam)}";
            }

            await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} fires a magical arrow!{str}\n{inst.GetCardTurn().Signature} dealt a total of {totalDam} damage.");

            OnCooldown      = true;
            CurrentCooldown = Cooldown;
            inst.GetCardTurn().Actions--;
        }
Esempio n. 6
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            foreach (BasicCard card in targets)
            {
                int dice = 4;
                if (inst.GetCardTurn().HasBuff("Firing Position"))
                {
                    dice++;
                }
                List <int> rolls = RandomGen.RollDice(dice, 10);
                await MessageHandler.DiceThrow(inst.Location, $"{dice}d10", rolls);

                int damage = 0;

                foreach (int roll in rolls)
                {
                    damage += roll;
                }

                damage = inst.GetCardTurn().ApplyDamageBuffs(damage);
                var damages = card.TakeDamage(damage);

                await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} fires an arrow into {card.Signature}! {card.DamageTakenString(damages)}");
            }

            inst.GetCardTurn().Actions--;
        }
Esempio n. 7
0
        public override async Task MoveEffect(CombatInstance inst)
        {
            int healing = 15;

            healing = inst.GetCardTurn().ApplyHealingBuffs(healing, true);
            string str       = "";
            var    totalHeal = 0;

            List <BasicCard> targets = inst.GetAOEAllyTargets();

            foreach (BasicCard card in targets)
            {
                if (!card.Name.Contains("Priam"))
                {
                    var tempHeal = card.Heal(healing, true);
                    totalHeal += tempHeal;
                    str       += $"\n{card.Signature} heals {tempHeal} HP!";

                    card.AddBuff(new BuffDebuff()
                    {
                        Name              = "Inspired",
                        Buff              = true,
                        Origin            = $"({inst.GetCardTurn().Signature})",
                        Description       = "10% bonus damage",
                        DamagePercentBuff = 0.10,
                        Attacks           = 1
                    });
                }
            }

            await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} inspires his troops!{str}\n{inst.GetCardTurn().Signature} healed a total of {totalHeal} health.");

            inst.GetCardTurn().Actions--;
        }
Esempio n. 8
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            foreach (BasicCard card in targets)
            {
                List <int> rolls = RandomGen.RollDice(2, 15);
                await MessageHandler.DiceThrow(inst.Location, "2d15", rolls);

                var flip = RandomGen.CoinFlip();
                await MessageHandler.CoinFlip(inst.Location, flip);

                var damage = 0;
                foreach (int roll in rolls)
                {
                    damage += roll;
                }

                if (flip)
                {
                    damage += 5;
                }

                damage = inst.GetCardTurn().ApplyDamageBuffs(damage);
                var damages = card.TakeDamage(damage);

                await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} smashes {card.Signature} with clenched fists! {card.DamageTakenString(damages)}");
            }

            inst.GetCardTurn().Actions--;
        }
Esempio n. 9
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            List <int> hitRoll = RandomGen.RollDice(1, 4);
            await MessageHandler.DiceThrow(inst.Location, "1d4", hitRoll);

            if (hitRoll[0] == 4)
            {
                foreach (BasicCard card in targets)
                {
                    List <int> rolls = RandomGen.RollDice(25, 10);
                    await MessageHandler.DiceThrow(inst.Location, "25d10", rolls);

                    var damage = 0;
                    foreach (int roll in rolls)
                    {
                        damage += roll;
                    }

                    damage = inst.GetCardTurn().ApplyDamageBuffs(damage);
                    var damages = card.TakeDamage(damage);

                    await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} picks up {card.Signature} and crushes them in his fist! {card.DamageTakenString(damages)}");
                }
            }
            else
            {
                await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} missed!");
            }

            inst.GetCardTurn().Actions--;
        }
Esempio n. 10
0
        public override async Task MoveEffect(CombatInstance inst)
        {
            int damage = 20;

            damage = inst.GetCardTurn().ApplyDamageBuffs(damage);
            string str      = "";
            var    totalDam = 0;

            foreach (Team team in inst.Teams)
            {
                if (team.TeamNum != inst.GetTeam(inst.GetCardTurn()).TeamNum)
                {
                    foreach (UserAccount user in team.Members)
                    {
                        foreach (BasicCard card in user.ActiveCards)
                        {
                            var tempDam = card.TakeDamage(damage);
                            totalDam += tempDam[0];
                            str      += $"\n{card.DamageTakenString(tempDam)}";
                        }
                    }
                }
            }

            await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} rushes the enemy team!{str}\n{inst.GetCardTurn().Signature} dealt a total of {totalDam}");

            OnCooldown      = true;
            CurrentCooldown = Cooldown;
            inst.GetCardTurn().Actions--;
        }
Esempio n. 11
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            foreach (BasicCard card in targets)
            {
                List <int> rolls = RandomGen.RollDice(2, 15);
                await MessageHandler.DiceThrow(inst.Location, "2d15", rolls);

                var damage = 0;
                foreach (int roll in rolls)
                {
                    damage += roll;
                }

                damage = inst.GetCardTurn().ApplyDamageBuffs(damage);
                var damages = card.TakeDamage(damage);

                card.AddBuff(new BuffDebuff()
                {
                    Name        = "Prone",
                    Buff        = false,
                    Origin      = $"({inst.GetCardTurn().Signature})",
                    Description = "disabled",
                    TurnSkip    = true,
                    Turns       = 1
                });

                await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} sweeps {card.Signature}'s legs out from under them! {card.DamageTakenString(damages)}");
            }

            OnCooldown      = true;
            CurrentCooldown = Cooldown;
            inst.GetCardTurn().Actions--;
        }
Esempio n. 12
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            string str = "";

            foreach (BasicCard card in targets)
            {
                List <int> rolls = RandomGen.RollDice(6, 5);
                await MessageHandler.DiceThrow(inst.Location, "6d5", rolls);

                int damage = 0;

                foreach (int roll in rolls)
                {
                    damage += roll;
                }

                damage = inst.GetCardTurn().ApplyDamageBuffs(damage);
                var damages = card.TakeDamage(damage);

                str += $"{inst.GetCardTurn().Signature} blasts {card.Signature} with a ball of energy! {card.DamageTakenString(damages)}\n";
            }
            await MessageHandler.SendMessage(inst.Location, $"{str}");

            inst.GetCardTurn().Actions--;
        }
Esempio n. 13
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            foreach (BasicCard card in targets)
            {
                var damage = 35;

                damage = inst.GetCardTurn().ApplyDamageBuffs(damage);
                var damages = card.TakeDamage(damage);

                await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} imaples {card.Signature}! {card.Signature} is bleeding. {card.DamageTakenString(damages)}");

                card.AddBuff(new BuffDebuff()
                {
                    Name             = "Impaled",
                    Buff             = false,
                    Origin           = $"({inst.GetCardTurn().Signature})",
                    Description      = "5 bleed damage every turn.",
                    DamagePerTurn    = 5,
                    Turns            = 3,
                    DPRAlternateText = "bleeding damage."
                });
            }

            OnCooldown      = true;
            CurrentCooldown = Cooldown;
            inst.GetCardTurn().Actions--;
        }
Esempio n. 14
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            foreach (BasicCard card in targets)
            {
                var damage = 40;

                damage = inst.GetCardTurn().ApplyDamageBuffs(damage);
                var damages = card.TakeDamage(damage);

                await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} imaples {card.Signature}! {card.Signature}'s defense is reduced by 20% on the next 2 hits they take. {card.DamageTakenString(damages)}");

                card.AddBuff(new BuffDebuff()
                {
                    Name                 = "Impaled",
                    Buff                 = false,
                    Origin               = $"({inst.GetCardTurn().Signature})",
                    Description          = "20% reduced defense on the next 2 hits taken.",
                    DefensePercentDebuff = 0.2,
                    Strikes              = 2
                });
            }

            OnCooldown      = true;
            CurrentCooldown = Cooldown;
            inst.GetCardTurn().Actions--;
        }
Esempio n. 15
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            foreach (BasicCard card in targets)
            {
                List <int> rolls = RandomGen.RollDice(3, 10);
                await MessageHandler.DiceThrow(inst.Location, "3d10", rolls);

                int healing = 0;

                foreach (int roll in rolls)
                {
                    healing += roll;
                }

                healing = inst.GetCardTurn().ApplyHealingBuffs(healing, true);
                healing = card.Heal(healing, true);

                card.AddBuff(new BuffDebuff()
                {
                    Name              = "Ithacan Wrath",
                    Buff              = true,
                    Origin            = $"({inst.GetCardTurn().Signature})",
                    Description       = "50% increased damage on next attack.",
                    DamagePercentBuff = 0.50,
                    Attacks           = 1
                });

                await MessageHandler.SendMessage(inst.Location, $"{card.Signature} is instilled with the Wrath of Ithaca! They heal for {healing} and gain 50% increased damage on their next attack.");
            }

            OnCooldown      = true;
            CurrentCooldown = Cooldown;
            inst.GetCardTurn().Actions--;
        }
Esempio n. 16
0
        public static async Task CheckTeamElimination(CombatInstance inst, Team team)
        {
            var teamCount = 0;
            var teamDead  = 0;

            foreach (UserAccount player in team.Members)
            {
                foreach (BasicCard card in player.ActiveCards)
                {
                    teamCount++;
                    if (card.Dead)
                    {
                        teamDead++;
                    }
                }
            }

            if (teamCount == teamDead)
            {
                await MessageHandler.TeamEliminated(inst.Location, team.TeamNum);

                inst.Teams.Remove(team);
                await CheckDuelVictory(inst);
            }
        }
Esempio n. 17
0
        public override async Task MoveEffect(CombatInstance inst)
        {
            List <int> rolls = RandomGen.RollDice(4, 10);
            await MessageHandler.DiceThrow(inst.Location, "4d10", rolls);

            int damage = 0;

            foreach (int roll in rolls)
            {
                damage += roll;
            }

            damage = inst.GetCardTurn().ApplyDamageBuffs(damage);
            string str      = "";
            var    totalDam = 0;

            List <BasicCard> targets = inst.GetAOEAllyTargets();

            foreach (BasicCard card in targets)
            {
                var tempDam = card.TakeDamage(damage);
                totalDam += tempDam[0];
                str      += $"\n{card.DamageTakenString(tempDam)}";
            }

            await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} shreds the enemy with their claws!{str}\n{inst.GetCardTurn().Signature} dealt a total of {totalDam} damage.");

            inst.GetCardTurn().Actions--;
        }
Esempio n. 18
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            foreach (BasicCard card in targets)
            {
                List <int> rolls = RandomGen.RollDice(15);
                var        flip  = RandomGen.CoinFlip();

                int damage = rolls[0];
                damage = inst.GetCardTurn().ApplyDamageBuffs(damage);
                var damages = card.TakeDamage(damage);
                await MessageHandler.DiceThrow(inst.Location, "1d15", rolls);

                await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} crashes into {card.Signature}. {card.DamageTakenString(damages)}");

                await MessageHandler.CoinFlip(inst.Location, flip);

                if (!flip)
                {
                    await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} gains a 15% boost on their next attack.");

                    inst.GetCardTurn().AddBuff(new BuffDebuff()
                    {
                        Name              = "Crashed",
                        Buff              = true,
                        Origin            = $"({inst.GetCardTurn().Signature})",
                        Description       = "15% increased damage on next attack.",
                        DamagePercentBuff = 0.15,
                        Attacks           = 1
                    });
                }
            }

            inst.GetCardTurn().Actions--;
        }
Esempio n. 19
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            string str = "The king is empowering his soldiers!";

            foreach (BasicCard card in targets)
            {
                card.AddBuff(new BuffDebuff()
                {
                    Name         = "Regent",
                    Buff         = true,
                    Origin       = $"({inst.GetCardTurn().Signature})",
                    Description  = "untargetable.",
                    Untargetable = true,
                    Rounds       = 1
                });

                card.AddBuff(new BuffDebuff()
                {
                    Name              = "Regent",
                    Buff              = true,
                    Origin            = $"({inst.GetCardTurn().Signature})",
                    Description       = "50% damage boost",
                    DamagePercentBuff = 0.50,
                    Attacks           = 1
                });

                str += $"\n{card.Signature} has become untargetable and deals 50% more damage on their next attack!";
            }

            await MessageHandler.SendMessage(inst.Location, $"{str}");

            OnCooldown      = true;
            CurrentCooldown = Cooldown;
            inst.GetCardTurn().Actions--;
        }
Esempio n. 20
0
        public override async Task MoveEffect(CombatInstance inst)
        {
            foreach (UserAccount user in inst.GetTeam(UserHandler.GetUser(inst.GetCardTurn().Owner)).Members)
            {
                foreach (BasicCard card in user.ActiveCards)
                {
                    BuffDebuff buff = new BuffDebuff()
                    {
                        Name           = $"Stalwart Soul",
                        Buff           = true,
                        Origin         = $"({inst.GetCardTurn().Signature})",
                        Description    = "All damage nullified.",
                        DefenseSetBuff = 0,
                        Rounds         = 2
                    };

                    card.Effects.Add(buff);
                }
            }

            await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} fortifies the party against all damage!");

            inst.GetCardTurn().Actions--;
            OnCooldown      = true;
            CurrentCooldown = Cooldown;
        }
Esempio n. 21
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            foreach (BasicCard card in targets)
            {
                List <int> rolls = RandomGen.RollDice(5, 5);
                await MessageHandler.DiceThrow(inst.Location, "5d5", rolls);

                var damage = 0;
                foreach (int roll in rolls)
                {
                    damage += roll;
                }

                damage = inst.GetCardTurn().ApplyDamageBuffs(damage);
                var damages = card.TakeDamage(damage);

                card.AddBuff(new BuffDebuff()
                {
                    Name                = "Egged",
                    Buff                = false,
                    Origin              = $"({inst.GetCardTurn().Signature})",
                    Description         = "15% decreased damage.",
                    DamagePercentDebuff = 0.15,
                    Attacks             = 1
                });

                await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} drops an egg on {card.Signature}'s head! {card.DamageTakenString(damages)} Their next attack is reduced by 15%.");
            }

            inst.GetCardTurn().Actions--;
        }
Esempio n. 22
0
        public override async Task MoveEffect(CombatInstance inst)
        {
            foreach (UserAccount user in inst.GetTeam(UserHandler.GetUser(inst.GetCardTurn().Owner)).Members)
            {
                foreach (BasicCard card in user.ActiveCards)
                {
                    if (card.Owner != inst.GetCardTurn().Owner)
                    {
                        BuffDebuff buff = new BuffDebuff()
                        {
                            Name               = "Hair Raise",
                            Buff               = true,
                            Origin             = $"({inst.GetCardTurn().Signature})",
                            Description        = "Untargetable and take 25% less damage.",
                            DefensePercentBuff = 0.25,
                            Untargetable       = true,
                            Rounds             = 2
                        };

                        card.Effects.Add(buff);
                    }
                }
            }

            await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} alerts the party to danger! All other party members are untargetable for 2 rounds and take 25% less damage.");

            OnCooldown      = true;
            CurrentCooldown = Cooldown;
            inst.GetCardTurn().Actions--;
        }
Esempio n. 23
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            foreach (BasicCard card in targets)
            {
                int heal = 80;
                var flip = RandomGen.CoinFlip();
                await MessageHandler.CoinFlip(inst.Location, flip);

                heal = inst.GetCardTurn().ApplyHealingBuffs(heal, true);
                heal = card.Heal(heal, true);

                string str = "";
                if (flip)
                {
                    card.AddBuff(new BuffDebuff()
                    {
                        Name           = "Champion's Favor",
                        Buff           = true,
                        Origin         = $"({inst.GetCardTurn().Signature})",
                        Description    = "invulnerable",
                        DefenseSetBuff = 5,
                        Rounds         = 2
                    });
                    str += " and are invulnerable for 1 turn";
                }

                await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} blesses {card.Signature}. They heal for {heal} HP{str}.");
            }

            OnCooldown      = true;
            CurrentCooldown = Cooldown;
            inst.GetCardTurn().Actions--;
        }
Esempio n. 24
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            foreach (BasicCard card in targets)
            {
                List <int> rolls = RandomGen.RollDice(4, 8);
                await MessageHandler.DiceThrow(inst.Location, "4d8", rolls);

                int damage = 0;
                foreach (int roll in rolls)
                {
                    damage += roll;
                }

                damage = inst.GetCardTurn().ApplyDamageBuffs(damage);
                var damages = card.TakeDamage(damage);
                await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} prances around {card.Signature}. {card.DamageTakenString(damages)}");

                var flip = RandomGen.CoinFlip();
                await MessageHandler.CoinFlip(inst.Location, flip);

                var flip2 = RandomGen.CoinFlip();
                await MessageHandler.CoinFlip(inst.Location, flip2);

                if (flip && flip2)
                {
                    await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} is hyper! They may use another ability.");

                    inst.GetCardTurn().Actions++;
                }
            }

            inst.GetCardTurn().Actions--;
        }
Esempio n. 25
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            foreach (BasicCard card in targets)
            {
                List <int> rolls = RandomGen.RollDice(3, 10);
                await MessageHandler.DiceThrow(inst.Location, "3d10", rolls);

                var damage = 0;
                foreach (int roll in rolls)
                {
                    damage += roll;
                }

                damage = inst.GetCardTurn().ApplyDamageBuffs(damage);
                var damages = card.TakeDamage(damage);

                await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} punches {card.Signature}! Their next attack is reduced by 15%. {card.DamageTakenString(damages)}");

                card.AddBuff(new BuffDebuff()
                {
                    Name                = "Stunned",
                    Buff                = false,
                    Origin              = $"({inst.GetCardTurn().Signature})",
                    Description         = "15% less damage on next attack.",
                    DamagePercentDebuff = 0.15,
                    Attacks             = 1
                });
            }

            OnCooldown      = true;
            CurrentCooldown = Cooldown;
            inst.GetCardTurn().Actions--;
        }
Esempio n. 26
0
        public override async Task MoveEffect(CombatInstance inst)
        {
            int damage = 25;

            damage = inst.GetCardTurn().ApplyDamageBuffs(damage);

            string str      = "";
            var    totalDam = 0;

            foreach (Team team in inst.Teams)
            {
                if (team.TeamNum != inst.GetTeam(inst.GetCardTurn()).TeamNum)
                {
                    foreach (UserAccount user in team.Members)
                    {
                        foreach (BasicCard card in user.ActiveCards)
                        {
                            var tempDams = card.TakeDamage(damage);
                            totalDam += tempDams[0];
                            str      += $"\n{card.DamageTakenString(tempDams)}";
                        }
                    }
                }
            }

            await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} swipes using their tail!{str}\n{inst.GetCardTurn().Signature} dealt a total of {totalDam} damage.");

            inst.GetCardTurn().Actions--;
        }
Esempio n. 27
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            foreach (BasicCard card in targets)
            {
                int heal = 35;

                heal = inst.GetCardTurn().ApplyHealingBuffs(heal, true);
                heal = card.Heal(heal, true);
                card.AddBuff(new BuffDebuff()
                {
                    Name              = "Mended",
                    Buff              = true,
                    Origin            = $"({inst.GetCardTurn().Signature})",
                    Description       = "100% increased damage.",
                    DamagePercentBuff = 1.00,
                    Attacks           = 1
                });

                await MessageHandler.SendMessage(inst.Location, $"{card.Signature} is mended by {inst.GetCardTurn().Signature}. They heal {heal} HP.");
            }

            OnCooldown      = true;
            CurrentCooldown = Cooldown;
            inst.GetCardTurn().Actions--;
        }
Esempio n. 28
0
        public override async Task MoveEffect(CombatInstance inst, List <BasicCard> targets)
        {
            foreach (BasicCard card in targets)
            {
                List <int> rolls = RandomGen.RollDice(3, 10);
                await MessageHandler.DiceThrow(inst.Location, "3d10", rolls);

                int damage = 0;
                foreach (int roll in rolls)
                {
                    damage += roll;
                }

                damage = inst.GetCardTurn().ApplyDamageBuffs(damage);
                var damages = card.TakeDamage(damage);

                await MessageHandler.SendMessage(inst.Location, $"{inst.GetCardTurn().Signature} laughs hysterically at {card.Signature}. {card.DamageTakenString(damages)} {inst.GetCardTurn().Signature} gains a 20% boost on their next attack.");

                inst.GetCardTurn().AddBuff(new BuffDebuff()
                {
                    Name              = "Hysterical",
                    Buff              = true,
                    Origin            = $"({inst.GetCardTurn().Signature})",
                    Description       = "20% increased damage on next attack.",
                    DamagePercentBuff = 0.2,
                    Attacks           = 1
                });
            }

            OnCooldown      = true;
            CurrentCooldown = Cooldown;
            inst.GetCardTurn().Actions--;
        }
        public override void Update(CombatInstance inst, BasicCard owner)
        {
            var playerCount = inst.CardList.Count;

            eff.DamagePercentBuff = 0.01 * (double)playerCount;

            Status = $"Currently at **{eff.DamagePercentBuff*100.0}%** increased damage.";
        }
Esempio n. 30
0
        public override void Update(CombatInstance inst, BasicCard owner)
        {
            var playerCount = inst.CardList.Count;

            eff.DamageStaticBuff = 1 * playerCount;

            Status = $"Currently at **{eff.DamageStaticBuff}** bonus damage.";
        }