Neue Gameloop zum testen

MapEngine mit javadoc

HeatUp/src/de/heatup/mapengine/MapEngine.java

@@ -14,7 +14,14 @@ import javax.swing.JFileChooser;
 import de.heatup.cfg.Config;
 import de.heatup.logging.Logger;
 import de.heatup.objects.*;
-
+/**
+ * Diese Klasse soll als primäre Schnittstelle zu anderen Spielmodulen dienen.
+ * Sie generiert die Map als StaticObjects um diese dann auf ein Spielfeld zu malen.
+ * Außerdem erstellt sie eine MapGrid, welches zur Kollisionserkennung und Positionierung
+ * von Entitäten dient.
+ * @author daniel
+ *
+ */
 public class MapEngine {
 	
 	private static final int singleTileWidth = Config.singleTilePixels;
@@ -53,7 +60,11 @@ public class MapEngine {
 		}
 		this.createTiles(input);
 	}
-	
+	/**
+	 * Erstellt aus einem gegebenen Scanner, welche eine Datei einliest,
+	 * eine Map, welche dann zu einem Spielfeld hinzugefügt werden kann.
+	 * @param input Ein Scanner der auf eine Map-Datei zeigt.
+	 */
 	private void createTiles(Scanner input) {
 		int lineCount = 0;
 		int x = 0;
@@ -147,31 +158,50 @@ public class MapEngine {
 	protected ArrayList<Point> getAllCoordinatesOfTileType(char c) {
 		return getAllMapTiles().get(c);
 	}
-	
+	/*
+	 * obsolet bisher.
+	 */
 	protected Point getFirstTilesCoordinatesOfTileType(char c) {
 		return getAllMapTiles().get(c).get(0);
 	}
-	
+	/*
+	 * obsolet bisher.
+	 */
 	protected Point getLastTilesCoordinatesOfTileType(char c) {
 		return getAllMapTiles().get(c).get(getAllMapTiles().get(c).size()-1);
 	}
-	
+	/**
+	 * 
+	 * @return Gibt alle MapObjekte als ArrayList<StaticObject> zurück.
+	 */
 	public ArrayList<StaticObject> getAllMapObjects() {
 		return MapObjectHandler.getAllMapObjects(this);
 	}
-	
+	/**
+	 * 
+	 * @return Gibt alle HardwareObjekte auf einer Map als ArrayList<StaticObject> zurück.
+	 */
 	public ArrayList<StaticObject> getAllHardwareObjects() {
 		return MapObjectHandler.getAllHardwareObjects();
 	}
-	
+	/**
+	 * 
+	 * @return Gibt alle WallObjekte auf einer Map als ArrayList<StaticObject> zurück.
+	 */
 	public ArrayList<StaticObject> getAllWallObjects() {
 		return MapObjectHandler.getAllWallObjects();
 	}
-	
+	/**
+	 * 
+	 * @return Gibt alle WayObjekte auf einer Map als ArrayList<StaticObject> zurück.
+	 */
 	public ArrayList<StaticObject> getAllWayObjects() {
 		return MapObjectHandler.getAllWayObjects();
 	}
-	
+	/**
+	 * 
+	 * @return Gibt alle HardwareTriggerObjekte auf einer Map als ArrayList<StaticObject> zurück.
+	 */
 	public ArrayList<StaticObject> getAllHardwareTriggerObjects() {
 		return MapObjectHandler.getAllHardwareTriggerObjects();
 	}
@@ -188,7 +218,9 @@ public class MapEngine {
 		}
 		return false;
 	}
-	
+	/**
+	 *  Schreibt eine mit Trigger konvertierte Map-Datei in die Konsole
+	 */
 	public void printMapGridWithTriggers() {
 		for (int i = 0; i < 24; i++) {
 			for (int j = 0; j < 32; j++) {

HeatUp/src/de/heatup/testing/GameLoopD.java

@@ -0,0 +1,195 @@
+package de.heatup.testing;
+
+import java.awt.BorderLayout;
+import java.awt.Dimension;
+import java.awt.GridLayout;
+
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+
+import de.heatup.mapengine.MapEngine;
+import de.heatup.objects.DynamicObject;
+import de.heatup.objects.StaticObject;
+import de.heatup.objects.logic;
+import de.heatup.ui.GameInterface;
+import de.heatup.ui.KeyBindings;
+
+public class GameLoopD extends JFrame implements Runnable {
+	
+	private static final long serialVersionUID = 1L;
+	
+	
+	private boolean running = false;
+	
+	private Thread thread;
+	
+	private static JPanel outerPanel;
+	private static JPanel statusPanel;
+	private static JPanel gamePanel;
+	private static JPanel actionPanel;
+	
+	DynamicObject dynO3;
+	
+	public static void main(String[] args) {
+		
+		/*
+		 * hier drin bauen wir unser ui zusammen.
+		 */
+		
+		GameLoopD frame = new GameLoopD();
+		
+
+		frame.setTitle("HeatUP!");
+		frame.setDefaultCloseOperation(EXIT_ON_CLOSE);
+		
+		
+		outerPanel = new JPanel();
+		outerPanel.setLayout(new BorderLayout());
+		outerPanel.setVisible(true);
+		
+		statusPanel = new JPanel();
+		statusPanel.setLayout(new GridLayout(1,4));
+		statusPanel.setPreferredSize(new Dimension(800,80));
+
+		gamePanel = new JPanel();
+		gamePanel.setLayout(null);
+		gamePanel.setPreferredSize(new Dimension(800,600));
+		gamePanel.setVisible(true);
+		
+		actionPanel = new JPanel();
+		actionPanel.setLayout(new GridLayout(1,1));
+		actionPanel.setPreferredSize(new Dimension(800,80));
+	
+
+		outerPanel.add(statusPanel,BorderLayout.NORTH);
+		outerPanel.add(gamePanel,BorderLayout.CENTER);
+		outerPanel.add(actionPanel,BorderLayout.SOUTH);
+		
+		frame.add(outerPanel);
+		frame.pack();
+		frame.setVisible(true);
+		
+		/*
+		 * zeug aus dem alten gameloop
+		 */
+		DynamicObject dynO1 = new DynamicObject();
+		gamePanel.add(dynO1);
+		DynamicObject dynO2 = new DynamicObject();
+		gamePanel.add(dynO2);
+		DynamicObject dynO3 = new DynamicObject();
+		gamePanel.add(dynO3);
+		DynamicObject dynO4 = new DynamicObject();
+		gamePanel.add(dynO4);
+		
+		Player player01 = new Player();
+		Query.setPlayer(player01);
+		gamePanel.add(player01);
+		player01.setBounds(25, 25, 200, 200);
+		
+
+		// Keybindings as object so we can load different bindings depending on number of players.
+//		KeyBindings kb = new KeyBindings();
+		gamePanel.setFocusable(true);
+//		kb.setKeyBindings();
+		
+		
+		//dynO3.setRescale(1.5,3.5);
+		
+//		Config.setGamePanelWidth(900);
+		MapEngine me = new MapEngine(1);
+		for (StaticObject currentStaticObject : me.getAllMapObjects()) {
+			gamePanel.add(currentStaticObject);
+		}
+		
+		gamePanel.setVisible(true);
+		
+		//GameInterface.getGamePanel().repaint();
+		//GameInterface.getGamePanel().setComponentZOrder(dynO1, 1);
+		//GameInterface.getGamePanel().add(dynO1);
+		//logic.startMovement(dynO1);
+		//logic.startMovement(dynO2);
+
+		logic.startMovement(dynO3);
+		
+		//logic.startMovement(dynO4);
+		
+		
+		/*
+		 * ende
+		 */
+		
+
+		frame.repaint();
+		frame.start();
+	}
+	
+	private synchronized void start() {
+		if (running) {
+			return;
+		}
+		
+		running = true;
+		thread = new Thread(this);
+		thread.start();
+		
+	}
+	
+	private synchronized void stop() {
+		if (!running) {
+			return;
+		}
+		
+		running = false;
+		try {
+			thread.join();
+		} catch (InterruptedException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		System.exit(1);
+		
+	}
+	
+	public void run() {
+		
+		long lastTime = System.nanoTime();
+		final double fps = 60.0;
+		double ns = 1000000000 / fps;
+		double delta = 0;
+		int updates = 0;
+		int frames = 0;
+		long timer = System.currentTimeMillis();
+		
+		while (running) {
+		
+			long now = System.nanoTime();
+			delta += (lastTime - now) / ns;
+			lastTime = now;
+			if (delta >= 1) {
+				tick();
+				updates++;
+				delta--;
+			}
+			render();
+			frames++;
+			
+			if (System.currentTimeMillis() - timer > 1000) {
+				timer += 1000;
+				System.out.println(updates +" Ticks, fps " + frames);
+				updates = 0;
+				frames = 0;
+			}
+		}
+		
+		stop();
+	}
+	// alles was geupdatet werden muss hier rein
+	private void tick() {
+		
+	}
+	// alles was animiert wird hier rein (paints)
+	private void render() {
+		
+	}
+
+}