KeywordsTest.java :  » Game » magicwars » mw » server » abilities » Java Open Source

package mw.server.abilities;

import junit.framework.Assert;
import mw.server.card.MWBaseTest;
import mw.server.model.Card;
import mw.server.model.CounterType;
import mw.server.model.MagicWarsModel;
import mw.server.model.SpellAbility;
import mw.server.pattern.Command;

import org.apache.log4j.Logger;
import org.junit.Test;

public class KeywordsTest extends MWBaseTest {
  
  public static Logger log = Logger.getLogger(KeywordsTest.class);

  /**
   * Test "{cost}: Regenerate $this".
   */
  @Test
  public void testRegenerate() {
    Card drudge = createCard("Drudge Skeletons", TEST_PLAYER_RED);
    Assert.assertEquals(2, drudge.getSpellAbilities().size());
    addPermanent(drudge);
    assertTableCount(1);
    
    SpellAbility regenerate = drudge.getSpellAbilities().get(1);
    resolveSpellAbility(regenerate);
    
    Card shock = createCard("Shock", TEST_PLAYER_GREEN);
    Assert.assertEquals(1, shock.getSpellAbilities().size());
    SpellAbility dealDamageSA = shock.getSpellAbilities().get(0);
    
    dealDamageSA.setTargetCard(drudge);
    resolveSpellAbility(dealDamageSA);
    assertTableCount(1);
    
    // second Shock should kill him
    Card shock2 = createCard("Shock", TEST_PLAYER_GREEN);
    dealDamageSA = shock2.getSpellAbilities().get(0);
    dealDamageSA.setTargetCard(drudge);
    resolveSpellAbility(dealDamageSA);
    assertTableCount(0);
  }
  
  /**
   * Test "Unearth {cost}"
   */
  @Test
  public void testUnearth() {
    Card shambling = createCard("Shambling Remains", TEST_PLAYER_RED);
    Assert.assertEquals(2, shambling.getSpellAbilities().size());
    addPermanent(shambling);
    assertTableCount(1);
    int uid = shambling.getUniqueNumber();
    
    Card lightning = createCard("Lightning Bolt", TEST_PLAYER_GREEN);
    Assert.assertEquals(1, lightning.getSpellAbilities().size());
    SpellAbility dealDamageSA = lightning.getSpellAbilities().get(0);
    
    dealDamageSA.setTargetCard(shambling);
    resolveSpellAbility(dealDamageSA);
    assertTableCount(0);
    // Lightning Bolt + Shambling Remains
    assertGraveCount(2);
    
    Card shamblingInGrave = getGrave().getCard(uid);
    Assert.assertNotNull(shamblingInGrave);
    Assert.assertEquals(shambling.getSpellAbilities().size(), shamblingInGrave.getSpellAbilities().size());
  }
  
  /**
   * Test "Cascade" keyword
   */
  @Test
  public void testCascade() {
    loadDeckAndDrawHand();
    
    Card elves = createCard("Llanowar Elves", TEST_PLAYER_RED);
    Assert.assertEquals(Command.Blank, elves.getWhenPlayCommand());
    
    Card bloodbraid = createCard("Bloodbraid Elf", TEST_PLAYER_RED);
    Assert.assertEquals(1, bloodbraid.getSpellAbilities().size());
    Assert.assertNotSame(Command.Blank, bloodbraid.getWhenPlayCommand());
    
    bloodbraid.getWhenPlayCommand().execute(); // should put effect to stack
    assertStackCount(1);
    
    Card pulse = createCard("Maelstrom Pulse", TEST_PLAYER_RED);
    testPlayerRed.getLibrary().addFirst(pulse);
    Card mountain = createCard("Mountain", TEST_PLAYER_RED);
    testPlayerRed.getLibrary().addFirst(mountain);
    
    Card cascadedCard = null;
    for (Card card : getTestPlayerRed().getLibrary()) {
      if (card.getManacost().getConverted() < 4 && !card.isLand()) {
        cascadedCard = card;
        break;
      }
    }
    Assert.assertNotNull(cascadedCard);
    Assert.assertEquals("Maelstrom Pulse", cascadedCard.getName());
    
    SpellAbility chooseSA = getStack().pop();
    chooseSA.formChoice();
    Assert.assertEquals(1, chooseSA.getChoice().size());
    Assert.assertEquals(cascadedCard, chooseSA.getChoice().get(0));
  }
  
