public void TestRenderFieldGrid_PlayerAtStartPosition()
        {
            int[,] labyrinthGrid = new int[7, 7]
                        {
                            {0, 0, 1, 1, 0, 1, 1},
                            {1, 1, 1, 0, 0, 0, 1},
                            {0, 0, 0, 0, 1, 0, 0},
                            {1, 0, 1, 0, 1, 1, 1},
                            {1, 0, 0, 1, 0, 0, 0},
                            {1, 0, 1, 0, 0, 1, 1},
                            {1, 0, 0, 1, 0, 1, 0}
                        };
            Playfield playfield = new Playfield(labyrinthGrid);

            string actualOutput = Renderer.RenderField(playfield.LabyrinthGrid,
                                                       playfield.PlayerPosition.Row, playfield.PlayerPosition.Col);

            StringBuilder expectedOutput = new StringBuilder();
            expectedOutput.AppendLine("--XX-XX");
            expectedOutput.AppendLine("XXX---X");
            expectedOutput.AppendLine("----X--");
            expectedOutput.AppendLine("X-X*XXX");
            expectedOutput.AppendLine("X--X---");
            expectedOutput.AppendLine("X-X--XX");
            expectedOutput.AppendLine("X--X-X-");

            bool areEqual = actualOutput == expectedOutput.ToString();
            Assert.IsTrue(areEqual);
        }
        public static void PrintTable(Playfield playfield)
        {
            string columnHeader = "    ";
            for (int i = 0; i < playfield.Width; i++)
            {
                columnHeader += i.ToString().PadLeft(3);
            }

            Console.WriteLine(columnHeader);

            Console.WriteLine("    " + new String('-', playfield.Width * 3));

            for (int row = 0; row < playfield.Height; row++)
            {
                Console.Write(row.ToString().PadLeft(2) + " | ");
                for (int col = 0; col < playfield.Width; col++)
                {
                    Console.Write(playfield.Field[row, col].ToString().PadLeft(2) + " ");
                }

                Console.WriteLine("| ");
            }

            Console.WriteLine("    " + new String('-', playfield.Width * 3));
        }
        public void TestIsValidMove_CanMoveDown()
        {
            int[,] labyrinthGrid = new int[7, 7]
                        {
                            {0, 1, 1, 0, 1, 1, 1},
                            {0, 0, 0, 0, 0, 0, 1},
                            {1, 0, 1, 0, 1, 0, 1},
                            {1, 0, 1, 0, 1, 0, 0},
                            {0, 1, 1, 1, 1, 1, 0},
                            {0, 0, 1, 0, 0, 0, 1},
                            {1, 0, 0, 0, 0, 0, 0}
                        };

            Playfield playfield = new Playfield(labyrinthGrid);

            //Moving playerPosition at row=5 and col=2
            playfield.PlayerPosition.MoveAtDirection(Direction.Up);
            playfield.PlayerPosition.MoveAtDirection(Direction.Up);
            playfield.PlayerPosition.MoveAtDirection(Direction.Right);
            playfield.PlayerPosition.MoveAtDirection(Direction.Right);
            playfield.PlayerPosition.MoveAtDirection(Direction.Down);

            Direction directionDown = Direction.Down;
            bool expected = true;
            bool actual = MovesChecker.IsValidMove(playfield, directionDown);
            Assert.AreEqual(expected, actual);
        }
        public void TestGetTopResults()
        {
            Playfield playfield = new Playfield();
            GameEngine engine = new GameEngine(playfield);

            string expected = engine.GetTopResults();
            string actual = new ScoreBoard().ShowScoreboard();
            Assert.AreEqual(expected, actual);
        }
        public void TestInitializeField_IsCorrectStartPosition()
        {
            Playfield playfield = new Playfield();
            playfield.InitializeField();

            Position expected = new Position(3, 3);
            Position actual = playfield.PlayerPosition;
            Assert.AreEqual(expected.Row, actual.Row);
            Assert.AreEqual(expected.Col, actual.Col);
        }
        public void TestInitializeNewGame_ScoreIsUpdated()
        {
            Playfield playfield = new Playfield();
            GameEngine engine = new GameEngine(playfield);
            engine.MoveAtDirection(Direction.Down, engine.MoveDown);
            engine.InitializeNewGame();

            int expected = 0;
            int actual = engine.Score;
            Assert.AreEqual(expected, actual);
        }
        public void TestMoveAtDirection_MoveAtUp()
        {
            Playfield playfield = new Playfield();
            GameEngine engine = new GameEngine(playfield);
            engine.MoveAtDirection(Direction.Up, engine.MoveUp);

            Position expected = new Position(2, 3);
            Position actual = playfield.PlayerPosition;
            Assert.AreEqual(expected.Row, actual.Row);
            Assert.AreEqual(expected.Col, actual.Col);
        }
        public void TestProcessInput_OnWriteExit()
        {
            Playfield playfield = new Playfield();
            GameEngine engine = new GameEngine(playfield);
            AssignEvents(engine, engine.UserInput);
            engine.UserInput.ProcessInput("exit");

            bool expected = true;
            bool actual = engine.HasGameQuit;
            Assert.AreEqual(expected, actual);
        }
        public void TestProcessInput_OnWriteRestart()
        {
            Playfield playfield = new Playfield();
            GameEngine engine = new GameEngine(playfield);
            AssignEvents(engine, engine.UserInput);
            engine.UserInput.ProcessInput("restart");

            int expected = 0;
            int actual = engine.Score;
            Assert.AreEqual(expected, actual);
        }
        public void TestProcessInput_OnWriteR()
        {
            Playfield playfield = new Playfield();
            GameEngine engine = new GameEngine(playfield);
            AssignEvents(engine, engine.UserInput);
            engine.UserInput.ProcessInput("R");

            Position expected = new Position(3, 4);
            Position actual = playfield.PlayerPosition;

            Assert.AreEqual(expected.Row, actual.Row);
            Assert.AreEqual(expected.Col, actual.Col);
        }
        public void TestInitializeField_IsClearPlayerPosition()
        {
            Playfield playfield = new Playfield();
            playfield.InitializeField();

            int expectedRow = 3;
            int expectedCol = 3;
            int actualRow = playfield.PlayerPosition.Row;
            int actualCol = playfield.PlayerPosition.Col;

            Position actual = playfield.PlayerPosition;
            Assert.AreEqual(expectedRow, actualRow);
            Assert.AreEqual(expectedCol, actualCol);
        }
        public void TestIsVictory_NorthEastCornerExit()
        {
            int[,] labyrinthGrid = new int[7, 7]
                        {
                            {0, 0, 1, 1, 1, 1, 0},
                            {1, 1, 1, 1, 0, 0, 1},
                            {0, 0, 0, 1, 0, 1, 0},
                            {1, 0, 1, 0, 0, 1, 1},
                            {0, 1, 0, 1, 1, 0, 0},
                            {0, 0, 1, 0, 0, 0, 0},
                            {0, 0, 1, 0, 1, 0, 0}
                        };
            Position customPosition = new Position(0, 6);
            Playfield playfield = new Playfield(labyrinthGrid, customPosition);

            bool expected = true;
            bool actual = playfield.IsVictory();
            Assert.AreEqual(expected, actual);
        }
        public void TestIsValidMove_CanMoveRight()
        {
            int[,] labyrinthGrid = new int[7, 7]
                        {
                            {0, 0, 1, 1, 1, 1, 1},
                            {1, 1, 1, 1, 1, 1, 1},
                            {0, 0, 0, 0, 0, 0, 0},
                            {1, 0, 1, 0, 0, 1, 1},
                            {0, 1, 0, 1, 0, 0, 0},
                            {0, 0, 1, 0, 0, 0, 0},
                            {0, 0, 0, 0, 0, 0, 0}
                        };

            Playfield playfield = new Playfield(labyrinthGrid);
            Direction directionRight = Direction.Right;

            bool expected = true;
            bool actual = MovesChecker.IsValidMove(playfield, directionRight);
            Assert.AreEqual(expected, actual);
        }
        public void TestRenderFieldGrid_PlayerAtOtherPosition()
        {
            int[,] labyrinthGrid = new int[7, 7]
                        {
                            {0, 0, 1, 1, 0, 1, 1},
                            {1, 1, 1, 0, 0, 0, 1},
                            {0, 0, 0, 0, 1, 0, 0},
                            {1, 0, 1, 0, 1, 1, 1},
                            {1, 0, 0, 1, 0, 0, 0},
                            {1, 0, 1, 0, 0, 1, 1},
                            {1, 0, 0, 1, 0, 1, 0}
                        };
            Playfield playfield = new Playfield(labyrinthGrid);

            //Moving playerPosition at row=2 and col=6 (start index=0)
            playfield.PlayerPosition.MoveAtDirection(Direction.Up);
            playfield.PlayerPosition.MoveAtDirection(Direction.Up);
            playfield.PlayerPosition.MoveAtDirection(Direction.Right);
            playfield.PlayerPosition.MoveAtDirection(Direction.Right);
            playfield.PlayerPosition.MoveAtDirection(Direction.Down);
            playfield.PlayerPosition.MoveAtDirection(Direction.Right);

            string actualOutput = Renderer.RenderField(playfield.LabyrinthGrid,
                                                       playfield.PlayerPosition.Row, playfield.PlayerPosition.Col);

            StringBuilder expectedOutput = new StringBuilder();
            expectedOutput.AppendLine("--XX-XX");
            expectedOutput.AppendLine("XXX---X");
            expectedOutput.AppendLine("----X-*");
            expectedOutput.AppendLine("X-X-XXX");
            expectedOutput.AppendLine("X--X---");
            expectedOutput.AppendLine("X-X--XX");
            expectedOutput.AppendLine("X--X-X-");

            bool areEqual = actualOutput == expectedOutput.ToString();
            Assert.IsTrue(areEqual);
        }
