- bugs

- Help state naar volledigheid geintegreerd.

README.md

@@ -1,2 +1,4 @@
-# Arcade
+JSON Parser
-Arcade game for the fourth term at Avans Hogeschool Breda.
+Add the libraries to your build path.
+Add all the folders EXCEPT the 'songs' folder to your source.
+The 'songs' folder should be in your project root.

audio/AudioPlayer.java

@@ -0,0 +1,75 @@
+package audio;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+import javazoom.jl.decoder.JavaLayerException;
+import javazoom.jl.player.Player;
+
+public class AudioPlayer{
+
+	private Player clip;
+	private FileInputStream fis;
+	private Song s;
+	private Thread thread;
+
+	public AudioPlayer() {
+		clip = null;
+	}
+
+	public void setClip(Song s) {
+		try {
+			if(clip!=null)
+				clip.close();
+			this.s = s;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	public void play() {
+		try {
+			fis = new FileInputStream(s.getAudio());
+			clip = new Player(fis);
+		} catch (JavaLayerException | FileNotFoundException e1) {
+			e1.printStackTrace();
+		}
+		Thread thread = new Thread(() -> {
+				while (clip != null){
+					try {
+						clip.play();
+					} catch (JavaLayerException e) {
+						e.printStackTrace();
+					}
+				}
+			});
+		 thread.start();
+	}
+
+	public void close() {
+		if(clip != null)
+		{
+			clip.close();
+			clip = null;
+
+			try {
+				if(fis != null)
+					fis.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+	}
+	
+
+	
+	public long getProgress()
+	{
+		if(clip != null)
+			return clip.getPosition()*1000;
+		else
+			return 0L;
+	}
+
+}

audio/ButtonInstance.java

@@ -0,0 +1,58 @@
+package audio;
+
+import java.awt.Color;
+
+import control.button.Button;
+import control.button.ButtonHandler;
+
+public class ButtonInstance {
+	
+	private long time;
+	private int buttonID;
+	private Color color;
+	private Button button;
+	
+	public ButtonInstance()
+	{
+		time = 0;
+		buttonID = 0;
+		
+		color = null;
+		
+		button = null;
+	}
+	
+	public Button getButton() {
+		return button;
+	}
+
+	public long getTime() {
+		return time;
+	}
+
+	public void setTime(long time) {
+		this.time = time;
+	}
+
+	public int getButtonID() {
+		return buttonID;
+	}
+
+	public void setButtonID(int buttonID) {
+		if(buttonID < ButtonHandler.getButtons().size() - 1)
+		{
+			this.buttonID = buttonID;
+			this.button = ButtonHandler.getButton(buttonID);
+		}
+	}
+
+	public Color getColor() {
+		return color;
+	}
+
+	public void setColor(Color color) {
+		this.color = color;
+	}
+	
+	
+}

audio/ObjectInstance.java

@@ -0,0 +1,86 @@
+package audio;
+
+import java.awt.Color;
+
+import control.button.Button;
+import control.button.ButtonHandler;
+
+public class ObjectInstance {
+	
+	private long time;
+	private int direction;
+	
+	private int buttonID;
+	private Button button;
+	
+	private boolean hold;
+	private long length;
+	
+	public ObjectInstance()
+	{
+		time = 0;
+		direction = 0;
+		
+		buttonID = 0;
+		button = null;
+		
+		hold = false;
+		length = 0;
+	}
+
+	public long getTime() {
+		return time;
+	}
+
+	public void setTime(long time) {
+		this.time = time;
+	}
+
+	public int getDirection() {
+		return direction;
+	}
+
+	public void setDirection(int direction) {
+		this.direction = direction;
+	}
+
+	public int getButtonID() {
+		return buttonID;
+	}
+
+	public void setButtonID(int buttonID) {
+		if(buttonID < ButtonHandler.getButtons().size() - 1)
+		{
+			this.buttonID = buttonID;
+			this.button = ButtonHandler.getButton(buttonID);
+		}
+	}
+	
+	public Color getColor()
+	{
+		return button.getColor();
+	}
+
+	public Button getButton() {
+		return button;
+	}
+
+	public boolean isHold() {
+		return hold;
+	}
+
+	public void setHold(boolean hold) {
+		this.hold = hold;
+	}
+
+	public long getLength() {
+		if(hold)
+			return length;
+		else
+			return 1;
+	}
+
+	public void setLength(long length) {
+		this.length = length;
+	}
+}

audio/Song.java

@@ -0,0 +1,168 @@
+package audio;
+
+import image.Images;
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Song implements Comparable<Song>{
+
+	private String title;
+	private String subtitle;
+	private String author;
+	private double sample_start;
+	private double BPM;
+
+	private File audio;
+	private File background;
+	private File banner;
+	private File file;
+	
+	private BufferedImage backgroundImage;
+	private BufferedImage bannerImage;
+
+	public List<SongInstance> songs;
+
+	public Song() {
+		title = "";
+		subtitle = "";
+		author = "";
+		sample_start = 0;
+		BPM = 0.0;
+
+		audio = null;
+		background = null;
+		banner = null;
+		file = null;
+		
+		backgroundImage = null;
+		bannerImage = null;
+
+		songs = new ArrayList<SongInstance>();
+	}
+
+	public void addSongInstance(SongInstance s) {
+		songs.add(s);
+	}
+
+	public String getTitle() {
+		return title;
+	}
+
+	public void setTitle(String title) {
+		this.title = title;
+	}
+
+	public String getSubtitle() {
+		return subtitle;
+	}
+
+	public void setSubtitle(String subtitle) {
+		this.subtitle = subtitle;
+	}
+
+	public String getAuthor() {
+		return author;
+	}
+
+	public void setAuthor(String author) {
+		this.author = author;
+	}
+
+	public double getSampleStart() {
+		return sample_start;
+	}
+
+	public void setSampleStart(double sample_start) {
+		this.sample_start = sample_start;
+	}
+
+	public double getBPM() {
+		return BPM;
+	}
+
+	public void setBPM(double bPM) {
+		BPM = bPM;
+	}
+
+	public File getAudio() {
+		return audio;
+	}
+	
+	public void setAudio(File audio) {
+		this.audio = audio;
+	}
+
+	public File getBackground() {
+		return background;
+	}
+
+	public void setBackground(File background) {
+		this.background = background;
+		
+	}
+	
+	public BufferedImage getBackgroundImage()
+	{
+		if(backgroundImage == null)
+		{
+			this.backgroundImage = Images.readImage(background);
+		}
+		return backgroundImage;
+	}
+
+	public File getBanner() {
+		return banner;
+	}
+	
+	public BufferedImage getBannerImage()
+	{
+		if(bannerImage == null)
+		{
+			this.bannerImage = Images.readImage(banner);
+		}
+		return bannerImage;
+	}
+
+	public void setBanner(File banner) {
+		this.banner = banner;
+	}
+
+	public File getFile() {
+		return file;
+	}
+	
+	public String getFolder()
+	{
+		return file.getParentFile().getName();
+	}
+
+	public void setFile(File file) {
+		this.file = file;
+	}
+
+	public List<SongInstance> getSongs() {
+		return songs;
+	}
+	
+	public void close()
+	{
+	}
+
+	@Override
+	public int compareTo(Song s) {
+		return getTitle().compareTo(s.getTitle());
+	}
+	
+	public int getTimesPlayed()
+	{
+		int timesPlayed = 0;
+		for(SongInstance s : songs)
+		{
+			timesPlayed += s.getTimesPlayed();
+		}
+		return timesPlayed;
+	}
+}

audio/SongInstance.java

@@ -0,0 +1,101 @@
+package audio;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SongInstance {
+
+	private String difficulty;
+	private int timesPlayed;
+	
+	private List<ObjectInstance> objects;
+	private List<ButtonInstance> buttons;
+	
+	public SongInstance(String difficulty)
+	{
+		this.difficulty = difficulty;
+		this.timesPlayed = 0;
+		
+		objects = new ArrayList<ObjectInstance>();
+		buttons = new ArrayList<ButtonInstance>();
+	}
+	
+	public void addObjectInstance(ObjectInstance obj)
+	{
+		objects.add(obj);
+	}
+	public void addButtonInstance(ButtonInstance btn)
+	{
+		buttons.add(btn);
+	}
+
+	public List<ObjectInstance> getObjects() {
+		return objects;
+	}
+	
+	public List<ButtonInstance> getButtons() {
+		return buttons;
+	}
+
+	public String getDifficulty() {
+		return difficulty;
+	}
+
+	public void setDifficulty(String difficulty) {
+		this.difficulty = difficulty;
+	}
+
+	public List<ObjectInstance> getObjectsBetween(long oldProgress, long progress) {
+		List<ObjectInstance> b = new ArrayList<ObjectInstance>();
+		
+		for(ObjectInstance i : objects)
+		{
+			if(i.getTime() >= progress)
+			{
+				return b;
+			}
+			if(i.getTime() >= oldProgress && i.getTime() < progress)
+			{
+				b.add(i);
+			}
+		}
+		
+		return b;
+	}
+	
+	public long getEndTime()
+	{
+		return objects.get(objects.size()-1).getTime();
+	}
+	
+	public List<ButtonInstance> getButtonsBetween(long oldProgress, long progress) {
+		List<ButtonInstance> b = new ArrayList<ButtonInstance>();
+		
+		for(ButtonInstance i : buttons)
+		{
+			if(i.getTime() > progress)
+			{
+				return b;
+			}
+			if(i.getTime() >= oldProgress && i.getTime() < progress)
+			{
+				b.add(i);
+			}
+		}
+		
+		return b;
+	}
+
+	public int getTimesPlayed() {
+		return timesPlayed;
+	}
+
+	public void setTimesPlayed(int timesPlayed) {
+		this.timesPlayed = timesPlayed;
+	}
+	
+	public void played()
+	{
+		timesPlayed++;
+	}
+}

audio/io/DirScanner.java

@@ -0,0 +1,55 @@
+package audio.io;
+
+import java.io.File;
+import java.io.FileFilter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import audio.Song;
+
+public class DirScanner {
+	
+	public static List<Song> scanDirectories(File f)
+	{
+		List<Song> songs = new ArrayList<Song>();
+
+		if(!f.isDirectory())
+			return songs;
+		
+		FileFilter dirs = new FileFilter()
+		{
+			public boolean accept(File e) {
+				if(e.isDirectory())
+					return true;
+				else
+					return false;
+			}
+		};
+		FileFilter csf = new FileFilter()
+		{
+			public boolean accept(File e) {
+				if(e.isFile() && e.getName().endsWith(".csf"))
+					return true;
+				else
+					return false;
+			}
+		};
+		
+		for(File file : f.listFiles(dirs))
+		{
+			for(File file2 : file.listFiles(csf))
+			{
+					try {
+						Song s = JSONReader.readSong(file2);
+						songs.add(s);
+					} catch (IOException e1) {
+						e1.printStackTrace();
+					}
+					
+			}
+		}
+		
+		return songs;
+	}
+}

audio/io/JSONReader.java

@@ -0,0 +1,134 @@
+package audio.io;
+
+import java.awt.Color;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+
+import javax.json.Json;
+import javax.json.JsonArray;
+import javax.json.JsonObject;
+import javax.json.JsonReader;
+
+import model.GameModel;
+import audio.ButtonInstance;
+import audio.ObjectInstance;
+import audio.Song;
+import audio.SongInstance;
+
+public class JSONReader {
+
+	public static Song readSong(File f) throws IOException {
+
+		if(!f.exists())
+			throw new FileNotFoundException("CSF File does not exist");
+		
+		// Get CSF File
+		InputStream is = new FileInputStream(f);
+
+		// Read CSF Content
+		JsonReader rdr = Json.createReader(is);
+		JsonObject obj = rdr.readObject();
+		rdr.close();
+		is.close();
+		
+		if(!obj.containsKey("meta") || !obj.containsKey("file") || !obj.containsKey("data"))
+			throw new IOException("Corrupt CSF File");
+
+		// Create new Song
+		Song s = new Song();
+
+		// Read META data
+		JsonObject meta = obj.getJsonObject("meta");
+
+		s.setTitle(meta.getString("title"));
+		s.setSubtitle(meta.getString("subtitle"));
+		s.setAuthor(meta.getString("author"));
+		s.setSampleStart(meta.getInt("sample_start"));
+		s.setBPM(meta.getInt("BPM"));
+		
+		//Read FILE data
+		JsonObject file = obj.getJsonObject("file");
+		
+		File audio = new File(f.getParent() + File.separator + file.getString("audio"));
+		if(!audio.exists() || !audio.getName().toLowerCase().endsWith(".mp3"))
+			throw new FileNotFoundException("Audio file does not exist: " + audio.getPath());
+		s.setAudio(audio);
+		
+		/*
+		File background = new File(f.getParent() + File.separator + file.getString("background"));
+		if(!background.exists() || !(background.getName().toLowerCase().endsWith(".jpg") || background.getName().toLowerCase().endsWith(".png")))
+			throw new FileNotFoundException("Background image does not exist: " + background.getPath());
+		s.setBackground(background);*/
+		s.setBackground(null);
+
+		/*
+		File banner = new File(f.getParent() + File.separator + file.getString("banner"));
+		if(!banner.exists() || !(banner.getName().toLowerCase().endsWith(".jpg") || banner.getName().toLowerCase().endsWith(".png")))
+			throw new FileNotFoundException("Banner image does not exist: " + banner.getPath());
+		s.setBanner(banner);*/
+		s.setBanner(null);
+		
+		s.setFile(f);
+		
+		//Read Data data
+		JsonArray data = obj.getJsonArray("data");
+		for(int i = 0; i < data.size(); i++)
+		{
+			s.addSongInstance( readSongInstance(data.getJsonObject(i)) );
+		}
+		
+		return s;
+	}
+
+	private static SongInstance readSongInstance(JsonObject obj) throws IOException {
+		String difficulty = obj.getString("difficulty");
+		SongInstance si = new SongInstance(difficulty);
+		
+		JsonArray object = obj.getJsonArray("objects");
+		for(int i = 0; i < object.size(); i++)
+		{
+			si.addObjectInstance( readObjectInstance(object.getJsonObject(i)) );
+		}
+		
+		JsonArray buttons = obj.getJsonArray("buttons");
+		for(int i = 0; i < buttons.size(); i++)
+		{
+			si.addButtonInstance( readButtonInstance(buttons.getJsonObject(i)) );
+		}
+		
+		return si;
+	}
+
+	private static ObjectInstance readObjectInstance(JsonObject obj)
+	{
+		ObjectInstance oi = new ObjectInstance();
+		
+		oi.setTime(obj.getInt("time"));
+		oi.setDirection(obj.getInt("direction"));
+		oi.setButtonID(obj.getInt("button"));
+		
+		if(obj.containsKey("hold") && obj.getBoolean("hold"))
+		{
+			oi.setHold(obj.getBoolean("hold"));
+			oi.setLength(obj.getInt("length"));
+		}
+		
+		return oi;
+	}
+	
+	private static ButtonInstance readButtonInstance(JsonObject obj)
+	{
+		ButtonInstance bi = new ButtonInstance();
+		
+		bi.setTime(obj.getInt("time"));
+		bi.setButtonID(obj.getInt("button"));
+		
+		Color color = GameModel.colors[obj.getInt("color") % GameModel.colors.length];
+		bi.setColor(color);
+		
+		return bi;
+	}
+}

audio/sorting/SortALPHA.java

@@ -0,0 +1,14 @@
+package audio.sorting;
+
+import java.util.Comparator;
+
+import audio.Song;
+
+public class SortALPHA implements Comparator<Song> {
+
+	@Override
+	public int compare(Song s1, Song s2) {
+		return s1.getTitle().compareTo(s2.getTitle());
+	}
+
+}

audio/sorting/SortPLAYED.java

@@ -0,0 +1,19 @@
+package audio.sorting;
+
+import java.util.Comparator;
+
+import audio.Song;
+
+public class SortPLAYED implements Comparator<Song> {
+
+	@Override
+	public int compare(Song s1, Song s2) {
+		if(s1.getTimesPlayed() < s2.getTimesPlayed())
+			return 1;
+		else if(s1.getTimesPlayed() > s2.getTimesPlayed())
+			return -1;
+		else
+			return s1.getTitle().compareTo(s2.getTitle());
+	}
+
+}

control/GameControl.java

@@ -0,0 +1,57 @@
+package control;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.Timer;
+
+import model.GameModel;
+import view.GameView;
+import control.button.ButtonEvent;
+import control.button.ButtonListener;
+import control.joystick.JoystickEvent;
+import control.joystick.JoystickListener;
+
+public class GameControl implements JoystickListener, ButtonListener, ActionListener {
+	
+	private long lastTime = System.currentTimeMillis();
+	private GameModel model;
+	private GameView view;
+	private GameStateManager gsm;
+	private Timer update;
+	
+	public GameControl(final GameModel model, final GameView view,GameStateManager gsm)	{
+		this.model = model;
+		this.view = view;
+		this.gsm = gsm;
+
+		view.setIgnoreRepaint(true);
+		(update = new Timer(1000/60,this)).start();
+	}
+
+	@Override
+	public void buttonPressed(ButtonEvent e) {	
+		gsm.buttonPressed(e);
+	}
+
+	@Override
+	public void buttonReleased(ButtonEvent e) {	
+		gsm.buttonReleased(e);
+	}
+
+	@Override
+	public void onJoystickMoved(JoystickEvent e) {
+		gsm.onJoystickMoved(e);
+	}
+
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		long currentTime = System.currentTimeMillis();
+		long time = currentTime - lastTime;
+		if(time > 1000/60)
+			time = 1000/60;
+		model.update(time);
+		lastTime = currentTime;
+		view.repaint();				
+	}
+}

control/GameStateManager.java

@@ -0,0 +1,92 @@
+package control;
+
+import java.awt.Color;
+import java.util.ArrayList;
+import java.util.List;
+
+import model.SongHandler;
+import model.gameState.*;
+import control.button.Button;
+import control.button.ButtonEvent;
+import control.button.ButtonHandler;
+import control.joystick.JoystickEvent;
+import control.joystick.JoystickHandler;
+import data.io.SQLConnector;
+
+public class GameStateManager {
+
+	private List<GameState> gamestates;
+
+	public 	GameState 	currentState;
+	private SongHandler sh;
+
+	private int 	index 					= 0;
+	public 	int 	fps;
+	private float 	timeOfNoAction 			= 0,
+					maxTimeToHaveNoAction 	= 45000;
+
+	public enum State {
+		TITLE_STATE,
+		MENU_STATE,
+		HELP_STATE,
+		PLAY_STATE,
+		GAMEOVER_STATE,
+		PRE_GAME_STATE
+	}
+	
+	public GameStateManager(SongHandler sh, SQLConnector sql){
+		this.sh = sh;
+		gamestates = new ArrayList<>();
+		gamestates.add(new TitleState(this, sh, sql));
+		gamestates.add(new MenuState(this, sh, sql));
+		gamestates.add(new HelpState(this, sh, sql));
+		gamestates.add(new PlayState(this, sh, sql));
+		gamestates.add(new GameOverState(this, sh, sql));
+		gamestates.add(new PreGameState(this, sh, sql));
+		setState(State.TITLE_STATE);
+	}
+
+	public void setState(State st)
+	{
+		if (currentState != null)
+			currentState.stopAudio();
+
+		currentState = gamestates.get(st.ordinal());
+		init();
+	}
+	
+	public void update(float factor){
+		timeOfNoAction += factor;	
+		if(timeOfNoAction > maxTimeToHaveNoAction){
+			setState(State.TITLE_STATE);
+			timeOfNoAction = 0;
+		}
+		currentState.update(factor);
+		fps = (int) (60/(factor/10));
+	}
+	
+	public void init()
+	{
+		JoystickHandler.REPEAT = false;
+		for (int i = 1; i < ButtonHandler.getButtons().size(); i++) {
+			Button b = ButtonHandler.getButton(i);
+			b.setColor(Color.BLACK);
+		}
+		currentState.init();
+	}
+
+	public void buttonPressed(ButtonEvent e) {
+		timeOfNoAction = 0;
+		currentState.buttonPressed(e);
+	}
+
+	public void buttonReleased(ButtonEvent e) {
+		timeOfNoAction = 0;
+		currentState.buttonReleased(e);
+	}
+
+	public void onJoystickMoved(JoystickEvent e) {
+		timeOfNoAction = 0;
+		currentState.onJoystickMoved(e);		
+	}
+}

control/LedHandler.java

@@ -0,0 +1,72 @@
+package control;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+
+public class LedHandler {
+    private BufferedReader inp;
+    private BufferedWriter out;
+    private Process p;
+    
+    public LedHandler(){
+	    try {
+	        p = Runtime.getRuntime().exec("sudo python led.py");
+	        inp = new BufferedReader( new InputStreamReader(p.getInputStream()) );
+	        out = new BufferedWriter( new OutputStreamWriter(p.getOutputStream()) );      
+	    }
+	    catch (Exception err) {
+	        err.printStackTrace();
+	    }
+    }
+    
+    public void close(){
+        try {
+			inp.close();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+        try {
+			out.close();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+        p.destroy();
+    }
+    
+    
+    /**
+     * Set the color of a specific led
+     * @param Pixel number of the led
+     * @param Red value
+     * @param Green value
+     * @param Blue value
+     * Remember: Button leds are GRB, normal ledstrip is RGB
+     */
+    public void setLed(int led, int r, int g, int b) {
+	    if(led<0)
+	    	return;
+    	try {
+	        out.write( "1|" + led + "|" + r + "|" + g + "|" + b + "\n" );
+	        out.flush();
+	    }
+	    catch (Exception err) {
+	    	err.printStackTrace();
+	    }
+    }
+
+    /**
+     * Shows the (new) colors 
+     */
+    public void show(){
+	    try {
+	        out.write( "0\n" );
+	        out.flush();
+	    }
+	    catch (Exception err) {
+	    	err.printStackTrace();
+	    }
+    }
+}

control/NetworkHandler.java

@@ -0,0 +1,168 @@
+package control;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+
+import control.button.ButtonHandler;
+import control.joystick.Joystick.Position;
+import control.joystick.JoystickHandler;
+
+public class NetworkHandler implements Runnable{
+
+	private DatagramSocket udp;
+
+	private String 	host;
+	private int 	port;
+
+	private boolean running;
+	private Thread  t;
+
+	private byte[] 	send,
+					receive;
+
+	private ButtonHandler bth;
+	private JoystickHandler jth;
+	
+	public NetworkHandler(String host, int port, ButtonHandler bth, JoystickHandler jth)
+	{
+		this.host = host;
+		this.port = port;
+		
+		this.bth = bth;
+		this.jth = jth;
+		
+		udp = null;
+		
+		send = new byte[1024];
+		receive = new byte[1024];
+		
+			try {
+				udp = new DatagramSocket(1113);
+			} catch (SocketException e) {
+				e.printStackTrace();
+			}
+		
+		running = true;
+		t = new Thread(this);
+		t.start();
+	}
+	
+	public void setLed(int led, int r, int g , int b)
+	{
+		String cmd = "1|" + led + "|" + r + "|" + g + "|" + b + "\n";
+		send(cmd);
+	}
+	
+	public void show(){
+		String cmd = "0\n";
+		send(cmd);
+	}
+	
+	private void send(String str)	{	}
+	
+	public void close()
+	{
+		running = false;
+		udp.disconnect();
+		udp.close();
+	}
+
+	@Override
+	public void run() {
+		
+		while(running)
+		{
+			DatagramPacket receivePacket = new DatagramPacket(receive, receive.length);     
+			try {
+				udp.receive(receivePacket);
+			} catch (IOException e) {
+				e.printStackTrace();
+			}                   
+			String sentence = new String( receivePacket.getData());  
+			
+			sentence = sentence.trim();
+			
+			String[] controls = sentence.split("\\|");
+			int[] control = new int[controls.length];
+			for(int i=0; i<controls.length; i++)
+				control[i] = Integer.parseInt(controls[i]);
+			
+			for(int i = 0; i < 7; i++){
+				if(control[i] != ButtonHandler.getButton(i).pressed)
+				{
+					ButtonHandler.getButton(i).pressed = control[i];
+					if(control[i] == 0)
+						bth.buttonPress(ButtonHandler.getButton(i));
+				}
+			}
+			
+			if(control[7] == 0 && control[8] == 0){
+				if(JoystickHandler.j.getPos() != Position.UP_LEFT)
+				{
+					JoystickHandler.j.setPosition(Position.UP_LEFT);
+					jth.onJoystickMoved(JoystickHandler.j);
+				}
+			}
+			else if(control[7] == 0 && control[9] == 0){
+				if(JoystickHandler.j.getPos() != Position.UP_RIGHT)
+				{
+					JoystickHandler.j.setPosition(Position.UP_RIGHT);
+					jth.onJoystickMoved(JoystickHandler.j);
+				}
+			}
+			else if(control[10] == 0 && control[8] == 0){
+				if(JoystickHandler.j.getPos() != Position.DOWN_LEFT)
+				{
+					JoystickHandler.j.setPosition(Position.DOWN_LEFT);
+					jth.onJoystickMoved(JoystickHandler.j);
+				}
+			}
+			else if(control[10] == 0 && control[9] == 0){
+				if(JoystickHandler.j.getPos() != Position.DOWN_RIGHT)
+				{
+					JoystickHandler.j.setPosition(Position.DOWN_RIGHT);
+					jth.onJoystickMoved(JoystickHandler.j);
+				}
+			}
+			
+			else if(control[7] == 0){
+				if(JoystickHandler.j.getPos() != Position.UP)
+				{
+					JoystickHandler.j.setPosition(Position.UP);
+					jth.onJoystickMoved(JoystickHandler.j);
+				}
+			}
+			else if(control[8] == 0){
+				if(JoystickHandler.j.getPos() != Position.LEFT)
+				{
+					JoystickHandler.j.setPosition(Position.LEFT);
+					jth.onJoystickMoved(JoystickHandler.j);
+				}
+			}
+			else if(control[9] == 0){
+				if(JoystickHandler.j.getPos() != Position.RIGHT)
+				{
+					JoystickHandler.j.setPosition(Position.RIGHT);
+					jth.onJoystickMoved(JoystickHandler.j);
+				}
+			}
+			else if(control[10] == 0){
+				if(JoystickHandler.j.getPos() != Position.DOWN)
+				{
+					JoystickHandler.j.setPosition(Position.DOWN);
+					jth.onJoystickMoved(JoystickHandler.j);
+				}
+			}else {
+				if(JoystickHandler.j.getPos() != Position.CENTER){
+					JoystickHandler.j.setPosition(Position.CENTER);
+					jth.onJoystickMoved(JoystickHandler.j);
+				}
+			}
+		}
+			
+	}
+}

control/button/Button.java

@@ -0,0 +1,49 @@
+package control.button;
+
+import java.awt.Color;
+
+import main.Window;
+import control.NetworkHandler;
+
+public class Button {
+
+	private 	Color 			color;
+	private 	int 			ledID,
+								buttonID;
+	public		int				pressed;
+
+	private		NetworkHandler	ntw;
+	
+	public Button(int buttonID, int ledID, NetworkHandler ntw) {
+		color = new Color(255,255,255);
+		this.ledID = ledID;
+		this.buttonID = buttonID;
+		this.ntw = ntw;
+		pressed = 1;
+		setLed();
+	}
+	
+	private void setLed() {
+		if(Window.ON_RASP) {
+			ntw.setLed(ledID, color.getGreen(), color.getRed(), color.getBlue());
+			ntw.show();
+		}
+	}
+	
+	public void setColor(Color newColor) {
+		color = newColor;
+		setLed();
+	}
+	
+	public Color getColor(){
+		return color;
+	}
+	public int getButtonID()
+	{
+		return buttonID;
+	}
+	public int getLedID()
+	{
+		return ledID;
+	}
+}

control/button/ButtonEvent.java

@@ -0,0 +1,19 @@
+package control.button;
+
+public class ButtonEvent {
+	private Button button;
+	private Long now;
+	
+	public ButtonEvent(Button button, Long now){
+		this.button = button;
+		this.now = now;
+	}
+
+	public Button getButton() {
+		return button;
+	}
+
+	public Long getNow() {
+		return now;
+	}		
+}

control/button/ButtonHandler.java

@@ -0,0 +1,176 @@
+package control.button;
+
+import java.awt.Color;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+import java.util.ArrayList;
+import java.util.List;
+
+import main.Window;
+
+import com.pi4j.io.gpio.GpioController;
+import com.pi4j.io.gpio.GpioFactory;
+import com.pi4j.io.gpio.GpioPinDigitalInput;
+import com.pi4j.io.gpio.PinState;
+import com.pi4j.io.gpio.RaspiPin;
+import com.pi4j.io.gpio.event.GpioPinDigitalStateChangeEvent;
+import com.pi4j.io.gpio.event.GpioPinListenerDigital;
+
+import control.NetworkHandler;
+
+public class ButtonHandler implements KeyListener{
+
+	private List<ButtonListener> listeners;
+	public  static List<Button> buttons;
+	private NetworkHandler ntw;
+	
+	public ButtonHandler()
+	{
+		this.ntw = null;
+		listeners = new ArrayList<ButtonListener>();
+		buttons = new ArrayList<Button>();
+		
+	}
+	
+	private void addGpioListeners(){
+		ArrayList<GpioPinDigitalInput> inputpins = new ArrayList<GpioPinDigitalInput>();
+        final GpioController gpio = GpioFactory.getInstance();
+        
+        inputpins.add(gpio.provisionDigitalInputPin(RaspiPin.GPIO_02, "1")); //button 1 to 6 + start button
+        inputpins.add(gpio.provisionDigitalInputPin(RaspiPin.GPIO_03, "2"));
+        inputpins.add(gpio.provisionDigitalInputPin(RaspiPin.GPIO_13, "3"));
+        inputpins.add(gpio.provisionDigitalInputPin(RaspiPin.GPIO_14, "4"));
+        inputpins.add(gpio.provisionDigitalInputPin(RaspiPin.GPIO_00, "5"));
+        inputpins.add(gpio.provisionDigitalInputPin(RaspiPin.GPIO_12, "6"));
+        inputpins.add(gpio.provisionDigitalInputPin(RaspiPin.GPIO_06, "0"));
+
+        for(GpioPinDigitalInput p:inputpins){
+        	  p.addListener(new GpioPinListenerDigital() {
+                  @Override
+                  public void handleGpioPinDigitalStateChangeEvent(GpioPinDigitalStateChangeEvent e) {
+                	  if(e.getState() == PinState.HIGH){
+                		  buttonRelease(buttons.get(Integer.parseInt(e.getPin().getName())));
+                		  System.out.println(e.getPin().getName() + " Released");
+                	  }else{
+                		  buttonPress(buttons.get(Integer.parseInt(e.getPin().getName())));
+                		  System.out.println(e.getPin().getName() + " Pressed");
+                	  }
+                  }                  
+              });
+        }
+	}
+
+	public void addButtonListener(ButtonListener toAdd) {
+	    listeners.add(toAdd);
+	}
+	
+	public void buttonPress(Button b) {
+		if(Window.ON_RASP)
+		{
+			Color c = b.getColor().brighter().brighter();
+			ntw.setLed(b.getLedID(), c.getGreen(), c.getRed(), c.getBlue());
+			ntw.show();
+		}
+		ButtonEvent e = new ButtonEvent(b, System.currentTimeMillis());
+	    for (ButtonListener bt : listeners)
+	        bt.buttonPressed(e);
+	}
+	 
+	public void buttonRelease(Button b) {
+		if(Window.ON_RASP) {
+			ntw.setLed(b.getLedID(), b.getColor().getGreen(), b.getColor().getRed(), b.getColor().getBlue());
+			ntw.show();
+		}
+		ButtonEvent e = new ButtonEvent(b, System.currentTimeMillis());
+
+	    for (ButtonListener bt : listeners)
+	        bt.buttonReleased(e);
+	}
+
+	
+	@Override
+	public void keyPressed(KeyEvent e) {
+		switch(e.getKeyCode())
+		{
+		case KeyEvent.VK_0:
+			buttonPress(buttons.get(0));
+			break;
+		case KeyEvent.VK_1:
+			buttonPress(buttons.get(1));
+			break;
+		case KeyEvent.VK_2:
+			buttonPress(buttons.get(2));
+			break;
+		case KeyEvent.VK_3:
+			buttonPress(buttons.get(3));
+			break;
+		case KeyEvent.VK_4:
+			buttonPress(buttons.get(4));
+			break;
+		case KeyEvent.VK_5:
+			buttonPress(buttons.get(5));
+			break;
+		case KeyEvent.VK_6:
+			buttonPress(buttons.get(6));
+			break;
+		case KeyEvent.VK_ESCAPE:
+			if(!Window.ON_RASP)
+				System.exit(0);
+			break;
+		}
+	}
+
+	public void keyReleased(KeyEvent e) {
+		switch(e.getKeyCode())
+		{
+		case KeyEvent.VK_0:
+			buttonRelease(buttons.get(0));
+			break;
+		case KeyEvent.VK_1:
+			buttonRelease(buttons.get(1));
+			break;
+		case KeyEvent.VK_2:
+			buttonRelease(buttons.get(2));
+			break;
+		case KeyEvent.VK_3:
+			buttonRelease(buttons.get(3));
+			break;
+		case KeyEvent.VK_4:
+			buttonRelease(buttons.get(4));
+			break;
+		case KeyEvent.VK_5:
+			buttonRelease(buttons.get(5));
+			break;
+		case KeyEvent.VK_6:
+			buttonRelease(buttons.get(6));
+			break;
+		}
+	}
+	public void keyTyped(KeyEvent arg0) {}
+	
+	public static List<Button> getButtons()
+	{
+		return buttons;
+	}
+	
+	public static Button getButton(int id)
+	{
+		for(Button b : buttons)
+			if(b.getButtonID() == id)
+				return b;
+
+		return null;
+	}
+
+	public void setNetwork(NetworkHandler ntw) {
+		this.ntw = ntw;
+		
+		buttons.add(new Button(0, -1, ntw));
+		buttons.add(new Button(1, 2, ntw));
+		buttons.add(new Button(2, 1, ntw));
+		buttons.add(new Button(3, 0, ntw));
+		buttons.add(new Button(4, 3, ntw));
+		buttons.add(new Button(5, 4, ntw));
+		buttons.add(new Button(6, 5, ntw));
+	}
+}

control/button/ButtonListener.java

@@ -0,0 +1,6 @@
+package control.button;
+
+public interface ButtonListener {
+	void buttonPressed(ButtonEvent e);
+	void buttonReleased(ButtonEvent e);
+}

control/joystick/Joystick.java

@@ -0,0 +1,32 @@
+package control.joystick;
+
+public class Joystick {
+	
+	public enum Position {
+		UP,
+		LEFT,
+		DOWN,
+		RIGHT,
+		UP_RIGHT,
+		DOWN_RIGHT,
+		UP_LEFT,
+		DOWN_LEFT,
+		CENTER
+	}
+	
+	private Position pos;
+	
+	public Joystick()
+	{
+		pos = Position.CENTER;
+	}
+	
+	public void setPosition(Position pos)
+	{
+		this.pos = pos;
+	}
+	public Position getPos() {
+		return pos;
+	}
+	
+}

control/joystick/JoystickEvent.java

@@ -0,0 +1,19 @@
+package control.joystick;
+
+public class JoystickEvent {
+	private Joystick joystick;
+	private Long now;
+	
+	public JoystickEvent(Joystick joystick, Long now){
+		this.joystick = joystick;
+		this.now = now;
+	}
+
+	public Joystick getJoystick() {
+		return joystick;
+	}
+
+	public Long getNow() {
+		return now;
+	}	
+}

control/joystick/JoystickHandler.java

@@ -0,0 +1,183 @@
+package control.joystick;
+
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import com.pi4j.io.gpio.GpioController;
+import com.pi4j.io.gpio.GpioFactory;
+import com.pi4j.io.gpio.GpioPinDigitalInput;
+import com.pi4j.io.gpio.PinState;
+import com.pi4j.io.gpio.RaspiPin;
+import com.pi4j.io.gpio.event.GpioPinDigitalStateChangeEvent;
+import com.pi4j.io.gpio.event.GpioPinListenerDigital;
+
+import control.joystick.Joystick.Position;
+
+public class JoystickHandler implements KeyListener{
+
+	List<JoystickListener> listeners;
+	Set<Integer> keys;
+	public static boolean REPEAT = false;
+	public static Joystick j = new Joystick();;
+	
+	public JoystickHandler()
+	{
+		listeners = new ArrayList<JoystickListener>();
+		keys = new HashSet<Integer>();
+//		if(Window.ON_RASP)
+//			addGpioListeners();
+	}
+	
+	private void addGpioListeners(){
+		ArrayList<GpioPinDigitalInput> inputpins = new ArrayList<GpioPinDigitalInput>();
+        final GpioController gpio = GpioFactory.getInstance();
+        
+        inputpins.add(gpio.provisionDigitalInputPin(RaspiPin.GPIO_04, "UP")); //button 1 to 6 + start button
+        inputpins.add(gpio.provisionDigitalInputPin(RaspiPin.GPIO_05, "LEFT"));
+        inputpins.add(gpio.provisionDigitalInputPin(RaspiPin.GPIO_11, "RIGHT"));
+        inputpins.add(gpio.provisionDigitalInputPin(RaspiPin.GPIO_10, "DOWN"));
+
+        
+        for(GpioPinDigitalInput p:inputpins){
+        	  p.addListener(new GpioPinListenerDigital() {
+                  @Override
+                  public void handleGpioPinDigitalStateChangeEvent(GpioPinDigitalStateChangeEvent e) {
+                	  if(e.getState() == PinState.HIGH){
+                		  keyReleased(new KeyEvent(
+                				  		new java.awt.Component(){
+
+											/**
+											 * 
+											 */
+											private static final long serialVersionUID = 1L;}, 
+                				  		KeyEvent.KEY_RELEASED, 
+                				  		System.nanoTime(), 
+                				  		0, 
+                				  		stringToKeyevent(e.getPin().getName()), 
+                				  		KeyEvent.CHAR_UNDEFINED)
+                				  );
+                		  System.out.println(e.getPin().getName() + " Released");
+                	  }else{
+                		  keyPressed(new KeyEvent(
+          				  		new java.awt.Component(){
+
+									/**
+									 * 
+									 */
+									private static final long serialVersionUID = 1L;}, 
+          				  		KeyEvent.KEY_PRESSED, 
+          				  		System.nanoTime(), 
+          				  		0, 
+          				  		stringToKeyevent(e.getPin().getName()), 
+          				  		KeyEvent.CHAR_UNDEFINED)
+          				  );
+                		  System.out.println(e.getPin().getName() + " Pressed");
+                	  }
+                  }                  
+              });
+        }
+	}
+
+	public void addJoystickListener(JoystickListener toAdd) {
+		listeners.add(toAdd);
+	}
+
+	public void onJoystickMoved(Joystick j) {
+		JoystickEvent e = new JoystickEvent(j, System.currentTimeMillis());
+		for (JoystickListener yst : listeners)
+			yst.onJoystickMoved(e);
+	}
+	
+	private void updateJoystickPosition()
+	{
+		if(keys.contains(KeyEvent.VK_UP) && keys.contains(KeyEvent.VK_RIGHT))
+		{
+			j.setPosition(Position.UP_RIGHT);
+		}
+		else if(keys.contains(KeyEvent.VK_UP) && keys.contains(KeyEvent.VK_LEFT))
+		{
+			j.setPosition(Position.UP_LEFT);
+		}
+		else if(keys.contains(KeyEvent.VK_DOWN) && keys.contains(KeyEvent.VK_RIGHT))
+		{
+			j.setPosition(Position.DOWN_RIGHT);
+		}
+		else if(keys.contains(KeyEvent.VK_DOWN) && keys.contains(KeyEvent.VK_LEFT))
+		{
+			j.setPosition(Position.DOWN_LEFT);
+		}
+		
+		else if(keys.contains(KeyEvent.VK_UP))
+		{
+			j.setPosition(Position.UP);
+		}
+		else if(keys.contains(KeyEvent.VK_LEFT))
+		{
+			j.setPosition(Position.LEFT);
+		}
+		else if(keys.contains(KeyEvent.VK_RIGHT))
+		{
+			j.setPosition(Position.RIGHT);
+		}
+		else if(keys.contains(KeyEvent.VK_DOWN))
+		{
+			j.setPosition(Position.DOWN);
+		}
+		
+		else
+		{
+			j.setPosition(Position.CENTER);
+		}
+	}
+	
+	private int stringToKeyevent(String s){
+		switch(s){
+		case "UP":
+			return KeyEvent.VK_UP;
+		case "DOWN":
+			return KeyEvent.VK_DOWN;
+		case "LEFT":
+			return KeyEvent.VK_LEFT;
+		case "RIGHT":
+			return KeyEvent.VK_RIGHT;
+		}
+		return -1;
+	}
+	
+	@Override
+	public void keyPressed(KeyEvent e) {
+		if(e.getKeyCode() == KeyEvent.VK_UP || e.getKeyCode() == KeyEvent.VK_DOWN || e.getKeyCode() == KeyEvent.VK_LEFT || e.getKeyCode() == KeyEvent.VK_RIGHT)
+		{
+			Set<Integer> keysCopy = new HashSet<Integer>(keys);
+			keys.add(e.getKeyCode());
+			updateJoystickPosition();
+			
+			if(REPEAT || !keys.equals(keysCopy) )
+			{
+				onJoystickMoved(j);				
+			}
+		}
+	}
+
+	@Override
+	public void keyReleased(KeyEvent e) {
+		if(e.getKeyCode() == KeyEvent.VK_UP || e.getKeyCode() == KeyEvent.VK_DOWN || e.getKeyCode() == KeyEvent.VK_LEFT || e.getKeyCode() == KeyEvent.VK_RIGHT)
+		{
+			Set<Integer> keysCopy = new HashSet<Integer>(keys);
+			
+			keys.remove(e.getKeyCode());
+			updateJoystickPosition();
+			
+			if(REPEAT || !keys.equals(keysCopy))
+			{
+				onJoystickMoved(j);				
+			}
+		}
+	}
+
+	public void keyTyped(KeyEvent e) {}
+}	

control/joystick/JoystickListener.java

@@ -0,0 +1,5 @@
+package control.joystick;
+
+public interface JoystickListener {
+	public void onJoystickMoved(JoystickEvent e);
+}

data/io/.gitignore

@@ -0,0 +1,2 @@
+/SQLConnector.class
+/WebcamUploader.class

data/io/SQLConnector.java

@@ -0,0 +1,228 @@
+package data.io;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.sun.crypto.provider.RSACipher;
+
+import model.objects.highscore.Highscore;
+import audio.Song;
+import audio.SongInstance;
+
+public class SQLConnector
+{
+    private Connection myConn = null;
+    public 	SQLConnector()
+    {
+        this("178.62.254.153", "3306","colorstrike","csadmin","aardbei123");
+    }
+
+    //Start connection with Database
+    public SQLConnector(String host, String port, String dbName, String userName, String password)
+    {
+        try  {
+            String url = "jdbc:mysql://" + host + ":" + port + "/"+ dbName + "?user="
+            + userName
+            + "&password="
+            + password;
+            Class.forName("com.mysql.jdbc.Driver").newInstance ();
+            myConn = DriverManager.getConnection(url);
+        }
+        catch( SQLException ex) {
+                System.out.println("SQLException: " + ex.getMessage());
+                System.out.println("SQLState: " + ex.getSQLState());
+                System.out.println("VendorError: " + ex.getErrorCode());
+        }
+        catch(Exception ex)
+        {
+            System.out.println("Error : " + ex.getMessage());
+        }
+    }
+    
+    public List<Highscore> getHighscores(Song s, SongInstance si)
+    {
+    	String query = "SELECT * FROM highscore WHERE songinstance = (SELECT id FROM songinstance WHERE difficulty='" + si.getDifficulty() + "' AND song=(SELECT id FROM song WHERE folder='" + s.getFolder() + "')) ORDER BY score DESC";
+    	//System.out.println(query);
+    	Statement st = executeResultQuery(query);
+    	ResultSet result = null;
+    	List<Highscore> hsc = new ArrayList<>();
+
+		try {
+			result = st.getResultSet();
+		} catch (SQLException e1) {
+			e1.printStackTrace();
+		}
+    	try {
+			while(result.next())
+				hsc.add(new Highscore(si, result.getString("username"), result.getInt("score"), result.getDate("date").getTime()));
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+    	
+    	return hsc;
+    }
+    
+    public List<Highscore> getHighscoresToday(Song s, SongInstance si)
+    {
+    	Statement st = executeResultQuery("SELECT * FROM highscore WHERE date=CURDATE() AND songinstance = (SELECT id FROM songinstance WHERE difficulty='" + si.getDifficulty() + "' AND song=(SELECT id FROM song WHERE folder='" + s.getFolder() + "')) ORDER BY score DESC");
+    	ResultSet result = null;
+    	List<Highscore> hsc = new ArrayList<>();
+		try {
+			result = st.getResultSet();
+		} catch (SQLException e1) {
+			e1.printStackTrace();
+		}
+    	try {
+			while(result.next())
+			{
+				hsc.add(new Highscore(si, result.getString("username"), result.getInt("score"), result.getDate("date").getTime()));
+			}
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+    	
+    	return hsc;
+    }
+    
+    public int addHighscore(Song s, SongInstance si, String name, int currentScore) {
+    	if(name.length() <= 5 && currentScore <= Integer.MAX_VALUE)	{
+			String query = "INSERT INTO highscore (username, score, date, songinstance) VALUES ('" + name.trim() + "', " + currentScore + ", CURDATE(), (SELECT id FROM songinstance WHERE difficulty='" + si.getDifficulty() + "' AND song=(SELECT id FROM song WHERE folder='" + s.getFolder() + "')))";
+			//System.out.println(query);
+			return executeInsertQuery(query);
+		}
+    	return -1;		
+	}
+    
+    public void addPlaydata(Song s, SongInstance si, long time, int enemies_missed, int enemies_hit, int buttons_pressed, int  joystick_moved) {
+    	System.out.println("Inserting PlayData: " + time + ", " + enemies_missed + ", " + enemies_hit + ", " + buttons_pressed + ", " + joystick_moved);
+		String query = "INSERT INTO playdata (enemies_missed, enemies_hit, buttons_pressed, joystick_moved, start_time, play_time, songinstance) VALUES (" + enemies_missed + ", " + enemies_hit + ", " + buttons_pressed + ", " + joystick_moved + ", NOW(), " + time + ", (SELECT id FROM songinstance WHERE difficulty='" + si.getDifficulty() + "' AND song=(SELECT id FROM song WHERE folder='" + s.getFolder() + "')))";
+		//System.out.println(query);
+		executeInsertQuery(query);
+	}
+    
+    public void update(List<Song> songs)
+    {
+    	for(Song s : songs)
+    	{
+    		executeInsertQuery("INSERT INTO song (folder, title, author) VALUES ('" + s.getFolder() + "', '" + s.getTitle() + "', '" + s.getAuthor() + "');");
+    		
+    		Statement st = executeResultQuery("SELECT id FROM song WHERE folder='" + s.getFolder() + "'");
+    		
+    		ResultSet rs = null;
+    		int id = -1;
+    		
+			try {
+				rs = st.getResultSet();
+				rs.next();
+				id = rs.getInt(1);
+				//System.out.println("Song " + id + " added to database");
+				rs.close();
+				st.close();
+			} catch (SQLException e) {
+				System.out.println("Empty return set");
+			}
+    	
+    		if(id != -1) {
+    			for(SongInstance si : s.getSongs()) {
+	    			Statement st2 = executeResultQuery("SELECT id FROM songinstance WHERE song=" + id + " AND difficulty='" + si.getDifficulty() + "'");
+	        		
+	        		ResultSet rs2 = null;
+	        		
+	    			try {
+	    				rs2 = st2.getResultSet();
+	    				if(!rs2.first()) {
+	    					executeInsertQuery("INSERT INTO songinstance (song, enemies, difficulty) VALUES (" + id + ", " + si.getObjects().size() + ", '" + si.getDifficulty() + "');");
+	    					//System.out.println("Songinstance Added");
+	    				}
+	    				rs.close();
+	    				st.close();
+	    			} catch (SQLException e) {
+	    				e.printStackTrace();
+	    			}
+	    			
+	    			Statement st3 = executeResultQuery("SELECT COUNT(1) FROM playdata WHERE songinstance = (SELECT id FROM songinstance WHERE difficulty='" + si.getDifficulty() + "' AND song=(SELECT id FROM song WHERE folder='" + s.getFolder() + "'))");
+	    			try {
+						ResultSet rs3 = st3.getResultSet();
+						rs3.next();
+						int i = rs3.getInt(1);
+		    			si.setTimesPlayed(i);
+		    			System.out.println(s.getTitle() + " - " + si.getDifficulty() + ": " + i);
+					} catch (SQLException e) {
+						e.printStackTrace();
+					}
+    			}
+    		}
+ 
+    	}
+    }
+    
+    private int executeInsertQuery(String query)
+    {
+        try{
+            Statement s = myConn.createStatement();
+            s.executeUpdate(query, Statement.RETURN_GENERATED_KEYS);
+            ResultSet rs = s.getGeneratedKeys();
+
+            int id = 0;
+            if(rs.next())
+            	id = rs.getInt(1);
+
+            s.close();
+            return id;
+        }
+        catch( SQLException ex)
+        {
+            System.out.println("SQLException: " + ex.getMessage());
+            System.out.println("SQLState: " + ex.getSQLState());
+            System.out.println("VendorError: " + ex.getErrorCode());
+        }
+        catch( Exception ex)
+        {
+           System.out.println("getMeasurement: " + ex.getMessage());
+        }
+        return -1;
+    }
+
+    //Execute a custom query
+    private Statement executeResultQuery(String query)
+    {   
+        Statement s = null;
+        try {
+            s = myConn.createStatement();
+            s.executeQuery(query);
+        }
+        catch( SQLException ex)
+        {
+            System.out.println("SQLException: " + ex.getMessage());
+            System.out.println("SQLState: " + ex.getSQLState());
+            System.out.println("VendorError: " + ex.getErrorCode());
+        }
+        catch( Exception ex) {
+           System.out.println("getMeasurement: " + ex.getMessage());
+        }
+        
+        return s;
+    }
+    
+    //Close connection with Database
+    @Override
+    public void finalize() throws Throwable
+    {
+        // Close database connection
+        if( myConn != null ) {
+            try {
+                myConn.close();
+                System.out.println("Database connection terminated");
+            }
+            catch( Exception e ) {}
+        }
+
+        super.finalize();
+    }
+
+}

data/io/WebcamUploader.java

@@ -0,0 +1,90 @@
+package data.io;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.Hashtable;
+
+import javax.imageio.ImageIO;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.EncodeHintType;
+import com.google.zxing.WriterException;
+import com.google.zxing.common.BitMatrix;
+import com.google.zxing.qrcode.QRCodeWriter;
+import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;
+
+public class WebcamUploader {
+
+        public static void takePictureAndUpload(int id) throws IOException{
+
+		Runtime.getRuntime().exec("streamer -c /dev/video0 -b 16 -o" + System.getProperty( "user.home" ) + "/ColorStrike/picture.jpeg");
+		
+		HttpURLConnection httpUrlConnection = (HttpURLConnection)new URL("http://178.62.254.153/colorstrike/images/photoupload.php?filename="+id+".jpeg").openConnection();
+        httpUrlConnection.setDoOutput(true);
+        httpUrlConnection.setRequestMethod("POST");
+        OutputStream os = httpUrlConnection.getOutputStream();
+        try {
+			Thread.sleep(2000);
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+        FileInputStream fis = new FileInputStream(System.getProperty( "user.home" ) +"/ColorStrike/picture.jpeg");
+
+        byte[] buffer = new byte[2048]; 
+        int bytesRead;
+        while ((bytesRead = fis.read(buffer)) != -1)
+        {
+            os.write(buffer, 0, bytesRead);
+        }
+
+        os.close();
+        BufferedReader in = new BufferedReader(
+                new InputStreamReader(
+                httpUrlConnection.getInputStream()));
+
+        String s = null;
+        while ((s = in.readLine()) != null) {
+            System.out.println(s);
+        }
+        in.close();
+        fis.close();
+	}
+	
+    public static BufferedImage createQRImage(String qrCodeText, int size) throws WriterException, IOException {
+        // Create the ByteMatrix for the QR-Code that encodes the given String
+        Hashtable hintMap = new Hashtable();
+        hintMap.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.L);
+        QRCodeWriter qrCodeWriter = new QRCodeWriter();
+        BitMatrix byteMatrix = qrCodeWriter.encode(qrCodeText,
+                BarcodeFormat.QR_CODE, size, size, hintMap);
+        // Make the BufferedImage that are to hold the QRCode
+        int matrixWidth = byteMatrix.getWidth();
+        BufferedImage image = new BufferedImage(matrixWidth, matrixWidth,
+                BufferedImage.TYPE_INT_RGB);
+        image.createGraphics();
+ 
+        Graphics2D graphics = (Graphics2D) image.getGraphics();
+        graphics.setColor(Color.WHITE);
+        graphics.fillRect(0, 0, matrixWidth, matrixWidth);
+        // Paint and save the image using the ByteMatrix
+        graphics.setColor(Color.BLACK);
+ 
+        for (int i = 0; i < matrixWidth; i++) {
+            for (int j = 0; j < matrixWidth; j++) {
+                if (byteMatrix.get(i, j)) {
+                    graphics.fillRect(i, j, 1, 1);
+                }
+            }
+        }
+        return image;
+    }
+}

image/Images.java

@@ -0,0 +1,112 @@
+package image;
+
+import java.awt.Graphics2D;
+import java.awt.GraphicsConfiguration;
+import java.awt.GraphicsDevice;
+import java.awt.GraphicsEnvironment;
+import java.awt.Transparency;
+import java.awt.image.BufferedImage;
+import java.awt.image.VolatileImage;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+
+import javax.imageio.ImageIO;
+
+import main.Main;
+
+public class Images {
+
+	public static ArrayList<BufferedImage> images = new ArrayList<>();
+
+	public Images() {
+	}
+
+	static {
+		try {
+			images.add(toCompatibleImage(ImageIO.read(Main.class.getResource("/image/pulse.png"))));
+			images.add(toCompatibleImage(ImageIO.read(Main.class.getResource("/image/cursor.png"))));
+			images.add(toCompatibleImage(ImageIO.read(Main.class.getResource("/image/pressstart.png")))); 
+			images.add(toCompatibleImage(ImageIO.read(Main.class.getResource("/image/colorstrike.png")))); 
+		   	images.add(toCompatibleImage(ImageIO.read(Main.class.getResource("/image/background.png"))));
+		   	images.add(toCompatibleImage(ImageIO.read(Main.class.getResource("/image/aanwijzers4sho.png"))));
+		   	images.add(toCompatibleImage(ImageIO.read(Main.class.getResource("/image/kast.png"))));
+		   	images.add(toCompatibleImage(ImageIO.read(Main.class.getResource("/image/gameover.png"))));
+		   	images.add(toCompatibleImage(ImageIO.read(Main.class.getResource("/image/help.png"))));
+		    images.add(toCompatibleImage(ImageIO.read(Main.class.getResource("/image/screenshot.png"))));			// HELP, MAAR NOG GEEN JUIST PLAATJE
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+	public static BufferedImage getImage(ImageType img) {
+		return images.get(img.ordinal());
+	}
+
+	public enum ImageType {
+		pulse, 			cursor, 		pressstart,
+		colorstrike, 	background, 	aanwijzers,
+		kast, 			gameover, 		help,
+		screenshot
+	}
+
+	public static BufferedImage readImage(File f) {
+		BufferedImage bf = null;
+		try {
+			bf = ImageIO.read(f);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+
+		return bf;
+	}
+	
+	public static BufferedImage toCompatibleImage(BufferedImage image)
+	{
+		// obtain the current system graphical settings
+		GraphicsConfiguration gfx_config = GraphicsEnvironment.
+			getLocalGraphicsEnvironment().getDefaultScreenDevice().
+			getDefaultConfiguration();
+
+		/*
+		 * if image is already compatible and optimized for current system 
+		 * settings, simply return it
+		 */
+		if (image.getColorModel().equals(gfx_config.getColorModel()))
+			return image;
+
+		// image is not optimized, so create a new image that is
+		BufferedImage new_image = gfx_config.createCompatibleImage(
+				image.getWidth(), image.getHeight(), image.getTransparency());
+
+		// get the graphics context of the new image to draw the old image on
+		Graphics2D g2d = (Graphics2D) new_image.getGraphics();
+
+		// actually draw the image and dispose of context no longer needed
+		g2d.drawImage(image, 0, 0, null);
+		g2d.dispose();
+
+		// return the new optimized image
+		new_image.setAccelerationPriority(1);
+		new_image.flush();
+		return new_image; 
+	}
+	
+	public static BufferedImage initBufferedImage(int width, int height){
+		GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
+		GraphicsDevice device = env.getDefaultScreenDevice();
+		GraphicsConfiguration config = device.getDefaultConfiguration();
+		return config.createCompatibleImage(width, height, Transparency.TRANSLUCENT);
+	}
+	
+	public static VolatileImage initVolatileImage(int width, int height, int opc){
+		GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
+		GraphicsConfiguration gc = ge.getDefaultScreenDevice().getDefaultConfiguration();
+		VolatileImage image = null;
+		image = gc.createCompatibleVolatileImage(width, height, opc);
+		int valid = image.validate(gc);
+	    if (valid == VolatileImage.IMAGE_INCOMPATIBLE)
+	    	image = initVolatileImage(width, height, opc);
+		return image;
+	}
+}

led.py

@@ -0,0 +1,52 @@
+import sys
+import time
+from neopixel import *
+
+# LED strip configuration:
+LED_COUNT      = 66      # Number of LED pixels.
+LED_PIN        = 18      # GPIO pin connected to the pixels (must support PWM!).
+LED_FREQ_HZ    = 700000  # LED signal frequency in hertz (usually 800khz)
+LED_DMA        = 5       # DMA channel to use for generating signal (try 5)
+LED_BRIGHTNESS = 255     # Set to 0 for darkest and 255 for brightest
+LED_INVERT     = False   # True to invert the signal (when using NPN transistor level shift)
+
+def setLed(strip, l,r,g,b):
+	strip.setPixelColor(l,Color(r,g,b))
+	
+def strobetest(strip):
+	on = True
+	while True:
+		if on:			
+			on = False
+			for i in range(strip.numPixels()):
+				strip.setPixelColor(i, Color(255,255,255))
+		else:
+			on = True
+			for i in range(strip.numPixels()):
+				strip.setPixelColor(i, Color(0,0,0))
+		strip.show()
+		time.sleep(100.0/1000)
+		
+if __name__ == '__main__':
+	ledstrip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS)
+	ledstrip.begin()
+	s = sys.stdin.readline().strip()
+	while s not in ['break', 'quit']:
+		message =  s.split("|")
+		returnms = 'e'
+		if(message[0] == '1'):
+			if (len(message) == 5):
+				try: 
+					led = int(message[1])
+					r = int(message[2])
+					g = int(message[3])
+					b = int(message[4])
+					setLed(ledstrip, led,r,g,b)
+					returnms = 'a'
+				except ValueError:
+					returnms = 'e'
+		elif (message[0] == '0'):
+			ledstrip.show()
+			returnms = 'a'
+		s = sys.stdin.readline().strip()
+

main/Main.java

@@ -0,0 +1,15 @@
+package main;
+
+public class Main {
+
+	public static void main(String[] args) {
+		if(args.length != 1)
+		{
+			new Window(false);
+		}
+		else
+		{
+			new Window(true);
+		}		
+	}
+}

main/Window.java

@@ -0,0 +1,98 @@
+package main;
+
+
+import java.awt.Cursor;
+import java.awt.GraphicsDevice;
+import java.awt.GraphicsEnvironment;
+import java.awt.Point;
+import java.awt.Toolkit;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.awt.image.BufferedImage;
+
+import javax.swing.JFrame;
+
+import model.GameModel;
+import model.SongHandler;
+import view.GameView;
+import control.GameControl;
+import control.GameStateManager;
+import control.NetworkHandler;
+import control.button.ButtonHandler;
+import control.joystick.JoystickHandler;
+import data.io.SQLConnector;
+
+public class Window extends JFrame {	
+	private static final long serialVersionUID = -9222956702898533696L;
+	public static boolean ON_RASP;
+	
+	public final static int WIDTH = 1280;
+	public final static int HEIGHT = 1024;
+	
+	public Window(boolean ON_RASP)
+	{
+		//Create window
+		super("Arcade");
+		setSize(WIDTH, HEIGHT);
+		
+		//Create Events
+		Window.ON_RASP = ON_RASP;
+		if(ON_RASP){ //Only on the raspberry pi
+			GraphicsEnvironment graphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
+			GraphicsDevice[] devices =  graphicsEnvironment.getScreenDevices();
+
+			if (!devices[0].isFullScreenSupported ()){
+			     throw new UnsupportedOperationException ("Fullscreen mode is unsupported.");
+			}else{
+				devices[0].setFullScreenWindow(this);
+			}			
+			//Remove cursor
+			BufferedImage cursorImg = new BufferedImage(16, 16, BufferedImage.TYPE_INT_ARGB);
+			Cursor blankCursor = Toolkit.getDefaultToolkit().createCustomCursor(cursorImg, new Point(0, 0), "blank cursor");
+			this.setCursor(blankCursor);
+		}
+		
+		ButtonHandler bth = new ButtonHandler();
+		JoystickHandler jsh = new JoystickHandler();
+		
+
+		final SQLConnector sql = new SQLConnector();
+
+		NetworkHandler ntw = new NetworkHandler("10.42.0.5", 1113, bth, jsh);
+		
+		bth.setNetwork(ntw);
+		
+		//Create Instances
+		final SongHandler sh = new SongHandler(sql);
+		GameStateManager gsm = new GameStateManager(sh, sql);
+		GameView view = new GameView(gsm);
+		GameModel model = new GameModel(sh, gsm, ntw);
+		GameControl control = new GameControl(model, view,gsm);
+		setContentPane(view);
+		
+		//Set window close listener
+		setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
+		addWindowListener(new WindowAdapter(){
+			public void windowClosing(WindowEvent e) {
+				sh.close();
+				try {
+					sql.finalize();
+				} catch (Throwable e1) {
+					e1.printStackTrace();
+				}
+				System.exit(0);
+			}
+		});
+		
+		//Create EventListeners
+			addKeyListener(bth);
+			addKeyListener(jsh);
+		bth.addButtonListener(control);
+		jsh.addJoystickListener(control);
+		
+		//Display
+		setResizable(false);
+		pack();
+		setVisible(true);
+	}
+}

model/GameModel.java

@@ -0,0 +1,42 @@
+package model;
+
+import java.awt.Color;
+
+import main.Window;
+import control.GameStateManager;
+import control.NetworkHandler;
+import control.button.ButtonHandler;
+
+public class GameModel {
+
+	public static Color[] colors = { Color.GREEN, Color.YELLOW, Color.RED, Color.MAGENTA, Color.CYAN, Color.ORANGE };
+	private GameStateManager gsm;
+	private NetworkHandler ntw;
+	private int count = 0;
+
+	public GameModel(SongHandler sh, GameStateManager gsm, NetworkHandler ntw) {
+		this.gsm = gsm;
+		this.ntw = ntw;
+
+		for (int i = 1; i < ButtonHandler.getButtons().size(); i++) {
+			ButtonHandler.getButtons().get(i).setColor(colors[i - 1]);
+		}
+	}
+
+	public void update(float factor) {
+		gsm.update(factor);
+
+		Color c = colors[(int) (Math.random() * (colors.length - 1) + 1)];
+
+		if (Window.ON_RASP) {
+			count++;
+			if(count>15) {
+				for (int i = 7; i < 54; i++) {
+					ntw.setLed(i, c.getRed(), c.getGreen(), c.getBlue());
+				}
+				ntw.show();
+				count = 0;
+			}
+		}
+	}
+}

model/SongHandler.java

@@ -0,0 +1,129 @@
+package model;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import main.Window;
+import audio.AudioPlayer;
+import audio.Song;
+import audio.SongInstance;
+import audio.io.DirScanner;
+import audio.sorting.SortALPHA;
+import audio.sorting.SortPLAYED;
+import data.io.SQLConnector;
+
+public class SongHandler {
+	
+	private List<Song> songs;
+	
+	private Song currentSong;
+	private SongInstance currentSongInstance;
+	private int currentIndex;
+	private SQLConnector sql;
+	
+	private File dir;
+	
+	private AudioPlayer p;
+
+	public SongHandler(SQLConnector sql)
+	{
+		this.sql = sql;
+		
+		songs = new ArrayList<Song>();
+		currentSong = null;
+		currentSongInstance = null;
+		currentIndex = 0;
+		
+		p = new AudioPlayer();
+		
+		if(Window.ON_RASP)
+			dir = new File(System.getProperty( "user.home" ) + "/ColorStrike/Songs/");
+		else
+			dir = new File(System.getProperty( "user.home" ) + "/Documents/songs/");
+		
+		songs = DirScanner.scanDirectories(dir);
+		
+		sql.update(songs);
+		
+		sort(new SortPLAYED());
+		
+		updatePlayer();
+	}
+	
+	public void next()
+	{
+		currentIndex++;
+		updatePlayer();
+	}
+	public void previous()
+	{
+		currentIndex--;
+		updatePlayer();
+	}
+	public void set(int i)
+	{
+		currentIndex = i;
+		updatePlayer();
+	}
+	public void set(SongInstance si)
+	{
+		currentSongInstance = si;
+	}
+	
+	
+	private void updatePlayer()
+	{
+		if(currentIndex < 0)
+			currentIndex = songs.size() + currentIndex;
+		if(currentIndex >= songs.size())
+			currentIndex = currentIndex - songs.size();
+	
+		currentSong = songs.get(currentIndex);
+		currentSongInstance = currentSong.getSongs().get(0);
+		
+		p.close();
+		p.setClip(currentSong);
+	}
+	
+	public long getProgress()
+	{
+		return p.getProgress();
+	}
+	
+	public List<Song> getSongs()
+	{
+		return songs;
+	}
+	public Song getCurrentSong()
+	{
+		return currentSong;
+	}
+	public SongInstance getCurrentSongInstance()
+	{
+		return currentSongInstance;
+	}
+	
+	public void close()
+	{
+		p.close();
+		for(Song s : songs)
+		{
+			s.close();
+		}
+	}
+	
+	public void play()
+	{
+		p.play();
+	}
+	
+	public void sort(Comparator<Song> sorter)
+	{
+		Collections.sort(songs, sorter);
+	}
+	
+	
+}

model/drawObjects/CoinAnimation.java

@@ -0,0 +1,73 @@
+package model.drawObjects;
+
+import model.gameState.PlayState;
+
+import java.awt.*;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
+import java.io.IOException;
+
+/**
+ * CoinAnimation klasse: Weergeeft een balletje (resembleerd een muntje) dat omlaag valt.
+ *      Je hoeft alleen achter elkaar de paint(Graphics2D) methode aan te roepen, deze roep automatisch een 'reposition' aan,
+ *      waardoor je het balletje alleen snel achter elkaar hoeft te repainten.
+ *
+ * *    Init (startX, startY):  Punt waar de animatie begint met vallen
+ *
+ *      start(): aanroepen om te starten
+ * *
+ * *
+ **/
+public class CoinAnimation extends DrawObject {
+
+    private Ellipse2D       coinShape;
+    private Point2D.Double  coinSetPoint;
+
+    // Hoevaak de timer gelopen heeft
+    private static int timerLoops      = 0;
+
+    public CoinAnimation(int startX, int startY) {
+        coinSetPoint        = new Point2D.Double(startX, startY);
+        coinShape           = new Ellipse2D.Double(startX, startY, 20, 20);
+    }
+
+    // Start
+    public void start() {
+        timerLoops          = 1;
+    }
+
+    public void draw(Graphics2D g2) {
+        Color oldColor = g2.getColor();
+        update(timerLoops);                                             // UPDATE
+        g2.setColor(new Color(255, 255, 0));    // GEEL
+        g2.draw(coinShape);                                             // MUNTJE TEKENEN
+        g2.fill(coinShape);
+        g2.setColor(oldColor);
+    }
+
+    // Wordt na elke paint aangeroepen
+    public void update(float factor) {
+
+        // Coin omlaag verschuiven doordat Y * loops omlaag gaat.
+        // Per frame verschuift het balletje delta 10 op Y-as.
+        try {
+            coinShape.setFrame(coinSetPoint.getX(), coinSetPoint.getY() + (1000 - 35 * PlayState.comboMulitplier) / 25 * timerLoops,
+                    coinShape.getWidth(), coinShape.getHeight());
+        } catch (ArithmeticException a) { a.printStackTrace(); }
+
+        timerLoops++;
+    }
+
+    // Zijn we al begonnen/klaar?
+    public boolean areWeDoneYet() {
+        if (timerLoops > 24 || timerLoops == 0) {
+            timerLoops = 0;
+            return true;
+        }
+        return false;
+    }
+
+    // Zitten we in de laatste loop?
+    public boolean isLastLoop() { return (timerLoops == 24) ? true : false;  }
+
+}

model/drawObjects/DrawObject.java

@@ -0,0 +1,29 @@
+package model.drawObjects;
+
+import java.awt.Graphics2D;
+import java.awt.geom.AffineTransform;
+
+public abstract class DrawObject {
+
+	protected AffineTransform transform;
+
+	protected double 	width,
+					 	height;
+
+	protected int index = 0;
+
+	public DrawObject() {	
+		transform = new AffineTransform();
+	}	
+
+	public int getIndex(){
+		return index;
+	}
+	
+	public void setIndex(int index){
+		this.index = index;
+	}
+
+	public abstract void draw(Graphics2D g2);
+	public abstract void update(float factor);
+}

model/drawObjects/Enemy.java

@@ -0,0 +1,164 @@
+package model.drawObjects;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.geom.Line2D;
+
+import model.objects.Path;
+
+public class Enemy extends DrawObject {
+
+	public static final double 	distanceToOctagon 	= 	1000,
+								secondsToEnd 		= 	5.0;
+	private int 	length;
+	private double 	lengthOf1Side,
+					distanceFromStart;	//lengthOf1Side wordt alleen gebruikt als de lijn een schuine lijn is.
+	public 	Line2D 	enemy;
+	private Color 	c;
+	private Path	path;
+	
+	public Enemy(int pathID,int lengthOfEnemy,Color c,Path path){
+		super();		
+		this.length = lengthOfEnemy;			
+		lengthOf1Side = Math.sqrt(Math.pow(lengthOfEnemy,2)/2);		
+		this.c = c;		
+		this.index = pathID;
+		this.path = path;
+		double beginX, beginY,endX = 0,endY = 0;	
+		
+		beginX = path.getX1();
+		beginY = path.getY1();					
+		
+		//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;				
+		}
+		
+		endX += beginX;
+		endY += beginY;
+		
+		enemy = new Line2D.Double(beginX, beginY, endX, endY);	
+	}
+
+	@Override
+	public void draw(Graphics2D g2) {
+		g2.setPaint(c);
+		g2.draw(enemy);		
+	}
+	public void draw(Graphics2D g2, boolean b) {
+		g2.setPaint(c.darker().darker());
+		g2.draw(enemy);		
+	}
+
+	@Override
+	public void update(float factor) {	
+		
+		distanceFromStart += (distanceToOctagon/(secondsToEnd*1000))*factor;		
+		
+		double x1,x2,y1,y2;
+		x1 = enemy.getX1();
+		x2 = enemy.getX2();
+		y1 = enemy.getY1();
+		y2 = enemy.getY2();		
+		
+		double angleX,angleY;
+		angleX = Math.cos(Math.toRadians(45))*distanceFromStart;
+		angleY = Math.sin(Math.toRadians(45))*distanceFromStart;
+
+		switch(index){
+		case 0:
+			y1 = path.getY1() +  distanceFromStart;
+			y2 = y1 - length;				
+			break;
+		case 1:
+			x1 = path.getX1() - angleX;
+			x2 = x1 + lengthOf1Side;	
+			
+			y1 = path.getY1() + angleY;
+			y2 = y1 - lengthOf1Side;							
+			break;
+		case 2:			
+			x1 = path.getX1()-distanceFromStart;
+			x2 = x1 + length;				
+			break;
+		case 3:			
+			x1 = path.getX1() - angleX;
+			x2 = x1 + lengthOf1Side;
+			
+			y1 = path.getY1() - angleY;
+			y2 = y1 + lengthOf1Side;
+			break;		
+		case 4:
+			y1 = path.getY1() - distanceFromStart;
+			y2 = y1 + length;		
+			break;
+		case 5:
+			x1 = path.getX1() + angleX;
+			x2 = x1 - lengthOf1Side;
+			
+			y1 = path.getY1() - angleY;
+			y2 = y1 + lengthOf1Side;
+			break;
+		case 6:
+			x1 = path.getX1() + distanceFromStart;
+			x2 = x1 - length;				
+			break;
+		case 7:
+			x1 = path.getX1() + angleX;
+			x2 = x1 - lengthOf1Side;
+			
+			y1 = path.getY1() + angleY;
+			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 double getDistanceFromStart() {
+		return distanceFromStart;
+	}	
+}

model/drawObjects/Player.java

@@ -0,0 +1,68 @@
+package model.drawObjects;
+
+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 {
+	
+	private BufferedImage img,pulse;	
+	private AffineTransform transform;
+	private int lastindex;
+	private Point2D middlePoint;
+	
+	private int subImgX,subImgY, indexCursor =0;
+	
+	private int subImgXBeat, indexBeat = 0;
+	private boolean beat = false;
+	
+	public Player(int x, int y){
+		img = Images.getImage(Images.ImageType.cursor);	
+		pulse = Images.getImage(Images.ImageType.pulse);
+		width = 100;//img.getWidth();
+		height = 100;//img.getHeight();	
+		lastindex = -10;
+		middlePoint = new Point2D.Double(x,y);
+	}
+	
+	public void draw(Graphics2D g2){//		
+		subImgX 	= 	(indexCursor % 8) *	100;
+		subImgY 	= 	(indexCursor / 8) *	100;
+		subImgXBeat = 	(indexBeat % 9  ) *	100;
+
+		BufferedImage subImg2 = pulse.getSubimage(subImgXBeat,0,100,100);
+		g2.drawImage(subImg2, transform, null);	
+
+		BufferedImage subImg = img.getSubimage(subImgX,subImgY,100,100);
+		g2.drawImage(subImg, transform, null);
+	}
+	
+	public void update(float update){
+        if(beat){
+            indexBeat++;
+            if(indexBeat >= 9) {
+            	indexBeat = 0;
+            	beat = false;
+            }
+          }
+
+        indexCursor++;
+		indexCursor%=32;
+        
+		if(lastindex != index){
+			transform = new AffineTransform();
+			transform.rotate(Math.toRadians(index*45),middlePoint.getX(),middlePoint.getY());
+			transform.translate(middlePoint.getX() - width/2, middlePoint.getY() - height);
+			lastindex = index;
+		}
+	}
+	
+	public void setBeat() {
+		beat = true;
+		indexBeat = 0;
+	}
+}
+	

model/drawObjects/PointAnimation.java

@@ -0,0 +1,48 @@
+package model.drawObjects;
+
+import model.gameState.PlayState;
+
+import java.awt.*;
+import java.awt.geom.Point2D;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+
+public class PointAnimation extends DrawObject {
+
+    LinkedList<Point2D.Double>  puntenPos   =   new LinkedList<>();
+    LinkedList<Integer>         puntenGain  =   new LinkedList<>();
+    LinkedList<Integer>         iterations  =   new LinkedList<>();
+
+    public PointAnimation() {    }
+
+    public void enemyDied(Point2D.Double p) {
+        puntenPos.add(new Point2D.Double(p.getX(), p.getY()));
+        puntenGain.add(PlayState.lastScoreChange);
+        iterations.add(0);
+    }
+
+    @Override
+    public void draw(Graphics2D g2) {
+            for (int x = 0; x < puntenPos.size(); x++) {
+                g2.drawString("" + puntenGain.get(x), (int) puntenPos.get(x).getX(), (int) puntenPos.get(x).getY());
+
+                update(0);
+            }
+    }
+
+    @Override
+    public void update(float factor) {
+
+        for (int x = 0; x < puntenPos.size(); x++) {
+            puntenPos.get(x).setLocation(puntenPos.get(x).getX(), puntenPos.get(x).getY() - 3);
+            iterations.set(x, iterations.get(x) + 1);
+
+            if (iterations.get(x) > 100) {
+                puntenPos.remove(x);
+                iterations.remove(x);
+                puntenGain.remove(x);
+            }
+        }
+    }
+}

model/gameState/GameOverState.java

@@ -0,0 +1,174 @@
+package model.gameState;
+
+import image.Images;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.Transparency;
+import java.awt.image.BufferedImage;
+import java.awt.image.VolatileImage;
+import java.io.IOException;
+
+import model.GameModel;
+import model.SongHandler;
+import model.objects.InfoPanel;
+import model.objects.highscore.HighscoreName;
+
+import com.google.zxing.WriterException;
+
+import control.GameStateManager;
+import control.GameStateManager.State;
+import control.button.ButtonEvent;
+import control.button.ButtonHandler;
+import control.joystick.JoystickEvent;
+import control.joystick.JoystickHandler;
+import data.io.SQLConnector;
+import data.io.WebcamUploader;
+
+public class GameOverState extends GameState {
+
+	private BufferedImage gameOver = Images.getImage(Images.ImageType.gameover);
+	private VolatileImage background;
+	private Font textFont = new Font("OCR A Extended", Font.BOLD, 70);
+	private HighscoreName hsn;
+	private int image_x = 0;
+	private boolean uploaded;
+	private BufferedImage QRimage;
+	
+    int frame;
+
+	public GameOverState(GameStateManager gsm, SongHandler sh, SQLConnector sql) {
+		super(gsm, sh, sql);
+		hsn = new HighscoreName(640,717,5,textFont);
+	}
+
+	@Override
+	public void init() {
+		createBackground();
+		ButtonHandler.getButton(1).setColor(GameModel.colors[0]);
+		ButtonHandler.getButton(2).setColor(GameModel.colors[2]);
+		
+		try {
+			Thread.sleep(1000);
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+		
+		JoystickHandler.REPEAT = true;
+		uploaded = false;
+	}
+
+	@Override
+	public void update(float factor) {
+		image_x = ((frame / 5) % 5) * 40;
+        frame++;
+	}
+
+	@Override
+	public void draw(Graphics2D g2) {
+		g2.drawImage(background, 0, 0, 1280, 1024, null);		
+		g2.drawImage(gameOver.getSubimage(image_x, 0, 40, 26),  640-122, 400, 245, 130, null);
+		if(!uploaded)
+			hsn.drawName(g2);
+		else if(QRimage != null){
+			g2.drawImage(QRimage, (1280/2)-(QRimage.getWidth()/2), 600,null);
+			//1280 is de breedte van de panel
+		}
+			
+	}
+	
+	@Override
+	public void buttonPressed(ButtonEvent e) {
+		//System.out.println("Name: "+hsn.getName());
+		switch(e.getButton().getButtonID()){
+		case 0:
+			gsm.setState(State.TITLE_STATE);
+			break;
+		case 1:
+			if(hsn.getName().trim().length() >= 3)
+			{
+				if(!uploaded){
+					int id = sql.addHighscore(sh.getCurrentSong(), sh.getCurrentSongInstance(), hsn.getName(), PlayState.currentScore);
+					try {
+						WebcamUploader.takePictureAndUpload(id);
+					} catch (IOException e2) {
+						e2.printStackTrace();
+					}
+					 		
+					try {
+						QRimage = WebcamUploader.createQRImage("http://portfolio.jancokock.me/colorstrike/message.php?id="+id, 400);
+					} catch (WriterException | IOException e1) {
+						e1.printStackTrace();
+					}
+					uploaded = true;
+
+				}else{
+					gsm.setState(State.MENU_STATE);
+				}
+			}
+			break;			
+		case 2:
+			gsm.setState(State.MENU_STATE);
+			break;
+		case 3:
+			gsm.setState(State.HELP_STATE);
+			break;
+		}
+		
+		
+	}
+	@Override
+	public void buttonReleased(ButtonEvent e) {
+		
+	}
+	@Override
+	public void onJoystickMoved(JoystickEvent e) {
+		switch(e.getJoystick().getPos()){		
+		case DOWN:
+			hsn.down();
+			break;			
+		case LEFT:
+			hsn.left();
+			break;
+		case RIGHT:
+			hsn.right();
+			break;
+		case UP:
+			hsn.up();
+			break;		
+		default:
+			break;	
+		}
+	}
+	
+	public void createBackground(){
+		background = Images.initVolatileImage(1280, 1024, Transparency.OPAQUE);
+		Graphics2D g2 = background.createGraphics();
+
+		RenderingHints rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+	    g2.setRenderingHints(rh);
+		g2.setColor(new Color(1,1,1, 0.3f));
+		g2.fillRect(0,0,1280,1024);
+		
+		g2.setColor(new Color(0,1,0, 0.7f));
+		g2.fillRect(0,0,100,1024);
+		g2.fillRect(1180,0,100,1024);
+		
+		g2.setColor(new Color(1,1,0, 0.7f));
+		g2.fillRect(100,0,100,1024);
+		g2.fillRect(1080,0,100,1024);
+		
+		g2.setColor(new Color(1,0,0, 0.7f));
+		g2.fillRect(200,0,100,1024);
+		g2.fillRect(980,0,100,1024);
+		
+		g2.setColor(Color.BLACK);
+		g2.setFont(textFont);
+		
+		g2.drawString("High Score", 385, 212);
+		g2.drawString(InfoPanel.getTotalHighscore() + "", 390, 342);
+		g2.dispose();
+	}
+}

model/gameState/GameState.java

@@ -0,0 +1,31 @@
+package model.gameState;
+
+import java.awt.Graphics2D;
+
+import model.SongHandler;
+import control.GameStateManager;
+import control.button.ButtonEvent;
+import control.joystick.JoystickEvent;
+import data.io.SQLConnector;
+
+public abstract class GameState  {
+
+	protected GameStateManager gsm;
+	protected SongHandler sh;
+	protected SQLConnector sql;
+
+	public GameState(GameStateManager gsm, SongHandler sh, SQLConnector sql) {
+		this.gsm = gsm;
+		this.sh = sh;
+		this.sql = sql;
+	}
+	
+	public abstract void init();
+	public abstract void update(float factor);
+	public abstract void draw(Graphics2D g2);	
+	public abstract void buttonPressed(ButtonEvent e);	
+	public abstract void buttonReleased(ButtonEvent e);	
+	public abstract void onJoystickMoved(JoystickEvent e);
+
+	public void stopAudio() { 	sh.close();   }
+}

model/gameState/HelpState.java

@@ -0,0 +1,85 @@
+package model.gameState;
+
+import image.Images;
+import image.Images.ImageType;
+
+import java.awt.Font;
+import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.Transparency;
+import java.awt.image.BufferedImage;
+import java.awt.image.VolatileImage;
+
+import model.GameModel;
+import model.SongHandler;
+import control.GameStateManager;
+import control.GameStateManager.State;
+import control.button.ButtonEvent;
+import control.joystick.JoystickEvent;
+import data.io.SQLConnector;
+
+public class HelpState extends GameState {
+
+    private BufferedImage help = Images.getImage(ImageType.help);
+    private VolatileImage background;
+	private Font textFontSmall = new Font("OCR A Extended", Font.BOLD, 15);
+
+    int index = 0,
+    	frame;
+
+    
+	public HelpState(GameStateManager gsm, SongHandler sh, SQLConnector sql){
+		super(gsm, sh, sql);
+		createBackground();
+	}
+
+	@Override
+	public void init() {
+		sh.play();
+	}
+
+	@Override
+	public void update(float factor) {
+        frame++;
+	}
+
+	@Override
+	public void draw(Graphics2D g2) {
+		g2.drawImage(background, 0, 0, 1280, 1024, null);
+	}
+
+	@Override
+	public void buttonPressed(ButtonEvent e) {
+		if(e.getButton().getButtonID() == 2)
+			gsm.setState(State.MENU_STATE);
+	}
+
+	@Override
+	public void buttonReleased(ButtonEvent e) {
+
+	}
+
+	@Override
+	public void onJoystickMoved(JoystickEvent e) {
+	}
+
+	public void createBackground() {
+		background = Images.initVolatileImage(1280, 1024, Transparency.OPAQUE);
+		Graphics2D g2 = background.createGraphics();
+		RenderingHints rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+		g2.setRenderingHints(rh);
+		
+		g2.drawImage(help, 0,0,1280,1024,null);
+		
+		g2.setFont(textFontSmall);
+		
+		//back
+		g2.setColor(GameModel.colors[2]);
+		g2.fillOval(80, 965, 30, 30);
+		g2.drawString("Back", 115, 985);
+
+		g2.dispose();
+		background.createGraphics();
+	}
+
+}

model/gameState/MenuState.java

@@ -0,0 +1,461 @@
+package model.gameState;
+
+import image.Images;
+import image.Images.ImageType;
+
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.GradientPaint;
+import java.awt.Graphics2D;
+import java.awt.Polygon;
+import java.awt.RenderingHints;
+import java.awt.Transparency;
+import java.awt.image.BufferedImage;
+import java.awt.image.VolatileImage;
+import java.util.ArrayList;
+import java.util.List;
+
+import model.GameModel;
+import model.SongHandler;
+import model.objects.DifficultyButton;
+import model.objects.MenuButton;
+import model.objects.highscore.Highscore;
+import audio.Song;
+import audio.SongInstance;
+import audio.sorting.SortALPHA;
+import audio.sorting.SortPLAYED;
+import control.GameStateManager;
+import control.GameStateManager.State;
+import control.button.ButtonEvent;
+import control.button.ButtonHandler;
+import control.joystick.Joystick;
+import control.joystick.Joystick.Position;
+import control.joystick.JoystickEvent;
+import control.joystick.JoystickHandler;
+import data.io.SQLConnector;
+
+public class MenuState extends GameState {
+	private ArrayList<MenuButton> buttons;
+	private ArrayList<DifficultyButton> buttons2;
+	private int selected, oldselected;
+	private List<Song> songs;
+	private SQLConnector sql;
+
+	private int animationcounter;
+	private boolean subscreen, startanimation;
+	private VolatileImage mainScreenBackground, subScreenBackground, subScreenForeground;
+
+	private int difSelect=0, oldDifSelect = -1;
+	Font textFont = new Font("OCR A Extended", Font.BOLD, 50);
+	Font textFont2 = new Font("OCR A Extended", Font.BOLD, 35);
+	Font textFont3 = new Font("OCR A Extended", Font.BOLD, 20);
+	Font textFontSmall = new Font("OCR A Extended", Font.BOLD, 15);
+	BufferedImage aanwijzers = Images.getImage(ImageType.aanwijzers);
+
+	private int index 		 	= 	0,
+				yPosDiffButton	= 	900,
+				kleurButton1 	= 	0,
+				kleurButton2 	= 	1,
+				kleurButton3 	= 	2,
+				kleurButton4 	= 	3,
+				kleurButton5 	= 	4;
+
+	public MenuState(GameStateManager gsm, SongHandler sh, SQLConnector sql) {	
+		super(gsm, sh, sql);
+		buttons = new ArrayList<>();
+		buttons2 = new ArrayList<>();
+		this.songs = sh.getSongs();
+		startanimation = true;
+		subscreen = false;
+		this.sql = sql;
+		
+		selected = 0;
+		oldselected = -1;
+		
+		buttons2.clear();
+ 		int instanceNr = 0;
+ 		for(int i = selectedToSong(selected).getSongs().size(); i>0; i--){
+ 			if(sh.getCurrentSong().getSongs().size() == 0)
+ 				continue;
+ 			SongInstance si = selectedToSong(selected).getSongs().get(i-1);
+ 			buttons2.add(new DifficultyButton(yPosDiffButton-instanceNr,si.getDifficulty(), GameModel.colors[i-1]));
+ 			instanceNr += 100;
+ 		}
+		difSelect = 0;
+
+		generateMainScreenBackground();	
+		generateSubScreenBackground();
+	}
+	@Override
+	public void init() {
+		if(subscreen) {
+			ButtonHandler.getButton(1).setColor(GameModel.colors[0]);
+			ButtonHandler.getButton(2).setColor(GameModel.colors[2]);
+			generateSubScreenForeground();
+		}
+		else {
+			ButtonHandler.getButton(1).setColor(GameModel.colors[0]);
+			
+			ButtonHandler.getButton(5).setColor(GameModel.colors[1]);
+			ButtonHandler.getButton(6).setColor(GameModel.colors[4]);
+			JoystickHandler.REPEAT = true;
+		}
+
+	}
+
+	@Override
+	public void update(float factor) {
+		if(startanimation){
+			buttonInAnimation(animationcounter);
+			if(animationcounter == 5){
+				startanimation = false;
+			}
+		}/*else if(subscreen){
+			//nextScreen();
+		}else{
+			//previousScreen();
+		}*/
+	     if(selected != oldselected){
+	    	 for(int i = 0; i < buttons.size(); i++)
+		    	 buttons.get(i).setSong(selectedToSong(selected+(i-2)));
+
+	    	 oldselected = selected;
+	     }
+	     if(difSelect != oldDifSelect) {
+	    	 oldDifSelect = difSelect;
+	    	 generateSubScreenForeground();
+	     }
+	     index++;
+	     
+	}
+
+	@Override
+	public void draw(Graphics2D g2) {
+
+		buttons.clear();		
+		buttons.add(new MenuButton(400,250,GameModel.colors[kleurButton1],selectedToSong(selected-2)));
+		buttons.add(new MenuButton(400,390,GameModel.colors[kleurButton2],selectedToSong(selected-1)));
+		buttons.add(new MenuButton(360,525,920,80,GameModel.colors[kleurButton3],selectedToSong(selected)));
+		buttons.add(new MenuButton(400,670,GameModel.colors[kleurButton4],selectedToSong(selected+1)));
+		buttons.add(new MenuButton(400,810,GameModel.colors[kleurButton5],selectedToSong(selected+2)));
+		buttons.get(2).setSelected(true);
+		
+		
+		g2.setColor(Color.BLACK);
+		Font textFont2 = new Font("OCR A Extended", Font.BOLD, 50);
+		g2.setFont(textFont2);
+		if(!subscreen) {
+			g2.drawImage(mainScreenBackground, 0, 0, 1280,1024,null);
+			for(MenuButton b:buttons){
+		    	 b.draw(g2);
+		     }
+		}
+		if(subscreen) {
+			g2.drawImage(subScreenBackground,0,0,1280,1024,null);
+			g2.drawImage(subScreenForeground,0,0,1280,1024,null);
+			index%=25;
+			int y = (index/5)*75;
+			int x = (index%5)*75;
+			g2.drawImage(aanwijzers.getSubimage(x, y, 75, 75), 825,900 - difSelect*100,75,75,null);		
+		}
+	}
+	
+	@Override
+	public void buttonPressed(ButtonEvent e) {
+		if(subscreen){								//Screen for Song details
+			if(e.getButton().getButtonID() == 2){
+				subscreen = false;
+				gsm.init();
+			}
+			if(e.getButton().getButtonID() == 1){
+				sh.close();
+				gsm.setState(control.GameStateManager.State.PLAY_STATE);
+			}
+		}else{										//Screen for selecting song
+			if(e.getButton().getButtonID() == 1){
+				subscreen = true;
+				gsm.init();
+				generateSubScreenForeground();
+			}else if(e.getButton().getButtonID() == 5){
+				sh.sort(new SortALPHA());
+				selected = 0;
+				sh.set(songs.indexOf(selectedToSong(selected)));
+				sh.play();	
+			}else if(e.getButton().getButtonID() == 6){
+				sh.sort(new SortPLAYED());
+				selected = 0;
+				sh.set(songs.indexOf(selectedToSong(selected)));
+				sh.play();	
+			}else if(e.getButton().getButtonID() == 3){
+				gsm.setState(control.GameStateManager.State.HELP_STATE);
+			}
+		}
+		
+		if(e.getButton().getButtonID() == 0)
+		{
+			gsm.setState(State.TITLE_STATE);
+		}
+	}
+	@Override
+	public void buttonReleased(ButtonEvent e) {
+		
+	}
+	@Override
+	public void onJoystickMoved(JoystickEvent e) {
+		
+		if(subscreen){		
+			if(e.getJoystick().getPos() == Joystick.Position.DOWN){
+				difSelect--;
+				if(difSelect < 0)
+					difSelect += buttons2.size();
+				else if(e.getJoystick().getPos() == Joystick.Position.UP)
+					difSelect++;
+				if(difSelect > buttons2.size()-1)
+					difSelect = 0;
+			}
+			else if(e.getJoystick().getPos() == Joystick.Position.CENTER)
+				sh.set(selectedToSong(selected).getSongs().get(difSelect));
+			//generateSubScreenForeground();			
+		}else{										//Screen for selecting song
+			if(e.getJoystick().getPos() == Joystick.Position.DOWN){
+				selected++;
+
+				kleurButton1++;
+				kleurButton1 %= 6;
+				
+				kleurButton2++;
+				kleurButton2 %= 6;
+				
+				kleurButton3++;
+				kleurButton3 %= 6;
+				
+				kleurButton4++;
+				kleurButton4 %= 6;
+				
+				kleurButton5++;
+				kleurButton5 %= 6;
+
+			}else if(e.getJoystick().getPos() == Joystick.Position.UP){
+				selected--;
+
+				if(--kleurButton1 < 0)
+					kleurButton1 = 5;
+
+				if(--kleurButton2 < 0)
+					kleurButton2 = 5;
+
+				if(--kleurButton3 < 0)
+					kleurButton3 = 5;
+
+				if(--kleurButton4 < 0)
+					kleurButton4 = 5;
+
+				if(--kleurButton5 < 0)
+					kleurButton5 = 5;
+			}
+			
+			else if(e.getJoystick().getPos() == Joystick.Position.CENTER)
+			{
+				buttons2.clear();
+		 		int instanceNr = 0;
+		 		for(int i = selectedToSong(selected).getSongs().size(); i>0; i--){
+		 			if(sh.getCurrentSong().getSongs().size() == 0)
+		 				continue;
+		 			SongInstance si = selectedToSong(selected).getSongs().get(i-1);
+		 			buttons2.add(new DifficultyButton(yPosDiffButton-instanceNr,si.getDifficulty(), GameModel.colors[i-1]));
+		 			instanceNr += 100;
+		 		}
+				difSelect = 0;
+		 		
+				sh.set(songs.indexOf(selectedToSong(selected)));
+				sh.play();	
+			}
+		}
+	}
+	
+	public void generateMainScreenBackground(){
+		mainScreenBackground = Images.initVolatileImage(1280, 1024, Transparency.OPAQUE);
+		Graphics2D g2 = mainScreenBackground.createGraphics();
+		RenderingHints rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+	    g2.setRenderingHints(rh);
+		g2.setFont(textFont);
+		g2.setPaint(new GradientPaint(0, 0, new Color(0,0,1, 0.6f),1280,1024 ,new Color(0,0,1, 0.2f)));
+		g2.fillRect(0, 0, 1280, 1024);	
+		g2.setPaint(new GradientPaint(0, 0, new Color(1,1,0, 0.6f),1280,1024 ,new Color(0,0,1, 0.2f)));
+
+		Polygon triangle2 = new Polygon();
+
+		triangle2.addPoint(0, 0);
+		triangle2.addPoint(0, 1024/4+50);
+		triangle2.addPoint(1280/2+50, 0);
+		g2.fillPolygon(triangle2);
+		
+		g2.setColor(Color.ORANGE);
+		Polygon triangle = new Polygon();
+	    triangle.addPoint(0, 0);
+	    triangle.addPoint(0, 1024/4);
+	    triangle.addPoint(1280/2, 0);
+		g2.fillPolygon(triangle);
+		
+		g2.setColor(Color.BLACK);
+		g2.drawString("Main Menu", 32, 60);
+		
+		g2.setFont(textFontSmall);
+	
+		//select
+		g2.setColor(GameModel.colors[0]);
+		g2.fillOval(20, 860, 30, 30);
+		g2.drawString("Play", 55, 880);
+
+		//help
+		g2.setColor(GameModel.colors[3]);
+		g2.fillOval(20, 900, 30, 30);
+		g2.drawString("Help", 55, 920);
+
+		//letters
+		g2.setColor(GameModel.colors[1]);
+		g2.fillOval(20, 940, 30, 30);
+		g2.drawString("A-Z", 55, 960);
+		
+		//most played
+		g2.setColor(GameModel.colors[4]);
+		g2.fillOval(20, 980, 30, 30);
+		g2.drawString("Most Played", 55, 1000);		
+		g2.dispose();
+	
+		mainScreenBackground.createGraphics();
+		
+		
+	}
+	
+	public void generateSubScreenBackground(){
+		subScreenBackground = Images.initVolatileImage(1280, 1024, Transparency.OPAQUE);
+		Graphics2D g2 = subScreenBackground.createGraphics();
+		RenderingHints rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+	    g2.setRenderingHints(rh);
+	    g2.setColor(Color.BLACK);
+		GradientPaint gp3 = new GradientPaint(640, 1024/8,Color.BLUE,640,1024 ,Color.WHITE);
+		g2.setPaint(gp3);
+		g2.fillRect(0, 0, 1280, 1024);
+		GradientPaint gp4 = new GradientPaint(0, 0,new Color(1,1,0,0.6f),1280,1024,new Color(1,1,1,0.2f));
+		g2.setPaint(gp4);
+		g2.fillRect(0,128,1280,25);
+		g2.setColor(Color.ORANGE);
+		g2.fillRect(0, 0, 1280, 1024/8);
+		g2.setColor(Color.BLACK);
+		g2.dispose();
+		subScreenBackground.createGraphics();
+	}
+	
+	public void generateSubScreenForeground(){
+		subScreenForeground = Images.initVolatileImage(1280, 1024, Transparency.TRANSLUCENT);
+		Graphics2D g2 = subScreenForeground.createGraphics();
+		RenderingHints rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+		g2.setComposite(AlphaComposite.DstOut);
+		g2.fillRect(0, 0, subScreenForeground.getWidth(), subScreenForeground.getHeight());
+		g2.setComposite(AlphaComposite.SrcOver);
+	    g2.setRenderingHints(rh);
+	    g2.setColor(Color.BLACK);
+ 		g2.setFont(textFont);
+		g2.drawString(selectedToSong(selected).getTitle(), 30, 60);
+		
+ 		g2.setFont(textFont3);
+		g2.setColor(Color.WHITE);
+		g2.drawString("Author: " + selectedToSong(selected).getAuthor(), 30, 100);
+		g2.setFont(textFont);
+		
+		boolean highscoresFound = true;
+		int HIGHSCORES_TO_DISPLAY = 5;
+		
+		List<Highscore> highscores = sql.getHighscoresToday(selectedToSong(selected), sh.getCurrentSong().getSongs().get(difSelect));
+		if(highscores.isEmpty())
+		{
+			highscores = sql.getHighscores(selectedToSong(selected), sh.getCurrentSong().getSongs().get(difSelect));
+
+			if(highscores.isEmpty())
+				highscoresFound = false;
+			else
+				g2.drawString("All Time Highscores", 30, 300);
+		}
+		else
+			g2.drawString("Daily Highscore", 30, 300);
+
+		g2.setFont(textFont2);
+		if(highscoresFound)
+		{
+			HIGHSCORES_TO_DISPLAY = HIGHSCORES_TO_DISPLAY > highscores.size() ? highscores.size() : HIGHSCORES_TO_DISPLAY;
+			
+			for(int i = 0; i<HIGHSCORES_TO_DISPLAY; i++)
+			{
+				Highscore hi = highscores.get(i);
+				
+				g2.drawString(hi.getName() + " - " + hi.getScore(), 30, 350 + i*100);
+			}
+		}
+		else
+			g2.drawString("No Highscores found", 30, 400);
+		
+		/*
+		List<Highscore> highscores = sql.getHighscores(selectedToSong(selected), sh.getCurrentSong().getSongs().get(difSelect));
+		List<Highscore> dailyHighs = new ArrayList<Highscore>();
+		int highest = 0;
+		int oldHighest = 0;
+		*/
+		for(DifficultyButton b : buttons2)
+			b.draw(g2);
+		
+		g2.setFont(textFontSmall);
+		
+		//play song
+		g2.setColor(GameModel.colors[0]);
+		g2.fillOval(20, 860, 30, 30);
+		g2.drawString("Play", 55, 880);
+		
+		//back
+		g2.setColor(GameModel.colors[2]);
+		g2.fillOval(20, 900, 30, 30);
+		g2.drawString("Back", 55, 920);
+		
+		//up
+		g2.setColor(Color.BLACK);		
+		Polygon p  = new Polygon();
+		p.addPoint(35, 940);
+		p.addPoint(20, 960);
+		p.addPoint(50, 960);	
+		g2.fillPolygon(p);
+		g2.drawString("Up", 55, 960);
+		
+		//down
+		Polygon p2  = new Polygon();
+		p2.addPoint(35, 1000);
+		p2.addPoint(20, 980);
+		p2.addPoint(50, 980);	
+		g2.fillPolygon(p2);
+
+		g2.drawString("Down", 55, 1000);	
+
+	    g2.dispose();
+	    subScreenForeground.createGraphics();
+	}
+	
+	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);
+		}
+	}
+
+	public Song selectedToSong(int s){
+		s %= songs.size();
+		if(s < 0)
+			return songs.get(songs.size()+s);
+		else
+			return songs.get(s);
+	}
+	
+}

model/gameState/PlayState.java

@@ -0,0 +1,297 @@
+package model.gameState;
+
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Stroke;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.util.Iterator;
+
+import main.Window;
+import model.SongHandler;
+import model.drawObjects.Enemy;
+import model.drawObjects.Player;
+import model.objects.InfoPanel;
+import model.objects.Path;
+import model.objects.PlayArea;
+import audio.ButtonInstance;
+import audio.ObjectInstance;
+import control.GameStateManager;
+import control.GameStateManager.State;
+import control.button.Button;
+import control.button.ButtonEvent;
+import control.button.ButtonHandler;
+import control.joystick.JoystickEvent;
+import data.io.SQLConnector;
+
+public class PlayState extends GameState {
+
+	public static final Rectangle2D borderRect = new Rectangle2D.Double(256, 0, 1024, 1024);
+	private PlayArea area;
+	private InfoPanel infoPanel;
+	private Player player;
+	private Stroke stroke;
+	private Stroke borderStroke;
+
+	public static int sizeOfEnemy = 40;
+	public static int currentScore = 0;
+	public static int comboMulitplier = 0;
+	public static int lastScoreChange = 0;
+	public static int sinceScoreChanged = 75;
+	public static double lifePoints = 100;
+	
+	private int enemies_hit = 0;
+	private int enemies_missed = 0;
+	private int buttons_pressed = 0;
+	private int joystick_moved = 0;
+	
+	private boolean init = false;
+
+	private boolean prestateShown = false;
+
+	private long oldProgress = 0;
+
+	public PlayState(GameStateManager gsm, SongHandler sh, SQLConnector sql) {
+		super(gsm, sh, sql);
+		infoPanel = new InfoPanel(0, 0, sh);
+		area = new PlayArea(256, 1024, 1024, 125);
+		player = new Player(1280 - 1024 + 1024 / 2, 1024 / 2);
+		stroke = new BasicStroke(sizeOfEnemy, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND);
+		borderStroke = new BasicStroke(sizeOfEnemy+2, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND);
+	}
+
+	@Override
+	public void init() {
+		init = true;
+		currentScore = 0;
+		oldProgress = 0;
+		
+		enemies_hit = 0;
+		enemies_missed = 0;
+		buttons_pressed = 0;
+		joystick_moved = 0;
+		
+		for(Path p : area.paths)
+			p.getEnemysInPath().clear();
+
+		for (int i = 1; i < ButtonHandler.getButtons().size(); i++) {
+			Button b = ButtonHandler.getButton(i);
+			b.setColor(Color.BLACK);
+		}
+		
+		ButtonHandler.getButton(1).setColor(sh.getCurrentSongInstance().getButtons().get(0).getColor());
+		
+		sh.play();
+		init = false;
+	}
+
+	@Override
+	public void update(float factor) {
+		if(init)
+			return;
+
+		if (!prestateShown) {
+			gsm.setState(control.GameStateManager.State.PRE_GAME_STATE);
+			prestateShown = true;
+		}
+
+		long progress = (long) ((sh.getProgress() / 1000) + (Enemy.secondsToEnd * 1000));
+
+		for (ButtonInstance bu : sh.getCurrentSongInstance().getButtonsBetween(oldProgress, progress)) {
+			Button b = ButtonHandler.getButton(bu.getButtonID());
+			b.setColor(bu.getColor());
+		}
+
+		for (ObjectInstance ob : sh.getCurrentSongInstance().getObjectsBetween(oldProgress, progress)) {
+			Path p = area.paths.get(ob.getDirection());
+			p.addEnemy(ob.getColor(), ob.getDirection(), (int) ob.getLength());
+		}
+		
+
+		if(progress > sh.getCurrentSongInstance().getEndTime() + Enemy.secondsToEnd*1000*2)
+			endGame();
+
+		oldProgress = progress;
+		Enemy closedEnemy = null;
+		player.update(factor);
+
+		for (Path path : area.paths) {
+			Iterator<Enemy> enemyIterator = path.getEnemysInPath().iterator();
+
+			while (enemyIterator.hasNext()) {
+				Enemy e = enemyIterator.next();
+				if (e.getDistanceFromStart() > Enemy.distanceToOctagon + (sizeOfEnemy * 1.5)) {
+					enemyIterator.remove();
+					lastScoreChange = -5;
+					lifePoints -= lastScoreChange;
+					sinceScoreChanged = 1;
+					comboMulitplier = 0;
+					enemies_missed++;
+				}
+				if(closedEnemy == null)
+					closedEnemy = e;
+				if((Enemy.distanceToOctagon-closedEnemy.getDistanceFromStart()) > (Enemy.distanceToOctagon-e.getDistanceFromStart()))
+						closedEnemy = e;
+
+				e.update(factor);
+			}
+		}
+
+		lifePoints -= 0.002 * factor;
+		infoPanel.updateIPanel();
+
+		if(lifePoints <= 0) 				// STERF!
+			endGame();
+
+		if(comboMulitplier >= 20) {			// '20' hit streak voor bonuspunten
+			comboMulitplier 	= 	0;
+			sinceScoreChanged 	= 	1;
+			lastScoreChange 	= 	500;
+			currentScore 	   += 	lastScoreChange;
+		}
+
+		area.count();
+		if(closedEnemy == null)
+			area.pathPainted(-1, null);
+		else
+			area.pathPainted(closedEnemy.getIndex(), closedEnemy.getColor());
+
+	}
+
+	private void endGame() {
+		if(sh.getProgress()/1000 > 5000) {
+			sql.addPlaydata(sh.getCurrentSong(), sh.getCurrentSongInstance(), sh.getProgress()/1000, enemies_missed, enemies_hit, buttons_pressed, joystick_moved);
+			sh.getCurrentSongInstance().played();
+		}
+
+		comboMulitplier = 0;
+		prestateShown = false;
+		
+		if(currentScore == 0)
+			gsm.setState(State.MENU_STATE);
+		else
+			gsm.setState(State.GAMEOVER_STATE);
+	}
+
+	@Override
+	public void draw(Graphics2D g2) {
+		try {
+			infoPanel.draw(g2);
+			g2.setClip(borderRect);
+			area.draw(g2);
+			sinceScoreChanged++;
+
+			for (Path p : area.paths) {
+				if (p.getEnemysInPath() != null) {
+					for (Enemy enemy : p.getEnemysInPath()) {
+						g2.setStroke(borderStroke);
+						enemy.draw(g2, true);
+						g2.setStroke(stroke);
+						enemy.draw(g2);
+					}
+				}
+			}
+			if (player != null)
+				player.draw(g2);
+
+		} catch (Exception e) {
+		}
+		if(!Window.ON_RASP){
+			int width,height;
+			height = g2.getFontMetrics().getHeight();
+			for (int i = 1; i < ButtonHandler.getButtons().size(); i++) {
+				Ellipse2D oval = new Ellipse2D.Double(880+(50*i), 0, 50, 50);
+				g2.setColor(ButtonHandler.getButton(i).getColor());
+				g2.fill(oval);
+				g2.setColor(Color.BLACK);
+				width = g2.getFontMetrics().stringWidth(""+i);
+				g2.drawString(""+i, (int)oval.getCenterX()-width/2,(int)oval.getMaxY()+height);
+			}
+		}
+	}
+
+	@Override
+	public void buttonPressed(ButtonEvent e) {
+		boolean notHit = true;
+		Iterator<Enemy> enemysInPath = area.paths.get(player.getIndex()).getEnemysInPath().iterator();
+		while (enemysInPath.hasNext()) {
+			Enemy enemy = enemysInPath.next();
+			if (enemy.getDistanceFromStart() > Enemy.distanceToOctagon || enemy.getDistanceFromStart() > Enemy.distanceToOctagon + sizeOfEnemy) {
+				if (e.getButton().getColor().equals(enemy.getColor())) {
+					comboMulitplier++;
+					lastScoreChange = 5 * comboMulitplier;
+					currentScore += lastScoreChange;
+					sinceScoreChanged = 1;
+					area.enemyDied((Point2D.Double) enemy.getEnemy().getP1());
+					lifePoints = Math.min(lifePoints+10, 100);
+					area.setHitAreaColor(enemy.getColor());
+					area.hit();
+					enemies_hit++;
+					enemysInPath.remove();
+					notHit = false;
+					infoPanel.throwACoin(); // Coin Animatie starten bij hit
+					break;
+				}
+			}
+		}
+
+		player.setBeat();
+
+		if(notHit) {
+			if(area.paths.get(player.getIndex()).getEnemysInPath().size() > 0)
+				lifePoints -= 1.5;
+		}
+		
+		if(e.getButton().getButtonID() == 0)
+			endGame();
+		else
+			buttons_pressed++;
+	}
+
+	@Override
+	public void buttonReleased(ButtonEvent e) {
+	}
+
+	@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;
+		}
+		joystick_moved++;
+	}
+
+	public void addEnemy(int pathID, Color color) {
+		Path path = area.paths.get(pathID);
+		Enemy e = new Enemy(pathID, 1, color, path);
+		path.getEnemysInPath().addLast(e);
+	}
+}

model/gameState/PreGameState.java

@@ -0,0 +1,97 @@
+package model.gameState;
+
+import data.io.SQLConnector;
+import image.Images;
+
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+
+import model.SongHandler;
+import control.GameStateManager;
+import control.button.ButtonEvent;
+import control.joystick.JoystickEvent;
+
+public class PreGameState extends GameState {
+
+	private double 	index2 = 3,
+					index = 3;
+
+	private int grootte = 150;
+
+	private SQLConnector sql;
+
+	private BasicStroke s = new BasicStroke(20);
+	
+	private BufferedImage screenshot;
+	
+	public PreGameState(GameStateManager gsm, SongHandler sh, SQLConnector sql) {
+		super(gsm, sh, sql);
+		this.sql = sql;
+		screenshot = Images.getImage(Images.ImageType.screenshot);
+	}
+
+	@Override
+	public void init() {
+		
+	}
+
+	@Override
+	public void update(float factor) {
+
+		index2 -= factor/1000;
+		index = (double) Math.round(index2*1000)/1000;
+		if(index <= 0){
+			grootte = 150;
+			index = 3;
+			index2 = 3;
+			gsm.setState(control.GameStateManager.State.PLAY_STATE);
+		}
+		
+		if(grootte > 270)
+			grootte = 150;
+		grootte+=2;
+	}
+
+	@Override
+	public void draw(Graphics2D g2) {
+		g2.drawImage(screenshot,0,0,1280,1024,null);
+		Font textFont = new Font("OCR A Extended", Font.BOLD,grootte);		
+		g2.setFont(textFont);
+		g2.setStroke(s);
+		g2.setColor(Color.RED);
+		String text = "" + index;
+		int width = g2.getFontMetrics().stringWidth(text);		
+		g2.drawString(text,  325, 400);
+		if(index < 1){
+			text = "GO!!!";
+		}
+		else if (index < 2){
+			text = "SET";
+		}
+		else{
+			text = "READY";
+		}
+		width =  g2.getFontMetrics().stringWidth(text);
+		g2.drawString(text, (256+1024/2)-width/2, 600);
+	}
+	
+
+	@Override
+	public void buttonPressed(ButtonEvent e) {
+		
+	}
+
+	@Override
+	public void buttonReleased(ButtonEvent e) {
+		
+	}
+
+	@Override
+	public void onJoystickMoved(JoystickEvent e) {
+		
+	}
+
+}

model/gameState/TitleState.java

@@ -0,0 +1,140 @@
+package model.gameState;
+
+import image.Images;
+import image.Images.ImageType;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.GradientPaint;
+import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.Transparency;
+import java.awt.image.BufferedImage;
+import java.awt.image.VolatileImage;
+
+import model.SongHandler;
+import control.GameStateManager;
+import control.GameStateManager.State;
+import control.button.ButtonEvent;
+import control.joystick.JoystickEvent;
+import data.io.SQLConnector;
+
+public class TitleState extends GameState {
+
+	private BufferedImage 	pressStart 	= 	Images.getImage(ImageType.pressstart),
+							colorStrike = 	Images.getImage(ImageType.colorstrike),
+							kast 		= 	Images.getImage(ImageType.kast);
+	private VolatileImage 	background;
+
+	private Font 			textFont 	= 	new Font("OCR A Extended", Font.BOLD, 15),
+							textFont2 	=	new Font("OCR A Extended", Font.BOLD, 130);
+
+	private GradientPaint gp = new GradientPaint(300, 0, new Color(0, 0, 1, 0.6f), 980, 1024, new Color(0, 0, 1, 0.2f));
+
+	
+    private int index 		= 0,
+    			varx 		= 0,
+    			indexKast 	= 0,
+				xKast	  	= 0,
+				frame;
+    
+	public TitleState(GameStateManager gsm, SongHandler sh, SQLConnector sql){
+		super(gsm, sh, sql);
+		createBackground();
+	}
+
+	@Override
+	public void init() {
+		sh.play();
+	}
+
+	@Override
+	public void update(float factor) {
+        frame++;
+        indexKast++;
+	}
+
+	public void draw(Graphics2D g2) {
+		// Scherm beelt wat kleurrijke rectangles op het scherm.
+		if (frame > 0) {
+			g2.drawImage(background, 0, 0, 1280, 1024, null);
+			createBackground();
+		}
+		if (frame > 160) {
+			// Code die de arcadekast en 'Press Start' toont.
+			int image_x = ((frame / 6) % 6) * 49;
+			g2.drawImage(pressStart.getSubimage(image_x, 0, 49, 26), 640 - 122, 512, 245, 130, null);
+
+			xKast = indexKast / 10;
+			xKast %= 4;
+			g2.drawImage(kast.getSubimage(xKast * 300, 0, 300, 400), 100, 300, 300, 400, null);
+		}
+	}
+
+	@Override
+	public void buttonPressed(ButtonEvent e) {
+
+		switch (e.getButton().getButtonID()) {
+		case 0:
+			gsm.setState(State.MENU_STATE);
+			break;
+		}
+	}
+
+	@Override
+	public void buttonReleased(ButtonEvent e) {
+
+	}
+
+	@Override
+	public void onJoystickMoved(JoystickEvent e) {
+	}
+
+	public void createBackground() {
+		background = Images.initVolatileImage(1280, 1024, Transparency.OPAQUE);
+		Graphics2D g2 = background.createGraphics();
+
+		if (frame > 0) {
+			RenderingHints rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+			g2.setRenderingHints(rh);
+		}
+		if (frame > 20) {
+			g2.setColor(new Color(1, 1, 1, 0.3f));
+			g2.fillRect(0, 0, 1280, 1024);
+		}
+		if (frame > 40) {
+			g2.setColor(new Color(0, 1, 0, 0.7f));
+			g2.fillRect(0, 0, 100, 1024);
+			g2.fillRect(1180, 0, 100, 1024);
+		}
+		if (frame > 60) {
+			g2.setColor(new Color(1, 1, 0, 0.7f));
+			g2.fillRect(100, 0, 100, 1024);
+			g2.fillRect(1080, 0, 100, 1024);
+		}
+		if (frame > 80) {
+			g2.setColor(new Color(1, 0, 0, 0.7f));
+			g2.fillRect(200, 0, 100, 1024);
+			g2.fillRect(980, 0, 100, 1024);
+		}
+		if (frame > 100) {
+			g2.setPaint(gp);
+			g2.fillRect(300, 0, 680, 1024);
+		}
+		if (frame > 120) {
+			g2.setFont(textFont);
+			g2.setColor(Color.WHITE);
+			g2.drawString("©2015 Team Hamtaro", 550, 1012);
+		}
+		if (frame > 140) {
+			g2.setColor(Color.RED);
+			g2.setFont(textFont2);
+			g2.drawString("Color", 385, 212);
+			g2.drawString("Strike", 390, 342);
+			g2.dispose();
+		}
+
+		background.createGraphics();
+	}
+
+}

model/objects/DifficultyButton.java

@@ -0,0 +1,48 @@
+package model.objects;
+
+import image.Images;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Graphics2D;
+import java.awt.Transparency;
+import java.awt.image.VolatileImage;
+
+public class DifficultyButton {
+	
+	private int x = 900;
+	private int y;
+	private String str;
+	private Color color;
+	private VolatileImage button;
+
+	public DifficultyButton(int y, String str, Color color) {
+		this.y = y;
+		this.str = str;
+		this.color = color;
+		generateButton();
+	}
+	
+	public void generateButton(){
+		button = Images.initVolatileImage(305, 80, Transparency.OPAQUE);
+		Graphics2D g2 = button.createGraphics();
+		g2.setColor(Color.WHITE);
+		g2.fillRect(0, 0, 300, 75);
+		g2.setColor(Color.ORANGE);
+		g2.drawRect(0, 0, 300, 75);
+		//g2.drawRect(0-2, 0-2, 304, 79);
+		
+		g2.setColor(color);
+		Font textFont2 = new Font("OCR A Extended", Font.BOLD, 50);
+		g2.setFont(textFont2);
+		
+		g2.drawString(str, 0+5, 0+50);
+		g2.dispose();
+		button.createGraphics();
+	}
+	
+	public void draw(Graphics2D g2) {
+		g2.drawImage(button, x, y, 305, 80, null);
+	}
+	
+}

model/objects/InfoPanel.java

@@ -0,0 +1,119 @@
+package model.objects;
+
+import image.Images;
+
+import java.awt.*;
+import java.awt.geom.Point2D;
+import java.awt.image.VolatileImage;
+
+import model.SongHandler;
+import model.drawObjects.CoinAnimation;
+import model.drawObjects.PointAnimation;
+import model.gameState.PlayState;
+
+public class InfoPanel {
+	
+	private static String totalHighscore = "000000";
+	private int x, y;
+	private VolatileImage infoPanel;
+	private SongHandler sh;
+	private String time;
+
+	private int tempComboMulitplier;
+
+	private CoinAnimation coinAnimation = new CoinAnimation(125, 300);
+
+
+	public InfoPanel(int x, int y, SongHandler sh){
+		this.x = x;
+		this.y = y;
+		this.sh = sh;
+		updateIPanel();
+		generateInfoPanel();
+	}
+	
+	public void updateIPanel() {		
+		totalHighscore  = "" + PlayState.currentScore;
+		
+		long progress = (sh.getProgress() / 1000);
+		String millis = ((progress) % 1000) + "".length() > 3 ? ("" +((progress) % 1000)).substring(0, 2) : "" + ((progress) % 1000);
+		String second = ((progress / 1000) % 60 + "").length() <= 1 ? "0" +((progress / 1000) % 60) : "" + ((progress / 1000) % 60);
+		String minute = ((progress / (1000 * 60)) % 60 + "").length() <= 1 ? "0" +((progress / (1000 * 60)) % 60) : "" + ((progress / (1000 * 60)) % 60);
+		time = minute + ":" + second + ":" + millis;
+		generateInfoPanel();
+	}
+	
+	private void generateInfoPanel(){
+		infoPanel = Images.initVolatileImage(256, 1024, Transparency.OPAQUE);
+		Graphics2D g2 = infoPanel.createGraphics();
+		RenderingHints rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+	    g2.setRenderingHints(rh);	
+	    g2.setColor(Color.BLACK);
+	    
+//	    g2.setColor(Color.GRAY);
+	    GradientPaint gp = new GradientPaint(0, 0, new Color(245,245,245), 256, 1024, Color.WHITE);
+	    g2.setPaint(gp);
+		g2.fillRect(x, y, 256, 1024);
+
+		// Score balk
+		g2.setColor(Color.BLACK);
+		g2.drawRect(x, y, 255, 1023);
+
+		Font scoreFont = new Font("OCR A Extended", Font.BOLD, 30);
+		g2.setFont(scoreFont);
+		g2.setColor(Color.GREEN);
+		g2.fillRect(25, 100, (int)(2 * PlayState.lifePoints), 30);
+
+		// Laatste punten in-/decrease tonen.
+		if (PlayState.sinceScoreChanged < 60 && PlayState.sinceScoreChanged != 0) {
+			g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, (float)(1 - (PlayState.sinceScoreChanged * 0.015))));
+			g2.setColor(Color.RED);
+			g2.drawString("+" + PlayState.lastScoreChange, 185, 40);
+			g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f));
+		}
+
+		g2.setColor(Color.ORANGE);
+		g2.drawString("Score: " + totalHighscore, 25, 75);
+
+		g2.setColor(Color.BLACK);
+		// BALK
+		g2.drawRect(25, 100, 200, 30);
+		g2.drawRect(25, 300, 200, 700);
+
+		g2.drawString(sh.getCurrentSong().getTitle(), 25, 200);
+		g2.drawString(sh.getCurrentSongInstance().getDifficulty(), 25, 230);
+		g2.drawString(sh.getCurrentSong().getAuthor(), 25, 260);
+		g2.drawString(time, 25, 290);
+
+		// Controlen of coin animatie nodig is
+		if (!coinAnimation.areWeDoneYet()) {
+			coinAnimation.draw(g2);
+			// Score pas updaten wanneer coin in zijn laatste draw loop zit
+			if (coinAnimation.isLastLoop())
+				tempComboMulitplier = PlayState.comboMulitplier;
+		} else
+			tempComboMulitplier = PlayState.comboMulitplier;
+
+		g2.drawString(sh.getCurrentSongInstance().getDifficulty(), 25, 230);
+		g2.drawString(sh.getCurrentSong().getAuthor(), 25, 260);
+		g2.drawString(time, 25, 290);
+			
+		g2.setColor(Color.YELLOW);
+		g2.fillRect(25, 1000 - tempComboMulitplier * 35, 200, 35 * tempComboMulitplier);
+		g2.dispose();
+		infoPanel.createGraphics();
+	}
+
+	public void throwACoin() {
+		coinAnimation.start();		// Teller weer op 1 zetten
+	}
+
+	public void draw(Graphics2D g2){
+		g2.drawImage(infoPanel, 0, 0, 256,1024,null);
+	}
+	
+	public static String getTotalHighscore()
+	{
+		return totalHighscore;
+	}
+}

model/objects/MenuButton.java

@@ -0,0 +1,99 @@
+package model.objects;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Graphics2D;
+import java.util.ArrayList;
+
+import main.Window;
+import audio.Song;
+
+public class MenuButton {
+
+	private ArrayList<Color> colors;
+	private int x, y;
+	private int xx,yy;
+	private boolean selected; 
+	private Song song;
+	Color color;
+	
+	public MenuButton(int x, int y, Color color, Song song){
+		this.x = x;
+		this.y = y;
+		this.color = color;
+		setSong(song);
+		
+	}
+	
+	public MenuButton(int x, int y, int xx, int yy, Color color, Song song){
+		this.x = x;
+		this.y = y;
+		this.color = color;
+		this.yy = yy;
+		this.xx = xx;
+		setSong(song);
+	}
+
+	public void draw(Graphics2D g2d){
+
+		
+		if(selected){
+			g2d.setColor(color.darker().darker().darker().darker());
+			g2d.fillRect(x-10, y-10,xx+20,yy+20);
+			g2d.setColor(color.darker().darker());
+			g2d.fillRect(x-5, y-5,xx+10,yy+10);
+			g2d.setColor(color);
+			g2d.fillRect(x,y,xx,yy);
+			g2d.setColor(Color.BLACK);
+			g2d.drawRect(x-10, y-10, xx+20, yy+20);
+			g2d.drawRect(x-5, y-5, xx+10, yy+10);
+			g2d.drawRect(x, y, xx, yy);
+		}
+		else{
+			g2d.setColor(color.darker().darker());
+			g2d.fillRect(x-5, y-5,990,80);
+			g2d.setColor(color);
+			g2d.fillRect(x,y,980,70);
+		}
+
+		//draw text
+		g2d.setColor(Color.BLACK);
+		Font textFont = new Font("OCR A Extended", Font.BOLD,60);
+		g2d.setFont(textFont);
+		if(selected)
+		{
+			g2d.drawString(song.getTitle(),  x+50, y+63);
+			
+			Font textFont2 = new Font("OCR A Extended", Font.PLAIN,30);
+			g2d.setFont(textFont2);
+			g2d.drawString("# Played: " + song.getTimesPlayed(), Window.WIDTH - 450 - Math.min(song.getAuthor().length()*16, 570), y+yy+45);
+			g2d.drawString("Author: " + song.getAuthor(), Window.WIDTH - 200 - Math.min(song.getAuthor().length()*16, 570) , y+yy+45);
+		}
+		else
+			g2d.drawString(song.getTitle(),  x+50, y+57);
+	}
+	
+	
+	public void setSelected(boolean selected) {
+		this.selected = selected;
+	}
+
+	public boolean isSelected(){
+		return selected;
+	}
+	public void setX(int x){
+		this.x = x;
+	}
+
+	public int getX() {
+		return x;
+	}
+
+	public Song getSong() {
+		return song;
+	}
+
+	public void setSong(Song song) {
+		this.song = song;
+	}
+}

model/objects/Path.java

@@ -0,0 +1,34 @@
+package model.objects;
+
+import java.awt.Color;
+import java.awt.geom.Line2D;
+import java.util.ArrayDeque;
+
+import model.drawObjects.Enemy;
+
+public class Path extends Line2D.Double {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -4209367336660836698L;
+	private ArrayDeque<Enemy> enemysInPath;
+	
+	public Path(double x1, double y1, double x2, double y2) {
+		super(x1,y1,x2,y2);
+		enemysInPath = new ArrayDeque<Enemy>();
+	}
+
+	public ArrayDeque<Enemy> getEnemysInPath() {
+		return enemysInPath;
+	}
+
+	public void setEnemysInPath(ArrayDeque<Enemy> enemysInPath) {
+		this.enemysInPath = enemysInPath;
+	}	
+	
+	public void addEnemy(Color c, int pathID, int length)
+	{
+		enemysInPath.addLast(new Enemy(pathID, length, c,this));
+	}
+}

model/objects/PlayArea.java

@@ -0,0 +1,177 @@
+package model.objects;
+
+import image.Images;
+
+import java.awt.*;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Line2D;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.VolatileImage;
+import java.util.ArrayList;
+import java.util.List;
+
+import model.drawObjects.Enemy;
+import model.drawObjects.PointAnimation;
+import model.gameState.PlayState;
+
+public class PlayArea {
+
+	public  List<Path> paths;
+	private Polygon innerHitAreaBorder,outsideHitAreaBorder;	
+	private GeneralPath hitArea;
+	private Color hitAreaColor,pathColor = null;
+	private VolatileImage background;
+	private boolean hit = false;
+	private int count = 0,
+				maxCount = 100,
+				pathID = -1,
+				oldPathId = pathID;
+
+	private PointAnimation pointAnimation = new PointAnimation();
+	private Stroke stroke = new BasicStroke(5);
+	
+	private Rectangle2D backgroundPlay = new Rectangle2D.Double(256, 0, 1024, 1024);
+
+	public PlayArea(double xToRight,double heightOfGameScreen,double widthOfGameScreen, int sizeOctagon) {
+		super();
+		paths = new ArrayList<>();
+		setHitAreaColor(Color.WHITE);
+		//make the polygons
+		int amountOfAngles = 8;
+		double middlePointX = widthOfGameScreen/2+xToRight;
+		double middlePointY = heightOfGameScreen/2;
+		
+		//the inner octagon
+		innerHitAreaBorder = new Polygon();		
+		for(int i = 0; i < amountOfAngles; i++){
+			innerHitAreaBorder.addPoint((int)(middlePointX+sizeOctagon*Math.cos(i*Math.PI/(amountOfAngles/2))), 
+							 (int)(middlePointY+sizeOctagon*Math.sin(i*Math.PI/(amountOfAngles/2))));			
+		}
+		
+		//the outside octagon
+		outsideHitAreaBorder = new Polygon();
+		sizeOctagon += PlayState.sizeOfEnemy;		
+		for(int i = 0; i < amountOfAngles; i++){
+			outsideHitAreaBorder.addPoint((int)(middlePointX+sizeOctagon*Math.cos(i*Math.PI/(amountOfAngles/2))), 
+							 (int)(middlePointY+sizeOctagon*Math.sin(i*Math.PI/(amountOfAngles/2))));
+		}
+		
+		//hitArea the area where you must click the enemy
+		hitArea = new GeneralPath(GeneralPath.WIND_EVEN_ODD);
+		
+		hitArea.moveTo(innerHitAreaBorder.xpoints[0], innerHitAreaBorder.ypoints[0]);
+		for(int i = 1; i < innerHitAreaBorder.npoints;i++)
+			hitArea.lineTo(innerHitAreaBorder.xpoints[i], innerHitAreaBorder.ypoints[i]);
+		
+		hitArea.moveTo(outsideHitAreaBorder.xpoints[0], outsideHitAreaBorder.ypoints[0]);
+		for(int i = 1; i < innerHitAreaBorder.npoints;i++)
+			hitArea.lineTo(outsideHitAreaBorder.xpoints[i], outsideHitAreaBorder.ypoints[i]);
+		
+		//make the paths
+		double angleX,angleY;
+		angleX = (Math.cos(Math.toRadians(45)))*Enemy.distanceToOctagon;
+		angleY = (Math.sin(Math.toRadians(45)))*Enemy.distanceToOctagon;
+		
+		paths.add(new Path(outsideHitAreaBorder.xpoints[6],outsideHitAreaBorder.ypoints[6]-Enemy.distanceToOctagon,
+							outsideHitAreaBorder.xpoints[6],outsideHitAreaBorder.ypoints[6]));//top
+		paths.add(new Path(outsideHitAreaBorder.xpoints[7] + angleX,outsideHitAreaBorder.ypoints[7] - angleY,
+							outsideHitAreaBorder.xpoints[7],outsideHitAreaBorder.ypoints[7]));//right 	-top
+		paths.add(new Path(outsideHitAreaBorder.xpoints[0]+Enemy.distanceToOctagon,outsideHitAreaBorder.ypoints[0],
+							outsideHitAreaBorder.xpoints[0],outsideHitAreaBorder.ypoints[0]));//right
+		paths.add(new Path(outsideHitAreaBorder.xpoints[1]+angleX,outsideHitAreaBorder.ypoints[1]+angleY,
+							outsideHitAreaBorder.xpoints[1],outsideHitAreaBorder.ypoints[1]));//right	-down
+		paths.add(new Path(outsideHitAreaBorder.xpoints[2],outsideHitAreaBorder.ypoints[2]+Enemy.distanceToOctagon,
+							outsideHitAreaBorder.xpoints[2],outsideHitAreaBorder.ypoints[2]));//down
+		paths.add(new Path(outsideHitAreaBorder.xpoints[3] - angleX,outsideHitAreaBorder.ypoints[3] + angleY,
+							outsideHitAreaBorder.xpoints[3],outsideHitAreaBorder.ypoints[3]));//left		-down
+		paths.add(new Path(outsideHitAreaBorder.xpoints[4] - Enemy.distanceToOctagon,outsideHitAreaBorder.ypoints[4],
+							outsideHitAreaBorder.xpoints[4],outsideHitAreaBorder.ypoints[4]));//left
+		paths.add(new Path(outsideHitAreaBorder.xpoints[5] - angleX,outsideHitAreaBorder.ypoints[5] - angleY,
+							outsideHitAreaBorder.xpoints[5],outsideHitAreaBorder.ypoints[5]));//left	 	-top
+
+		generateBackground();
+	}	
+	
+	public void draw(Graphics2D g2){		
+		g2.drawImage(background, 0, 0, 1280, 1024, null);
+		if(hit){
+			g2.setColor(hitAreaColor);
+			g2.fill(hitArea);
+
+			if(count == maxCount)
+				hit = false;
+		}		
+		if (oldPathId != pathID){
+			generateBackground();
+			oldPathId = pathID;
+		}
+
+		Font scoreFont = new Font("OCR A Extended", Font.BOLD, 40);
+		g2.setFont(scoreFont);
+		pointAnimation.draw(g2);
+	}
+	
+	public Line2D getLine(int index){
+		if(index < 0)
+			index = 0;
+		else if(index >= 8)
+			index = 7;
+
+		return paths.get(index);
+	}
+
+	public void setHitAreaColor(Color color) {	
+		hitAreaColor = color;	
+		count = 0;
+	}
+	
+	public void hit(){
+		hit = true;
+	}	
+	
+	public void count(){
+		if(hit){
+			count += 3;
+			if(count > maxCount)
+				count = maxCount;
+			hitAreaColor = new Color(hitAreaColor.getRed(),hitAreaColor.getGreen(),hitAreaColor.getBlue(),255-(255*count)/maxCount);	
+		}
+	}
+	
+	public void pathPainted(int pathID,Color pathColor){
+		this.pathID = pathID;
+		this.pathColor = pathColor;
+	}
+	
+	public void generateBackground(){
+		//drawing into buffer
+		background = Images.initVolatileImage(1280,1024, Transparency.BITMASK);
+		Graphics2D g2 = background.createGraphics();		
+		RenderingHints rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+	    g2.setRenderingHints(rh);
+ 
+		Line2D current;	
+		g2.setColor(Color.BLACK);
+		g2.setStroke(stroke);
+
+		paths.forEach(path -> {
+			g2.draw(path);
+		});
+		g2.draw(innerHitAreaBorder);
+		g2.draw(outsideHitAreaBorder);
+		
+	    if(pathID >= 0 && pathColor != null ){
+		    g2.setColor(new Color(pathColor.getRed(), pathColor.getGreen(), pathColor.getBlue(),50));
+			g2.fill(backgroundPlay);
+			g2.setStroke(stroke);
+			g2.setColor(pathColor);
+			g2.draw(paths.get(pathID));
+	    }
+	    
+		g2.dispose();
+		background.createGraphics();
+	}
+
+	public void enemyDied(Point2D.Double p) { pointAnimation.enemyDied(p); }
+}

model/objects/highscore/Highscore.java

@@ -0,0 +1,34 @@
+package model.objects.highscore;
+
+import java.util.Date;
+
+import audio.SongInstance;
+
+public class Highscore {
+	private SongInstance si;
+	private String name;
+	private int score;
+	private long time;
+	
+	public Highscore(SongInstance si, String name, int score, long time) {
+		this.si = si;
+		this.name = name;
+		this.score = score;
+		this.time = time;
+	}
+
+	public int getScore() {
+		return score;
+	}
+	
+	public long getTime(){
+		return time;
+	}
+	public Date getDate(){
+		return new Date(getTime());
+	}
+	
+	public String getName(){
+		return name;
+	}
+}

model/objects/highscore/HighscoreLetter.java

@@ -0,0 +1,39 @@
+package model.objects.highscore;
+
+import java.awt.Graphics2D;
+
+public class HighscoreLetter {
+	
+	public static int charLength = 46;
+	private char[] letters;
+	private int x,y,index = 0;
+		
+	public HighscoreLetter(char[] letters, int x, int y) {
+		super();
+		this.letters = letters;
+		this.x = x;
+		this.y = y;
+	}
+	
+	public void draw(Graphics2D g2){
+		charLength = g2.getFontMetrics().stringWidth(letters[index]+"");
+		g2.drawString(letters[index]+"", x, y);
+		g2.drawLine(x, y, x+charLength, y);
+	}
+	
+	public void up(){
+		index++;
+		index %= letters.length;
+	}
+	
+	public void down(){
+		index--;
+		if(index < 0){
+			index = letters.length-1;
+		}
+	}
+	
+	public String getCurrentString(){
+		return letters[index]+"";
+	}
+}

model/objects/highscore/HighscoreName.java

@@ -0,0 +1,65 @@
+package model.objects.highscore;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Graphics2D;
+
+public class HighscoreName {
+
+	private final char[] characters = " abcdefghijklmnopqrstuvwxyz0123456789+-?!".toUpperCase().toCharArray();
+	private int spacing = 10;
+	private HighscoreLetter[] letters;
+	private Font font;
+	private int index = 0;
+	
+	public HighscoreName(int x, int y,int nameLength,Font font) {
+		this.font = font;
+		letters = new HighscoreLetter[nameLength];
+		int marge = (int) (Math.floor(nameLength/2)-1)*spacing;
+		x -= (double)HighscoreLetter.charLength*(nameLength/2.0) + marge;
+		
+		for(int i = 0; i < letters.length; i++){			
+				letters[i] = new HighscoreLetter(characters, x+(HighscoreLetter.charLength*i)+(spacing*i), y);		
+		}
+	}
+	
+	public void drawName(Graphics2D g2){
+		g2.setFont(font);
+		for(int i = 0; i < letters.length; i++){
+			if(i == index){
+				g2.setColor(Color.RED);
+			}else{
+				g2.setColor(Color.BLACK);
+			}
+			letters[i].draw(g2);			
+		}
+	}	
+	
+	public void left(){
+		index--;
+		if(index < 0){
+			index = letters.length-1;
+		}
+	}
+	
+	public void right(){
+		index++;
+		index %= letters.length;
+	}
+	
+	public void up(){
+		letters[index].up();
+	}
+	
+	public void down(){
+		letters[index].down();
+	}
+	
+	public String getName(){
+		String name = "";
+		for(int i = 0; i < letters.length; i++){
+			name += letters[i].getCurrentString();
+		}
+		return name;
+	}
+}

view/GameView.java

@@ -0,0 +1,40 @@
+package view;
+
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.Toolkit;
+
+import javax.swing.JPanel;
+
+import control.GameStateManager;
+
+public class GameView extends JPanel {
+
+	private static final long serialVersionUID = 1939480784205689618L;
+
+	private GameStateManager gsm;
+
+	// Font fpsfont = new Font("OCR A Extended", Font.BOLD, 60);
+
+	public GameView(GameStateManager gsm) {
+		this.gsm = gsm;
+		this.setPreferredSize(new Dimension(1280, 1024));
+	}
+
+	@Override
+	public void paintComponent(Graphics g) {
+		super.paintComponent(g);
+
+		Graphics2D g2d = (Graphics2D) g;
+		RenderingHints rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+		g2d.setRenderingHints(rh);
+		gsm.currentState.draw(g2d);
+
+		//g2d.setColor(Color.RED);
+		//g2d.setFont(fpsfont);
+		//g2d.drawString(gsm.fps + "fps", 1000, 40);
+		Toolkit.getDefaultToolkit().sync();
+	}
+}