Kleine Anfaenge fuer Powerups sowie neue Timer.

nach 15 sekunden erhoeht die hardware nicht mehr die temperatur, kann
aber noch nicht wieder manipuliert werden. erst nach weiteren 15
sekunden kann sie wieder manipuliert werden. erzwingt, dass der spieler
mehr rumlaufen muss.

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

@@ -4,11 +4,13 @@ import java.awt.Point;
 import java.util.ArrayList;
 
 import de.heatup.logging.Logger;
+import de.heatup.objects.PowerUp;
 import de.heatup.testing.Opponent;
 import de.heatup.testing.Player;
 
 public class CollisionHandler {
 	private static ArrayList<Player> movingObjects = new ArrayList<Player>();
+	private static ArrayList<PowerUp> powerUpObjects = new ArrayList<PowerUp>();
 	/**
 	 * Prüfe ob eine Kollision vorliegt
 	 * @param movingObject Kann alles sein, dass sich bewegt. Spieler oder KI.
@@ -139,4 +141,7 @@ public class CollisionHandler {
 	public static void addMovingObject(Player movingObject) {
 		movingObjects.add(movingObject);
 	}
+	public static void addPowerUpObject(PowerUp powerUp) {
+		powerUpObjects.add(powerUp);
+	}
 }

HeatUp/src/de/heatup/objects/PositionHandler.java

@@ -0,0 +1,8 @@
+package de.heatup.objects;
+
+import java.awt.Point;
+import java.util.ArrayList;
+
+public class PositionHandler {
+	
+}

HeatUp/src/de/heatup/objects/PowerUp.java

@@ -0,0 +1,75 @@
+package de.heatup.objects;
+
+import java.awt.BasicStroke;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.RenderingHints;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.util.Random;
+
+import javax.imageio.ImageIO;
+import javax.swing.JComponent;
+
+import de.heatup.cfg.Config;
+import de.heatup.logging.Logger;
+import de.heatup.mapengine.CollisionHandler;
+
+public class PowerUp extends JComponent {
+	private static final long serialVersionUID = 1L;
+	protected BufferedImage bf1;
+	protected Graphics2D g2d;
+	private Point currentGridPosition;
+	private int type;
+	
+	public PowerUp() {
+		Random rand = new Random();
+		CollisionHandler.addPowerUpObject(this);
+		this.type = rand.nextInt(3);
+	}
+	
+ 	public void setGridLocation(int x, int y) {
+		currentGridPosition.setLocation(x, y);
+	}
+	
+	public Point getGridLocation() {
+		return currentGridPosition;
+	}
+
+	public void paintComponent(Graphics g) {
+		g2d = (Graphics2D) g;
+		if (bf1 == null) {
+			loadBufferedImage();
+		}
+
+		g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+		g2d.drawImage(bf1, 0, 0, this);
+		g2d.setStroke(new BasicStroke(8.0f));
+		g2d.finalize();
+	}
+	
+	public void spawnAt(Point spawnPoint) {
+		this.currentGridPosition = spawnPoint;
+		this.setAutoBounds(spawnPoint.x*25, spawnPoint.y*25);
+		this.repaint();
+	}
+	
+	protected void loadBufferedImage() {
+		try {
+			this.bf1 = ImageIO.read(new File("src/de/heatup/resources/images/powerup.png"));
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+	public void setImage(BufferedImage image) {
+		this.bf1 = image;
+	}
+
+	public void setAutoBounds(int x, int y) {
+		this.setBounds(x, y, this.bf1.getWidth(), this.bf1.getHeight());
+	}
+
+}

HeatUp/src/de/heatup/objects/PowerUpHandler.java

@@ -0,0 +1,5 @@
+package de.heatup.objects;
+
+public class PowerUpHandler {
+	private static 
+}

HeatUp/src/de/heatup/timers/HardwareResetTimers.java

@@ -13,6 +13,7 @@ public class HardwareResetTimers {
 	private static int tickRoundMax = 10000;
 	private static int nrOfTicksUntilReset = 900; /* entspricht 15 sekunden ingame zeit (nicht unbedingt echtzeit!); berechnet durch 15*targetTickRate im Gameloop. */ 
 	private static Map<Character, Integer> HardwareResetTickstamps = new HashMap<Character, Integer>();
+	private static Map<Character, Integer> HardwareCooldownTimestamps = new HashMap<Character, Integer>();
 	/**
 	 * Zählt ticks und resettet somit Spielzeit orientiert die Hardware-Objekte.
 	 */
@@ -24,23 +25,36 @@ public class HardwareResetTimers {
 		for (char i = Config.firstHardwareChar; i<=Config.lastHardwareChar; i++) {
 			if (HardwareResetTickstamps.containsKey(i)) {
 				if (HardwareResetTickstamps.get(i).equals(tickCount)) {
-					Logger.write("Hardware "+i+" reset");
-					HardewareManipulate.resetHardware(i);
+					Logger.write("Hardware "+i+" cools down");
 					StatusPanelAdder.reduceMod();
 				}
 			}
 		}
+		for (char i = Config.firstHardwareChar; i<=Config.lastHardwareChar; i++) {
+			if (HardwareCooldownTimestamps.containsKey(i)) {
+				if (HardwareCooldownTimestamps.get(i).equals(tickCount)) {
+					Logger.write("Hardware "+i+" can be manipulated again");
+					HardewareManipulate.resetHardware(i);
+				}
+			}
+		}
 	}
 	/**
-	 * Setzt das gegebene Hardware-Objekt auf "manipuliert" und merkt sich den aktuellen Tick + Resetzeit = Tick an dem resettet werden muss.
+	 * Setzt das gegebene Hardware-Objekt auf "manipuliert" und merkt sich den aktuellen Tick + Resetzeit = Tick an dem resettet werden muss,
+	 * sowie aktueller Tick + 2*Resetzeit als Cooldown.
 	 * @param c Hardware-Objekt, welches als manipuliert gelten soll.
 	 */
 	public static void setManipulated(char c) {
 		int resetTimestamp = tickCount+nrOfTicksUntilReset;
+		int cooldownTimestamp = tickCount+2*nrOfTicksUntilReset;
 		if (resetTimestamp > tickRoundMax) {
 			resetTimestamp = resetTimestamp % tickRoundMax;
 		}
+		if (cooldownTimestamp > tickRoundMax) {
+			cooldownTimestamp = cooldownTimestamp % tickRoundMax;
+		}
 		HardwareResetTickstamps.put(c, resetTimestamp);
+		HardwareCooldownTimestamps.put(c, cooldownTimestamp);
 		StatusPanelAdder.raiseMod();
 	}
 }