MWGraveyard.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.bean.CardBean;

public class MWGraveyard implements Serializable {

    private HashMap<Integer, Card> graveyard;
    private HashMap<Integer, Integer> graveCountPerPlayer;
    
    private GameManager game;
    private EventManager eventManager = new EventManager();

    public MWGraveyard(GameManager game) {
      this.game = game;
        graveyard = new HashMap<Integer, Card>();
        graveCountPerPlayer = new HashMap<Integer, Integer>();
    }

    public void add(Card card) {
      updateCountForAdd(card);
      Card original = CardManager.copyCard(card);
        //card.setUniqueNumber(0);
      card.addAspect(MagicWarsModel.ASPECT_TEMPORARY_CARD);
      
      original.addAspect(MagicWarsModel.ASPECT_SINCE_TURN_NUMBER, Integer.valueOf(game.getTurnNumber()));
        graveyard.put(original.getUniqueNumber(), original);
        this.eventManager.getGraveyardAddEvent().notifyObservers(original);
      
      /*card.addAspect(MagicWarsModel.ASPECT_SINCE_TURN_NUMBER, Integer.valueOf(game.getTurnNumber()));
        graveyard.put(card.getUniqueNumber(), card);
        this.eventManager.getGraveyardAddEvent().notifyObservers(card);*/
        
        EventParam event = new EventParam();
    event.addParam(card.getOwner());
    event.addParam(graveCountPerPlayer.get(card.getOwner()));
    game.getEventManager().getGraveyardCountEvent().notifyObservers(event);
    }
    
    private void updateCountForAdd(Card card) {
      if (!graveyard.containsKey(card.getUniqueNumber())) {
        int ownerId = card.getOwner();
        Integer count = graveCountPerPlayer.get(ownerId);
        if (count == null) count = Integer.valueOf(0);
        count++;
        graveCountPerPlayer.put(ownerId, count);
      }
    }

    public Card getCard(Integer uniqueID) {
        return graveyard.get(uniqueID);
    }

    public CardList getPersonalCards(int playerID) {
      CardList cardList = new CardList();
        
        for (Integer uid : graveyard.keySet()) {
            Card p = graveyard.get(uid);
            
            if (p.getOwnerID() == playerID) {
                cardList.add(p);
            }
        }
        
        return cardList;
    }
    
    public ArrayList<CardBean> getPersonalCardBeans(int playerID) {
        ArrayList<CardBean> cardList = new ArrayList<CardBean>();
        
        for (Integer uid : graveyard.keySet()) {
            Card p = graveyard.get(uid);
            
            if (p.getOwnerID() == playerID) {
                CardBean c = new CardBean(p);
                cardList.add(c);
            }
        }
        
        return cardList;
    }
    
    public CardList getAllCards() {
        CardList cardList = new CardList();
        
        for (Integer uid : graveyard.keySet()) {
            Card p = graveyard.get(uid);
            cardList.add(p);
        }
        
        return cardList;
    }

    public boolean isCardInGrave(Integer CardID) {
        return graveyard.containsKey(CardID);
    }
    
    public boolean isCardInGrave(Card card) {
      return graveyard.containsValue(card);
    }

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

    public int getCount() {
        return graveyard.size();
    }
    
    public void clear() {
        graveyard.clear();
    }
    
    public Card remove(Card card) {
      updateCountForRemove(card);
      Card removed = graveyard.remove(card.getUniqueNumber());
      
      EventParam event = new EventParam();
    event.addParam(card.getOwner());
    event.addParam(graveCountPerPlayer.get(card.getOwner()));
    game.getEventManager().getGraveyardCountEvent().notifyObservers(event);
      
        return removed;
    }
    
    private void updateCountForRemove(Card card) {
      if (graveyard.containsKey(card.getUniqueNumber())) {
        int ownerId = card.getOwner();
        Integer count = graveCountPerPlayer.get(ownerId);
        if (count == null) count = Integer.valueOf(1);
        count--;
        graveCountPerPlayer.put(ownerId, count);
      }
    }
    
    public void addCountObserver(Observer obs) {
      this.eventManager.getGraveyardCountEvent().addObserver(obs);
    }
    
    public void removeCountObserver(Observer obs) {
      this.eventManager.getGraveyardCountEvent().deleteObserver(obs);
    }
    
    public void addCardAddObserver(Observer obs) {
      this.eventManager.getGraveyardAddEvent().addObserver(obs);
    }
    
    public void removeCardAddObserver(Observer obs) {
      this.eventManager.getGraveyardAddEvent().deleteObserver(obs);
    }

    public ArrayList<Card> getList() {
      ArrayList<Card> list = new ArrayList<Card>();
      for (Card c : graveyard.values()) {
        list.add(c);
      }
      return list;
    }
    
    /**
     * Default UID.
     */
    private static final long serialVersionUID = 1L;
}