Merge gogs.informatik.hs-fulda.de:jkonert/prog2-codebase

GameProject/src/base/BreakoutGame.java

@@ -0,0 +1,38 @@
+package base;
+import java.io.IOException;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import playground.*;
+
+
+/**
+ * main class to start a game with only one level.
+ *
+ */
+public class BreakoutGame extends GameLoop {
+  
+  private static Logger logger = LogManager.getLogger(BreakoutGame.class);
+  
+  /**
+   * adds only one level to play ({@link playground.LevelBreakout1}).
+   */
+  @Override
+  public void defineLevels() {
+    this.resetLevels(); // removes Level1 added by superclass constructor
+    // this.addLevel(new BreakoutLevel1());  // FIXME add this as soon as your level exists
+  }
+  
+  /**
+   * starts this game.
+   * 
+   * @param args command line parameters (forwarded to {@link GameLoop#runGame(String[])}).
+   * @throws IOException if highscore.txt file cannot be written or accessed, the exception is
+   *         thrown (and game ends).
+   */
+  public static void main(String[] args) throws IOException {
+    GameLoop myGame = new BreakoutGame();
+    logger.info("BreakoutGame program started.");
+    myGame.runGame(args);
+  }
+
+}

GameProject/src/playground/BreakoutLevelBase.java

@@ -0,0 +1,173 @@
+package playground;
+
+import gameobjects.*;
+import java.util.LinkedList;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import java.awt.Graphics2D;
+import controller.*;
+
+public abstract class BreakoutLevelBase extends Playground {
+
+  /**
+   * instance of the ball, needs to be set by {@link #prepareLevel(String) }
+   * 
+   */
+  protected GameObject ball = null,
+      /**
+       * instance of the ego objects, needs to be set by {@link #prepareLevel(String) }
+       * 
+       */
+      ego = null;
+
+  private static Logger logger = LogManager.getLogger(BreakoutLevelBase.class);
+
+  public BreakoutLevelBase() {
+    super();
+    this.canvasX = this.preferredSizeX();
+    this.canvasY = this.preferredSizeY();
+  }
+
+  /**
+   * signals to game engine that the game has finished by game over. called every game loop. default
+   * implementation is always false.
+   * 
+   * @return false
+   */
+  public boolean gameOver() {
+    return false;
+  }
+
+
+  /**
+   * signals to game engine that the game has finished by success. called every game loop. default
+   * implementation is always false.
+   * 
+   * @return false
+   */
+  public boolean levelFinished() {
+    return false;
+  }
+
+
+  /**
+   * signals to game engine that the game has been requested to be reseted (restart). called every
+   * game loop. default implementation is always false.
+   * 
+   * @return false
+   */
+  public boolean resetRequested() {
+    return false;
+  }
+
+  /**
+   * unimplemented empty method called by game engine every loop.
+   * 
+   */
+  public void redrawLevel(Graphics2D g) {
+
+  }
+
+
+
+  /**
+   * Signal that the level has a size of 700x700 pixels.
+   * 
+   * @return x size of level 700
+   */
+  @Override
+  public int preferredSizeX() {
+    return 700;
+  }
+
+  /**
+   * Signal that the level has a size of 700x700 pixels.
+   * 
+   * @return y size of level 700
+   */
+  @Override
+  public int preferredSizeY() {
+    return 700;
+  }
+
+
+  /**
+   * Method that gets called by applyGameLogic() whenever the ball collides with a brick.
+   * 
+   * 
+   * @param ball A reference to the current ball object
+   * @param brick A reference to the ego object
+   */
+  protected abstract void actionIfBallHitsBrick(GameObject ball, GameObject brick);
+
+  /**
+   * Method that gets called by applyGameLogic() whenever the ball collides with the ego object.
+   * 
+   * @param ball A reference to the current ball object
+   * @param ego A reference to the ego object
+   */
+  protected abstract void actionIfBallHitsEgo(GameObject ball, GameObject ego);
+
+  /**
+   * checks for interactions between GameObjects; notably ball with ego and ball with brick. 
+   * In case of detected collisions, it calls either  {@link #actionIfBallHitsBrick(GameObject, GameObject)}
+   * or {@link #actionIfBallHitsEgo(GameObject, GameObject)}.
+   * Called every game loop.
+   */
+  @Override
+  public void applyGameLogic() {
+    LinkedList<GameObject> bricks = collectObjects("brick", false);
+
+    for (GameObject brick : bricks) {
+      if (this.ball.collisionDetection(brick)) {
+        logger.trace("Collision detected of ball and brick " + brick.getId());
+        this.actionIfBallHitsBrick(this.ball, brick);
+      }
+    }
+
+    if (this.ego.collisionDetection(ball)) {
+      logger.trace("Collision detected of ball and ego");
+      actionIfBallHitsEgo(this.ball, this.ego);
+    }
+  }
+
+  /**
+   * Creates the ego object and returns it, called by {@link #prepareLevel}. Does NOT add the ego
+   * object to the playground, but returns it.
+   * 
+   * @return The created ego object instance (of class {@link RectObject} with
+   *         {@link EgoController}.
+   */
+  protected abstract GameObject createEgoObject();
+
+  /**
+   * Creates the ball object and returns it, called by #prepareLevel. Does NOT add the ball object
+   * to the playground, but returns it.
+   * 
+   * @return The created ball object instance (of class {@link FallingStar})
+   */
+  protected abstract GameObject createBall();
+
+  /**
+   * Creates the GameObject (RectObject) instance representing a single brick at a certain grid
+   * position. The brick is NOT added here, but returned.
+   * 
+   * @param row row position in the grid, ranges from 0 to calcNrBricksY()-1
+   * @param column column position in the grid of bricks, ranges from 0 to calcNrBricksX()-1
+   * @return The GameObject instance (really a RectObject) representing the created brick.
+   */
+  protected abstract GameObject createBrick(int row, int column);
+
+  /**
+   * Prepares a generic Breakout-Type level. This method relies on the methods {@link #createEgoObject()},
+   * {@link #createBall} and {@link #createBrick}, among others, which are meant to be overwritten
+   * in subclasses. <br>
+   * Attention: the attributes {@link #ball} and {@link #ego} need to be set properly to GameObject
+   * instances when implementing this method {@link #prepareLevel(String)}.
+   * 
+   * @param level String passes by the game engine (not used currently and can be ignored).
+   */
+  @Override
+  abstract public void prepareLevel(String level);
+
+}