Exemple #15
0
        //Battlecry: Adapt, then Adapt.

        public override void GetBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
        {
            p.getBestAdapt(own);
            p.getBestAdapt(own);
        }
Exemple #16
0
 public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
 {
     p.drawACard(CardDB.cardName.unknown, own.own, true);
 }
Exemple #17
0
 public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
 {
 }
Exemple #18
0
 public int getManaCost(Playfield p)
 {
     return(this.card.getManaCost(p, this.manacost));
 }
Exemple #19
0
        CardDB.Card wcard = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_398t); //battleaxe

        public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
        {
            p.equipWeapon(wcard, own.own);
        }
Exemple #20
0
 public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
 {
     p.equipWeapon(weapon, ownplay);
 }
Exemple #21
0
 public virtual void onTurnStartTrigger(Playfield p, Minion triggerEffectMinion, bool turnStartOfOwner)
 {
     return;
 }
        public override int getPlayfieldValue(Playfield p)
        {
            if (p.value >= -2000000)
            {
                return(p.value);
            }
            int retval = 0;

            retval -= p.evaluatePenality;
            retval += p.owncards.Count * 1;

            retval += p.ownHeroHp + p.ownHeroDefence;
            retval += -(p.enemyHeroHp + p.enemyHeroDefence);

            retval += p.ownMaxMana * 15 - p.enemyMaxMana * 15;

            if (p.ownWeaponAttack >= 1)
            {
                retval += p.ownWeaponAttack * p.ownWeaponDurability;
            }

            if (!p.enemyHeroFrozen)
            {
                retval -= p.enemyWeaponDurability * p.enemyWeaponAttack;
            }
            else
            {
                if (p.enemyHeroName != HeroEnum.mage && p.enemyHeroName != HeroEnum.priest)
                {
                    retval += 11;
                }
            }

            retval += p.owncarddraw * 5;
            retval -= p.enemycarddraw * 15;

            bool useAbili = false;
            bool usecoin  = false;

            foreach (Action a in p.playactions)
            {
                if (a.heroattack && p.enemyHeroHp <= p.attackFaceHP)
                {
                    retval++;
                }
                if (a.useability)
                {
                    useAbili = true;
                }
                if (p.ownHeroName == HeroEnum.warrior && a.heroattack && useAbili)
                {
                    retval -= 1;
                }
                if (a.useability && a.handcard.card.name == CardDB.cardName.lesserheal && ((a.enemytarget >= 10 && a.enemytarget <= 20) || a.enemytarget == 200))
                {
                    retval -= 5;
                }
                if (!a.cardplay)
                {
                    continue;
                }
                if ((a.handcard.card.name == CardDB.cardName.thecoin || a.handcard.card.name == CardDB.cardName.innervate))
                {
                    usecoin = true;
                }
                if (a.handcard.card.name == CardDB.cardName.flamestrike && a.numEnemysBeforePlayed <= 2)
                {
                    retval -= 20;
                }
            }
            if (usecoin && useAbili && p.ownMaxMana <= 2)
            {
                retval -= 40;
            }
            //if (usecoin && p.mana >= 1) retval -= 20;

            foreach (Minion m in p.ownMinions)
            {
                retval += m.Hp * 1;
                retval += m.Angr * 2;
                retval += m.handcard.card.rarity;
                if (m.windfury)
                {
                    retval += m.Angr;
                }
                if (m.taunt)
                {
                    retval += 1;
                }
                if (!m.taunt && m.stealth && penman.specialMinions.ContainsKey(m.name))
                {
                    retval += 20;
                }
                if (m.handcard.card.name == CardDB.cardName.silverhandrecruit && m.Angr == 1 && m.Hp == 1)
                {
                    retval -= 5;
                }
                if (m.handcard.card.name == CardDB.cardName.direwolfalpha || m.handcard.card.name == CardDB.cardName.flametonguetotem || m.handcard.card.name == CardDB.cardName.stormwindchampion || m.handcard.card.name == CardDB.cardName.raidleader)
                {
                    retval += 10;
                }
            }

            foreach (Minion m in p.enemyMinions)
            {
                retval -= this.getEnemyMinionValue(m, p);
            }

            retval -= p.enemySecretCount;
            retval -= p.lostDamage;//damage which was to high (like killing a 2/1 with an 3/3 -> => lostdamage =2
            retval -= p.lostWeaponDamage;
            if (p.ownMinions.Count == 0)
            {
                retval -= 20;
            }
            if (p.enemyMinions.Count >= 4)
            {
                retval -= 20;
            }
            if (p.enemyHeroHp <= 0)
            {
                retval = 10000;
            }
            //soulfire etc
            int deletecardsAtLast = 0;

            foreach (Action a in p.playactions)
            {
                if (!a.cardplay)
                {
                    continue;
                }
                if (a.handcard.card.name == CardDB.cardName.soulfire || a.handcard.card.name == CardDB.cardName.doomguard || a.handcard.card.name == CardDB.cardName.succubus)
                {
                    deletecardsAtLast = 1;
                }
                if (deletecardsAtLast == 1 && !(a.handcard.card.name == CardDB.cardName.soulfire || a.handcard.card.name == CardDB.cardName.doomguard || a.handcard.card.name == CardDB.cardName.succubus))
                {
                    retval -= 20;
                }
            }
            if (p.enemyHeroHp >= 1 && p.guessingHeroHP <= 0)
            {
                retval += p.owncarddraw * 500;
                retval -= 1000;
            }
            if (p.ownHeroHp <= 0)
            {
                retval = -10000;
            }

            p.value = retval;
            return(retval);
        }
