cicaprojekt/cicaprojekt/Tile.java

package cicaprojekt;

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

/**
 * A játékban megjelenő különböző csempetípusokat reprezentáló osztály.
 * @author MelindaTekla
 *
 */
public abstract class Tile {
	/**
	 * A csempe szomszédos csempéit tároló <code>Map</code>.
	 */
    protected Map<Direction, Tile> adjacentTile;
    /**
     * A csempén lévő ZPM.
     */
    protected ZPM zpmOnTile;
    /**
     * A csempén lévő dobozok.
     */
    protected Stack<Box> boxStack;
    /**
     * A csempe y-koordinátája.
     */
    protected int y = -666;
    /**
     * A csempe x-koordinátája.
     */
    protected int x = -666;
    /**
     * A csempén lévő személy.
     */
    protected PlayerBase playerBaseOnTile = null;


    /**
     * Az osztály konstruktora.
     */
    public Tile() {
        adjacentTile = new HashMap<>();
        boxStack = new Stack<>();
    }

    /**
     * A csempe x-koordinátájával tér vissza.
     * 
     * @return x-koordináta
     */
    public int getX() { return this.x; }

    /**
     * A csempe y-koordinátájával tér vissza.
     * 
     * @return y-koordináta
     */
    public int getY() { return this.y; }

    /**
     * A csempe x-koordinátáját állítja be a kapott paraméterre.
     * 
     * @param x a kapott x-koordináta
     */
    public void setX(int x) {
        if (x >= 0)
            this.x = x;
    }

    /**
     * A csempe y-koordinátáját állítja be a kapott paraméterre.
     * 
     * @param y a kapott y-koordináta
     */
    public void setY(int y) {
        if (y >= 0)
            this.y = y;
    }

    /**
     * A csempére való léphetőséget adja vissza.
     * @return léphetőség
     */
    public abstract boolean isSteppable();

    /**
     * A csempe kapott irányban lévő szomszédos csempéjével tér vissza.
     * 
     * @param direction a kapott irány
     * @return a szomszédos csempe
     */
    public Tile getAdjacentTile(Direction direction) {
        return adjacentTile.get(direction);
    }

    /**
     * A csempe kapott irányban lévő szomszédjára állítja be a kapott csempét.
     * 
     * @param newTile a kapott csempe
     * @param direction a kapott irány
     */
    public void setAdajacentTile(Tile newTile, Direction direction) {
        adjacentTile.put(direction, newTile);
    }

    /**
     * A függvény akkor hívódik meg, ha egy csillagkapu érkezik a csempére.
     * Ekkor ha a Replikátor áll a csempén, az megsemmisül, a csillagkapu pedig
     * a kapott irányban halad tovább.
     * 
     * @param stargate az érkező csillagkapu
     * @param direction a kapott irány
     */
    public void spawnStargate(Stargate stargate, Direction direction) {
        if (playerBaseOnTile != null && playerBaseOnTile.name.equals("Replicator"))
            playerBaseOnTile.destroy();

        adjacentTile.get(direction).spawnStargate(stargate, direction);
    }

    /**
     * A függvény akkor hívódik meg, ha egy személy lép a csempére.
     * 
     * @param playerBase a <code>PlayerBase</code> példány, amely a csempére lépett
     */
    public void onEntry(PlayerBase playerBase) {
        playerBaseOnTile = playerBase;
    }

    /**
     * A függvény akkor hívódik meg, ha egy személy lelép a csempéről.
     * 
     * @param playerBase a <code>PlayerBase</code> példány, amely lelépett
     * 					 a csempéről
     */
    public abstract void onExit(PlayerBase playerBase);

    /**
     * Beállítja a kapott ZPM-et a csempére.
     * 
     * @param zpm a kapott ZPM
     */
    public void setZPMOnTile(ZPM zpm) {
        zpmOnTile = zpm;
    }

    /**
     * Visszatér a csempén lévő ZPM-el, majd a csempén lévő ZPM értékét null-ra
     * állítja.
     * 
     * @return a csempén lévő ZPM
     */
    public ZPM getZPMFromTile() {
        ZPM zpm = zpmOnTile;
        zpmOnTile = null;
        return zpm;
    }

    /**
     * A függvény igazzal tér vissza, ha a csempe egy szakadék.
     * 
     * @return false
     */
    public boolean isGap() {
        return false;
    }

    /**
     * A függvény a kapott dobozt rárakja a csempére.
     * 
     * @param box a kapott doboz
     */
    public void putABox(Box box) {
        if (box == null)
            return;
        boxStack.push(box);
    }

    /**
     * A függvény leveszi a csempén lévő dobozrakás tetején lévő dobozt,
     * azzal tér vissza.
     * 
     * @return a levett doboz
     */
    public Box getABox() {
        if (boxStack.isEmpty())
            return null;
        return boxStack.pop();
    }

    /**
     * Kiírja a csempe koordinátáit.
     */
    @Override
    public String toString() {
        return String.format("%d, %d", x, y);
    }
    
    /**
     * A függvény aszerint tér vissza, hogy van-e a csempén ZPM.
     * 
     * @return true, ha van a csempén ZPM
     * 		   false, egyébként
     */
    public boolean hasZPM() {
        return zpmOnTile != null;
    }
    
    /**
     * A függvény aszerint tér vissza, hogy van-e a csempén doboz.
     * 
     * @return true, ha van a csempén doboz
     * 		   false, egyébként
     */
    public boolean hasBox() {
        return !boxStack.isEmpty();
    }

    /**
     * A függvény aszerint tér vissza, hogy lehet-e a csempén doboz.
     * 
     * @return true
     */
    public boolean boxPermission() {
        return true;
    }

    /**
     * A függvény aszerint tér vissza, hogy lehet-e a csempén ZPM.
     * 
     * @return false
     */
    public boolean canHazZPM() {
        return false;
    }
}