  /**
   * Test "Persist" keyword
   */
  @Test
  public void testPersist() {
    Card restlessApparition = createCard("Restless Apparition", TEST_PLAYER_RED);
    Assert.assertEquals(true, restlessApparition.hasKeyword(MagicWarsModel.KEYWORD_PERSIST_SA));
    addPermanent(restlessApparition);
    assertTableCount(1);
    Assert.assertEquals(2, restlessApparition.getPower());
    Assert.assertEquals(2, restlessApparition.getToughness());
    
    Card shock = createCard("Shock", TEST_PLAYER_GREEN);
    SpellAbility sa = shock.getSpellAbilities().get(0);
    sa.setTargetCard(restlessApparition);
    
    resolveSpellAbility(sa);
    assertTableCount(0); // R.I.P.
    assertGraveCount(2); // Shock + Restless Apparition
    assertStackCount(1); // Persist goes to stack
    
    acceptAllInTheStack(); 
    assertTableCount(1); // Persist in action
    assertGraveCount(1);
    assertStackCount(0);
    
    Card persistedRestlessApp = game.getBattlefield().getAllCreatures().get(0);
    Assert.assertEquals(TEST_PLAYER_RED, persistedRestlessApp.getController());
    Assert.assertEquals(TEST_PLAYER_RED, persistedRestlessApp.getOwner());
    Assert.assertEquals(true, persistedRestlessApp.hasKeyword(MagicWarsModel.KEYWORD_PERSIST_SA));
    Assert.assertEquals(1, persistedRestlessApp.getCounters(CounterType.M1M1));
    Assert.assertEquals(1, persistedRestlessApp.getPower());
    Assert.assertEquals(1, persistedRestlessApp.getToughness());
  }
  
  @Test
  public void testBasicLandCycling() {
    loadDeckAndDrawHand();
    
    Card island = createCard("Island", TEST_PLAYER_RED);
    getTestPlayerRed().getLibrary().add(island);
    
    int basicLandCount = 0;
    for (Card card : testPlayerRed.getLibrary()) {
      if (card.isBasicLand()) basicLandCount++;
    }
    Assert.assertEquals("To test we need any amount of basic lands in player's deck.", true, basicLandCount > 0);
    
    Card traumaticVisions = createCard("Traumatic Visions", TEST_PLAYER_RED);
    Assert.assertEquals(2, traumaticVisions.getSpellAbilities().size());
    
    SpellAbility sa = traumaticVisions.getSpellAbilities().get(1);
    resolveSpellAbility(sa);
    
    assertGraveCount(1);
    assertStackCount(1);

    sa = getStack().peek();
    sa.formChoice();
    Assert.assertEquals(basicLandCount, sa.getChoice().size());
  }
  
  @Test
  public void testModular() {
    Card arcboundBruiser = createCard("Arcbound Bruiser", TEST_PLAYER_RED);
    Card copperMyr = createCard("Copper Myr", TEST_PLAYER_RED);
    addPermanent(arcboundBruiser);
    addPermanent(copperMyr);
    Assert.assertEquals(3, arcboundBruiser.getCounters(CounterType.P1P1));
    
    Card lighting = createCard("Lightning Bolt", TEST_PLAYER_RED);
    SpellAbility sa = lighting.getSpellAbilities().get(0);
    sa.setTargetCard(arcboundBruiser);
    resolveSpellAbility(sa);
    
    assertTableCount(1);
    assertStackCount(1);
    
    sa = getStack().peek();
    sa.formChoice();
    Assert.assertEquals(1, sa.getChoice().size());
    sa.setTargetCard(copperMyr);
    resolveSpellAbility(sa);
    
    Assert.assertEquals(3, copperMyr.getCounters(CounterType.P1P1));
  }
}