Exemple #23
0
        //    Give each player a Mana Crystal.

        public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
        {
            p.drawACard(CardDB.cardIDEnum.None, true);
            p.drawACard(CardDB.cardIDEnum.None, false);
        }
Exemple #24
0
        CardDB.Card kid = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_160t); //panther
//    ruft einen panther (3/2) herbei.

        public override void OnCardPlay(Playfield p, bool ownplay, Minion target, int choice)
        {
            int posi = (ownplay) ? p.ownMinions.Count : p.enemyMinions.Count;

            p.callKid(kid, posi, true);
        }
Exemple #25
0
        //Give a friendly minion Charge. It can't attack heroes this turn.

        public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
        {
            p.minionGetCharge(target);
            target.cantAttackHeroes = true;
        }
Exemple #26
0
//    +5 angriff.
        public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
        {
            p.minionGetBuffed(own, 5, 0);
        }
Exemple #27
0
 public virtual void onAuraEnds(Playfield p, Minion m)
 {
     return;
 }
Exemple #28
0
 // Start is called before the first frame update
 void Start()
 {
     Playfield.insertLines(8, Brick);
 }
Exemple #29
0
 public virtual void onAHeroGotHealedTrigger(Playfield p, Minion triggerEffectMinion, bool ownerOfHeroGotHealed)
 {
     return;
 }
Exemple #30
0
//    bringt alle feindlichen diener zum schweigen/. zieht eine karte.

        public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
        {
            p.allMinionsGetSilenced(!ownplay);
            p.drawACard(CardDB.cardName.unknown, ownplay);
        }
