public JSONObject toJSON() { JSONObject json = new JSONObject(); json.put("name", name); json.put("playerId", playerId); json.put("hero", hero.toJSON()); if (mana != maxMana) json.put("mana", mana); if (maxMana > 0) json.put("maxMana", maxMana); json.put("deckPos", deckPos); if (overload > 0) json.put("overload", overload); if (fatigueDamage > 0) json.put("fatigueDamage", fatigueDamage); if (minions.size() > 0) { JSONArray array = new JSONArray(); for (Minion minion : minions) { array.put(minion.toJSON()); } json.put("minions", array); } if (hand.size() > 0) { JSONArray array = new JSONArray(); for (Card card : hand) { array.put(card.toJSON()); } json.put("hand", array); } if (numCardsUsed > 0) { json.put("numCardsUsed", numCardsUsed); } return json; }
public JSONObject toJSON() { JSONObject json = new JSONObject(); json.put("p0_mana", p0_mana_); json.put("p1_mana", p1_mana_); json.put("p0_maxMana", p0_maxMana_); json.put("p1_maxMana", p0_maxMana_); json.put("p0_deckPos", p0_deckPos_); json.put("p1_deckPos", p1_deckPos_); JSONArray p0_minions = new JSONArray(); for (Minion minion : p0_minions_) p0_minions.put(minion.toJSON()); json.put("p0_minions", p0_minions); JSONArray p1_minions = new JSONArray(); for (Minion minion : p1_minions_) p1_minions.put(minion.toJSON()); json.put("p1_minions", p1_minions); JSONArray p0_hand = new JSONArray(); for (Card card : p0_hand_) p0_hand.put(card.toJSON()); json.put("p0_hand", p0_hand); JSONArray p1_hand = new JSONArray(); for (Card card : p1_hand_) p1_hand.put(card.toJSON()); json.put("p1_hand", p1_hand); json.put("p0_hero", p0_hero_.toJSON()); json.put("p1_hero", p1_hero_.toJSON()); json.put("p0_fatigue", p0_fatigueDamage_); json.put("p1_fatigue", p1_fatigueDamage_); json.put("p0_spellDamage", p0_spellDamage_); json.put("p1_spellDamage", p1_spellDamage_); return json; }
/** * Use the card on the given target * * <p>Gives all friendly totems +2 health * * @param thisCardIndex The index (position) of the card in the hand * @param playerIndex The index of the target player. 0 if targeting yourself or your own minions, * 1 if targeting the enemy * @param minionIndex The index of the target minion. * @param boardState The BoardState before this card has performed its action. It will be * manipulated and returned. * @return The boardState is manipulated and returned */ @Override protected HearthTreeNode use_core( int targetPlayerIndex, Minion targetMinion, HearthTreeNode boardState, Deck deckPlayer0, Deck deckPlayer1, boolean singleRealizationOnly) throws HSException { if (!(targetMinion instanceof Hero) || targetPlayerIndex == 1) { return null; } HearthTreeNode toRet = super.use_core( targetPlayerIndex, targetMinion, boardState, deckPlayer0, deckPlayer1, singleRealizationOnly); if (toRet != null) { for (Minion minion : toRet.data_.getMinions_p0()) { if (minion instanceof Totem) { minion.setHealth((byte) (2 + minion.getHealth())); minion.setMaxHealth((byte) (2 + minion.getMaxHealth())); } } } return toRet; }
/** * Checks to see if there are dead minions * * @return */ public boolean hasDeadMinions() { for (Minion minion : p0_minions_) { if (minion.getTotalHealth() <= 0) return true; } for (Minion minion : p1_minions_) { if (minion.getTotalHealth() <= 0) { return true; } } return false; }
@Override public EffectCharacter<Minion> getBattlecryEffect() { return (PlayerSide targetSide, CharacterIndex targetCharacterIndex, HearthTreeNode boardState) -> { Minion targetCharacter = boardState.data_.getCharacter(targetSide, targetCharacterIndex); Voljin.this.setHealth(targetCharacter.getHealth()); Voljin.this.setMaxHealth(targetCharacter.getMaxHealth()); targetCharacter.setHealth((byte) 2); targetCharacter.setMaxHealth((byte) 2); return boardState; }; }
public void startTurn(Deck deckPlayer0, Deck deckPlayer1) throws HSException { this.resetHand(); this.resetMinions(); for (Minion targetMinion : p0_minions_) { try { targetMinion.startTurn(0, this, deckPlayer0, deckPlayer1); } catch (HSInvalidPlayerIndexException e) { e.printStackTrace(); } } for (Minion targetMinion : p1_minions_) { try { targetMinion.startTurn(1, this, deckPlayer0, deckPlayer1); } catch (HSInvalidPlayerIndexException e) { e.printStackTrace(); } } ArrayList<Minion> toRemove = new ArrayList<Minion>(); for (Minion targetMinion : p0_minions_) { if (targetMinion.getTotalHealth() <= 0) toRemove.add(targetMinion); } for (Minion minion : toRemove) p0_minions_.remove(minion); toRemove.clear(); for (Minion targetMinion : p1_minions_) { if (targetMinion.getTotalHealth() <= 0) toRemove.add(targetMinion); } for (Minion minion : toRemove) p1_minions_.remove(minion); }
public void endTurn(Deck deckPlayer0, Deck deckPlayer1) throws HSInvalidPlayerIndexException { p0_hero_.endTurn(0, this, deckPlayer0, deckPlayer1); p1_hero_.endTurn(1, this, deckPlayer0, deckPlayer1); for (int index = 0; index < p0_minions_.size(); ++index) { Minion targetMinion = p0_minions_.get(index); try { targetMinion.endTurn(0, this, deckPlayer0, deckPlayer1); } catch (HSException e) { e.printStackTrace(); } } for (int index = 0; index < p1_minions_.size(); ++index) { Minion targetMinion = p1_minions_.get(index); try { targetMinion.endTurn(1, this, deckPlayer0, deckPlayer1); } catch (HSException e) { e.printStackTrace(); } } ArrayList<Minion> toRemove = new ArrayList<Minion>(); for (Minion targetMinion : p0_minions_) { if (targetMinion.getTotalHealth() <= 0) toRemove.add(targetMinion); } for (Minion minion : toRemove) p0_minions_.remove(minion); toRemove.clear(); for (Minion targetMinion : p1_minions_) { if (targetMinion.getTotalHealth() <= 0) toRemove.add(targetMinion); } for (Minion minion : toRemove) p1_minions_.remove(minion); }
/** * Place a minion onto the board. Does not trigger any events. * * <p>This is a function to place a minion on the board. Use this function only if you want no * events to be trigger upon placing the minion. * * @param minion The minion to be placed on the board. The minion is placed on the right-most * space. * @throws HSInvalidPlayerIndexException */ public void placeMinion(int playerIndex, Minion minion) throws HSInvalidPlayerIndexException { minion.isInHand(false); if (playerIndex == 0) p0_minions_.add(minion); else if (playerIndex == 1) p1_minions_.add(minion); else throw new HSInvalidPlayerIndexException(); this.allMinionsFIFOList_.add(new MinionPlayerIDPair(minion, playerIndex)); }
@Override public boolean targetMatches( PlayerSide originSide, Card origin, PlayerSide targetSide, Minion targetCharacter, BoardModel board) { if (!super.targetMatches(originSide, origin, targetSide, targetCharacter, board)) { return false; } if (targetCharacter.getHealth() == targetCharacter.getMaxHealth()) { return false; } return true; }
public ArrayList<Integer> getAttackableMinions_p1() { ArrayList<Integer> toRet = new ArrayList<Integer>(); boolean hasTaunt = false; for (final Minion minion : p1_minions_) { hasTaunt = hasTaunt || minion.getTaunt(); } if (!hasTaunt) { toRet.add((Integer) 0); int counter = 1; for (Iterator<Minion> iter = p1_minions_.iterator(); iter.hasNext(); iter.next()) { toRet.add((Integer) counter); counter++; } return toRet; } else { int counter = 1; for (Minion aP1_minions_ : p1_minions_) { if (aP1_minions_.getTaunt()) toRet.add(counter); counter++; } return toRet; } }
@Before public void setup() throws HSException { board = new HearthTreeNode(new BoardState()); Minion minion0_0 = new Minion("" + 0, mana, attack0, health0, attack0, health0, health0); Minion minion0_1 = new Minion("" + 0, mana, attack0, (byte) (health1 - 1), attack0, health1, health1); Minion minion1_0 = new Minion("" + 0, mana, attack0, health0, attack0, health0, health0); Minion minion1_1 = new Minion("" + 0, mana, attack0, (byte) (health1 - 1), attack0, health1, health1); Minion minion1_2 = new Abomination(); minion1_2.setHealth((byte) 1); board.data_.placeMinion(0, minion0_0); board.data_.placeMinion(0, minion0_1); board.data_.placeMinion(1, minion1_0); board.data_.placeMinion(1, minion1_1); board.data_.placeMinion(1, minion1_2); Card cards[] = new Card[10]; for (int index = 0; index < 10; ++index) { cards[index] = new TheCoin(); } deck = new Deck(cards); Minion fb = new ElvenArcher(); board.data_.placeCard_hand_p0(fb); board.data_.setMana_p0((byte) 7); board.data_.setMana_p1((byte) 4); board.data_.setMaxMana_p0((byte) 7); board.data_.setMaxMana_p1((byte) 4); }
/** * Reset all minions to clear their has_attacked state. * * <p>Call this function at the beginning of each turn */ public void resetMinions() { p0_hero_.hasAttacked(false); p0_hero_.hasBeenUsed(false); p1_hero_.hasAttacked(false); p1_hero_.hasBeenUsed(false); for (Minion minion : p0_minions_) { minion.hasAttacked(false); minion.hasBeenUsed(false); } for (Minion minion : p1_minions_) { minion.hasAttacked(false); minion.hasBeenUsed(false); } }
@Override public int hashCode() { int hs = p0_hand_.size(); if (hs < 0) hs = 0; int res = hs + p0_minions_.size() * 10 + p1_minions_.size() * 100; res += (p0_mana_ <= 0 ? 0 : (p0_mana_ - 1) * 1000); res += ((p0_hero_.getHealth() + p1_hero_.getHealth()) % 100) * 10000; int th = 0; if (hs > 0) { Card cc = p0_hand_.get(0); try { Minion mm = (Minion) cc; th += (cc.hasBeenUsed() ? 1 : 0) + mm.getAttack() + mm.getHealth() + cc.getMana(); } catch (ClassCastException e) { th += (cc.hasBeenUsed() ? 1 : 0) + cc.getMana(); } } if (hs > 1) { Card cc = p0_hand_.get(1); try { Minion mm = (Minion) cc; th += (cc.hasBeenUsed() ? 1 : 0) + mm.getAttack() + mm.getHealth() + cc.getMana(); } catch (ClassCastException e) { th += (cc.hasBeenUsed() ? 1 : 0) + cc.getMana(); } } res += (th % 10) * 1000000; int mh0 = 0; if (p0_minions_.size() > 0) { mh0 += p0_minions_.get(0).getHealth(); } if (p0_minions_.size() > 1) { mh0 += p0_minions_.get(1).getHealth(); } res += (mh0 % 100) * 10000000; int mh1 = 0; if (p1_minions_.size() > 0) { mh1 += p1_minions_.get(0).getHealth(); } if (p1_minions_.size() > 1) { mh1 += p1_minions_.get(1).getHealth(); } res += (mh1 % 20) * 100000000; return res; }
// TODO Unused? public HearthTreeNode perform(HearthTreeNode boardState) throws HSException { HearthTreeNode toRet = boardState; PlayerModel actingPlayer = actionPerformerPlayerSide != null ? boardState.data_.modelForSide(actionPerformerPlayerSide) : null; PlayerModel targetPlayer = targetPlayerSide != null ? boardState.data_.modelForSide(targetPlayerSide) : null; switch (verb_) { case USE_CARD: { Card card = actingPlayer.getHand().get(cardOrCharacterIndex_); toRet = card.useOn(targetPlayerSide, targetCharacterIndex, toRet); } break; case HERO_ABILITY: { Hero hero = actingPlayer.getHero(); Minion target = targetPlayer.getCharacter(targetCharacterIndex); toRet = hero.useHeroAbility(targetPlayerSide, target, toRet); } break; case ATTACK: { Minion attacker = actingPlayer.getCharacter(CharacterIndex.fromInteger(cardOrCharacterIndex_)); toRet = attacker.attack(targetPlayerSide, targetCharacterIndex, toRet); } break; case UNTARGETABLE_BATTLECRY: { Minion minion = actingPlayer.getCharacter(CharacterIndex.fromInteger(cardOrCharacterIndex_)); toRet = minion.useUntargetableBattlecry(targetCharacterIndex, toRet); break; } case TARGETABLE_BATTLECRY: { Minion minion = actingPlayer.getCharacter(CharacterIndex.fromInteger(cardOrCharacterIndex_)); toRet = minion.useTargetableBattlecry(targetPlayerSide, targetCharacterIndex, toRet); break; } case START_TURN: { toRet = new HearthTreeNode(Game.beginTurn(boardState.data_.deepCopy())); break; } case END_TURN: { toRet = new HearthTreeNode(Game.endTurn(boardState.data_.deepCopy()).flipPlayers()); break; } case DO_NOT_USE_CARD: { for (Card c : actingPlayer.getHand()) { c.hasBeenUsed(true); } break; } case DO_NOT_ATTACK: { for (Minion minion : actingPlayer.getMinions()) { minion.hasAttacked(true); } actingPlayer.getHero().hasAttacked(true); break; } case DO_NOT_USE_HEROPOWER: { actingPlayer.getHero().hasBeenUsed(true); break; } case RNG: { // We need to perform the current state again if the children don't exist yet. This can // happen in certain replay scenarios. // Do not do this if the previous action was *also* RNG or we will end up in an infinite // loop. if (toRet.isLeaf() && boardState.getAction().verb_ != Verb.RNG) { boardState.data_.getCurrentPlayer().addNumCardsUsed((byte) -1); // do not double count toRet = boardState.getAction().perform(boardState); } // RNG has declared this child happened toRet = toRet.getChildren().get(cardOrCharacterIndex_); break; } case DRAW_CARDS: { // Note, this action only supports drawing cards from the deck. Cards like Ysera or // Webspinner need to be implemented using RNG children. for (int indx = 0; indx < cardOrCharacterIndex_; ++indx) { actingPlayer.drawNextCardFromDeck(); } break; } } return toRet; }
@Test public void test0() throws HSException { // null case Minion target = board.data_.getCharacter(1, 0); Minion minion = board.data_.getMinion_p0(0); HearthTreeNode ret = minion.attack(1, target, board, deck, null); assertFalse(ret == null); assertEquals(board.data_.getNumCards_hand(), 1); assertEquals(board.data_.getNumMinions_p0(), 2); assertEquals(board.data_.getNumMinions_p1(), 2); assertEquals(board.data_.getMana_p0(), 8); assertEquals(board.data_.getMana_p1(), 8); assertEquals(board.data_.getHero_p0().getHealth(), 30); assertEquals(board.data_.getHero_p1().getHealth(), 28); assertEquals(board.data_.getMinion_p0(0).getHealth(), 2); assertEquals(board.data_.getMinion_p0(1).getHealth(), 7); assertEquals(board.data_.getMinion_p1(0).getHealth(), 2); assertEquals(board.data_.getMinion_p1(1).getHealth(), 7); assertEquals(board.data_.getMinion_p0(0).getTotalAttack(), 2); assertEquals(board.data_.getMinion_p0(1).getTotalAttack(), 7); assertEquals(board.data_.getMinion_p1(0).getTotalAttack(), 2); assertEquals(board.data_.getMinion_p1(1).getTotalAttack(), 7); target = board.data_.getCharacter(1, 0); Hero hero = board.data_.getHero_p0(); ret = hero.useHeroAbility(1, target, board, deck, null); assertEquals(board.data_.getNumCards_hand(), 1); assertEquals(board.data_.getNumMinions_p0(), 2); assertEquals(board.data_.getNumMinions_p1(), 2); assertEquals(board.data_.getMana_p0(), 6); assertEquals(board.data_.getMana_p1(), 8); assertEquals(board.data_.getHero_p0().getHealth(), 30); assertEquals(board.data_.getHero_p1().getHealth(), 26); assertEquals(board.data_.getMinion_p0(0).getHealth(), 2); assertEquals(board.data_.getMinion_p0(1).getHealth(), 7); assertEquals(board.data_.getMinion_p1(0).getHealth(), 2); assertEquals(board.data_.getMinion_p1(1).getHealth(), 7); assertEquals(board.data_.getMinion_p0(0).getTotalAttack(), 2); assertEquals(board.data_.getMinion_p0(1).getTotalAttack(), 7); assertEquals(board.data_.getMinion_p1(0).getTotalAttack(), 2); assertEquals(board.data_.getMinion_p1(1).getTotalAttack(), 7); minion.hasAttacked(false); target = board.data_.getCharacter(1, 2); ret = minion.attack(1, target, board, deck, null); assertEquals(board.data_.getNumCards_hand(), 1); assertEquals(board.data_.getNumMinions_p0(), 1); assertEquals(board.data_.getNumMinions_p1(), 2); assertEquals(board.data_.getMana_p0(), 6); assertEquals(board.data_.getMana_p1(), 8); assertEquals(board.data_.getHero_p0().getHealth(), 30); assertEquals(board.data_.getHero_p1().getHealth(), 26); assertEquals(board.data_.getMinion_p0(0).getHealth(), 7); assertEquals(board.data_.getMinion_p1(0).getHealth(), 2); assertEquals(board.data_.getMinion_p1(1).getHealth(), 5); assertEquals(board.data_.getMinion_p0(0).getTotalAttack(), 6); assertEquals(board.data_.getMinion_p1(0).getTotalAttack(), 2); assertEquals(board.data_.getMinion_p1(1).getTotalAttack(), 7); minion.hasAttacked(false); target = board.data_.getCharacter(1, 2); ret = hero.useHeroAbility(1, target, board, deck, null); assertTrue(ret == null); assertEquals(board.data_.getNumCards_hand(), 1); assertEquals(board.data_.getNumMinions_p0(), 1); assertEquals(board.data_.getNumMinions_p1(), 2); assertEquals(board.data_.getMana_p0(), 6); assertEquals(board.data_.getMana_p1(), 8); assertEquals(board.data_.getHero_p0().getHealth(), 30); assertEquals(board.data_.getHero_p1().getHealth(), 26); assertEquals(board.data_.getMinion_p0(0).getHealth(), 7); assertEquals(board.data_.getMinion_p1(0).getHealth(), 2); assertEquals(board.data_.getMinion_p1(1).getHealth(), 5); assertEquals(board.data_.getMinion_p0(0).getTotalAttack(), 6); assertEquals(board.data_.getMinion_p1(0).getTotalAttack(), 2); assertEquals(board.data_.getMinion_p1(1).getTotalAttack(), 7); }
public byte getSpellDamage() { byte spellDamage = 0; for (Minion minion : minions) spellDamage += minion.getSpellDamage(); return spellDamage; }
@Test public void test2() throws HSInvalidPlayerIndexException { // null case Card theCard = board.data_.getCard_hand_p0(0); HearthTreeNode ret = theCard.useOn(0, 0, 3, board, deck, null); assertFalse(ret == null); assertEquals(board.data_.getNumCards_hand(), 0); assertEquals(board.data_.getNumMinions_p0(), 3); assertEquals(board.data_.getNumMinions_p1(), 3); assertEquals(board.data_.getMana_p0(), 5); assertEquals(board.data_.getMana_p1(), 8); assertEquals(board.data_.getHero_p0().getHealth(), 30); assertEquals(board.data_.getHero_p1().getHealth(), 30); assertEquals(board.data_.getMinion_p0(0).getHealth(), 2); assertEquals(board.data_.getMinion_p0(1).getHealth(), 7); assertEquals(board.data_.getMinion_p0(2).getHealth(), 1); assertEquals(board.data_.getMinion_p1(0).getHealth(), 1); assertEquals(board.data_.getMinion_p1(1).getHealth(), 2); assertEquals(board.data_.getMinion_p1(2).getHealth(), 7); assertEquals(board.data_.getMinion_p0(0).getAttack(), 2); assertEquals(board.data_.getMinion_p0(1).getAttack(), 7); assertEquals(board.data_.getMinion_p0(2).getAttack(), 4); assertEquals(board.data_.getMinion_p1(0).getAttack(), 4); assertEquals(board.data_.getMinion_p1(1).getAttack(), 2); assertEquals(board.data_.getMinion_p1(2).getAttack(), 7); assertTrue(board.data_.getMinion_p1(0).getDivineShield()); assertTrue(board.data_.getMinion_p0(2).getDivineShield()); // ------------------------------------------------------------ // Attacking with divine shield vs Hero, divine shield should // stay on // ------------------------------------------------------------ Minion m0 = board.data_.getMinion_p0(2); m0.hasAttacked(false); ret = m0.attack(3, 1, 0, board, deck, null); assertEquals(board.data_.getNumCards_hand(), 0); assertEquals(board.data_.getNumMinions_p0(), 3); assertEquals(board.data_.getNumMinions_p1(), 3); assertEquals(board.data_.getMana_p0(), 5); assertEquals(board.data_.getMana_p1(), 8); assertEquals(board.data_.getHero_p0().getHealth(), 30); assertEquals(board.data_.getHero_p1().getHealth(), 26); assertEquals(board.data_.getMinion_p0(0).getHealth(), 2); assertEquals(board.data_.getMinion_p0(1).getHealth(), 7); assertEquals(board.data_.getMinion_p0(2).getHealth(), 1); assertEquals(board.data_.getMinion_p1(0).getHealth(), 1); assertEquals(board.data_.getMinion_p1(1).getHealth(), 2); assertEquals(board.data_.getMinion_p1(2).getHealth(), 7); assertEquals(board.data_.getMinion_p0(0).getAttack(), 2); assertEquals(board.data_.getMinion_p0(1).getAttack(), 7); assertEquals(board.data_.getMinion_p0(2).getAttack(), 4); assertEquals(board.data_.getMinion_p1(0).getAttack(), 4); assertEquals(board.data_.getMinion_p1(1).getAttack(), 2); assertEquals(board.data_.getMinion_p1(2).getAttack(), 7); assertTrue(board.data_.getMinion_p1(0).getDivineShield()); assertTrue(board.data_.getMinion_p0(2).getDivineShield()); // ------------------------------------------------------------ // Attacking with divine shield // ------------------------------------------------------------ Minion m1 = board.data_.getMinion_p0(2); m1.hasAttacked(false); ret = m1.attack(3, 1, 3, board, deck, null); assertEquals(board.data_.getNumCards_hand(), 0); assertEquals(board.data_.getNumMinions_p0(), 3); assertEquals(board.data_.getNumMinions_p1(), 3); assertEquals(board.data_.getMana_p0(), 5); assertEquals(board.data_.getMana_p1(), 8); assertEquals(board.data_.getHero_p0().getHealth(), 30); assertEquals(board.data_.getHero_p1().getHealth(), 26); assertEquals(board.data_.getMinion_p0(0).getHealth(), 2); assertEquals(board.data_.getMinion_p0(1).getHealth(), 7); assertEquals(board.data_.getMinion_p0(2).getHealth(), 1); assertEquals(board.data_.getMinion_p1(0).getHealth(), 1); assertEquals(board.data_.getMinion_p1(1).getHealth(), 2); assertEquals(board.data_.getMinion_p1(2).getHealth(), 3); assertEquals(board.data_.getMinion_p0(0).getAttack(), 2); assertEquals(board.data_.getMinion_p0(1).getAttack(), 7); assertEquals(board.data_.getMinion_p0(2).getAttack(), 4); assertEquals(board.data_.getMinion_p1(0).getAttack(), 4); assertEquals(board.data_.getMinion_p1(1).getAttack(), 2); assertEquals(board.data_.getMinion_p1(2).getAttack(), 7); assertTrue(board.data_.getMinion_p1(0).getDivineShield()); assertFalse(board.data_.getMinion_p0(2).getDivineShield()); // ------------------------------------------------------------ // Being attacked with a divine shield // ------------------------------------------------------------ Minion m2 = board.data_.getMinion_p0(1); m2.hasAttacked(false); ret = m2.attack(2, 1, 1, board, deck, null); assertEquals(board.data_.getNumCards_hand(), 0); assertEquals(board.data_.getNumMinions_p0(), 3); assertEquals(board.data_.getNumMinions_p1(), 3); assertEquals(board.data_.getMana_p0(), 5); assertEquals(board.data_.getMana_p1(), 8); assertEquals(board.data_.getHero_p0().getHealth(), 30); assertEquals(board.data_.getHero_p1().getHealth(), 26); assertEquals(board.data_.getMinion_p0(0).getHealth(), 2); assertEquals(board.data_.getMinion_p0(1).getHealth(), 3); assertEquals(board.data_.getMinion_p0(2).getHealth(), 1); assertEquals(board.data_.getMinion_p1(0).getHealth(), 1); assertEquals(board.data_.getMinion_p1(1).getHealth(), 2); assertEquals(board.data_.getMinion_p1(2).getHealth(), 3); assertEquals(board.data_.getMinion_p0(0).getAttack(), 2); assertEquals(board.data_.getMinion_p0(1).getAttack(), 7); assertEquals(board.data_.getMinion_p0(2).getAttack(), 4); assertEquals(board.data_.getMinion_p1(0).getAttack(), 4); assertEquals(board.data_.getMinion_p1(1).getAttack(), 2); assertEquals(board.data_.getMinion_p1(2).getAttack(), 7); assertFalse(board.data_.getMinion_p1(0).getDivineShield()); assertFalse(board.data_.getMinion_p0(2).getDivineShield()); // ------------------------------------------------------------ // Being attacked with a divine shield that wore off // ------------------------------------------------------------ Minion m3 = board.data_.getMinion_p0(2); m3.hasAttacked(false); ret = m3.attack(3, 1, 3, board, deck, null); assertEquals(board.data_.getNumCards_hand(), 0); assertEquals(board.data_.getNumMinions_p0(), 2); assertEquals(board.data_.getNumMinions_p1(), 2); assertEquals(board.data_.getMana_p0(), 5); assertEquals(board.data_.getMana_p1(), 8); assertEquals(board.data_.getHero_p0().getHealth(), 30); assertEquals(board.data_.getHero_p1().getHealth(), 26); assertEquals(board.data_.getMinion_p0(0).getHealth(), 2); assertEquals(board.data_.getMinion_p0(1).getHealth(), 3); assertEquals(board.data_.getMinion_p1(0).getHealth(), 1); assertEquals(board.data_.getMinion_p1(1).getHealth(), 2); assertEquals(board.data_.getMinion_p0(0).getAttack(), 2); assertEquals(board.data_.getMinion_p0(1).getAttack(), 7); assertEquals(board.data_.getMinion_p1(0).getAttack(), 4); assertEquals(board.data_.getMinion_p1(1).getAttack(), 2); assertFalse(board.data_.getMinion_p1(0).getDivineShield()); }