MWBattlefield.java :  » Game » magicwars » mw » server » Java Open Source

package mw.server;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Observer;
import java.util.Set;

import mw.server.event.EventManager;
import mw.server.event.EventParam;
import mw.server.list.CardList;
import mw.server.model.Card;
import mw.server.model.MagicWarsModel;
import mw.server.model.MagicWarsModel.GameZone;
import mw.server.model.bean.CardBean;
import mw.server.model.effect.GlobalEffect;
import mw.server.model.zone.PlayerZone;

public class MWBattlefield implements Serializable {

    private int uniqueTableID = 0;
    
    private HashMap<Integer, Card> battlefield;
    
    private EventManager eventManager = new EventManager();
    
    private GameManager game;
   
    public MWBattlefield(GameManager game) {
        battlefield = new HashMap<Integer, Card>();
        this.game = game;
    }
    
    public void addPermanent(Card card) {
      addPermanent(card, false);
    }
    
    /**
     * Silent parameter was added as moveToZone(GameZone.Library, GameZone.Battefield, card)
     * generates two moveToZone events: in moveToZone() and here.
     * @param card
     * @param silent
     */
    public void addPermanent(Card card, boolean silent) {
        uniqueTableID++;
        card.setTableID(uniqueTableID);
        card.setGame(game);
        battlefield.put(uniqueTableID, card);
        
        if (card.hasAspect(MagicWarsModel.ASPECT_ENTERS_TAPPED)) card.entersTheBattlefieldTapped();
        
        /**
         * Apply global effects
         */
        applyGlobalEffects(card);
        card.getGame().refreshEffects();
        
        /**
         * Execute comes into play command.
         * By default, it's blank.
         */
        card.entersTheBattlefield();

        if (!silent) {
          EventParam params = new EventParam();
      params.addParam(new PlayerZone(GameZone.Any, card.getOwnerID()));
      params.addParam(new PlayerZone(GameZone.Battlefield, card.getOwnerID()));
      params.addParam(card);
      game.getEventManager().getMoveToZoneEvent().notifyObservers(params);
        }
    }
    
    public void enchantPermanent(Card permanent, Card enchantment) {
      addPermanent(enchantment);
        permanent.attachCard(enchantment);
        // dummy action to hide enchantment in play: but it will be still counted by other cards
        enchantment.equipCard(permanent);
        eventManager.getEnchantEvent().notifyObservers(permanent);
    }
    
    public void unEnchantPermanent(Card permanent, Card enchantment) {
      if (permanent == null || enchantment == null) {return;}
        permanent.unattachCard(enchantment);
        enchantment.unEquipCard(permanent);
        eventManager.getEnchantEvent().notifyObservers(permanent);
        
        game.destroy(enchantment);
    }
    
    /**
     * Apply global effects
     */
    public void applyGlobalEffects(Card card) {
        ArrayList<GlobalEffect> globalEffects = game.getGlobalEffects();
        for (int i = 0; i < globalEffects.size(); i++) {
            globalEffects.get(i).applyForNewPermanent(card);
        }
    }
    
    /**
     * Discard global effects
     */
    public void discardGlobalEffects(Card card) {
        ArrayList<GlobalEffect> globalEffects = game.getGlobalEffects();
        for (int i = 0; i < globalEffects.size(); i++) {
            globalEffects.get(i).discardFromPermanent(card);
        }
    }
    
    /**
     * Remove all global effects that came from @param card
     * @param card
     * @return removed effects
     */
    public ArrayList<GlobalEffect> clearGlobalEffects(Card card) {
        ArrayList<GlobalEffect> globalEffects = game.getGlobalEffects();
        ArrayList<GlobalEffect> removed = new ArrayList<GlobalEffect>();
        for (int i = 0; i < globalEffects.size(); i++) {
            GlobalEffect gb = globalEffects.get(i);
            if (gb.getSource().equals(card)) {
              removed.add(gb);
            }
        }
        for (GlobalEffect gb : removed) {
          game.removeGlobalEffect(gb);
        }
        return removed;
    }

    public Card getPermanent(Integer permanentID) {
        return battlefield.get(permanentID);
    }
    
    public Card getByUID(int uniqueId) {
        for (Card permanent : battlefield.values()) {
          if (permanent.getUniqueNumber() == uniqueId) return permanent;
        }
        return null;
    }

