Fix for empty object array

# Conflicts:
#	model/objects/DifficultyButton.java

README.md

@@ -1,2 +1,4 @@
-# Arcade
-Arcade game for the fourth term at Avans Hogeschool Breda.
+JSON Parser
+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,78 @@
+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(new Runnable() {
+			@Override
+			public void run() {
+				if(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();
+			}
+			if(thread != null && thread.isAlive())
+				thread.stop();
+		}
+	}
+	
+
+	
+	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,179 @@
+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;
+	}
+	
+	public int getHighestScore()
+	{
+		int highest = 0;
+		for(SongInstance s : songs)
+		{
+			if(s.getHighestScore() > highest)
+				highest = s.getHighestScore();
+		}
+		return highest;
+	}
+}

audio/SongInstance.java

@@ -0,0 +1,113 @@
+package audio;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SongInstance {
+
+	private String difficulty;
+	private int timesPlayed;
+	private int highestScore;
+	
+	private List<ObjectInstance> objects;
+	private List<ButtonInstance> buttons;
+	
+	public SongInstance(String difficulty)
+	{
+		this.difficulty = difficulty;
+		this.timesPlayed = 0;
+		this.highestScore = 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()
+	{
+		if(objects.size() == 0)
+			return 0;
+		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 int getHighestScore() {
+		return highestScore;
+	}
+
+	public void setHighestScore(int highestScore) {
+		this.highestScore = highestScore;
+	}
+	
+	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/SortAUTHOR.java

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

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());
+	}
+
+}

audio/sorting/SortSCORE.java

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

control/GameControl.java

@@ -0,0 +1,58 @@
+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();
+	GameModel model;
+	GameView view;
+	GameStateManager gsm;
+	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);
+		update.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,100 @@
+package control;
+
+import java.awt.Color;
+import java.util.ArrayList;
+import java.util.List;
+
+import model.gameState.EndState;
+import model.gameState.GameState;
+import model.gameState.HelpState;
+import model.gameState.MenuState;
+import model.gameState.PlayState;
+import model.gameState.PreGameState;
+import model.gameState.TitleState;
+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 int index = 0;
+	public int fps;
+	private float timeOfNoAction = 0,maxTimeToHaveNoAction = 45000;
+	
+	public enum State {
+		TITLE_STATE,
+		MENU_STATE,
+		HELP_STATE,
+		PLAY_STATE,
+		END_STATE,
+		PRE_GAME_STATE
+	}
+	
+	public GameStateManager(SongHandler sh, SQLConnector sql){
+		gamestates = new ArrayList<GameState>();
+		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 EndState(this, sh, sql));
+		gamestates.add(new PreGameState(this,sh, sql));
+		setState(State.TITLE_STATE);
+	}
+	
+	public void setState(State st)	{
+		if (st.ordinal() > 0 && ( !(currentState instanceof TitleState) || !(currentState instanceof EndState) ))
+			currentState.stopAudio();
+
+		currentState = gamestates.get(st.ordinal());
+		init();
+	}
+
+	public void next() {
+		index++;
+		index %= gamestates.size();
+		currentState = gamestates.get(index);
+		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,195 @@
+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 long fistpressed;
+
+	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)
+	{
+		try {
+			DatagramPacket sendPacket = new DatagramPacket(str.getBytes(), str.length(), InetAddress.getByName(host), 1113);
+			udp.send(sendPacket);
+		} catch (UnknownHostException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}  
+	}
+	
+	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.REPEAT)
+				{
+					if(JoystickHandler.j.getPos() != Position.UP)
+					{
+						fistpressed = System.currentTimeMillis();	
+						JoystickHandler.j.setPosition(Position.UP);
+						jth.onJoystickMoved(JoystickHandler.j);
+					}
+					if((fistpressed + 500) < System.currentTimeMillis()){
+						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.REPEAT)
+				{
+					if(JoystickHandler.j.getPos() != Position.DOWN){
+						fistpressed = System.currentTimeMillis();
+						JoystickHandler.j.setPosition(Position.DOWN);
+						jth.onJoystickMoved(JoystickHandler.j);
+					}
+					if((fistpressed + 500) < System.currentTimeMillis()){
+						JoystickHandler.j.setPosition(Position.DOWN);
+						jth.onJoystickMoved(JoystickHandler.j);
+					}
+				}
+			}else {
+				if(JoystickHandler.j.getPos() != Position.CENTER){
+					fistpressed = 0;
+					JoystickHandler.j.setPosition(Position.CENTER);
+					jth.onJoystickMoved(JoystickHandler.j);
+				}
+			}
+		}
+			
+	}
+}