Exemple #31
0
        // Deal 4 damage. Costs (1) less for each minion that died this turn.

        public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
        {
            int dmg = (ownplay) ? p.getSpellDamageDamage(4) : p.getEnemySpellDamageDamage(4);

            p.minionGetDamageOrHeal(target, dmg);
        }
Exemple #32
0
        //    Deal $2 damage to all enemy minions and Freeze them.
        public override void OnCardPlay(Playfield p, bool ownplay, Minion target, int choice)
        {
            int dmg = (ownplay) ? p.getSpellDamageDamage(2) : p.getEnemySpellDamageDamage(2);

            p.allMinionOfASideGetDamage(!ownplay, dmg, true);
        }
Exemple #33
0
        //Battlecry: Reveal a minion in each deck. If yours costs more, gain +1/+1.


        public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
        {
            //we assume we get the buff!
            p.minionGetBuffed(own, 1, 1);
        }
Exemple #34
0
        //Battlecry: Reveal a minion in each deck.If yours costs more, gain Charge.

        public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
        {
            p.minionGetCharge(own); // optimistic
        }
Exemple #35
0
 public bool canplayCard(Playfield p, bool own)
 {
     return(this.card.canplayCard(p, this.manacost, own));
 }
Exemple #36
0
 public virtual void onMinionDiedTrigger(Playfield p, Minion triggerEffectMinion, Minion diedMinion)
 {
     return;
 }
Exemple #37
0
//    kampfschrei:/ fügt allen anderen charakteren 1 schaden zu.
        public override void GetBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
        {
            int dmg = 1;

            p.allCharsGetDamage(dmg); // dreadinfernal is not on board yet!
        }
Exemple #38
0
 public virtual void onDeathrattle(Playfield p, Minion m)
 {
     return;
 }
Exemple #39
0
        //   Taunt

        public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
        {
        }
Exemple #40
0
        public override float getPlayfieldValue(Playfield p)
        {
            if (p.value >= -2000000) return p.value;
            int retval = 0;
            retval -= p.evaluatePenality;
            retval += p.owncards.Count * 3;

            retval += p.ownHero.Hp + p.ownHero.armor;
            retval += -(p.enemyHero.Hp + p.enemyHero.armor);

            retval += p.ownMaxMana * 15 - p.enemyMaxMana * 15;

            if (p.ownWeaponAttack >= 1)
            {
                retval += p.ownWeaponAttack * p.ownWeaponDurability;
            }

            if (!p.enemyHero.frozen)
            {
                retval -= p.enemyWeaponDurability * p.enemyWeaponAttack;
            }
            else
            {
                if (p.enemyHeroName != HeroEnum.mage && p.enemyHeroName != HeroEnum.priest)
                {
                    retval += 11;
                }
            }

            //RR card draw value depending on the turn and distance to lethal
            //RR if lethal is close, carddraw value is increased


            if (sf.Ai.lethalMissing <= 5) //RR
            {
                retval += p.owncarddraw * 100;
            }
            if (p.ownMaxMana < 4)
            {
                retval += p.owncarddraw * 2;
            }
            else
            {
                retval += p.owncarddraw * 5;
            }
            retval += p.owncarddraw * 5;
            retval -= p.enemycarddraw * 15;

            bool useAbili = false;
            bool usecoin = false;
            foreach (Action a in p.playactions)
            {
                if (a.actionType == actionEnum.attackWithHero && p.enemyHero.Hp <= p.attackFaceHP) retval++;
                if (a.actionType == actionEnum.useHeroPower) useAbili = true;
                if (p.ownHeroName == HeroEnum.warrior && a.actionType == actionEnum.attackWithHero && useAbili) retval -= 1;
                //if (a.actionType == actionEnum.useHeroPower && a.card.card.name == CardDB.cardName.lesserheal && (!a.target.own)) retval -= 5;
                if (a.actionType != actionEnum.playcard) continue;
                if ((a.card.card.name == CardDB.cardName.thecoin || a.card.card.name == CardDB.cardName.innervate)) usecoin = true;
            }
            if (usecoin && useAbili && p.ownMaxMana <= 2) retval -= 40;
            if (usecoin) retval -= 5 * p.manaTurnEnd;
            if (p.manaTurnEnd >= 2 && !useAbili)
            {
                retval -= 10;
                if (p.ownHeroName == HeroEnum.thief && (p.ownWeaponDurability >= 2 || p.ownWeaponAttack >= 2)) retval += 10;
            }
            //if (usecoin && p.mana >= 1) retval -= 20;

            foreach (Minion m in p.ownMinions)
            {
                retval += m.Hp * 1;
                retval += m.Angr * 2;
                retval += m.handcard.card.rarity;
                if (m.windfury) retval += m.Angr;
                if (m.taunt) retval += 1;
                if (!m.taunt && m.stealth && m.handcard.card.isSpecialMinion) retval += 20;
                if (m.handcard.card.name == CardDB.cardName.silverhandrecruit && m.Angr == 1 && m.Hp == 1) retval -= 5;
                if (m.handcard.card.name == CardDB.cardName.direwolfalpha || m.handcard.card.name == CardDB.cardName.flametonguetotem || m.handcard.card.name == CardDB.cardName.stormwindchampion || m.handcard.card.name == CardDB.cardName.raidleader) retval += 10;
                if (m.handcard.card.name == CardDB.cardName.nerubianegg)
                {
                    if (m.Angr >= 1) retval += 2;
                    if ((!m.taunt && m.Angr == 0) && (m.divineshild || m.maxHp > 2)) retval -= 10;
                }
            }

            foreach (Minion m in p.enemyMinions)
            {
                retval -= this.getEnemyMinionValue(m, p);
            }

            retval -= p.enemySecretCount;
            retval -= p.lostDamage;//damage which was to high (like killing a 2/1 with an 3/3 -> => lostdamage =2
            retval -= p.lostWeaponDamage;
            if (p.ownMinions.Count == 0) retval -= 20;
            if (p.enemyMinions.Count >= 4) retval -= 20;
            if (p.enemyHero.Hp <= 0) retval = 10000;
            //soulfire etc
            int deletecardsAtLast = 0;
            foreach (Action a in p.playactions)
            {
                if (a.actionType != actionEnum.playcard) continue;
                if (a.card.card.name == CardDB.cardName.soulfire || a.card.card.name == CardDB.cardName.doomguard || a.card.card.name == CardDB.cardName.succubus) deletecardsAtLast = 1;
                if (deletecardsAtLast == 1 && !(a.card.card.name == CardDB.cardName.soulfire || a.card.card.name == CardDB.cardName.doomguard || a.card.card.name == CardDB.cardName.succubus)) retval -= 20;
            }
            if (p.enemyHero.Hp >= 1 && p.guessingHeroHP <= 0)
            {
                if (p.turnCounter < 2) retval += p.owncarddraw * 500;
                retval -= 1000;
            }
            if (p.ownHero.Hp <= 0) retval = -10000;

            p.value = retval;
            return retval;
        }
