codingteam0815/spaceinvaders/GameProject/src/playground/Playground.java

package playground;

import java.awt.Graphics2D;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Stack;
import java.awt.event.*;
import gameobjects.GameObject;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;

/**
 * Playground represents a level of the game, focusing on the game LOGIC, i.e., not so much on the
 * graphical representation. In particular, an instance of Playground
 * <ul>
 * <li>manages the different moving or static objects in a level (e.g., collisions, adding objects,
 * removing objects). This is mainly done by the methods {@link #addObject}, {@link #deleteObject}.
 * <li>processes keyboard inputs provided by GameLoop in {@link #processKeyEvents(Stack)} and
 * {@link #processMouseEvents(Stack)}
 * <li>represents the state of a level represented by <b>flags</b>. Each flag has a name (a String)
 * and an arbitrary value of any type. Methods: {@link #setLevelFlag(String, Object)},
 * {@link #getLevelFlag(String)}. As an example, the current score is a flag usually named "points",
 * with an Integer as a value. This value can be retrieved and manipulated using the above mentioned
 * methods.
 * </ul>
 */
public abstract class Playground {

  public static final int FLAGS_GLOBAL = 1;
  public static final int FLAGS_LEVEL = 2;
  public static final int FLAGS_ALL = 3;
  protected int canvasX = -1;
  protected int canvasY = -1;

  /** only one set of objects exists concurrently so this can be static */
  protected static HashMap<String, GameObject> gameObjects = new HashMap<String, GameObject>();

  /** only one set of objects exists concurrently so this can be static */
  protected static HashMap<String, Object> flags = new HashMap<String, Object>();

  protected String level = "";
  protected double timeStep = 0;
  protected double gameTime = 0;
  LinkedList<GameObject> addables = new LinkedList<GameObject>();
  LinkedList<String> removables = new LinkedList<String>();
  // HashMap<Integer,Integer> keys ;
  Stack<KeyEvent> keyEvents;
  Stack<MouseEvent> mouseEvents;

  protected boolean pausedFlag = false;

  private static Logger logger = LogManager.getLogger(Playground.class);

  public Playground() {
    this.canvasX = -1;
    this.canvasY = -1;
  }

  // here, the level communicates its size preference to the GameUI
  // called automatically
  public abstract int preferredSizeX();

  public abstract int preferredSizeY();

  /**
   * Adds a graphics object to a level.
   * 
   * @param o GameObject The object to be added
   */
  public void addObject(GameObject o) {
    // gameObjects.put(o.getId(), o);
    addables.addLast(o);
  }

  /**
   * Adds a graphics object to a level.
   * 
   * @param o GameObject The object to be added
   */
  public void addObjectNow(GameObject o) {
    gameObjects.put(o.getId(), o);
  }


  /**
   * Puts objects with a certain substring in their name into a LinkedLisrt and returns them.
   * 
   * @param substr The string that must be part of the object name if object is to be considered
   *        found.
   * @param filterInactive if set true only active objects are considered.
   * @return a reference to a LinkedList filled with all objects that have <b>substr</b> in their
   *         name
   */
  public LinkedList<GameObject> collectObjects(String substr, boolean filterInactive) {
    LinkedList<GameObject> l = new LinkedList<GameObject>();
    for (Map.Entry<String, GameObject> entry : Playground.gameObjects.entrySet()) { // Iterator
                                                                                    // usage
      GameObject obj = entry.getValue();
      if (obj.getId().contains(substr)) {
        if (filterInactive == true) {
          if (obj.isActive()) {
            l.add(obj);
          }
        } else {
          l.add(obj);
        }
      }
    }
    return l;
  };


  /**
   * Removes a graphics object from a level.
   * 
   * @param id String The unique identifier of the object
   */
  public void deleteObject(String id) {
    // gameObjects.remove(id);
    removables.addLast(id);
  }

  /**
   * Removes a graphics object from a level immediately, CAUTION.
   * 
   * @param id String The unique identifier of the object
   */
  public void deleteObjectNow(String id) {
    gameObjects.remove(id);
  }


  /**
   * Retrieves a graphics object by name.
   * 
   * @param id String Unique id of the object
   * @return reference to the requested game object, or null if not found
   */
  public GameObject getObject(String id) {
    return gameObjects.get(id);
  }

  /**
   * Sets a level-wide permanent flag.
   * 
   * @param flag String Q unique name in this level. If it exists value is overwritten.
   * @param value Object Any Object can be the value of a flag!
   */

  public static void setGlobalFlag(String flag, Object value) {
    flags.put("/global/" + flag, value);
  }

  public Object setLevelFlag(String flag, Object value) {
    flags.put("/" + this.level + "/" + flag, value);
    return value;
  }