control/SongHandler.java

@@ -0,0 +1,131 @@
+package control;
+
+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.SortPLAYED;
+import data.io.SQLConnector;
+
+public class SongHandler {
+	
+	private List<Song> songs;
+	
+	private Song currentSong;
+	private SongInstance currentSongInstance;
+	private int currentIndex;
+	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_ARCADE)
+			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;
+	}
+	public boolean isPlaying(){
+		return getProgress() > 0 ? true : false;
+	}
+	
+	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);
+	}
+	
+	
+}

control/button/Button.java

@@ -0,0 +1,52 @@
+package control.button;
+
+import java.awt.Color;
+
+import main.Window;
+import control.NetworkHandler;
+
+public class Button {
+
+	Color color;
+	int ledID;
+	int buttonID;
+	NetworkHandler ntw;
+	public int pressed;
+	
+	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_ARCADE)
+		{
+			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,148 @@
+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 model.GameModel;
+import control.NetworkHandler;
+
+public class ButtonHandler implements KeyListener{
+
+	List<ButtonListener> listeners;
+	static List<Button> buttons;
+	NetworkHandler ntw;
+	
+	public ButtonHandler()
+	{
+		this.ntw = null;
+		
+		listeners = new ArrayList<ButtonListener>();
+		buttons = new ArrayList<Button>();
+		
+	}
+
+	public void addButtonListener(ButtonListener toAdd) {
+	    listeners.add(toAdd);
+	}
+	
+	public void buttonPress(Button b) {
+		if(Window.ON_ARCADE)
+		{
+			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_ARCADE)
+		{
+			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_ARCADE)
+				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, -1, ntw));
+		buttons.add(new Button(5, 3, ntw));
+		buttons.add(new Button(6, 4, ntw));
+		
+		for (int i = 1; i < buttons.size(); i++) {
+			buttons.get(i).setColor(GameModel.colors[i - 1]);
+		}
+	}
+}

control/button/ButtonListener.java