Exemple #41
0
        public override void OnAdaptChoice(Playfield p, bool ownplay, Minion target, CardDB.cardIDEnum choice)
        {
            List <Minion> temp = p.ownMinions;

            switch (choice)
            {
            case CardDB.cardIDEnum.UNG_999t3:      // 3attack
            {
                p.minionGetBuffed(target, 3, 0);
                break;
            }

            case CardDB.cardIDEnum.UNG_999t8:    //divine shield
            {
                target.divineshild = true;
                break;
            }

            case CardDB.cardIDEnum.UNG_999t13:     //poisonous
            {
                target.poisonous = true;
                break;
            }

            case CardDB.cardIDEnum.UNG_999t14:    // +1/+1
            {
                p.minionGetBuffed(target, 1, 1);
                break;
            }

            case CardDB.cardIDEnum.UNG_999t4:    // 3hp
            {
                p.minionGetBuffed(target, 0, 3);
                break;
            }

            case CardDB.cardIDEnum.UNG_999t2:    //deathrattle 2 1/1 plants
            {
                target.livingspores++;
                break;
            }

            case CardDB.cardIDEnum.UNG_999t7:     //windfury
            {
                p.minionGetWindfurry(target);
                break;
            }

            case CardDB.cardIDEnum.UNG_999t6:     //taunt
            {
                target.taunt = true;
                break;
            }

            case CardDB.cardIDEnum.UNG_999t10:    //stealth
            {
                target.stealth = true;
                break;
            }

            case CardDB.cardIDEnum.UNG_999t5:    //can't be targeted
            {
                target.AdaptedCantBeTargetedBySpellsOrHeroPowers++;
                break;
            }

            default: break;
            }
        }
 /// <summary>
 /// Creates the playfield matrix with the balloons in it
 /// </summary>
 public override Playfield CreatePlayfield()
 {
     var smallPlayfield = new Playfield(Width, Height);
     return smallPlayfield;
 }
Exemple #43
0
        CardDB.Card c = CardDB.Instance.getCardDataFromID(CardDB.cardIDEnum.EX1_534t);//hyena

        public override void onDeathrattle(Playfield p, Minion m)
        {
            p.callKid(c, m.zonepos - 1, m.own);
            p.callKid(c, m.zonepos - 1, m.own);
        }
        public override int getEnemyMinionValue(Minion m, Playfield p)
        {
           
            int retval = 5;
            retval += m.Hp * 2;
            if (!m.frozen && !((m.name == CardDB.cardName.ancientwatcher || m.name == CardDB.cardName.ragnarosthefirelord) && !m.silenced))
            {
                retval += m.Angr * 2;
                if (m.windfury) retval += m.Angr * 2;
                if (m.Angr >= 4) retval += 10;
                if (m.Angr >= 7)
                {
                    //this might be faster, than creating new lists, use findall and loop over them
                    int enemyAttackerscount = 0;
                    int ownTauntCount = 0;
                    int ownTauntHP = 0;
                    int enemyTotalAttack = 0;

                    foreach (Minion min in p.enemyMinions)
                    {
                        if (min.Angr >= 1)
                        {
                            enemyTotalAttack += min.Angr;
                            enemyAttackerscount++;
                        }

                    }

                    foreach (Minion min in p.ownMinions)
                    {
                        if (min.taunt)
                        {
                            ownTauntCount++;
                            ownTauntHP += min.Hp;
                        }
                    }

                    if (ownTauntCount < enemyAttackerscount && ownTauntHP <= enemyTotalAttack) retval += 30;

                }
            }

            if (m.Angr == 0) retval -= 7;

            retval += m.handcard.card.rarity;
            if (m.taunt) retval += 5;
            if (m.divineshild) retval += m.Angr;
            if (m.divineshild && m.taunt) retval += 5;
            if (m.stealth) retval += 1;

            if (m.poisonous) retval += 4;

            if (m.handcard.card.targetPriority >= 1 && !m.silenced)
            {
                retval += m.handcard.card.targetPriority;
            }
            if (m.name == CardDB.cardName.nerubianegg && m.Angr <= 3 && !m.taunt) retval = 0;

            

            return retval;
        }
Exemple #45
0
 public virtual void onEnrageStop(Playfield p, Minion m)
 {
     return;
 }
Exemple #46
0
 public new void AddNested(Playfield playfield)
 {
     AddInternal(playfield);
     base.AddNested(playfield);
 }
