original game? (reverted from commit 3fc6c98ea565f4ea79bc0ae79c407a55428abd84)

Fixed overwrited code

control/Button.java

@@ -1,5 +0,0 @@
-package control;
-
-public class Button {
-
-}

control/GameStateManager.java

@@ -5,6 +5,7 @@ import java.util.List;
 
 import model.gameState.GameState;
 import model.gameState.MenuState;
+import model.gameState.TitleState;
 import model.gameState.PlayState;
 
 public class GameStateManager {
@@ -15,6 +16,7 @@ public class GameStateManager {
 	
 	public GameStateManager(){
 		gamestates = new ArrayList<GameState>();
+		gamestates.add(new TitleState(this));
 		gamestates.add(new MenuState(this));
 		gamestates.add(new PlayState(this));
 		currentState = gamestates.get(0);

control/JoyStick.java

@@ -1,5 +0,0 @@
-package control;
-
-public class JoyStick {
-
-}

control/button/ButtonHandler.java

@@ -42,7 +42,7 @@ public class ButtonHandler implements KeyListener{
 		{
 			b.setColor(new Color((int)(Math.random()*254+1),(int)(Math.random()*254+1),(int)(Math.random()*254+1)));
 		}
-//		System.out.println(Window.ON_RASP);
+		System.out.println(Window.ON_RASP);
 		if (Window.ON_RASP)
 			addGpioListeners();
 		

image/Images.java

@@ -20,7 +20,10 @@ public class Images{
 		  try{
 		   images.add(ImageIO.read(Main.class.getResource("/image/player.png"))); 
 		   images.add(ImageIO.read(Main.class.getResource("/image/player2.png"))); 
-		  
+		   images.add(ImageIO.read(Main.class.getResource("/image/pressstart.png"))); 
+		   images.add(ImageIO.read(Main.class.getResource("/image/colorstrike.png"))); 
+		   images.add(ImageIO.read(Main.class.getResource("/image/background.png")));
+		   
 		  }catch(IOException e){
 		   e.printStackTrace();
 		  }
@@ -33,6 +36,6 @@ public class Images{
 
 	 public enum ImageType
 	 {
-	  player,player2	 
+	  player,player2,pressstart,colorstrike,background
 	 }
 }

main/Window.java

@@ -64,7 +64,7 @@ public class Window extends JFrame {
 		//Create Instances
 		GameStateManager gsm = new GameStateManager();
 		GameView view = new GameView(led,gsm);
-		GameModel model = new GameModel(view,gsm);
+		GameModel model = new GameModel(gsm);
 		GameControl control = new GameControl(model, view,gsm);
 		setContentPane(view);
 		

model/GameModel.java

@@ -6,23 +6,21 @@ import java.awt.event.ActionListener;
 
 import javax.swing.Timer;
 
-import view.GameView;
 import control.GameStateManager;
 import control.button.ButtonHandler;
 
 public class GameModel implements ActionListener{
 	
 	
-	public static double framePerSecondUpdate = 1000/30;
-	private  Timer update;
+	private Timer update;
 	public static Color[] colors = {Color.MAGENTA,Color.RED,Color.GREEN,Color.YELLOW,Color.CYAN,Color.WHITE};
 	private GameStateManager gsm;
 	
-	public GameModel(GameView view,GameStateManager gsm)
+	public GameModel(GameStateManager gsm)
 	{
 			
 		this.gsm = gsm;
-		update = new Timer((int) framePerSecondUpdate, this);
+		update = new Timer(1000/30, this);
 		update.start();
 		
 		for(int i = 1; i < ButtonHandler.getButtons().size(); i++){

model/drawObjects/Bullet.java

@@ -0,0 +1,106 @@
+package model.drawObjects;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.geom.Line2D;
+
+public class Bullet extends DrawObject {
+
+	private double speed,lengthOfBullet;
+	private Line2D bullet;
+	private Color c;
+	
+	public Bullet(double speed,Color c,double lengthOfBullet,int index,Line2D path) {
+		super();
+		this.speed = speed;
+		this.lengthOfBullet = lengthOfBullet;
+		this.c = c;
+		
+		double beginX = path.getX2();
+		double beginY = path.getY2();
+		double endX = beginX;
+		double endY = beginY;
+		
+		//the 8 richtingen van de octagon
+		switch(index){
+		case 0:	
+			endY = beginY - lengthOfBullet;
+			break;
+		case 1:
+			endX = beginX + lengthOfBullet;
+			endY = beginY - lengthOfBullet;
+			break;
+		case 2:
+			endX = beginX + lengthOfBullet;
+			break;
+		case 3:
+			endX = beginX + lengthOfBullet;
+			endY = beginY + lengthOfBullet;
+			break;
+		case 4:
+			endY = beginY + lengthOfBullet;
+			break;
+		case 5:
+			endX = beginX - lengthOfBullet;
+			endY = beginY + lengthOfBullet;
+			break;
+		case 6:
+			endX = beginX - lengthOfBullet;
+			break;
+		case 7:
+			endX = beginX - lengthOfBullet;
+			endY = beginY - lengthOfBullet;
+			break;		
+		}
+		bullet = new Line2D.Double(beginX, beginY, endX, endY);
+	}
+
+	@Override
+	public void draw(Graphics2D g2) {
+		g2.setPaint(c);
+		g2.draw(bullet);
+	}
+
+	@Override
+	public void update() {		
+		double x1 = bullet.getX1();
+		double x2 = bullet.getX2();
+		double y1 = bullet.getY1();
+		double y2 = bullet.getY2();
+		double yDifference = y2 - y1;
+		double xDifference = x2 - x1;		
+				
+		if(yDifference < 0.0){			
+			y1 -= speed;
+			y2 = y1-lengthOfBullet;
+		}else if(yDifference > 0.0){
+			y1 += speed;
+			y2 = y1+lengthOfBullet;
+		}
+		
+		if(xDifference < 0.0){			
+			x1 -= speed;
+			x2 = x1-lengthOfBullet;
+		}else if(xDifference > 0.0){
+			x1 += speed;
+			x2 = x1+lengthOfBullet;
+		}		
+		bullet.setLine(x1, y1, x2, y2);
+	}
+
+	public Color getColor() {
+		return c;
+	}
+
+	public void setColor(Color c) {
+		this.c = c;
+	}
+
+	public Line2D getBullet() {
+		return bullet;
+	}
+
+	public void setBullet(Line2D bullet) {
+		this.bullet = bullet;
+	}		
+}

model/drawObjects/Enemy.java

@@ -0,0 +1,99 @@
+package model.drawObjects;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics2D;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Line2D;
+import java.awt.geom.Point2D;
+
+public class Enemy extends Person{
+
+	private Color 				color;
+	private Ellipse2D.Double 	circle;
+	private Point2D				beginPoint;
+	private Dimension			size;
+	private double xSpeed,ySpeed;
+	
+	/**
+	 * 
+	 * @param path, the path the player is walking on.
+	 * @param c, the color of the enemy
+	 * @param size, the size of the enemy
+	 * @param stepsToFinishTheMiddle, the speed to finish the middle octagon
+	 */
+	public Enemy(Line2D path,Color c,int size,double stepsToFinishTheMiddle) {
+		
+		super(path.getX1()-size/2,path.getY1()-size/2);	
+		beginPoint = new Point2D.Double(middlePoint.getX(),middlePoint.getY());
+		this.size = new Dimension(size,size);
+		color = c;
+		circle = new Ellipse2D.Double(middlePoint.getX(),middlePoint.getY(),this.size.width,this.size.height);
+		index = 0;
+		xSpeed = (path.getX2() - circle.getCenterX())/stepsToFinishTheMiddle;
+		ySpeed = (path.getY2() - circle.getCenterY())/stepsToFinishTheMiddle;		
+	}
+
+	@Override
+	public void draw(Graphics2D g2) {
+		g2.setPaint(color);
+		g2.fill(circle);
+	}
+	
+	private void moveTowardsPlayer()
+	{
+		
+		double newX, newY;			
+		newX = index*xSpeed+beginPoint.getX();
+		newY = index*ySpeed+beginPoint.getY();
+		index++;
+		middlePoint.setLocation(newX, newY);		
+		circle.setFrame(middlePoint, size);		
+	}
+
+	@Override
+	public void update() {		
+		moveTowardsPlayer();		
+	}
+
+	public Color getColor() {
+		return color;
+	}
+
+	public void setColor(Color color) {
+		this.color = color;
+	}
+
+	public Ellipse2D.Double getCircle() {
+		return circle;
+	}
+
+	public void setCircle(Ellipse2D.Double circle) {
+		this.circle = circle;
+	}
+	
+	/**
+	 * Deze methode kijkt of de enemy is geraakt door een bullet
+	 * @param bullet, een kogel om te kijken of hij deze enemy heeft geraakt
+	 * @return, true = raakt, false = mis
+	 */
+	public boolean bulletHitMe(Bullet bullet){
+		if(circle.getBounds2D().intersectsLine(bullet.getBullet())){
+			return true;
+		}
+		return false;
+	}
+	
+	/**
+	 * Hier kijk je of de bullet de juiste kleur heeft, om de enemy te vermoorden
+	 * @param bullet, de kogel om te kije of hij de zelfde kleur heeft als deze enemy
+	 * @return,true = zelfde kleur, false = andere kleur
+	 */
+	public boolean ColorHitMe(Bullet bullet){
+		if(this.color.equals(bullet.getColor())){
+			return true;
+		}
+		return false;
+	}
+	
+}

model/drawObjects/Person.java

@@ -0,0 +1,13 @@
+package model.drawObjects;
+
+import java.awt.geom.Point2D;
+
+public abstract class Person extends DrawObject {
+
+	protected Point2D middlePoint;
+	
+	public Person(double x, double y) {
+		super();
+		middlePoint = new Point2D.Double(x, y);		
+	}
+}

model/drawObjects/Player.java

@@ -4,20 +4,17 @@ import image.Images;
 
 import java.awt.Graphics2D;
 import java.awt.geom.AffineTransform;
-import java.awt.geom.Point2D;
 import java.awt.image.BufferedImage;
 
-public class Player extends DrawObject {
+public class Player extends Person {
 	
 	private BufferedImage img;	
 	private AffineTransform transform;
 	private int lastindex;
-	private Point2D middlePoint;
 	
 	public Player(int x, int y){
-		super();		
-		img = Images.getImage(Images.ImageType.player2);
-		middlePoint = new Point2D.Double(x, y);		
+		super(x,y);		
+		img = Images.getImage(Images.ImageType.player2);	
 		width = img.getWidth();
 		height = img.getHeight();	
 		lastindex = -10;

model/drawObjects/enemy/Enemy.java

@@ -1,199 +0,0 @@
-package model.drawObjects.enemy;
-
-import java.awt.Color;
-import java.awt.Graphics2D;
-import java.awt.geom.Line2D;
-import java.awt.geom.Point2D;
-
-import model.drawObjects.DrawObject;
-
-public class Enemy extends DrawObject {
-
-	
-	private int length,timeToClick = 5,currentTimeToClick;	
-	private double speedX,speedY,lengthOf1Side;//lengthOf1Side wordt alleen gebruikt als de lijn een schuine lijn is.
-	public Line2D enemy;
-	private Color c;	
-	private boolean clickable = false;
-	/**
-	 * 
-	 * @param pathID
-	 * @param lengthOfEnemy
-	 * @param c
-	 * @param beginPoint
-	 * @param endPoint
-	 * @param steptsToEndPoint
-	 */
-	public Enemy(int pathID,int lengthOfEnemy,Color c,double steptsToEndPoint,Point2D beginPoint,Point2D endPoint){
-		super();		
-		this.length = lengthOfEnemy;			
-//		System.out.println(this.length*this.length/2);
-//		System.out.println(Math.sqrt(Math.pow(this.length,2)/2));
-		lengthOf1Side = Math.sqrt(Math.pow(lengthOfEnemy,2)/2);		
-		this.c = c;		
-		this.index = pathID;				
-		double beginX, beginY,endX = 0,endY = 0;
-		beginX =  beginPoint.getX();
-		beginY = beginPoint.getY();
-		endX = beginX;
-		endY = beginY;		
-		
-		//the 8 richtingen van de octagon
-		switch(index){
-		case 0:			
-			endY -= this.length;			
-			break;
-		case 1:			
-			endY -= lengthOf1Side;
-			endX += lengthOf1Side;			
-			break;
-		case 2:			
-			endX -= this.length;			
-			break;
-		case 3:			
-			endY += lengthOf1Side;
-			endX += lengthOf1Side;			
-			break;		
-		case 4:
-			endY += this.length;			
-			break;
-		case 5:
-			endY += lengthOf1Side;
-			endX -= lengthOf1Side;			
-			break;
-		case 6:
-			endX += this.length;			
-			break;
-		case 7:
-			endY -= lengthOf1Side;
-			endX -= lengthOf1Side;			
-			break;				
-		}
-			
-		
-		enemy = new Line2D.Double(beginX, beginY, endX, endY);	
-		//bereken de lengte van de enemy tot het einde van de lijn
-		double distanceX,distanceY;
-		distanceX = (enemy.getX1() - endPoint.getX());
-		distanceY = (enemy.getY1() - endPoint.getY());		
-		//de afstand mag niet negatief zijn
-		if(distanceX < 0){
-			distanceX *= -1;
-		}
-		if(distanceY < 0){
-			distanceY *= -1;
-		}
-//		System.out.println("Index: "+index+"\tX afstand: "+distanceX+"\tY afstand: "+distanceY);
-		//snelheid 	= afstand 	/tijd		
-		speedX 		= (distanceX	/steptsToEndPoint);
-		speedY 		= (distanceY	/steptsToEndPoint);
-//		System.out.println("Index: "+index+"\tX speed: "+speedX+"\tY speed: "+speedY);
-	}
-
-	@Override
-	public void draw(Graphics2D g2) {
-		g2.setPaint(c);
-		g2.draw(enemy);		
-	}
-
-	@Override
-	public void update() {	
-		if(clickable){
-			currentTimeToClick++;
-		}
-			double x1,x2,y1,y2;
-			x1 = enemy.getX1();
-			x2 = enemy.getX2();
-			y1 = enemy.getY1();
-			y2 = enemy.getY2();		
-			
-			switch(index){
-			case 0:
-				y1 += speedY;
-				y2 = y1 - length;				
-				break;
-			case 1:
-				x1 -= speedX;
-				x2 = x1 + lengthOf1Side;	
-				
-				y1 += speedY;
-				y2 = y1 - lengthOf1Side;							
-				break;
-			case 2:			
-				x1 -= speedX;
-				x2 = x1 + length;				
-				break;
-			case 3:			
-				x1 -= speedX;
-				x2 = x1 + lengthOf1Side;
-				
-				y1 -= speedY;
-				y2 = y1 + lengthOf1Side;
-				break;		
-			case 4:
-				y1 -= speedY;
-				y2 = y1 + length;		
-				break;
-			case 5:
-				x1 += speedX;
-				x2 = x1 - lengthOf1Side;
-				
-				y1 -= speedY;
-				y2 = y1 + lengthOf1Side;
-				break;
-			case 6:
-				x1 += speedX;
-				x2 = x1 - length;				
-				break;
-			case 7:
-				x1 += speedX;
-				x2 = x1 - lengthOf1Side;
-				
-				y1 += speedY;
-				y2 = y1 - lengthOf1Side;
-				break;					
-			}		
-			enemy.setLine(x1, y1, x2, y2);				
-	}
-	
-
-	public Color getColor() {
-		return c;
-	}
-
-	public void setColor(Color c) {
-		this.c = c;
-	}
-
-	public Line2D getEnemy() {
-		return enemy;
-	}
-
-	public void setBullet(Line2D bullet) {
-		this.enemy = bullet;
-	}	
-	
-	public void clickable(){
-		clickable = true;
-	}
-	
-	/**
-	 * deze methode kijkt hoeveel frame je nog hebt om te klikken op het moment dat je bolletje in de hitzone zit
-	 * @return
-	 */
-	public boolean finised(){
-		if(currentTimeToClick >= timeToClick){
-			return true;
-		}
-		return false;
-	}
-	
-	public boolean isClickable(){
-		return clickable;
-	}
-	
-	public int getTimeLeftToClick() {
-		return currentTimeToClick;
-	}
-
-}

model/gameState/MenuState.java

@@ -1,44 +1,62 @@
 package model.gameState;
 
+import image.Images;
+import image.Images.ImageType;
+
+import java.awt.Color;
 import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+import java.util.ArrayList;
 
+import model.objects.MenuButton;
 import control.GameStateManager;
+import control.button.Button;
 import control.button.ButtonEvent;
+import control.joystick.Joystick;
 import control.joystick.JoystickEvent;
 
+
+
 public class MenuState extends GameState {
+	private ArrayList<MenuButton> buttons;
+	private int selected;
 
-	public MenuState(GameStateManager gsm) {
+    int frame = 0;
+    int maxFrames = 2560;
+    int animationcounter;
+	
+	public MenuState(GameStateManager gsm) {	
 		super(gsm);
+		buttons = new ArrayList<MenuButton>();
+		buttons.add(new MenuButton(-600, 50,1.7,"Genre", 0, Color.green));
+		buttons.add(new MenuButton(-600, 150, 1.7, "Most played", 10, new Color(60,60,255)));
+		buttons.add(new MenuButton(-600, 250, 1.7, "Best played", 20, Color.red));
+		buttons.add(new MenuButton(-600, 350, 1.7, "Last played", 30, Color.yellow));
 	}
 	@Override
 	public void init() {
-		// TODO Auto-generated method stub
-
 	}
 
 	@Override
 	public void update() {
-		// TODO Auto-generated method stub
-
+		buttonInAnimation(animationcounter);
+	     for(MenuButton b:buttons){
+	    	 b.update();
+	     }
+	     frame++;
 	}
 
 	@Override
 	public void draw(Graphics2D g2) {
-		g2.drawString("Press 0 to start the game", 1280/2, 1024/2);
-
+	    g2.drawImage(Images.getImage(ImageType.background), -640 -((frame * 4) % maxFrames), 0, 5120, 1024, null); 
+		for(MenuButton b:buttons){
+	    	 b.draw(g2);
+	     }	   
+			
 	}
 	
 	@Override
 	public void buttonPressed(ButtonEvent e) {
-		
-		switch(e.getButton().getButtonID()){
-		case 0:
-			gsm.next();
-			break;
-		}
-		
-		
 	}
 	@Override
 	public void buttonReleased(ButtonEvent e) {
@@ -46,8 +64,40 @@ public class MenuState extends GameState {
 	}
 	@Override
 	public void onJoystickMoved(JoystickEvent e) {
-		// TODO Auto-generated method stub
-		
+		if(e.getJoystick().getPos() == Joystick.Position.DOWN){
+			selected++;
+			selected %= buttons.size();
+			for(int i = 0; i < buttons.size(); i++){
+				if(selected == i){
+					buttons.get(i).setSelected(true);
+				}else{
+					buttons.get(i).setSelected(false);
+				}
+			}
+		}else if(e.getJoystick().getPos() == Joystick.Position.UP){
+			selected--;
+			if(selected < 0) selected = buttons.size()-1;
+			for(int i = 0; i < buttons.size(); i++){
+				if(selected == i){
+					buttons.get(i).setSelected(true);
+				}else{
+					buttons.get(i).setSelected(false);
+				}
+			}
+		}
+	}
+	
+	public void buttonInAnimation(int button){
+		if(button >= 0 && button < buttons.size() ){
+			buttons.get(button).setX(buttons.get(button).getX()+40);
+			if(buttons.get(button).getX() >= 320){
+				animationcounter++;
+			}
+			if(buttons.get(button).getX() >= -200){
+				buttonInAnimation(button+1);
+				System.out.println(buttons.get(button).getX());
+			}
+		}
 	}
 
 }

model/gameState/PlayState.java

@@ -1,21 +1,19 @@
-
 package model.gameState;
 
 
 import java.awt.BasicStroke;
 import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.Stroke;
 import java.awt.geom.Line2D;
-import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 
 import model.GameModel;
+import model.drawObjects.Bullet;
+import model.drawObjects.Enemy;
 import model.drawObjects.Player;
-import model.drawObjects.enemy.Enemy;
 import model.objects.InfoPanel;
 import model.objects.PlayArea;
 import control.GameStateManager;
@@ -28,27 +26,26 @@ public class PlayState extends GameState{
 	private PlayArea area;
 	private InfoPanel infoPanel;
 	private Player player;
-	private List<Enemy> enemys;		
-	private Stroke stroke;
-	private Iterator<Enemy> enemyIterator;	
-	
-	public static int sizeOfEnemy = 40;
+	private List<Enemy> enemys;	
+	private List<Bullet> bullets;
+	private Iterator<Enemy> enemyIterator;
+	private Iterator<Bullet> bulletIterator;
+
 	public static int currentScore = 0; 
 	public static int lifePoints = 100;
 	
 	public PlayState(GameStateManager gsm) {
 		super(gsm);
-		area = new PlayArea(borderRect.getX(),1024,1024,150);
+		area = new PlayArea((int) borderRect.getX(),1024,1024,100);
 		infoPanel = new InfoPanel(0, 0);
-		enemys = new ArrayList<Enemy>();		
-		
-		for(int index = 0; index < 2; index++){
-			Line2D path = area.paths.get(index);			
-			addEnemy(index, GameModel.colors[index % 6], path.getP1(),path.getP2());
+		enemys = new ArrayList<Enemy>();
+		bullets =new ArrayList<Bullet>();
+		player = new Player(1280-1024+1024/2, 1024/2);
+		for(int i = 0; i < 8; i++){
+			Line2D line = area.getLine(i);
+			addEnemy(line, Color.RED, 200);
 		}
 		
-		player = new Player(1280-1024+1024/2, 1024/2);		
-		stroke = new BasicStroke(sizeOfEnemy,BasicStroke.CAP_ROUND,BasicStroke.JOIN_ROUND);
 	}
 
 	@Override
@@ -59,40 +56,88 @@ public class PlayState extends GameState{
 
 	@Override
 	public void update() {		
-		player.update();		
+		player.update();	
+		bulletIterator = bullets.iterator();
+		while(bulletIterator.hasNext()){
+			Bullet b = bulletIterator.next();
+
+			//als de bullet de border raakt verwijder hem, anders update je hem
+			if(!borderRect.intersectsLine(b.getBullet())){
+				bulletIterator.remove();
+				break;
+			}else{
+				b.update();
+			}
+		}
+		
 		enemyIterator = enemys.iterator();
-		while(enemyIterator.hasNext()){			
+		while(enemyIterator.hasNext()){
+			
 			Enemy e = enemyIterator.next();
-			Rectangle2D hitArea = area.hitAreas[e.getIndex()];
-			if(e.finised()){
+			e.update();
+			//als de enemy de octagon raakt verwijder hem
+			if(area.octagon.intersects(e.getCircle().getBounds2D())){
+				lifePoints -= 5;
+				
+				if(lifePoints < 10){
+					lifePoints += 10;	//Dit is voor te testen.
+				}
 				enemyIterator.remove();
-			}			
-			if(hitArea.intersectsLine(e.enemy) && !e.isClickable()){
-				e.clickable();
 			}
-			if(e.isClickable()){
+			
+			//nu kijken of je de enemy  raakt met een bullet
+			else{				
+				bulletIterator = bullets.iterator();
 				
+				while(bulletIterator.hasNext()){
+					Bullet b = bulletIterator.next();
+					
+					//kijkt of de enemy een bullet tegen komt, zoja verwijder de bullet, zoniet update de enemy.
+					if(e.bulletHitMe(b)){											
+						bulletIterator.remove();
+						
+						//kijkt of de bullet die de enemy heeft gehit, ook dezelfde kleur heeft als de enemy, zoja verwijder de enemy
+						if(e.ColorHitMe(b)){
+							
+						currentScore += 1;
+						if(lifePoints < 100) {
+							lifePoints += 5;
+						}							
+							enemyIterator.remove();
+							break;
+						}					
+					}							
+				}				
 			}
-//			System.out.println(e.enemy.getP1().distance(hitArea.getCenterX(), hitArea.getCenterY()));
-			e.update();				
-		}
 			infoPanel.updateIPanel();
+		}	
+		
+
+		while(enemys.size() < 8){
+			int index = (int)(Math.random()*8);
+			int color = (int)(Math.random()*GameModel.colors.length);
+			Line2D line = area.getLine(index);
+			addEnemy(line,GameModel.colors[color],200);
+		}		
 	}
-	
 
 	@Override
-	public void draw(Graphics2D g2) {			
-		try{			
+	public void draw(Graphics2D g2) {	
+		try{
 			infoPanel.draw(g2);
 			g2.setClip(borderRect);	
-			area.draw(g2);
+			area.draw(g2);		
 			
-			g2.setStroke(stroke);
 			if(enemys != null){
 				for(Enemy enemy : enemys){
 					enemy.draw(g2);
 				}
-			}			
+			}		
+
+			g2.setStroke(new BasicStroke(5));
+			for(Bullet b : bullets){
+				b.draw(g2);
+			}
 
 			if(player != null)
 				player.draw(g2);
@@ -103,19 +148,10 @@ public class PlayState extends GameState{
 	
 
 	@Override
-	public void buttonPressed(ButtonEvent e) {			
-		enemyIterator = enemys.iterator();
-		while(enemyIterator.hasNext()){			
-			Enemy enemy = enemyIterator.next();
-			if(enemy.isClickable()){
-				if(enemy.getIndex() == player.getIndex()){
-					if(enemy.getColor().equals(e.getButton().getColor())){
-						enemyIterator.remove();
-						currentScore += enemy.getTimeLeftToClick();
-					}
-				}
-			}
-		}	
+	public void buttonPressed(ButtonEvent e) {	
+		if(e.getButton().getButtonID() != 0){
+			addBullet(GameModel.colors[e.getButton().getButtonID()-1],player.getIndex());
+		}
 	}
 
 	@Override
@@ -156,7 +192,16 @@ public class PlayState extends GameState{
 		}
 	}
 
-	public void addEnemy(int pathID,Color color,Point2D beginPoint,Point2D endPoint){		
-		enemys.add(new Enemy(pathID,1,color,100,beginPoint, endPoint));	
-	}		
+	public void addEnemy(Line2D path,Color c,double speed){		
+		enemys.add(new Enemy(path,c,20,speed));	
+	}
+	
+	public void addBullet(Color c,int index){		;
+		bullets.add(new Bullet(10, c, 10, index,area.paths.get(index)));		
+	}
+	
+	public void removeBullet(Bullet bullet){
+		bullets.remove(bullet);
+	}
+
 }

model/gameState/TitleState.java

@@ -0,0 +1,91 @@
+package model.gameState;
+
+import image.Images;
+import image.Images.ImageType;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+
+import control.GameStateManager;
+import control.button.ButtonEvent;
+import control.joystick.JoystickEvent;
+
+public class TitleState extends GameState {
+
+    BufferedImage pressStart = Images.getImage(ImageType.pressstart);
+    BufferedImage colorStrike = Images.getImage(ImageType.colorstrike);
+    BufferedImage background = Images.getImage(ImageType.background);
+    
+    int index = 0;
+    int varx = 0;
+    int frame = 0;
+    int maxFrames = 2560;
+
+	public TitleState(GameStateManager gsm) {
+		super(gsm);
+	}
+	@Override
+	public void init() {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void update() {
+
+        frame++;
+	}
+
+	@Override
+	public void draw(Graphics2D g2) {
+		
+		g2.setColor(Color.WHITE);
+		g2.fillRect(0,0,1280,1024);
+		
+		g2.translate(640, 512);
+	    
+		BufferedImage subImg2 = background.getSubimage(0, 0, 5120, 1024);
+	    g2.drawImage(subImg2, -640 -((frame * 4) % maxFrames), -512, 5120, 1024, null);
+//		
+//		g2.setColor(Color.ORANGE);
+//		g2.fillRect( -25*5 -1, - 18*5 -1, 49*5 + 1, 26*5 + 1);
+//		g2.drawRect( -25*5 -3, - 18*5 -3, 49*5 + 4, 26*5 + 4);
+
+		int image_x = ((frame / 6) % 6) * 49;
+	    BufferedImage subImg = pressStart.getSubimage(image_x, 0, 49, 26);
+	    g2.drawImage(subImg, - 25*5, - 18*5, 49*5, 26*5, null);
+	    
+	    g2.drawImage(colorStrike, -27*8 , -300, 54*8, 18*8, null);
+
+	
+		Font textFont = new Font("OCR A Extended", Font.BOLD, 15);
+		g2.setFont(textFont);
+		g2.setColor(Color.WHITE);
+		g2.drawString("©2015 Team Hamtaro", - 18*5, 500);
+		
+	}
+	
+	@Override
+	public void buttonPressed(ButtonEvent e) {
+		
+		switch(e.getButton().getButtonID()){
+		case 0:
+			gsm.next();
+			break;
+		}
+		
+		
+	}
+	@Override
+	public void buttonReleased(ButtonEvent e) {
+		
+	}
+	@Override
+	public void onJoystickMoved(JoystickEvent e) {
+		// TODO Auto-generated method stub
+		
+	}
+
+}

model/objects/InfoPanel.java

@@ -34,6 +34,7 @@ public class InfoPanel {
 	}
 	
 	public void draw(Graphics2D g2){
+		g2.setColor(Color.BLACK);
 		g2.fillRect(x, y, 256, 1024);
 		Font scoreFont = new Font("OCR A Extended", Font.BOLD, 30);
 		g2.setFont(scoreFont);

model/objects/MenuButton.java

@@ -0,0 +1,136 @@
+package model.objects;
+
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Graphics2D;
+import java.awt.LinearGradientPaint;
+import java.awt.Paint;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
+import java.util.ArrayList;
+
+public class MenuButton {
+
+	private ArrayList<GeneralPath> buttonparts;
+	private GeneralPath border, line;
+	private ArrayList<Color> colors;
+	private Paint gradient;
+	private int x, y, rounding;
+	private double scalefactor;
+	private String text;
+	
+	private boolean selected; 
+	private int fadecounter;
+	
+	public MenuButton(int x, int y, double scale, String text, int rounding, Color c0){
+		this.x = x;
+		this.y = y;
+		this.scalefactor = scale;
+		this.text = text;
+		this.rounding = rounding;
+		calculateButton();
+		
+		colors = new ArrayList<Color>();
+		
+		Color c1 = c0.darker();
+		Color c2 = c0.darker().darker();
+		Color c3 = c0.darker().darker().darker();
+		
+		c1 = new Color((int)(c1.getRed()*0.8), (int)(c1.getGreen()*0.8),(int)(c1.getBlue()*0.8));
+		c2 = new Color((int)(c2.getRed()*0.8), (int)(c2.getGreen()*0.8),(int)(c2.getBlue()*0.8));
+		c3 = new Color((int)(c3.getRed()*0.8), (int)(c3.getGreen()*0.8),(int)(c3.getBlue()*0.8));
+		
+		colors.add(c2);
+		colors.add(c3);
+		colors.add(c2);
+		colors.add(c0);
+		colors.add(c1);
+		colors.add(c0);
+		
+		gradient = new LinearGradientPaint(
+							new Point2D.Double((-100)*scalefactor,(512)*scalefactor), 
+							new Point2D.Double((600)*scalefactor,(512)*scalefactor), 
+							new float[]{0.0f, 1.0f}, 
+							new Color[]{new Color(c1.getRed(), c1.getGreen(), c1.getBlue(), 10), c0});
+	}
+	
+	public void calculateButton(){
+		buttonparts = new ArrayList<GeneralPath>();
+		buttonparts.add(arrayToGeneralpath(new int[][]{{449, 1}, {449, 68},{113, 103}, {106, 35}}));															//background right
+		buttonparts.add(arrayToGeneralpath(new int[][]{{113, 103}, {106, 35},{70, 12+rounding}, {77, 88+rounding}}));										//background middle
+		buttonparts.add(arrayToGeneralpath(new int[][]{{70, 12+rounding}, {77, 88+rounding},{4, 104+(int)(rounding*0.5)}, {-4, 32+(int)(rounding*0.5)}}));	//background left
+		buttonparts.add(arrayToGeneralpath(new int[][]{{449, 15}, {449, 54},{118, 88}, {114, 48}}));															//foreground right
+		buttonparts.add(arrayToGeneralpath(new int[][]{{118, 88}, {114, 48},{78, 25+rounding}, {82, 73+rounding}}));											//foreground middle
+		buttonparts.add(arrayToGeneralpath(new int[][]{{78, 25+rounding}, {82, 73+rounding},{15, 88+(int)(rounding*0.5)}, {10, 43+(int)(rounding*0.5)}}));	//foreground left
+	
+		border = arrayToGeneralpath(new int[][]{{449,15}, {114,48},{78,25+rounding},{10,43+(int)(rounding*0.5)},{15,88+(int)(rounding*0.5)},{82,73+rounding},{118,88},{449,54}});
+		line = arrayToGeneralpath(new int[][]{{-11,55},{-40,60},{-38,78},{-358,170-rounding*3},{-358,174-rounding*3},{-37,87},{-35,102},{-5,95}});
+	}
+	
+	public GeneralPath arrayToGeneralpath(int block[][]){
+		GeneralPath polyline =  new GeneralPath(GeneralPath.WIND_EVEN_ODD, block.length);
+		polyline.moveTo ((block[0][0]+x)*scalefactor, (block[0][1]+y)*scalefactor);
+		for (int index = 1; index < block.length; index++) {
+		         polyline.lineTo((block[index][0]+x)*scalefactor, (block[index][1]+y)*scalefactor);
+		};
+		polyline.closePath();
+		return polyline;
+	}
+
+	public void draw(Graphics2D g2d){
+		for(int i = 0; i < buttonparts.size(); i++){ //fill every part of the button with a specific color
+			g2d.setColor(colors.get(i));
+			g2d.fill((buttonparts.get(i)));
+		}
+		
+		if(selected){
+			g2d.setStroke(new BasicStroke(4));
+			g2d.setColor(Color.BLACK);
+			g2d.draw(border);
+		}
+		g2d.setPaint(gradient);
+		g2d.fill(line);
+
+		//draw text
+		g2d.setColor(Color.BLACK);
+		Font textFont = new Font("OCR A Extended", Font.BOLD, (int)(30*scalefactor));
+		g2d.setFont(textFont);
+		g2d.translate((x+160)*scalefactor, (y+74)*scalefactor);
+		g2d.rotate(-0.1);
+		g2d.drawString(text,  0, 0);
+		g2d.rotate(0.1);
+		g2d.translate(-(x+160)*scalefactor, -(y+74)*scalefactor);
+	}
+	
+	public void update(){
+		if(selected && fadecounter < 5){
+			x -= 8;
+			y -=8;
+			scalefactor += 0.04;
+			fadecounter++;
+			calculateButton();
+		}else if(!selected && fadecounter >0){
+			x += 8;
+			y += 8;
+			fadecounter--;
+			scalefactor -= 0.04;
+			calculateButton();
+		}
+	}
+	
+	public void setSelected(boolean selected) {
+		this.selected = selected;
+	}
+	
+	public void setX(int x){
+		this.x = x;
+		calculateButton();
+	}
+
+	public int getX() {
+		return x;
+	}
+	
+	
+}

model/objects/PlayArea.java

@@ -2,96 +2,48 @@ package model.objects;
 
 import java.awt.Graphics2D;
 import java.awt.Polygon;
+import java.awt.Shape;
 import java.awt.geom.Line2D;
-import java.awt.geom.Point2D;
-import java.awt.geom.Rectangle2D;
 import java.util.ArrayList;
 import java.util.List;
 
-import model.gameState.PlayState;
-
 public class PlayArea {
 
 	public List<Line2D> paths;
-	private Polygon octagon,hitArea;	
-	public Rectangle2D[] hitAreas; //de area voor elk path die de enemy moet raken
+	public Polygon octagon;
+	
 	
-	public PlayArea(double xToRight,double heightOfGameScreen,double widthOfGameScreen, int sizeOctagon) {
+	public PlayArea(int xToRight,int heightOfGameScreen,int widthOfGameScreen, int sizeOctagon) {
 		super();
-		paths = new ArrayList<Line2D>();		
-		
+		paths = new ArrayList<Line2D>();
+		int middlePointX = widthOfGameScreen/2+xToRight;
+		int middlePointY = heightOfGameScreen/2;
 		int amountOfAngles = 8;
-		double middlePointX = widthOfGameScreen/2+xToRight;
-		double middlePointY = heightOfGameScreen/2;
 		
 		octagon = new Polygon();		
 		for(int i = 0; i < amountOfAngles; i++){
 			octagon.addPoint((int)(middlePointX+sizeOctagon*Math.cos(i*Math.PI/(amountOfAngles/2))), 
-							 (int)(middlePointY+sizeOctagon*Math.sin(i*Math.PI/(amountOfAngles/2))));			
-		}
-		
-		hitArea = new Polygon();
-		sizeOctagon += PlayState.sizeOfEnemy;		
-		for(int i = 0; i < amountOfAngles; i++){
-			hitArea.addPoint((int)(middlePointX+sizeOctagon*Math.cos(i*Math.PI/(amountOfAngles/2))), 
 							 (int)(middlePointY+sizeOctagon*Math.sin(i*Math.PI/(amountOfAngles/2))));
 		}
 		
-		hitAreas = new Rectangle2D[amountOfAngles];
-		int newIndex;
-		Point2D beginPoint,endPoint;
-		for(int index = 0; index < hitAreas.length; index++){
-			//in het polygon staat de cooridinaten van de top niet als eerste in de array, maar op index 6.n
-			newIndex = (index+6+8)%8;	
-			hitAreas[index] = new Rectangle2D.Double();
-			beginPoint = new Point2D.Double(octagon.xpoints[newIndex], octagon.ypoints[newIndex]);
-			endPoint = new Point2D.Double(hitArea.xpoints[newIndex], hitArea.ypoints[newIndex]);			
-			hitAreas[index].setFrameFromDiagonal(beginPoint,endPoint);			
-		}
-		
-		
-		Rectangle2D cr = null;//cr --> current rectangle
-		double size = hitAreas[1].getWidth();//dit is de grootte van een zijde als die van de oorspronklijke 0 was.
-		
-		cr = hitAreas[0];
-		hitAreas[0].setFrame(cr.getX()-size/2, cr.getY()+1, size, cr.getHeight());
-		
-		cr = hitAreas[2];
-		hitAreas[2].setFrame(cr.getX()-1, cr.getY()-size/2, cr.getWidth(), size);
-		
-		cr = hitAreas[4];
-		hitAreas[4].setFrame(cr.getX()-size/2, cr.getY()-1, size, cr.getHeight());
-		
-		cr = hitAreas[6];
-		hitAreas[6].setFrame(cr.getX()+1, cr.getY()-size/2, cr.getWidth(), size);
-		
-		widthOfGameScreen += xToRight;			
-		
-		paths.add(new Line2D.Double(middlePointX,0						,hitArea.xpoints[6],hitArea.ypoints[6]));//top
-		paths.add(new Line2D.Double(widthOfGameScreen,0					,hitArea.xpoints[7],hitArea.ypoints[7]));//right 	-top
-		paths.add(new Line2D.Double(widthOfGameScreen,middlePointY		,hitArea.xpoints[0],hitArea.ypoints[0]));//right
-		paths.add(new Line2D.Double(widthOfGameScreen,heightOfGameScreen,hitArea.xpoints[1],hitArea.ypoints[1]));//right	-down
-		paths.add(new Line2D.Double(middlePointX,heightOfGameScreen		,hitArea.xpoints[2],hitArea.ypoints[2]));//down
-		paths.add(new Line2D.Double(xToRight,heightOfGameScreen			,hitArea.xpoints[3],hitArea.ypoints[3]));//left		-down
-		paths.add(new Line2D.Double(xToRight,middlePointY				,hitArea.xpoints[4],hitArea.ypoints[4]));//left
-		paths.add(new Line2D.Double(xToRight,0							,hitArea.xpoints[5],hitArea.ypoints[5]));//left	 	-top
+		widthOfGameScreen += xToRight;	
 		
 		
+		paths.add(new Line2D.Double(middlePointX,0						,octagon.xpoints[6],octagon.ypoints[6]));//top
+		paths.add(new Line2D.Double(widthOfGameScreen,0					,octagon.xpoints[7],octagon.ypoints[7]));//right 	-top
+		paths.add(new Line2D.Double(widthOfGameScreen,middlePointY		,octagon.xpoints[0],octagon.ypoints[0]));//right
+		paths.add(new Line2D.Double(widthOfGameScreen,heightOfGameScreen,octagon.xpoints[1],octagon.ypoints[1]));//right	-down
+		paths.add(new Line2D.Double(middlePointX,heightOfGameScreen		,octagon.xpoints[2],octagon.ypoints[2]));//down
+		paths.add(new Line2D.Double(xToRight,heightOfGameScreen			,octagon.xpoints[3],octagon.ypoints[3]));//left		-down
+		paths.add(new Line2D.Double(xToRight,middlePointY				,octagon.xpoints[4],octagon.ypoints[4]));//left
+		paths.add(new Line2D.Double(xToRight,0							,octagon.xpoints[5],octagon.ypoints[5]));//left	 	-top		
 	}	
 	
 	public void draw(Graphics2D g2){
-		Line2D current;
-		int index;
-		for(int i = 0; i < paths.size(); i++){
-			current = paths.get(i);
-			index = (i+14)%8;
-			g2.drawLine((int)current.getX1(), (int)current.getY1(), octagon.xpoints[index],octagon.ypoints[index]);
+		for(Shape s : paths){
+			g2.draw(s);
 		}
 		g2.draw(octagon);
-		g2.draw(hitArea);	
-//		for(Rectangle2D hit : hitAreas){
-//			g2.fill(hit);
-//		}
 	}
 	
 	public Line2D getLine(int index){