@@ -0,0 +1,6 @@
+package control.button;
+
+public interface ButtonListener {
+	public void buttonPressed(ButtonEvent e);
+	public 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,286 @@
+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 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 Highscore getHighscore(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 LIMIT 1";
+    	//System.out.println(query);
+    	Statement st = executeResultQuery(query);
+    	ResultSet result = null;
+		try {
+			result = st.getResultSet();
+		} catch (SQLException e1) {
+			e1.printStackTrace();
+		}
+		
+		Highscore hsc = null;
+		
+    	try {
+    		if(result.next() && result != null)
+    			hsc = new Highscore(si, result.getString("username"), result.getInt("score"), result.getDate("date").getTime());
+    		
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+    	
+		return hsc;
+    }
+    
+    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<Highscore>();
+		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<Highscore>();
+		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) {
+				e.printStackTrace();
+			}
+    	
+    		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())
+	    				{
+	    					//System.err.println("SongInstance Already Exists ");
+	    				}
+	    				else
+	    				{
+	    					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();
+					}
+	    			
+	    			Statement st4 = executeResultQuery("SELECT MAX(`score`) as score FROM `highscore` WHERE `songinstance`=(SELECT id FROM songinstance WHERE song=" + id + " AND difficulty='" + si.getDifficulty() + "')");
+	    			try {
+						ResultSet rs4 = st4.getResultSet();
+						if(rs4.next())
+						{
+							int i = rs4.getInt(1);
+			    			si.setHighestScore(i);
+						}
+					} catch (SQLException e) {
+						e.printStackTrace();
+					}
+    			}
+    		}
+    		else
+    		{
+    			//System.err.println("Insert Failed");
+    		}
+ 
+    	}
+    }
+    
+    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,88 @@
+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,111 @@
+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<BufferedImage>();
+
+	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/screenshot.png"))));
+		   	images.add(toCompatibleImage(ImageIO.read(Main.class.getResource("/image/help.png"))));
+		   	images.add(toCompatibleImage(ImageIO.read(Main.class.getResource("/image/youwon.png"))));
+		} 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, screenshot, help,youwon
+	}
+
+	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,89 @@
+package main;
+
+
+import java.awt.Cursor;
+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 view.GameView;
+import control.GameControl;
+import control.GameStateManager;
+import control.NetworkHandler;
+import control.SongHandler;
+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_ARCADE;
+	
+	public final static int WIDTH = 1280;
+	public final static int HEIGHT = 1024;
+	
+	public Window(boolean ON_ARCADE)
+	{
+		//Create window
+		super("Arcade");
+		setSize(WIDTH, HEIGHT);
+		
+		//Create Events
+		Window.ON_ARCADE = ON_ARCADE;
+		if(ON_ARCADE){ //Only on the arcade machine
+			//Remove cursor
+			setUndecorated(true);
+			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,118 @@
+package model;
+
+import java.awt.Color;
+
+import main.Window;
+import control.GameStateManager;
+import control.NetworkHandler;
+import control.SongHandler;
+
+public class GameModel {
+
+	public static Color[] colors = { Color.GREEN, Color.YELLOW, Color.RED, Color.MAGENTA, Color.CYAN, Color.BLUE };
+	private static String[] ledStripModes = {"full", "half", "quarter", "random"};
+	private GameStateManager gsm;
+	private NetworkHandler ntw;
+	private int count = 0;
+
+	public GameModel(SongHandler sh, GameStateManager gsm, NetworkHandler ntw) {
+		this.gsm = gsm;
+		this.ntw = ntw;
+	}
+
+	public void update(float factor) {
+		gsm.update(factor);
+		if (Window.ON_ARCADE)
+			updateLedStrip(factor);
+	}
+	
+	private void updateLedStrip(float factor)
+	{
+		
+		count += factor;
+		if(count > 400)
+		{
+			String mode = ledStripModes[(int) (Math.random() * (ledStripModes.length - 1) + 1)];
+			
+			switch(mode)
+			{
+			default:
+			case "full":
+				
+				Color c = colors[(int) (Math.random() * (colors.length - 1) + 1)];
+				
+				for (int i = 6; i < 46; i++) { 
+					ntw.setLed(i, c.getRed(), c.getGreen(), c.getBlue());
+				}
+				
+				ntw.show();
+				
+				break;
+				
+			case "half":
+				
+				Color c1 = colors[(int) (Math.random() * (colors.length - 1) + 1)];
+				Color c2 = colors[(int) (Math.random() * (colors.length - 1) + 1)];
+				while(c1==c2)	
+					c2 = colors[(int) (Math.random() * (colors.length - 1) + 1)];
+				
+				for (int i = 6; i < 26; i++) {
+					ntw.setLed(i, c1.getRed(), c1.getGreen(), c1.getBlue());
+				}
+				for (int i = 27; i < 46; i++) {
+					ntw.setLed(i, c2.getRed(), c2.getGreen(), c2.getBlue());
+				}
+				
+				ntw.show();
+				
+				break;
+				
+			case "quarter":
+
+				Color c3 = colors[(int) (Math.random() * (colors.length - 1) + 1)];
+				Color c4 = colors[(int) (Math.random() * (colors.length - 1) + 1)];
+				Color c5 = colors[(int) (Math.random() * (colors.length - 1) + 1)];
+				Color c6 = colors[(int) (Math.random() * (colors.length - 1) + 1)];
+				
+				while(c3==c4)	
+					c4 = colors[(int) (Math.random() * (colors.length - 1) + 1)];
+				while(c4==c5)	
+					c5 = colors[(int) (Math.random() * (colors.length - 1) + 1)];
+				while(c5==c6)	
+					c6 = colors[(int) (Math.random() * (colors.length - 1) + 1)];
+				
+				for (int i = 6; i < 16; i++) {
+					ntw.setLed(i, c3.getRed(), c3.getGreen(), c3.getBlue());
+				}
+				for (int i = 17; i < 26; i++) {
+					ntw.setLed(i, c4.getRed(), c4.getGreen(), c4.getBlue());
+				}
+				for (int i = 27; i < 36; i++) {
+					ntw.setLed(i, c5.getRed(), c5.getGreen(), c5.getBlue());
+				}
+				for (int i = 37; i <46; i++) {
+					ntw.setLed(i, c6.getRed(), c6.getGreen(), c6.getBlue());
+				}
+				
+				ntw.show();
+				
+				break;
+				
+			case "random":
+				
+				Color c7;
+				
+				for (int i = 6; i < 46; i++) {
+					c7 = colors[(int) (Math.random() * (colors.length - 1) + 1)];
+					ntw.setLed(i, c7.getRed(), c7.getGreen(), c7.getBlue());
+				}
+				
+				ntw.show();
+				
+				break;
+			}
+			
+			count = 0;
+		}
+	}
+}

model/drawObjects/DrawObject.java

@@ -0,0 +1,27 @@
+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,74 @@
+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/gameState/EndState.java

@@ -0,0 +1,195 @@
+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.objects.InfoPanel;
+import model.objects.highscore.HighscoreName;
+
+import com.google.zxing.WriterException;
+
+import control.GameStateManager;
+import control.SongHandler;
+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 EndState extends GameState {
+
+    BufferedImage end = null;
+    VolatileImage background;
+	Font textFont = new Font("OCR A Extended", Font.BOLD, 70);
+	HighscoreName hsn;
+	int image_x = 0;	
+	private boolean uploaded;
+	private BufferedImage QRimage;
+	
+	boolean timeOut = false;
+	float timeOutCounter = 0;
+	
+    int frame;
+
+	public EndState(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]);
+		
+		JoystickHandler.REPEAT = true;
+		uploaded = false;
+		timeOut = true;
+		timeOutCounter = 0;
+
+		if(PlayState.won()){
+			end = Images.getImage(Images.ImageType.youwon);
+		}else{
+			end = Images.getImage(Images.ImageType.gameover);
+		}
+	}
+
+	@Override
+	public void update(float factor) {
+		if(timeOut)
+		{
+			timeOutCounter += factor;
+			
+			if(timeOutCounter > 800)
+			{
+				timeOut = false;
+			}
+		}
+		
+		
+		image_x = ((frame / 5) % 5) * 40;
+        frame++;
+	}
+
+	@Override
+	public void draw(Graphics2D g2) {
+		g2.drawImage(background, 0, 0, 1280, 1024, null);
+		
+		if(end != null){
+			g2.drawImage(end.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) {
+		if(!timeOut)
+		{
+			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;
+			}
+		}
+	}
+	
+	@Override
+	public void buttonReleased(ButtonEvent e) {}
+	
+	@Override
+	public void onJoystickMoved(JoystickEvent e) {
+		if(!timeOut)
+		{
+			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,30 @@
+package model.gameState;
+
+import java.awt.Graphics2D;
+
+import control.GameStateManager;
+import control.SongHandler;
+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,93 @@
+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 control.GameStateManager;
+import control.SongHandler;
+import control.GameStateManager.State;
+import control.button.ButtonEvent;
+import control.button.ButtonHandler;
+import control.joystick.JoystickEvent;
+import data.io.SQLConnector;
+
+public class HelpState extends GameState {
+
+    BufferedImage help = Images.getImage(ImageType.help);
+    VolatileImage background;
+	Font textFontSmall = new Font("OCR A Extended", Font.BOLD, 15);
+
+	
+    int index = 0;
+    int frame;
+
+    
+	public HelpState(GameStateManager gsm, SongHandler sh, SQLConnector sql){
+		super(gsm, sh, sql);
+		createBackground();
+	}
+
+	@Override
+	public void init() {
+		ButtonHandler.getButton(2).setColor(GameModel.colors[2]);
+		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,533 @@
+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.objects.DifficultyButton;
+import model.objects.MenuButton;
+import model.objects.highscore.Highscore;
+import audio.Song;
+import audio.SongInstance;
+import audio.sorting.SortALPHA;
+import audio.sorting.SortAUTHOR;
+import audio.sorting.SortPLAYED;
+import audio.sorting.SortSCORE;
+import control.GameStateManager;
+import control.SongHandler;
+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;
+	SQLConnector sql;
+
+	private int animationcounter;
+	private boolean subscreen, startanimation;
+	private VolatileImage mainScreenBackground, subScreenBackground, subScreenForeground;
+	
+	int yPosDiffButton = 900;
+	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);
+	int index = 0;
+	
+	
+	
+	int kleurButton1 = 0;
+	int kleurButton2 = 1;
+	int kleurButton3 = 2;
+	int kleurButton4 = 3;
+	int kleurButton5 = 4;
+	
+	
+	
+	public MenuState(GameStateManager gsm, SongHandler sh, SQLConnector sql) {	
+		super(gsm, sh, sql);
+		buttons = new ArrayList<MenuButton>();
+		buttons2 = new ArrayList<DifficultyButton>();
+		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(2).setColor(GameModel.colors[3]);
+			
+			ButtonHandler.getButton(3).setColor(GameModel.colors[1]);
+			ButtonHandler.getButton(4).setColor(GameModel.colors[2]);
+			ButtonHandler.getButton(5).setColor(GameModel.colors[4]);
+			ButtonHandler.getButton(6).setColor(GameModel.colors[5]);
+			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(300,260,GameModel.colors[kleurButton1],selectedToSong(selected-2)));
+		buttons.add(new MenuButton(300,380,GameModel.colors[kleurButton2],selectedToSong(selected-1)));
+		buttons.add(new MenuButton(260,520,1020,80,GameModel.colors[kleurButton3],selectedToSong(selected)));
+		buttons.add(new MenuButton(300,680,GameModel.colors[kleurButton4],selectedToSong(selected+1)));
+		buttons.add(new MenuButton(300,800,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.PRE_GAME_STATE);
+			}
+		}else{										//Screen for selecting song
+			if(e.getButton().getButtonID() == 1){
+				subscreen = true;
+				gsm.init();
+				generateSubScreenForeground();
+			}else if(e.getButton().getButtonID() == 2){
+				gsm.setState(control.GameStateManager.State.HELP_STATE);
+			}
+			else
+			{
+				if(e.getButton().getButtonID() == 3){
+					sh.sort(new SortALPHA());
+				}else if(e.getButton().getButtonID() == 4){
+					sh.sort(new SortAUTHOR());	
+				}else if(e.getButton().getButtonID() == 5){
+					sh.sort(new SortPLAYED());	
+				}else if(e.getButton().getButtonID() == 6){
+					sh.sort(new SortSCORE());	
+				}
+				
+				selected = 0;
+				sh.set(songs.indexOf(selectedToSong(selected)));
+				sh.play();	
+			}
+		}
+		
+		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( (sh.getCurrentSong().getSongs().size()-1) - 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--;
+				kleurButton1--;
+				if(kleurButton1 < 0){
+					kleurButton1 = 5;
+				}
+				
+				kleurButton2--;
+				if(kleurButton2 < 0){
+					kleurButton2 = 5;
+				}
+				
+				kleurButton3--;
+				if(kleurButton3 < 0){
+					kleurButton3 = 5;
+				}
+					
+				kleurButton4--;
+				if(kleurButton4 < 0){
+					kleurButton4 = 5;
+				}
+				
+				kleurButton5--;
+				if(kleurButton5 < 0){
+					kleurButton5 = 5;
+				}
+				
+
+				
+			}
+			
+			else if(e.getJoystick().getPos() == 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, 780, 30, 30);
+		g2.drawString("Play", 55, 800);
+
+		//help
+		g2.setColor(GameModel.colors[3]);
+		g2.fillOval(20, 820, 30, 30);
+		g2.drawString("Help", 55, 840);
+
+		//letters
+		g2.setColor(GameModel.colors[1]);
+		g2.fillOval(20, 860, 30, 30);
+		g2.drawString("A-Z", 55, 880);
+		
+		//most played
+		g2.setColor(GameModel.colors[2]);
+		g2.fillOval(20, 900, 30, 30);
+		g2.drawString("Author", 55, 920);		
+		
+		//most played
+		g2.setColor(GameModel.colors[4]);
+		g2.fillOval(20, 940, 30, 30);
+		g2.drawString("Most Played", 55, 960);		
+		
+		//most played
+		g2.setColor(GameModel.colors[5]);
+		g2.fillOval(20, 980, 30, 30);
+		g2.drawString("Highest Score", 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 = 7;
+		
+		List<Highscore> highscores = sql.getHighscoresToday(selectedToSong(selected), sh.getCurrentSong().getSongs().get((sh.getCurrentSong().getSongs().size() - 1) - difSelect));
+		if(highscores.isEmpty())
+		{
+			highscores = sql.getHighscores(selectedToSong(selected), sh.getCurrentSong().getSongs().get((sh.getCurrentSong().getSongs().size() - 1) - difSelect));
+			if(highscores.isEmpty())
+			{
+				highscoresFound = false;
+			}
+			else
+				g2.drawString("All Time Highscores", 30, 235);
+		}
+		else
+			g2.drawString("Daily Highscore", 30, 235);
+ 			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(" " + (i+1) + "#  " + hi.getName() + " - " + hi.getScore(), 30, 290 + i*80);
+			}
+		}
+		else
+		{
+			g2.drawString("No Highscores found", 30, 400);
+		}
+		
+		
+		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 void nextScreen(){
+		if(buttons.get(0).getX() > -700){
+			for(MenuButton b:buttons){
+				b.setX(b.getX()-100);
+			}
+		}
+	}
+	
+	public void previousScreen(){
+		if(buttons.get(0).getX() < 300){
+			for(MenuButton b:buttons){
+				b.setX(b.getX()+100);
+			}
+		}
+	}
+	*/
+	
+	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,287 @@
+package model.gameState;
+
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Stroke;
+import java.awt.geom.Rectangle2D;
+import java.util.Iterator;
+
+import model.drawObjects.Enemy;
+import model.drawObjects.Player;
+import model.objects.InfoPanel;
+import model.objects.Path;
+import model.objects.PlayArea;
+import model.objects.highscore.Highscore;
+import audio.ButtonInstance;
+import audio.ObjectInstance;
+import control.GameStateManager;
+import control.SongHandler;
+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 comboScore = 0;
+	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 static boolean won = false;
+
+	private long oldProgress = 0;
+
+	public PlayState(GameStateManager gsm, SongHandler sh, SQLConnector sql) {
+		super(gsm, sh, sql);
+		infoPanel = new InfoPanel(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;
+		won = false;
+		lifePoints = 100;
+		currentScore = 0;
+		comboScore = 0;
+		oldProgress = 0;
+		
+		enemies_hit = 0;
+		enemies_missed = 0;
+		buttons_pressed = 0;
+		joystick_moved = 0;
+		Highscore h = sql.getHighscore(sh.getCurrentSong(), sh.getCurrentSongInstance());
+		if(h != null)
+			infoPanel.init(h.getScore());
+		
+		for(Path p : area.paths)
+		{
+			p.getEnemysInPath().clear();
+		}
+		
+		ButtonHandler.getButton(1).setColor(sh.getCurrentSongInstance().getButtons().get(0).getColor());
+		
+		sh.play();
+		init = false;
+	}
+
+	@Override
+	public void update(float factor) {
+		if(init)
+			return;
+		
+		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*2500){
+			won = true;
+			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();
+					lifePoints -= 6;
+					comboScore /= 2;
+					enemies_missed++;
+				}
+				if(closedEnemy == null){
+					closedEnemy = e;
+				}
+				if((Enemy.distanceToOctagon-closedEnemy.getDistanceFromStart()) > (Enemy.distanceToOctagon-e.getDistanceFromStart())){
+						closedEnemy = e;
+				}
+				e.update(factor);
+			}
+		}
+
+		lifePoints -= 0.003 * factor;
+		
+		infoPanel.updateIPanel();
+		
+		if(lifePoints <= 0)
+		{
+			endGame();
+		}
+		if(comboScore >= 100)
+		{
+			comboScore = 0;
+			currentScore += 500;
+		}
+
+		
+		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();
+		}
+		
+		if(currentScore == 0)
+			gsm.setState(State.MENU_STATE);
+		else
+			gsm.setState(State.END_STATE);
+	}
+
+	@Override
+	public void draw(Graphics2D g2) {
+		try {
+			infoPanel.draw(g2);
+			g2.setClip(borderRect);
+			area.draw(g2);
+
+			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) {
+		}
+	}
+
+	@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())) {
+					currentScore += enemy.getDistanceFromStart() - Enemy.distanceToOctagon;
+					comboScore += 5;
+					lifePoints = Math.min(lifePoints+8, 100);
+					area.setHitAreaColor(enemy.getColor());
+					area.hit();
+					enemies_hit++;
+					enemysInPath.remove();
+					notHit = false;
+					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);
+	}	
+	
+	public static boolean won(){
+		return won;
+	}
+}