Exemple #47
0
 public virtual void onSecretPlay(Playfield p, bool ownplay, Minion attacker, Minion target, out int number)
 {
     number = 0;
 }
Exemple #48
0
        //Deathrattle: Copy a card from your opponent's deck and add it to your hand.

        public override void onDeathrattle(Playfield p, Minion m)
        {
            p.drawACard(SimCard.None, m.own, true);
        }
Exemple #49
0
 public virtual void onMinionGotDmgTrigger(Playfield p, Minion triggerEffectMinion, bool ownDmgdMinion)
 {
     return;
 }
Exemple #50
0
 public override float getPlayPenalty(Playfield p, Handmanager.Handcard hc, Minion target, int choice, bool isLethal)
 {
     return(0);
 }
Exemple #51
0
 public virtual void onMinionWasSummoned(Playfield p, Minion triggerEffectMinion, Minion summonedMinion)
 {
     return;
 }
Exemple #52
0
        CardDB.Card kid = CardDB.Instance.getCardDataFromID(CardIdEnum.KAR_030);//Cellar Spider

        public override void getBattlecryEffect(Playfield p, Minion own, Minion target, int choice)
        {
            p.CallKid(kid, own.zonepos, own.own);
        }
Exemple #53
0
        public override int getEnemyMinionValue(Minion m, Playfield p)
        {
            int retval = 0;
            if (p.enemyMinions.Count >= 4 || m.taunt || (m.handcard.card.targetPriority >= 1 && !m.silenced) || m.Angr >= 5)
            {
                retval += m.Hp;
                if (!m.frozen && !((m.name == CardDB.cardName.ancientwatcher || m.name == CardDB.cardName.ragnarosthefirelord) && !m.silenced))
                {
                    retval += m.Angr * 2;
                    if (m.windfury) retval += 2 * m.Angr;
                }
                if (m.taunt) retval += 5;
                if (m.divineshild) retval += m.Angr;
                if (m.frozen) retval -= 1; // because its bad for enemy :D
                if (m.poisonous) retval += 4;
                retval += m.handcard.card.rarity;
            }


            if (m.handcard.card.targetPriority >= 1 && !m.silenced) retval += m.handcard.card.targetPriority;
            if (m.Angr >= 4) retval += 20;
            if (m.Angr >= 7) retval += 50;
            if (m.name == CardDB.cardName.nerubianegg && m.Angr <= 3 && !m.taunt) retval = 0;
            return retval;
        }
Exemple #54
0
//    kampfschrei:/ stellt 3 leben wieder her.
        public override int getPlayPenalty(Playfield p, Minion m, Minion target, int choice, bool isLethal)
        {
            return(0);
        }
 /// <summary>
 /// Creates the playfield matrix with the balloons in it
 /// </summary>
 public override Playfield CreatePlayfield()
 {
     var largePlayfield = new Playfield(Width, Height);
     return largePlayfield;
 }
Exemple #56
0
        // Add a random Demon to your hand.

        public override void onCardPlay(Playfield p, bool ownplay, Minion target, int choice)
        {
            p.drawACard(CardDB.cardIDEnum.CFM_621_m4, ownplay, true);
        }
 //other value of the board for enemys turn? (currently the same as getplayfield value)
 public override float getPlayfieldValueEnemy(Playfield p)
 {
     return getPlayfieldValue(p);
 }