  /**
   * mode can be: FLAGS_ALL (all), FLAGS_GLOBAL(global), FLAGs_LEVEL(level)
   * 
   * @param mode can be only one of {@link #FLAGS_GLOBAL} {@link #FLAGS_ALL} or
   *        {@link #FLAGS_LEVEL }
   */
  public void resetFlags(int mode) {
    LinkedList<String> delKeys = new LinkedList<String>();
    for (Map.Entry<String, Object> entry : Playground.flags.entrySet()) {
      logger.trace(entry.getKey() + " IndexofGlobal = " + entry.getKey().indexOf("/global/"));
      if ((mode == FLAGS_GLOBAL) && (entry.getKey().indexOf("/global/") != -1)) {
        logger.debug("GLOBAL: scheduling for removal: " + entry.getKey());
        delKeys.add(entry.getKey());
      } else if ((mode == FLAGS_LEVEL) && (entry.getKey().indexOf("/global/") == -1)) {
        logger.debug("LEVEL: scheduling for removal: " + entry.getKey());
        delKeys.add(entry.getKey());
      } else if (mode == FLAGS_ALL) {
        logger.debug("ALL: scheduling for removal: " + entry.getKey());
        delKeys.add(entry.getKey());
      }
    }

    for (String str : delKeys) {
      logger.trace("removing key " + str);
      flags.remove(str);
    }
  }


  /**
   * Retrieves a level-wide flag by name.
   * 
   * @param flag String Unique flag id
   * @return the value associated with <b>flag</b>, or <b>null</b> if the flag does not exist.
   */
  public static Object getGlobalFlag(String flag) {
    return flags.get("/global/" + flag);
  }

  /** checks for existence and if not creates the new global flag with the given initial value. Returns the value.
   *  afterwards it is guaranteed that no priorly existing value is overridden and that it definitely exists (created if not present before). 
  * 
   * @param flag  String name for the global flag  (created if not present)
   * @param value Object value to be stored (used only if flag was not present)
   * @return the current value of the flag (maybe the initial one in case flag was not there before)
   */
  public static Object getOrCreateGlobalFlag(String flag, Object value) {
    Object tmp = getGlobalFlag(flag);
    if (tmp == null) {
      setGlobalFlag(flag, value);
      return value;
    } else {
      return tmp;
    }
  }


  public Object getLevelFlag(String flag) {
    return flags.get("/" + this.level + "/" + flag);
  }

  public Object getOrCreateLevelFlag(String flag, Object createValue) {
    Object tmp = getLevelFlag(flag);
    if (tmp == null) {
      return setLevelFlag(flag, createValue);
    } else {
      return tmp;
    }
  }


  /**
   * Reinitializes the level.
   */
  public void reset() {
    gameObjects.clear();
  }

  public boolean isPaused() {
    return this.pausedFlag;
  }

  public void setPaused(boolean p) {
    this.pausedFlag = p;
  }

  public void togglePause() {
    pausedFlag = !pausedFlag;

  }


  /**
   * Method meant to be filled with own code, processes Keyboard inputs.
   * 
   * @param keyEvents all collected {@link KeyEvent}s collected since last game loop.
   */

  public void processKeyEvents(Stack<KeyEvent> keyEvents) {
    this.keyEvents = keyEvents;
    Playground.setGlobalFlag("inputs", keyEvents);
  }


  public void processMouseEvents(Stack<MouseEvent> mouseEvents) {
    this.mouseEvents = mouseEvents;
    Playground.setGlobalFlag("inputs", mouseEvents);
  }


  public Stack<KeyEvent> getKeyEvents() {
    return this.keyEvents;
  }

  public Stack<MouseEvent> getMouseEvents() {
    return this.mouseEvents;
  }


  /**
   * Method meant to be filled with own code, handles the entore game logic (collision checks, timed
   * events, ...).
   * 
   */
  public abstract void applyGameLogic();

  /**
   * Sets up a single level. Prepares all objects etc.
   * 
   * @param level String a string identifying the level number etc
   */
  public abstract void prepareLevel(String level);

  public abstract boolean gameOver();

  public abstract boolean levelFinished();

  public int getSizeX() {
    return canvasX;
  }

  public int getSizeY() {
    return canvasY;
  }

  /**
   * Calls all object update methods in level. Internal, never call directly.
   * 
   */
  public void updateObjects() {
    for (GameObject gameObject : gameObjects.values()) { // Iterator usage
      if (gameObject.isActive() == true) {
        gameObject.updateObject();
        logger.trace("updated object " + gameObject.scol);
      }
    }

    for (GameObject o : addables) { // Iterator usage
      addObjectNow(o);
    }

    for (String s : removables) { // Iterator usage
      deleteObjectNow(s);
    }
    removables.clear();
    addables.clear();
  }

  public void setTimestep(double s) {
    timeStep = s;
  }

  public double getTimestep() {
    return timeStep;
  }

  /** set the game time value (in seconds)
   *
   * @param s  seconds the game is running
   */
  public void setGameTime(double s) {
    this.gameTime = s;
  }

  /** returns time in seconds since level start */
  public double getGameTime() {
    return this.gameTime;
  }


  /**
   * To be redefined!! Draws mainly h level background and global information like points etc.
   * 
   * @param g2 Graphics2D abstract drawing object of java Swing, used to carry out all drawing
   *        operations.
   */
  public abstract void redrawLevel(Graphics2D g2);

  /**
   * Internal, do not call directly.
   * 
   * @param g2 Graphics2D abstract drawing object of java Swing, used to carry out all drawing
   *        operations.
   */
  public void redraw(Graphics2D g2) {
    redrawLevel(g2);
    for (GameObject gameObject : gameObjects.values()) {
      if (gameObject.isActive()) {
        gameObject.draw(g2);
      }
    }
  }


}