model/gameState/PreGameState.java

@@ -0,0 +1,90 @@
+package model.gameState;
+
+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 control.GameStateManager;
+import control.SongHandler;
+import control.button.ButtonEvent;
+import control.joystick.JoystickEvent;
+import data.io.SQLConnector;
+
+public class PreGameState extends GameState {
+
+	double index2 = 3;
+	double index = 3;
+	int grootte = 150;
+	BasicStroke s = new BasicStroke(20);
+	
+	BufferedImage screenshot;
+	
+	public PreGameState(GameStateManager gsm, SongHandler sh, SQLConnector sql) {
+		super(gsm, sh, sql);
+		screenshot = Images.getImage(Images.ImageType.screenshot);	
+	}
+
+	@Override
+	public void init() {
+		grootte = 150;
+		index = 3;
+		index2 = 3;
+	}
+
+	@Override
+	public void update(float factor) {
+		index2 -= factor/1000;
+		index = (double) Math.round(index2*1000)/1000;
+		if(index <= 0){
+			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,136 @@
+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 control.GameStateManager;
+import control.SongHandler;
+import control.GameStateManager.State;
+import control.button.ButtonEvent;
+import control.joystick.JoystickEvent;
+import data.io.SQLConnector;
+
+public class TitleState extends GameState {
+
+    BufferedImage pressStart = Images.getImage(ImageType.pressstart);
+    BufferedImage colorStrike = Images.getImage(ImageType.colorstrike);
+    BufferedImage kast = Images.getImage(ImageType.kast);
+    VolatileImage background;
+	Font textFont = new Font("OCR A Extended", Font.BOLD, 15);
+	Font textFont2 = new Font("OCR A Extended", Font.BOLD, 130);
+	GradientPaint gp = new GradientPaint(300, 0, new Color(0, 0, 1, 0.6f), 980, 1024, new Color(0, 0, 1, 0.2f));
+
+	
+    int index = 0;
+    int varx = 0;
+    
+    int frame = 0;
+    int image_x = 0;
+
+    
+    int indexKast = 0;
+    int xKast=0;
+    
+	public TitleState(GameStateManager gsm, SongHandler sh, SQLConnector sql){
+		super(gsm, sh, sql);
+		if(!sh.isPlaying())
+			sh.play();
+		createBackground();
+	}
+
+	@Override
+	public void init() {
+		if(!sh.isPlaying())
+			sh.play();
+		
+		frame = 0;
+		image_x = 0;
+		
+		indexKast = 0;
+		xKast = 0;
+	}
+
+	@Override
+	public void update(float factor) {
+		image_x = ((frame / 6) % 6) * 49;
+        frame++;
+        
+        indexKast++;
+        xKast = indexKast/10;
+		xKast%=4;
+	}
+
+	@Override
+	public void draw(Graphics2D g2) {
+		g2.drawImage(background, 0, 0, 1280, 1024, null);
+		
+		g2.drawImage(pressStart.getSubimage(image_x, 0, 49, 26),  640-122, 512, 245, 130, null);
+		
+		g2.drawImage(kast.getSubimage(xKast*600,0,600,800), 490,624,300,400,null);
+		
+		g2.setFont(textFont);
+		g2.setColor(Color.WHITE);
+		g2.drawString("©2015 Team Hamtaro", 550, 1012);
+	}
+
+	@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();
+		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.setPaint(gp);
+		g2.fillRect(300, 0, 680, 1024);
+
+		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,51 @@
+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, 305, 80);
+		g2.setColor(Color.ORANGE);
+		g2.drawRect(0, 0, 304, 79);
+		g2.drawRect(2, 2, 300, 75);
+//		g2.drawRect(0, 0, 300, 75);
+//		g2.drawRect(0-2, 0-2, 304, 79);
+		g2.drawRect(0, 0, 304, 79);
+		g2.drawRect(2, 2, 300, 75);
+		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,132 @@
+package model.objects;
+
+import image.Images;
+
+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.geom.Ellipse2D;
+import java.awt.image.VolatileImage;
+
+import model.gameState.PlayState;
+import control.SongHandler;
+import control.button.ButtonHandler;
+
+public class InfoPanel {
+	
+	private static String totalHighscore = "000000";
+	private VolatileImage infoPanel;
+	private SongHandler sh;
+	private String time;
+	private int highscore = 0;
+	
+	public InfoPanel(SongHandler sh){
+		this.sh = sh;
+		updateIPanel();
+		generateInfoPanel();
+	}
+
+	public void init(int highscore)
+	{
+		this.highscore = highscore;
+		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);	
+	    
+	    GradientPaint gp = new GradientPaint(0, 0, new Color(245,245,245), 256, 1024, Color.WHITE);
+	    g2.setPaint(gp);
+		
+		g2.setColor(Color.GREEN);
+		g2.fillRect(25, 900, (int)(2 * PlayState.lifePoints), 30);
+		
+		g2.setColor(Color.YELLOW);		
+		g2.fillRect(25, 950, (int)(2 * PlayState.comboScore), 30);
+		
+		g2.setColor(Color.BLACK);
+		
+		g2.drawRect(25, 900, 200, 30);
+		g2.drawRect(25, 950, 200, 30);
+		
+		Font scoreFont = new Font("OCR A Extended", Font.BOLD, 35);
+		g2.setFont(scoreFont);
+		g2.drawString("Score: ", 25, 75);
+		
+		g2.drawString(sh.getCurrentSong().getTitle(), 25, 215);
+		g2.drawString(sh.getCurrentSongInstance().getDifficulty(), 25, 295);
+		g2.drawString(time, 25, 375);
+		g2.drawString("" + highscore, 25, 455);
+		
+		Font scoreFont2 = new Font("OCR A Extended", Font.BOLD, 25);
+		g2.setFont(scoreFont2);
+		g2.drawString("Title: ", 25, 185);
+		g2.drawString("Difficulty: ", 25, 265);
+		g2.drawString("Time: ", 25, 345);
+		g2.drawString("Best: ", 25, 425);
+		
+		
+		Font scoreFont3 = new Font("OCR A Extended", Font.BOLD, 45);
+		g2.setFont(scoreFont3);
+		g2.drawString("" + totalHighscore, 25, 115);
+		
+		
+
+
+
+			
+			
+			Ellipse2D oval1 = new Ellipse2D.Double(25, 700, 50, 50);
+			g2.setColor(ButtonHandler.getButton(1).getColor());
+			g2.fill(oval1);
+			
+			Ellipse2D oval2 = new Ellipse2D.Double(85, 700, 50, 50);
+			g2.setColor(ButtonHandler.getButton(2).getColor());
+			g2.fill(oval2);
+			
+			Ellipse2D oval3 = new Ellipse2D.Double(145, 700, 50, 50);
+			g2.setColor(ButtonHandler.getButton(3).getColor());
+			g2.fill(oval3);
+			
+			Ellipse2D oval4 = new Ellipse2D.Double(50, 760, 50, 50);
+			g2.setColor(ButtonHandler.getButton(4).getColor());
+			g2.fill(oval4);
+			
+			Ellipse2D oval5 = new Ellipse2D.Double(110, 760, 50, 50);
+			g2.setColor(ButtonHandler.getButton(5).getColor());
+			g2.fill(oval5);
+			
+			Ellipse2D oval6 = new Ellipse2D.Double(170, 760, 50, 50);
+			g2.setColor(ButtonHandler.getButton(6).getColor());
+			g2.fill(oval6);
+				
+		g2.dispose();
+		infoPanel.createGraphics();
+	}
+	
+	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,160 @@
+package model.objects;
+
+import image.Images;
+
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Polygon;
+import java.awt.RenderingHints;
+import java.awt.Stroke;
+import java.awt.Transparency;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Line2D;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.VolatileImage;
+import java.util.ArrayList;
+import java.util.List;
+
+import model.drawObjects.Enemy;
+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;
+	private Stroke stroke = new BasicStroke(5,BasicStroke.CAP_ROUND,BasicStroke.JOIN_ROUND);
+	
+	private Rectangle2D backgroundPlay = new Rectangle2D.Double(256, 0, 1024, 1024);
+	
+	
+	public PlayArea(double xToRight,double heightOfGameScreen,double widthOfGameScreen, int sizeOctagon) {
+		super();
+		paths = new ArrayList<Path>();		
+		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
+		
+		
+		//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);
+//	    g2.setColor(Color.WHITE);
+//	    g2.fillRect(256, 0, 1024, 1024);
+	    Line2D current;	
+		g2.setColor(Color.BLACK);
+		g2.setStroke(stroke);
+		for(int i = 0; i < paths.size(); i++){
+			current = paths.get(i);			
+			g2.draw(current);
+		}
+		g2.draw(innerHitAreaBorder);
+		g2.draw(outsideHitAreaBorder);
+		g2.dispose();
+		background.createGraphics();
+	}	
+	
+	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(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));
+		}
+	}
+	
+	public Line2D getLine(int index){
+		if(index < 0){
+			index = 0;
+		}
+		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;
+	}
+}

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,43 @@
+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;
+
+	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();
+	}
+}