Exemple #58
0
        //  Deathrattle: Deal 2 damage to all minions.

        public override void onDeathrattle(Playfield p, Minion m)
        {
            p.allMinionsGetDamage(2);
        }
        public override float getPlayfieldValue(Playfield p)
        {
            
            if (p.value >= -2000000) return p.value;
            int retval = 0;
            int hpboarder = 10;
            if (p.ownHeroName == HeroEnum.warlock && p.enemyHeroName != HeroEnum.mage) hpboarder = 6;
            int aggroboarder = 11;
            retval -= p.evaluatePenality;
            retval += p.owncards.Count * 5;

            retval += p.ownMaxMana;
            retval -= p.enemyMaxMana;
            
            retval += p.ownMaxMana * 20 - p.enemyMaxMana * 20;

            
            if (p.enemyHeroName == HeroEnum.mage || p.enemyHeroName == HeroEnum.druid) retval -= 2 * p.enemyspellpower;

            if (p.ownHero.Hp + p.ownHero.armor > hpboarder)
            {
                retval += p.ownHero.Hp + p.ownHero.armor;
            }
            else
            {
                retval -= 2 * (hpboarder + 1 - p.ownHero.Hp - p.ownHero.armor) * (hpboarder + 1 - p.ownHero.Hp - p.ownHero.armor);
            }

            if (p.enemyHero.Hp + p.enemyHero.armor > aggroboarder)
            {
                retval += -p.enemyHero.Hp - p.enemyHero.armor;
            }
            else
            {
                retval += 3 * (aggroboarder + 1 - p.enemyHero.Hp - p.enemyHero.armor);
            }

            if (p.ownWeaponAttack >= 1)
            {
                retval += p.ownWeaponAttack * p.ownWeaponDurability;
            }

            if (!p.enemyHero.frozen)
            {
                retval -= p.enemyWeaponDurability * p.enemyWeaponAttack;
            }
            else
            {
                if (p.enemyWeaponDurability >= 1)
                {
                    retval += 12;
                }
            }
            
            //RR card draw value depending on the turn and distance to lethal
            //RR if lethal is close, carddraw value is increased
            if (Ai.Instance.lethalMissing <= 5 && p.turnCounter ==0) //RR
            {
                retval += p.owncarddraw * 100;
            }
            if (p.ownMaxMana <= 4)
            {
                retval += p.owncarddraw * 2;
            }
            else
            {
                //retval += p.owncarddraw * 5;
                // value card draw this turn > card draw next turn (the sooner the better)
                retval += (p.turnCounter < 2 ? p.owncarddraw * 5 : p.owncarddraw * 3);
            }

            //retval += p.owncarddraw * 5;
            retval -= (p.enemycarddraw-p.anzEnemyCursed) * 10;

            //int owntaunt = 0;
            int readycount = 0;
            int ownMinionsCount = 0;

            bool enemyhaspatron = false;

            //
            bool canPingMinions = (p.ownHeroAblility.card.name == CardDB.cardName.fireblast);
            bool hasPingedMinion = false;


            foreach (Minion m in p.enemyMinions)
            {
                if (m.name == CardDB.cardName.grimpatron && !m.silenced) enemyhaspatron = true;

                int currMinionValue = this.getEnemyMinionValue(m, p);

                // Give a bonus for 1 hp minions as a mage, since we can remove it easier in the future with ping.
                // But we make sure we only give this bonus once among all enemies. We also give another +1 bonus once if the atk >= 4.
                if (canPingMinions && !hasPingedMinion && currMinionValue > 2 && m.Hp == 1)
                {
                    currMinionValue -= 1;
                    canPingMinions = false;  // only 1 per turn (-1 bonus regardless of atk)
                    hasPingedMinion = true;
                }
                if (hasPingedMinion && currMinionValue > 2 && m.Hp == 1 && m.Angr >= 4)
                {
                    currMinionValue -= 1;
                    hasPingedMinion = false;  // only 1 per turn (-1 bonus additional for atk >= 4)
                }

                retval -= currMinionValue;

                //hasTank = hasTank || m.taunt;
            }

            foreach (Minion m in p.ownMinions)
            {
                retval += 5;
                retval += m.Hp * 2;
                retval += m.Angr * 2;
                retval += m.handcard.card.rarity;
                if (!m.playedThisTurn && m.windfury) retval += m.Angr;
                if (m.divineshild) retval += 1;
                if (m.stealth) retval += 1;
                if (m.handcard.card.isSpecialMinion)
                {
                    retval += 1;
                    if (!m.taunt && m.stealth) retval += 20;
                }
                else
                {
                    if (m.Angr <= 2 && m.Hp <= 2 && !m.divineshild) retval -= 5;
                }
                //if (m.Angr <= m.Hp + 1) retval += m.Angr;
                //if (!m.taunt && m.stealth && penman.specialMinions.ContainsKey(m.name)) retval += 20;
                //if (m.poisonous) retval += 1;
                if (m.divineshild && m.taunt) retval += 4;
                //if (m.taunt && m.handcard.card.name == CardDB.cardName.frog) owntaunt++;
                //if (m.handcard.card.isToken && m.Angr <= 2 && m.Hp <= 2) retval -= 5;
                //if (!penman.specialMinions.ContainsKey(m.name) && m.Angr <= 2 && m.Hp <= 2) retval -= 5;
                if (m.handcard.card.name == CardDB.cardName.direwolfalpha || m.handcard.card.name == CardDB.cardName.flametonguetotem || m.handcard.card.name == CardDB.cardName.stormwindchampion || m.handcard.card.name == CardDB.cardName.raidleader) retval += 10;
                if (m.handcard.card.name == CardDB.cardName.bloodmagethalnos) retval += 10;
                if (m.handcard.card.name == CardDB.cardName.nerubianegg)
                {
                    if (m.Angr >= 1) retval += 2;
                    if (m.divineshild || (m.maxHp > 2 && !m.destroyOnOwnTurnEnd)) retval -= 10;
                    if (p.ownMinions.Count >= 3) retval += 15;
                }
                if (m.Ready) readycount++;
                if (m.maxHp >= 4 && (m.Angr > 2 || m.Hp > 3)) ownMinionsCount++;
            }

           

            /*if (p.enemyMinions.Count >= 0)
            {
                int anz = p.enemyMinions.Count;
                if (owntaunt == 0) retval -= 10 * anz;
                retval += owntaunt * 10 - 11 * anz;
            }*/

            bool useAbili = false;
            int usecoin = 0;
            //bool lastCoin = false;
            foreach (Action a in p.playactions)
            {
                //lastCoin = false;
                if (a.actionType == actionEnum.attackWithHero && p.enemyHero.Hp <= p.attackFaceHP) retval++;
                if (a.actionType == actionEnum.useHeroPower) useAbili = true;
                if (p.ownHeroName == HeroEnum.warrior && a.actionType == actionEnum.attackWithHero && useAbili) retval -= 1;
                //if (a.actionType == actionEnum.useHeroPower && a.card.card.name == CardDB.cardName.lesserheal && (!a.target.own)) retval -= 5;
                if (a.actionType != actionEnum.playcard) continue;
                if (a.card.card.name == CardDB.cardName.thecoin)
                {
                    usecoin = 1;
                }
                if (a.card.card.name == CardDB.cardName.innervate)
                {
                    usecoin = 2;
                }
                //save spell for all classes: (except for rouge if he has no combo)
                if (a.target == null) continue;
                if (p.ownHeroName != HeroEnum.thief && a.card.card.type == CardDB.cardtype.SPELL && (!a.target.own && a.target.isHero) && a.card.card.name != CardDB.cardName.shieldblock) retval -= 11;
                if (p.ownHeroName == HeroEnum.thief && a.card.card.type == CardDB.cardtype.SPELL && (a.target.isHero && !a.target.own)) retval -= 11;
            }
            //dont waste mana!!
            if (usecoin>=1 && useAbili && p.ownMaxMana <= 2) retval -= 40;
            if (usecoin >= 1 && p.manaTurnEnd >= usecoin && p.owncards.Count <= 8) retval -= 100 * p.manaTurnEnd;
            int heropowermana = p.ownHeroAblility.card.getManaCost(p, 2);
            if (p.manaTurnEnd >= heropowermana && !useAbili && p.ownAbilityReady)
            {
                if (!(p.ownHeroName == HeroEnum.thief && (p.ownWeaponDurability >= 2 || p.ownWeaponAttack >= 2))) retval -= 20;
                if (p.ownHeroName == HeroEnum.pala && enemyhaspatron) retval += 20;
            }
            if (useAbili && usecoin == 2) retval -= 5;
            //if (usecoin && p.manaTurnEnd >= 1 && p.owncards.Count <= 8) retval -= 100;

            int mobsInHand = 0;
            int bigMobsInHand = 0;
            foreach (Handmanager.Handcard hc in p.owncards)
            {
                if (hc.card.type == CardDB.cardtype.MOB)
                {
                    mobsInHand++;
                    if (hc.card.Attack >= 3 && hc.card.Health >= 3) bigMobsInHand++;
                }
            }

            //stuff for not flooding board
            int mobsturnbegin = Hrtprozis.Instance.ownMinions.Count;
            if (ownMinionsCount > mobsturnbegin)
            {
                if (ownMinionsCount - p.enemyMinions.Count >= 3)
                {
                    retval += bigMobsInHand * 50 + mobsInHand * 10;
                }

                if (p.turnCounter <= 1 && p.ownMinions.Count - p.enemyMinions.Count >= 4)
                {
                    retval -= (p.ownMinions.Count - p.enemyMinions.Count - 3) * 10;
                }
            }


            //bool hasTank = false;
            

            /*foreach (SecretItem si in p.enemySecretList)
            {
                if (readycount >= 1 && !hasTank && si.canbeTriggeredWithAttackingHero)
                {
                    retval -= 100;
                }
                if (readycount >= 1 && p.enemyMinions.Count >= 1 && si.canbeTriggeredWithAttackingMinion)
                {
                    retval -= 100;
                }
                if (si.canbeTriggeredWithPlayingMinion && mobsInHand >= 1)
                {
                    retval -= 25;
                }
            }*/
            retval -= p.enemySecretCount;
            retval -= p.numEnemySecretsTurnEnd*50;
            //Helpfunctions.Instance.ErrorLog("sc:" + p.enemySecretCount+ " " + p.numEnemySecretsTurnEnd);
            retval -= p.lostDamage;//damage which was to high (like killing a 2/1 with an 3/3 -> => lostdamage =2
            retval -= p.lostWeaponDamage;

            //if (p.ownMinions.Count == 0) retval -= 20;
            //if (p.enemyMinions.Count == 0) retval += 20;
            
            if (p.enemyHero.Hp <= 0)
            {
                if (p.turnCounter <= 1)
                {
                    retval = 10000;
                }
                else
                {
                    retval += 50;//10000
                    if (p.numPlayerMinionsAtTurnStart == 0) retval += 50; // if we can kill the enemy even after a board clear, bigger bonus
                    if (p.loathebLastTurn > 0) retval += 50;  // give a bonus to turn 2 sims where we played loatheb in turn 1 to protect our lethal board

                }
            }
            else if (p.ownHero.Hp > 0)
            {
                // if our damage on board is lethal, give a strong bonus so enemy AI avoids this outcome in its turn (i.e. AI will clear our minions if it can instead of ignoring them)
                if (p.turnCounter == 1 && p.guessHeroDamage(true) >= p.enemyHero.Hp + p.enemyHero.armor) retval += 100;
            }


            //soulfire etc
            int deletecardsAtLast = 0;
            foreach (Action a in p.playactions)
            {
                if (a.actionType != actionEnum.playcard) continue;
                if (a.card.card.name == CardDB.cardName.soulfire || a.card.card.name == CardDB.cardName.doomguard || a.card.card.name == CardDB.cardName.succubus) deletecardsAtLast = 1;
                if (deletecardsAtLast == 1 && !(a.card.card.name == CardDB.cardName.soulfire || a.card.card.name == CardDB.cardName.doomguard || a.card.card.name == CardDB.cardName.succubus)) retval -= 20;
            }

            if (p.enemyHero.Hp >= 1 && p.ownHero.Hp <= 0)
            {
                //Helpfunctions.Instance.ErrorLog("turncounter " + p.turnCounter + " " + retval);
                if (p.turnCounter == 0) // own turn 
                {
                    //worst case: we die on own turn
                    retval += p.owncarddraw * 100;
                    retval = -10000;
                }
                else
                {
                    if (p.turnCounter == 1) // enemys first turn
                    {
                        retval += p.owncarddraw * 100;
                        retval -= 1000;
                    }
                    if (p.turnCounter >= 2)
                    {
                        //carddraw next turn doesnt count this turn :D
                        retval -= 100;
                    }
                }
                
                
                
            }

            //if (p.ownHero.Hp <= 0 && p.turnCounter < 2) retval = -10000;

            // give a bonus for making the enemy spend more mana dealing with our board, so boards where the enemy makes different plays
            // aren't considered as equal value (i.e. attacking the enemy and making him spend mana to heal vs not attacking at all)
            if (p.turnCounter == 1 || p.turnCounter == 3) retval += p.enemyMaxMana - p.mana;

            p.value = retval;
            return retval;
        }
Exemple #60
0
        //Deathrattle: Restore 8 Health to the enemy hero.

        public override void onDeathrattle(Playfield p, Minion m)
        {
            var heal = m.own ? p.getMinionHeal(8) : p.getEnemyMinionHeal(8);

            p.minionGetDamageOrHeal(m.own ? p.enemyHero : p.ownHero, -heal);
        }