MWBaseTest.java :  » Game » magicwars » mw » server » card » Java Open Source

package mw.server.card;

import static org.junit.Assert.assertEquals;

import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;

import mw.server.CardManager;
import mw.server.GameManager;
import mw.server.MWBattlefield;
import mw.server.MWExile;
import mw.server.MWGraveyard;
import mw.server.MWPlayer;
import mw.server.MWStack;
import mw.server.core.MWGameThread;
import mw.server.model.Card;
import mw.server.model.Combat;
import mw.server.model.MagicWarsModel;
import mw.server.model.SpellAbility;
import mw.server.model.cost.AdditionalCost;
import mw.server.model.cost.Cost;
import mw.server.model.effect.GlobalEffect;
import mw.server.model.spell.Flashback;

import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;


public class MWBaseTest {

  @SuppressWarnings("serial")
  protected static ArrayList<String> KNOWN_RULE_NAMES = new ArrayList<String>() {{
    add("Lifelink Rule");
    add("Persist Rule");
    add("Rebound Rule");
    add("Exalted");
    add("Affinity");
  }};
  
    protected static final Logger log = Logger.getLogger(MWBaseTest.class);
  
    public static final int TEST_PLAYER_RED = 4;
    public static final int TEST_PLAYER_GREEN = 6;
    
    public static final String TEST_PLAYER_GREEN_DECK = "test-deck";
    public static final String TEST_PLAYER_RED_DECK = "test-deck";
    
    public static MWPlayer testPlayerRed;
  public static MWPlayer testPlayerGreen;
    
    @BeforeClass
    public static void prepareEnvironment() {
      game = new GameManager();
      
      CardManager.getManager(true, game).loadCardFactory(true, game);
        cardFactory = CardManager.getManager().cardFactory;
        
      testPlayerRed = new MWPlayer(TEST_PLAYER_RED, game);
        testPlayerGreen = new MWPlayer(TEST_PLAYER_GREEN, game);
        game.setPlayer1(testPlayerRed);
        game.setPlayer2(testPlayerGreen);

        List<MWPlayer> players = new ArrayList<MWPlayer>();
        players.add(testPlayerGreen);
        players.add(testPlayerRed);
      game.loadRules(players);
        game.loadRulePlugins();
      
        // Register system message observer
        final Observer systemMessageObserver = new Observer() {
        @Override
      public void update(Observable o, Object arg) {
          if (game.getSystemMessages().size() > 0) {
              for (String msg : game.getSystemMessages()) {
                log.info(msg);
              }
              game.resetSystemMessages();
              }
          
        }
      };
    game.getEventManager().getUpdateSystemMessageEvent().addObserver(systemMessageObserver);
    }
    
    public static void loadDeckAndDrawHand() {
      testPlayerRed.setDeckName(TEST_PLAYER_RED_DECK);
        testPlayerRed.prepareDeckAndDraw7();
        testPlayerGreen.setDeckName(TEST_PLAYER_GREEN_DECK);
        testPlayerGreen.prepareDeckAndDraw7();
    }
    
    @Before
    public void reset() {
      game.setGameActive(true);
      game.getGraveyard().clear();
      game.getBattlefield().clear();
      game.resetGlobalEffects();
      game.resetContiniousEffects();
      game.getStack().clear();
      game.initGameStateObserver();
      testPlayerRed.getHand().clear();
      testPlayerGreen.getHand().clear();
      testPlayerRed.setLifeCount(20);
      testPlayerGreen.setLifeCount(20);
      testPlayerRed.setRevealed(false);
      testPlayerGreen.setRevealed(false);
      combat = game.getCombat();
      combat.reset();
      combat.setAttackingPlayerId(TEST_PLAYER_RED);
      combat.setDefendingPlayerId(TEST_PLAYER_GREEN);
    }
    
    @After
    public void destroy() {
      game.getGameStateObserver().destroy();
    }
    
    public Card createCard(String cardName, int playerId) {
        Card card = cardFactory.getCard(cardName);
        card.entersTheGame();
        card.setOwner(playerId);
        card.setController(playerId);
        card.setUniqueNumber(game.getUniqueCardID());
        return card;
    }
    
    public MWBattlefield getTable() {
        return game.getBattlefield();
    }
    
    public MWGraveyard getGrave() {
        return game.getGraveyard();
    }
    
    public MWExile getExile() {
        return game.getExile();
    }
    
    public ArrayList<GlobalEffect> getGlobalEffects() {
        return game.getManager().getGlobalEffects();
    }
    
    public void addPermanent(Card card) {
        game.getBattlefield().addPermanent(card);
        game.checkChangesAndStateEffects();
    }   
   