    /**
     * Get permanents controlled by the player.
     * 
     * @param playerID
     * @return
     */
    public Card[] getControllerPermanents(int playerID) {
        ArrayList<Card> permanents = new ArrayList<Card>();
        
        for (Integer uid : battlefield.keySet()) {
            Card p = battlefield.get(uid);
            
            if (p.getControllerID() == playerID) {
                permanents.add(p);
            }
        }
        
        Card[] cards = new Card[permanents.size()];
        
        return permanents.toArray(cards);
    }
    
    /**
     * Get player's opponent's permanents.
     * 
     * @param playerID player id (not opponent)
     * @return
     */
    public CardList getOpponentPermanentList(int playerID) {
        CardList permanents = new CardList();
        
        for (Card c : battlefield.values()) {
            if (c.getControllerID() != playerID && !c.isSuspended()) {
                permanents.add(c);
            }
        }
        
        return permanents;
    }
    
    public CardList getPermanentList(int playerID) {
        CardList cardList = new CardList();
        
        for (Card c : battlefield.values()) {
            if (c.getControllerID() == playerID && !c.isSuspended()) {
                cardList.add(c);
            }
        }
        
        return cardList;
    }
    
    public CardList getSuspended(int playerID) {
        CardList cardList = new CardList();
        
        for (Card c : battlefield.values()) {
            if (c.getControllerID() == playerID && c.isSuspended()) {
                cardList.add(c);
            }
        }
        
        return cardList;
    }

    public CardList getAllPermanents() {
        CardList cardList = new CardList();
        
        for (Card c : battlefield.values()) {
          if (!c.isSuspended()) {
            cardList.add(c);
          }
        }
        
        return cardList;
    }
    
    public boolean isPermanentExist(Integer permanentID) {
        return battlefield.containsKey(permanentID);
    }
    
    public CardList getCreatures(int playerID) {
        return getPermanentList(playerID).getType("Creature");
    }
    
    public CardList getAllCreatures() {
        return getAllPermanents().getType("Creature");
    }
  
    /**
     * In the future there will be permanents that exist but not in play.
     * (e.g. suspended)
     */
    public boolean isCardInPlay(Integer permanentID) {
        return battlefield.containsKey(permanentID);
    }
    
    public boolean isCardInPlay(Card card) {
      if (card == null) {
        return false;
      }
        return battlefield.containsKey(card.getTableID());
    }


    public Set<Integer> getIDs() {
        return battlefield.keySet();
    }

    public int getComponentCount() {
        return battlefield.size();
    }
    
    public void clear() {
        battlefield.clear();
    }
    
    public Card remove(Card c) {
      return battlefield.remove(c.getTableID());
    }
    
    public HashMap<Integer, CardBean> getTableBeans() {
        HashMap<Integer, CardBean> tableBeans = new HashMap<Integer, CardBean>();
        
        for (Integer key : battlefield.keySet()) {
            tableBeans.put(key, new CardBean(battlefield.get(key)));
        }
        
        return tableBeans;
    }
    
  public void addEnchantObserver(Observer obs){
    eventManager.getEnchantEvent().addObserver(obs);
  }
  
  public void removeEnchantObserver(Observer obs){
    eventManager.getEnchantEvent().deleteObserver(obs);
  }  
  
  public void addUnenchantObserver(Observer obs){
    eventManager.getUnenchantEvent().addObserver(obs);
  }
  
  public void removeUnenchantObserver(Observer obs){
    eventManager.getUnenchantEvent().deleteObserver(obs);
  }
  
  public void addEquipObserver(Observer obs) {
    eventManager.getEquipEvent().addObserver(obs);  
  }
  
  public void removeEquipObserver(Observer obs) {
    eventManager.getEquipEvent().deleteObserver(obs);
  }
  
  public void addUnequipObserver(Observer obs) {
    eventManager.getUnequipEvent().addObserver(obs);  
  }
  
  public void removeUnequipObserver(Observer obs) {
    eventManager.getUnequipEvent().deleteObserver(obs);
  }
    
    /**
     * Has default visibility to be accessible from the same package only
     */
    EventManager getEventManager() {
      return this.eventManager;
    }
    
    public HashMap<Integer, Card> getBattlefieldLink() {
      return battlefield;
    }
    
    /**
     * Default UID.
     */
    private static final long serialVersionUID = 1L;
}