Merge branch 'testGameSprint1' into develop

control/GameControl.java

@@ -11,23 +11,29 @@ public class GameControl implements JoystickListener, ButtonListener{
 	
 	GameModel model;
 	GameView view;
+	GameStateManager gsm;
 	
-	public GameControl(GameModel model, GameView view)
+	public GameControl(GameModel model, GameView view,GameStateManager gsm)
 	{
 		this.model = model;
 		this.view = view;
+		this.gsm = gsm;
 	}
 
 	@Override
-	public void buttonPressed(ButtonEvent e) {
-		System.out.println(e.getButton().getButtonID());
+	public void buttonPressed(ButtonEvent e) {	
+//		System.out.println("Game control, button pressed: "+e.getButton().getButtonID());
+		gsm.currentState.buttonPressed(e);
 	}
 
 	@Override
-	public void buttonReleased(ButtonEvent e) {}
+	public void buttonReleased(ButtonEvent e) {	
+//		System.out.println("Game control, button released: "+e.getButton().getButtonID());
+		gsm.currentState.buttonReleased(e);
+	}
 
 	@Override
 	public void onJoystickMoved(JoystickEvent e) {
-
+		gsm.currentState.onJoystickMoved(e);
 	}
 }

control/GameStateManager.java

@@ -23,10 +23,10 @@ public class GameStateManager {
 	public void next() {
 		index++;
 		index %= gamestates.size();
+		currentState = gamestates.get(index);
 	}
 	
-	public void update(){
-		currentState = gamestates.get(index);
+	public void update(){		
 		currentState.update();
 	}
 }

control/joystick/JoystickHandler.java

@@ -50,7 +50,12 @@ public class JoystickHandler implements KeyListener{
                   public void handleGpioPinDigitalStateChangeEvent(GpioPinDigitalStateChangeEvent e) {
                 	  if(e.getState() == PinState.HIGH){
                 		  keyReleased(new KeyEvent(
-                				  		new java.awt.Component(){}, 
+                				  		new java.awt.Component(){
+
+											/**
+											 * 
+											 */
+											private static final long serialVersionUID = 1L;}, 
                 				  		KeyEvent.KEY_RELEASED, 
                 				  		System.nanoTime(), 
                 				  		0, 
@@ -60,7 +65,12 @@ public class JoystickHandler implements KeyListener{
                 		  System.out.println(e.getPin().getName() + " Released");
                 	  }else{
                 		  keyPressed(new KeyEvent(
-          				  		new java.awt.Component(){}, 
+          				  		new java.awt.Component(){
+
+									/**
+									 * 
+									 */
+									private static final long serialVersionUID = 1L;}, 
           				  		KeyEvent.KEY_PRESSED, 
           				  		System.nanoTime(), 
           				  		0, 

image/Images.java

@@ -19,6 +19,7 @@ public class Images{
 	 static{
 		  try{
 		   images.add(ImageIO.read(Main.class.getResource("/image/player.png"))); 
+		   images.add(ImageIO.read(Main.class.getResource("/image/player2.png"))); 
 		  
 		  }catch(IOException e){
 		   e.printStackTrace();
@@ -32,6 +33,6 @@ public class Images{
 
 	 public enum ImageType
 	 {
-	  player
+	  player,player2	 
 	 }
 }

main/Main.java

@@ -10,9 +10,7 @@ public class Main {
 		else
 		{
 			new Window(true);
-		}
-		
-		
+		}		
 	}
 
 }

main/Window.java

@@ -14,12 +14,17 @@ import javax.swing.JFrame;
 import model.GameModel;
 import view.GameView;
 import control.GameControl;
+import control.GameStateManager;
 import control.LedHandler;
 import control.button.ButtonHandler;
 import control.joystick.JoystickHandler;
 
 public class Window extends JFrame {
 	
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -9222956702898533696L;
 	public static boolean ON_RASP;
 	
 	public Window(boolean ON_RASP)
@@ -29,7 +34,7 @@ public class Window extends JFrame {
 		setSize(1280, 1024);
 		
 		Window.ON_RASP = ON_RASP;
-		System.out.println(ON_RASP);
+//		System.out.println(ON_RASP);
 		
 		//Set window close listener
 		setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
@@ -40,21 +45,19 @@ public class Window extends JFrame {
 		});
 		
 		//Set window to fullscreen
-		//		setExtendedState(getExtendedState() | JFrame.MAXIMIZED_BOTH);
-		//	setUndecorated(true);
-
-		GraphicsEnvironment graphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
-	    GraphicsDevice[] devices =  graphicsEnvironment.getScreenDevices();
-        if (!devices[0].isFullScreenSupported ())
-        {
-            throw new UnsupportedOperationException ("Fullscreen mode is unsupported.");
-        }
-        devices[0].setFullScreenWindow(this);
 		//Create Events
 		LedHandler led = null;
 		
 		if(ON_RASP) //TODO REMOVE
 		{
+			led = new LedHandler();
+			GraphicsEnvironment graphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
+			GraphicsDevice[] devices =  graphicsEnvironment.getScreenDevices();
+			if (!devices[0].isFullScreenSupported ())
+			{
+			     throw new UnsupportedOperationException ("Fullscreen mode is unsupported.");
+			}
+			devices[0].setFullScreenWindow(this);
 			led = new LedHandler();
 			//dissapear cursor
 			BufferedImage cursorImg = new BufferedImage(16, 16, BufferedImage.TYPE_INT_ARGB);
@@ -66,9 +69,10 @@ public class Window extends JFrame {
 		JoystickHandler jsh = new JoystickHandler();
 		
 		//Create Instances
-		GameView view = new GameView(led);
-		GameModel model = new GameModel(view);
-		GameControl control = new GameControl(model, view);
+		GameStateManager gsm = new GameStateManager();
+		GameView view = new GameView(led,gsm);
+		GameModel model = new GameModel(view,gsm);
+		GameControl control = new GameControl(model, view,gsm);
 		setContentPane(view);
 		
 		//Create EventListeners

model/GameModel.java

@@ -1,34 +1,36 @@
 package model;
 
+import java.awt.Color;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 
 import javax.swing.Timer;
 
 import view.GameView;
+import control.GameStateManager;
+import control.button.ButtonHandler;
 
 public class GameModel implements ActionListener{
 	
 	GameView view;
 	Timer update;
-	Player player;
+	public static Color[] colors = {Color.MAGENTA,Color.RED,Color.GREEN,Color.YELLOW,Color.CYAN,Color.BLUE};
+	GameStateManager gsm;
 	
-	
-	public GameModel(GameView view)
+	public GameModel(GameView view,GameStateManager gsm)
 	{
-		this.view = view;
-		player = new Player(1920/2, 1080/2);
-		update = new Timer(1000/10, this);
+		this.view = view;	
+		this.gsm = gsm;
+		update = new Timer(1000/30, this);
 		update.start();
-	}
-	
-	public void update(){
-		player.update();
-		view.setPlayer(player);
+		
+		for(int i = 1; i < ButtonHandler.getButtons().size(); i++){
+			ButtonHandler.getButtons().get(i).setColor(colors[i-1]);;
+		}
 	}
 	
 	@Override
 	public void actionPerformed(ActionEvent e) {
-		update();		
+		gsm.update();		
 	}
 }

model/drawObjects/Bullet.java

@@ -0,0 +1,107 @@
+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;
+	
+	public 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,beginY,endX,endY;
+		
+		beginX = path.getX2();
+		beginY = path.getY2();
+		endX = beginX;
+		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);
+//		System.out.println("Index: "+index);
+//		System.out.println("X difference: "+(bullet.getX2()-bullet.getX1()));
+//		System.out.println("Y difference: "+(bullet.getY2()-bullet.getY1()));
+	}
+
+	@Override
+	public void draw(Graphics2D g2) {
+		g2.setPaint(c);
+		g2.draw(bullet);
+	}
+
+	@Override
+	public void update() {		
+		double x1,x2,y1,y2,yDifference,xDifference;
+		x1 = bullet.getX1();
+		x2 = bullet.getX2();
+		y1 = bullet.getY1();
+		y2 = bullet.getY2();
+		yDifference = y2 - y1;
+		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;
+	}	
+	
+	
+}

model/drawObjects/DrawObject.java

@@ -2,19 +2,21 @@ package model.drawObjects;
 
 import java.awt.Graphics2D;
 import java.awt.geom.AffineTransform;
-import java.awt.geom.Point2D;
 
 public abstract class DrawObject {
 
-	protected Point2D middlePoint;
-	protected AffineTransform transform;
-	protected int index = 0,width,height;
 	
-	public DrawObject(int x, int y) {
-		middlePoint = new Point2D.Double(x, y);
+	protected AffineTransform transform;
+	protected double width,height;
+	protected int index = 0;
+	public DrawObject() {	
 		transform = new AffineTransform();
 	}
 	
+	public void setIndex(int index){
+		this.index = index;
+	}
+	
 	public abstract void draw(Graphics2D g2);
 	public abstract void update();
 }

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.bullet)){
+			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

@@ -2,28 +2,64 @@ package model.drawObjects;
 
 import image.Images;
 
+import java.awt.BasicStroke;
 import java.awt.Color;
 import java.awt.Graphics2D;
 import java.awt.geom.AffineTransform;
 import java.awt.image.BufferedImage;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
 
-public class Player extends DrawObject {
+import model.gameState.PlayState;
+import model.objects.PlayArea;
+
+public class Player extends Person {
 	
 	private BufferedImage img;
+	private PlayArea path ;
+	public List<Bullet> bullets;
 	
-	public Player(int x, int y){
+	public Player(int x, int y,PlayArea paths){
 		super(x,y);
-		img = Images.getImage(Images.ImageType.player);
-		
+		this.path = paths;
+		img = Images.getImage(Images.ImageType.player2);	
+		width = img.getWidth();
+		height = img.getHeight();
+		bullets = Collections.synchronizedList(new ArrayList<Bullet>());
 	}
 	
 	public void draw(Graphics2D g2){//		
-		g2.drawImage(img, transform, null);				
+		g2.drawImage(img, transform, null);	
+		
+		g2.setStroke(new BasicStroke(5));
+		for(Bullet b : bullets){
+			b.draw(g2);
+		}
 	}
 	
 	public void update(){
 		transform = new AffineTransform();
 		transform.rotate(Math.toRadians(index*45),middlePoint.getX(),middlePoint.getY());
-		transform.translate(middlePoint.getX() - width/2, middlePoint.getY() - height*2);		
+		transform.translate(middlePoint.getX() - width/2, middlePoint.getY() - height);
+		for(Bullet b : bullets){			
+			b.update();
+		}
+		Iterator<Bullet> i = bullets.iterator();
+		while(i.hasNext()){
+			if(!PlayState.borderRect.intersectsLine(i.next().bullet)){
+				i.remove();
+			}
+		}
+	}
+	
+	public void addBullet(Color c){	
+//		System.out.println(index);
+		bullets.add(new Bullet(10, c, 10, index,path.paths.get(index)));		
+	}
+	
+	public void removeBullet(Bullet bullet){
+		bullets.remove(bullet);
 	}
 }

model/gameState/GameState.java

@@ -1,11 +1,12 @@
 package model.gameState;
 
 import java.awt.Graphics2D;
-import java.awt.event.KeyEvent;
 
 import control.GameStateManager;
+import control.button.ButtonEvent;
+import control.joystick.JoystickEvent;
 
-public abstract class GameState {
+public abstract class GameState  {
 
 	protected GameStateManager gsm;
 
@@ -16,7 +17,8 @@ public abstract class GameState {
 	
 	public abstract void init();
 	public abstract void update();
-	public abstract void draw(Graphics2D g2);
-	public abstract void keyPressed(KeyEvent e);
-	public abstract void keyReleased(KeyEvent e);
+	public abstract void draw(Graphics2D g2);	
+	public abstract void buttonPressed(ButtonEvent e);	
+	public abstract void buttonReleased(ButtonEvent e);	
+	public abstract void onJoystickMoved(JoystickEvent e);
 }

model/gameState/MenuState.java

@@ -1,9 +1,10 @@
 package model.gameState;
 
 import java.awt.Graphics2D;
-import java.awt.event.KeyEvent;
 
 import control.GameStateManager;
+import control.button.ButtonEvent;
+import control.joystick.JoystickEvent;
 
 public class MenuState extends GameState {
 
@@ -24,22 +25,29 @@ public class MenuState extends GameState {
 
 	@Override
 	public void draw(Graphics2D g2) {
-		g2.fillRect(10, 10, 100, 10);
+		g2.drawString("Press 0 to start the game", 1280/2, 1024/2);
 
 	}
-
+	
 	@Override
-	public void keyPressed(KeyEvent e) {
-		if(e.getKeyCode() == KeyEvent.VK_Q){
+	public void buttonPressed(ButtonEvent e) {
+		
+		switch(e.getButton().getButtonID()){
+		case 0:
 			gsm.next();
+			break;
 		}
-
+		
+		
 	}
-
 	@Override
-	public void keyReleased(KeyEvent e) {
+	public void buttonReleased(ButtonEvent e) {
+		
+	}
+	@Override
+	public void onJoystickMoved(JoystickEvent e) {
 		// TODO Auto-generated method stub
-
+		
 	}
 
 }

model/gameState/PlayState.java

@@ -1,54 +1,165 @@
 package model.gameState;
 
+import java.awt.Color;
 import java.awt.Graphics2D;
-import java.awt.event.KeyEvent;
+import java.awt.geom.Line2D;
 import java.awt.geom.Rectangle2D;
+import java.util.ArrayList;
+import java.util.Collections;
+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.objects.InfoPanel;
-import model.objects.Lines;
+import model.objects.PlayArea;
 import control.GameStateManager;
+import control.button.ButtonEvent;
+import control.joystick.JoystickEvent;
 
 public class PlayState extends GameState{
 
 	public static final Rectangle2D borderRect = new Rectangle2D.Double(256, 0, 1024, 1024);
-	private Lines lines;
-	private InfoPanel hsb;
+	private PlayArea area;
+	private InfoPanel infoPanel;
+	private Player player;
+	private List<Enemy> enemys;	
+
+	
 	public PlayState(GameStateManager gsm) {
 		super(gsm);
-		lines = new Lines((int) borderRect.getX(),100);
-		hsb = new InfoPanel(0, 0);
+		area = new PlayArea((int) borderRect.getX(),1024,1024,100);
+		infoPanel = new InfoPanel(0, 0);
+		enemys = Collections.synchronizedList(new ArrayList<Enemy>());
+		player = new Player(1280-1024+1024/2, 1024/2,area);
+		for(int i = 0; i < 8; i++){
+			Line2D line = area.getLine(i);
+			addEnemy(line, Color.BLUE, 200);
+		}
 	}
 
 	@Override
 	public void init() {
-		// TODO Auto-generated method stub
+		
 		
 	}
 
 	@Override
-	public void update() {
-		// TODO Auto-generated method stub
-		
+	public void update() {		
+		player.update();	
+		Iterator<Enemy> enemyIterator = enemys.iterator();
+		while(enemyIterator.hasNext()){
+			Enemy e = enemyIterator.next();
+			Iterator<Bullet> bulletIterator = player.bullets.iterator();
+			while(bulletIterator.hasNext()){
+				Bullet b = bulletIterator.next();
+				if(e.bulletHitMe(b)){		//kijkt of de enemy een bullet tegen komt, zoja verwijder de bullet.
+					bulletIterator.remove();
+					if(e.ColorHitMe(b)){		//kijkt of de bullet die de enemy heeft gehit, ook dezelfde kleur heeft als de enemy, zoja verwijder de enemy
+						enemyIterator.remove();
+					}					
+				}
+			}
+			if(area.octagon.intersects(e.getCircle().getBounds2D())){
+				enemyIterator.remove();
+			}else{
+				e.update();
+			}
+		}		
+		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) {	
-		hsb.draw(g2);
+		infoPanel.draw(g2);
 		g2.setClip(borderRect);	
-		lines.draw(g2);
+		area.draw(g2);		
+		
+		if(enemys != null){
+			if(!enemys.isEmpty()){
+				for(Enemy enemy : enemys){
+					enemy.draw(g2);
+				}
+			}
+		}		
+		
+		if(player != null)
+			player.draw(g2);
 		
 	}
+	
+	public void addEnemy(Line2D path,Color c,double speed){		
+		enemys.add(new Enemy(path,c,20,speed));	
+	}
 
 	@Override
-	public void keyPressed(KeyEvent e) {
-		// TODO Auto-generated method stub
-		
+	public void buttonPressed(ButtonEvent e) {	
+//		System.out.println("Playstate button pressed: "+e.getButton().getButtonID());
+		switch(e.getButton().getButtonID()){
+			case 1:
+				player.addBullet(GameModel.colors[0]);
+				break;
+			case 2:
+				player.addBullet(GameModel.colors[1]);
+				break;
+			case 3:
+				player.addBullet(GameModel.colors[2]);
+				break;
+			case 4:
+				player.addBullet(GameModel.colors[3]);
+				break;
+			case 5:
+				player.addBullet(GameModel.colors[4]);
+				break;
+			case 6:
+				player.addBullet(GameModel.colors[5]);
+				break;
+		}
 	}
 
 	@Override
-	public void keyReleased(KeyEvent e) {
-		// TODO Auto-generated method stub
-		
+	public void buttonReleased(ButtonEvent e) {		
+//		System.out.println("Playstate button released: "+e.getButton().getButtonID());
 	}
 
+	@Override
+	public void onJoystickMoved(JoystickEvent e) {		
+		switch(e.getJoystick().getPos()){
+		case CENTER:
+			break;
+		case DOWN:
+			player.setIndex(4);
+			break;
+		case DOWN_LEFT:
+			player.setIndex(5);
+			break;
+		case DOWN_RIGHT:
+			player.setIndex(3);
+			break;
+		case LEFT:
+			player.setIndex(6);
+			break;
+		case RIGHT:
+			player.setIndex(2);
+			break;
+		case UP:
+			player.setIndex(0);
+			break;
+		case UP_LEFT:
+			player.setIndex(7);
+			break;
+		case UP_RIGHT:
+			player.setIndex(1);
+			break;
+		default:			
+			break;
+		}
+	}
 }

model/objects/InfoPanel.java

@@ -12,6 +12,6 @@ public class InfoPanel {
 	}
 	
 	public void draw(Graphics2D g2){
-		g2.drawRect(x, y, 256, 1024);
+		g2.fillRect(x, y, 256, 1024);
 	}
 }

model/objects/PlayArea.java

@@ -0,0 +1,58 @@
+package model.objects;
+
+import java.awt.Graphics2D;
+import java.awt.Polygon;
+import java.awt.Shape;
+import java.awt.geom.Line2D;
+import java.util.ArrayList;
+import java.util.List;
+
+public class PlayArea {
+
+	public List<Line2D> paths;
+	public Polygon octagon;
+	
+	
+	public PlayArea(int xToRight,int heightOfGameScreen,int widthOfGameScreen, int sizeOctagon) {
+		super();
+		paths = new ArrayList<Line2D>();
+		int middlePointX = widthOfGameScreen/2+xToRight;
+		int middlePointY = heightOfGameScreen/2;
+		int amountOfAngles = 8;
+		
+		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))));
+		}
+		
+		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){
+		for(Shape s : paths){
+			g2.draw(s);
+		}
+		g2.draw(octagon);
+	}
+	
+	public Line2D getLine(int index){
+		if(index < 0){
+			index = 0;
+		}
+		if(index >= 8 ){
+			index = 7;
+		}
+		return paths.get(index);
+	}
+}

view/GameView.java

@@ -3,13 +3,14 @@ package view;
 import java.awt.Dimension;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
+import java.awt.RenderingHints;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 
 import javax.swing.JPanel;
 import javax.swing.Timer;
 
-import model.Player;
+import control.GameStateManager;
 import control.LedHandler;
 
 public class GameView extends JPanel implements ActionListener{
@@ -18,14 +19,16 @@ public class GameView extends JPanel implements ActionListener{
 	 * 
 	 */
 	private static final long serialVersionUID = 1939480784205689618L;
-	Timer t;
-	Player player;
+	
+	Timer t;	
 	LedHandler led;
+	GameStateManager gsm;
 	
-	public GameView(LedHandler led)
+	public GameView(LedHandler led,GameStateManager gsm)
 	{
 		this.led=led;
-		t = new Timer(1000/30, this);
+		this.gsm = gsm;		
+		t = new Timer(1000/60, this);
 		t.start();
 		setPreferredSize(new Dimension(1280,1024));
 	}
@@ -38,13 +41,12 @@ public class GameView extends JPanel implements ActionListener{
 	public void paintComponent(Graphics g)
 	{
 		super.paintComponent(g);
-		Graphics2D g2d = (Graphics2D) g;
 		
-		if(player != null)
-		player.draw(g2d);
-	}
-	
-	public void setPlayer(Player player){
-		this.player = player;
-	}
+		Graphics2D g2d = (Graphics2D) g;
+		RenderingHints rh = new RenderingHints(
+	              RenderingHints.KEY_ANTIALIASING,
+	              RenderingHints.VALUE_ANTIALIAS_ON);
+	     g2d.setRenderingHints(rh);
+		gsm.currentState.draw(g2d);		
+	}	
 }