    public void resolveSpellAbility(SpellAbility sa) {
      if (MWGameThread.checkTargetIsLegal(game, sa)) {
        for (Cost cost : sa.getCost()) {
          if (!(cost instanceof AdditionalCost)) cost.pay(sa.getSourceCard());
        }
        
        sa.resolve();
          
          Card c = sa.getSourceCard();
  
          if ((c.isInstant() || c.isSorcery()) && !(sa instanceof Flashback)) {
        if (c.hasAspect(MagicWarsModel.ASPECT_EXILE_INSTEAD_ON_RESOLVE)) {
          game.getExile().add(c);
        } else {
          game.getGraveyard().add(c);
        }
          }
          
          game.checkChangesAndStateEffects();
      } else {
        log.warn("SpellAbility (" + sa.getSourceCard() + ") has been fizzled.");
      }
    }
    
    /**
     * While casting a spell, extracts all attached spells and calls whenPlayCommand
     * Not sure, but may be we should also call MWGameThread like reverseAttachedSpellsInTheStack()
     */
    public void castSpell(SpellAbility sa) {
      getStack().add(sa);
      while (sa.hasAspect(MagicWarsModel.ASPECT_HAS_ATTACHED_SPELLS)) {
        SpellAbility attachedSpell = (SpellAbility) sa.getSpellChain().getParam();
      game.getStack().add(attachedSpell);
      sa = attachedSpell;
      }
      sa.getSourceCard().whenPlayCommand();
    }
    
    public void acceptStack() {
      resolveSpellAbility(getStack().pop());
    }
    
    public void assertTableCount(int expectedCount) {
        assertEquals(expectedCount, getTable().getComponentCount());
    }
    
    public void assertTableCount(int expectedCount, int playerId) {
      int actualCount = 0;
    for (Card c : game.getBattlefield().getBattlefieldLink().values()) {
      if (c.getController() == playerId) actualCount++;
    }
        assertEquals(expectedCount, actualCount);
    }
    
    public void assertTapped(Card card) {
        assertEquals(true, checkTapped(card));
    }
    
    public void assertGlobalEffectCount(int expectedCount) {
        assertEquals(expectedCount, getGlobalEffects().size());
    }
    
    public void assertGraveCount(int expectedCount) {
        assertEquals(expectedCount, getGrave().getAllCards().size());
    }
    
    public void assertExileCount(int expectedCount) {
        assertEquals(expectedCount, getExile().getAllCards().size() - KNOWN_RULE_NAMES.size());
    }

    public void assertStackCount(int expectedCount) {
        assertEquals(expectedCount, getStack().size());
    }
    
    private boolean checkTapped(Card card) {
      if (game.getBattlefield().isCardInPlay(card.getTableID())) {
        return card.isTapped();
      } else {
        return false;
      }
    }
    
    public void equip(Card target, Card equipment) {
      game.equipCreature(target, equipment);
      game.checkChangesAndStateEffects();
    }
    
    public static MWPlayer getTestPlayerRed() {
    return testPlayerRed;
  }

    public static MWPlayer getTestPlayerGreen() {
    return testPlayerGreen;
  }
    
    public static Card getCardFromGrave(String cardName, int ownerId) {
      for (Card card : game.getGraveyard().getPersonalCards(ownerId)) {
        if (card.getName().equals(cardName)) {
          return card;
        }
      }
      return null;
    }
    
    public static MWStack getStack() {
      return game.getStack();
    }
    
    public void acceptAllInTheStack() {
      MWStack stack = getStack();
      while (stack.size() > 0) {
        SpellAbility sa = stack.pop();
        resolveSpellAbility(sa);
      }
    }
    
    public void acceptTopInvisible() {
      MWStack stack = getStack();
      while (stack.size() > 0) {
        if (!stack.peek().isInvisible()) break;
        SpellAbility sa = stack.pop();
        resolveSpellAbility(sa);
      }
    }
    
    public void fight() {
      game.setIsNeedFirstStrikeCombat(true);
    game.verifyCreaturesInPlay();
    game.acceptAssignedDamage();
    game.damageCreaturesAndPlayers(TEST_PLAYER_RED, TEST_PLAYER_GREEN);
    game.checkDamagePlayerEffects();
    game.checkChangesAndStateEffects();

    game.setIsNeedFirstStrikeCombat(false);
    game.verifyCreaturesInPlay();
    game.acceptAssignedDamage();
    game.damageCreaturesAndPlayers(TEST_PLAYER_RED, TEST_PLAYER_GREEN);
    game.checkDamagePlayerEffects();
    game.checkChangesAndStateEffects();
    }
    
    public void _upkeep(int playerId) {
      game.setActivePlayerId(playerId);
    game.upkeep();
    game.checkChangesAndStateEffects();
    }
    
    public void _endOfTurn() { 
      game.endOfTurn();
      game.checkChangesAndStateEffects();
    }
    
    public void _declareBlockers() {
      game.declareBlockers();
      game.checkChangesAndStateEffects();
    }
    
    private static CardFactory cardFactory;
    public static GameManager game;
    public static Combat combat;
}