diff --git a/src/server/BaseGame.java b/src/server/BaseGame.java
index 7d1b885..f953a75 100644
--- a/src/server/BaseGame.java
+++ b/src/server/BaseGame.java
@@ -1,17 +1,12 @@
 package server;
 
-import java.io.DataInputStream;
-import java.io.DataOutputStream;
-import java.io.File;
 import java.io.IOException;
-import java.net.MalformedURLException;
-import java.net.ServerSocket;
+import java.io.InputStream;
 import java.net.Socket;
-import java.net.UnknownHostException;
-import java.util.ArrayList;
 import java.util.List;
 
-import org.json.*;
+import card.Card;
+import player.BasePlayer;
 
 public abstract class BaseGame {
 	/*
@@ -24,8 +19,19 @@
 	 * (COLORED)
 	 */
 
-	public enum MSG_TYPES {ERROR, WARNING, INFORMATION, QUESTION};
-	
+	public static final byte[] MAGIC = { 1, 3, 3, 7 };
+	public static final byte MOVE_INVALID = 0;
+	public static final byte MOVE_VALID = 1;
+	public static final byte MOVE_UPDATE = 5;
+	public static final byte MOVE_WON = 6;
+	public static final byte MOVE_LOST = 7;
+	public static final byte MOVE_DRY = 1 << 6;
+	public static final byte MOVE_PLACE_CARD = 2;
+	public static final byte MOVE_TRASH_CARD = 3;
+	public static final byte MOVE_HINT = 4;
+	public static final byte HINT_COLOR = 0;
+	public static final byte HINT_VALUE = 1;
+
 	final static int GREEN = 0;
 	final static int RED = 1;
 	final static int YELLOW = 2;
@@ -36,23 +42,22 @@
 	final static int N_CARDS = 50;
 	final static int MAX_HINTS = 8;
 	final static int MAX_FLASHS = 3;
-	
-	int N_PLAYERS = 3;
+
+	int nrOfPlayers = 3;
 	static int CARDS_PER_PLAYER;
-	int CARDS_IN_DECK;
-	
+	int cardsInDeck;
+
 	int hints;
 	int flashs;
 	Card[][] deck;
 	int[] deckCounter;
-	ArrayList<Card> trash;
-	AbstractPlayer[] players;
+	List<Card> trash;
+	BasePlayer[] players;
 	int currentPlayer;
-	boolean won;
-	boolean lost;
-	
+
+	Socket socket;
 	int port;
-	
+
 	List<String> history;
 
 	public BaseGame(){
@@ -60,349 +65,26 @@
 	}
 	
 	protected void init(){
-		history = new ArrayList<>();
-		loadOptions();
-		loadFont();
+		createHistory();
 		//establishConnection();
-		CARDS_PER_PLAYER = (N_PLAYERS <= 3) ? 5 : 4;
+		CARDS_PER_PLAYER = (nrOfPlayers <= 3) ? 5 : 4;
 		hints = MAX_HINTS;
 		flashs = 0;
-		roundsLeft = -1;
-		createPlayers();
-		currentPlayer = 0;
-		resetMoveValues();
-		addCards();
-		CARDS_IN_DECK = cards.size();
-		createUI();
-		dealCards();
+		cardsInDeck = N_CARDS;
 	}
 	
-	protected void createPlayers(){
-		players = new AbstractPlayer[N_PLAYERS];
-	}
-	
-	private void addCards(){
-		cards = new ArrayList<>();
-		deck = new Card[COLORS][5];
-		deckCounter = new int[5];
-		for(int i=0; i<5; ++i){
-			deckCounter[i] = 0;
-		}
-		trash = new ArrayList<>();
-		int[] dist = new int[]{3, 2, 2, 2, 1};
-		int[][] tmp_cards = new int[][]{
-				dist.clone(),
-				dist.clone(),
-				dist.clone(),
-				dist.clone(),
-				dist.clone()
-			};
-		for(int i=0; i<N_CARDS; ++i){
-			//Point p = null;
-			int[] p = new int[2];
-			do{
-				p = randomPosition();
-			} while(tmp_cards[p[0]][p[1]] == 0);
-			tmp_cards[p[0]][p[1]]--;
-			cards.add(new Card(p[0], (p[1] + 1), -1, this));
-		}
-	}
-	
+	protected abstract void createHistory();
+
 	protected abstract void createUI();
-	
-	void moveCardToTrash(int index){
-		trash.add(players[currentPlayer].getCard(index).clone());
-		updateCards(index);
-	}
-	
-	void updateCards(int index){
-		dealCard(index, currentPlayer);
-		players[currentPlayer].setCardInfo(index, "");
-		Card c = players[currentPlayer].getCard(index);
-		if(c.getValue() == -1){ //dummy card, no more cards
-			setNoCard(index);
-		}
-	}
-	
-	protected abstract void setNoCard(int index);
-	
-	private void dealCard(int cardID, int playerID){
-		Card card;
-		if(CARDS_IN_DECK > 0){
-			int index = random(CARDS_IN_DECK--);
-			card = cards.remove(index);
-		} else {
-			if(roundsLeft == -1) roundsLeft = N_PLAYERS;
-			card = new Card(3, -1, playerID, this);
-		}
-		players[playerID].setCard(cardID, card);
-	}
-	
-	protected void dealCards(){
-		int dealtCards = 0;
-		for(; dealtCards < CARDS_PER_PLAYER; ++dealtCards){
-			for(int i=0; i<N_PLAYERS; ++i){
-				int index = random(CARDS_IN_DECK--);
-				Card card = cards.remove(index);
-				players[i].setCard(dealtCards, card);
-			}
-		}
-	}
-	
-	boolean hintAvailable(){
+
+	protected boolean hintAvailable(){
 		return hints > 0;
 	}
-	
-	void setWonOrLost(){
-		boolean won = true;
-		boolean lost = false;
-		for(int i=0; i<COLORS; ++i){
-			System.out.println("Deck " + i + ": " + deckCounter[i]);
-			if(deckCounter[i] != 5){
-				won = false;
-				break;
-			}
-		}
-		if(thunders == MAX_THUNDERS){
-			lost = true;
-			won = false;
-		}
-		if(roundsLeft == 0) lost = true;
-		if(won) printMessage("You won!", MSG_TYPES.INFORMATION);
-		else if(lost) printMessage("You lost...", MSG_TYPES.INFORMATION);
-		this.won = won;
-		this.lost = lost;
-	}
-	
-	private int[] randomPosition(){
-		int[] p = new int[2];
-		p[0] = random(5);
-		p[1] = random(5);
-		return p;
-	}
-	
-	private int random(int max){
-		return (int) (Math.random() * max);
-	}
-	
-	public void setSelectedPlayer(int selectedPlayer){
-		this.selectedPlayer = selectedPlayer;
-	}
-	
-	public int getSelectedPlayer(){
-		return selectedPlayer;
-	}
-	
-	public AbstractPlayer getPlayer(int index){
+
+	public BasePlayer getPlayer(int index){
 		return players[index];
 	}
 	
-	public int getCurrentPlayerIndex(){
-		return currentPlayer;
-	}
-	
-	public boolean isTrashCard(){
-		return trashCard;
-	}
-	
-	public boolean isPlaceCard(){
-		return placeCard;
-	}
-	
-	public boolean isUseColor(){
-		return useColor;
-	}
-	
-	public boolean isUseValue(){
-		return useValue;
-	}
-	
-	public int getChosenColor(){
-		return chosenColor;
-	}
-	
-	public void setChosenColor(int chosenColor){
-		this.chosenColor = chosenColor;
-	}
-	
-	public int getChosenValue(){
-		return chosenValue;
-	}
-	
-	public void setChosenValue(int chosenValue){
-		this.chosenValue = chosenValue;
-	}
-	
-	public int getSelectedCards(){
-		return selectedCards;
-	}
-	
-	public void addSelectedCards(){
-		selectedCards++;
-	}
-	
-	public void removeSelectedCards(){
-		selectedCards--;
-	}
-	
-	public int getDifficulty(){
-		return difficulty;
-	}
-	
-	public abstract void loadFont();
-	
-	public int getFontSize(){
-		return fontSize;
-	}
-	
-	public abstract Object getFont();
-
-
-	public abstract void printMessage(String msg, MSG_TYPES type);
-	
-	protected void removeHint(){
-		hints--;
-	}
-	
-	protected void addHint(){
-		if(hints != MAX_HINTS){
-			hints++;
-			if(hints > MAX_HINTS) hints = MAX_HINTS;
-		}
-	}
-	
-	protected void addThunder(){
-		thunders++;
-	}
-	
-	protected void placeCard(Card c, int color, int value){
-		deckCounter[color]++;
-		deck[color][value] = c;
-		if(value+1 == 5) addHint();
-	}
-	
-	protected void onNext(){
-		if(!checkValidMove()){
-			printMessage("Please select all cards of the selected color/value", MSG_TYPES.ERROR);
-			return;
-		}
-		if(roundsLeft >= 0) roundsLeft--;
-		int selCardIndex = 0;
-		AbstractPlayer player = players[selectedPlayer];
-		for(int i=0; i<CARDS_PER_PLAYER; ++i){
-			Card card = player.getCard(i);
-			String from = "(from Player " + currentPlayer + ")";
-			if(card.isSelected()){
-				selCardIndex = i;
-				card.setSelected(false);
-				if(useColor){
-					String color = "- " + Card.intColorToText(chosenColor);
-					player.setCardInfo(i, player.getCardInfo(i) + color + " " + from + "\n");
-				} else if(useValue){
-					String value = "- is " + chosenValue;
-					player.setCardInfo(i, player.getCardInfo(i) + value + " " + from + "\n");
-				}
-			} else {
-				if(useColor){
-					String color = "- not " + Card.intColorToText(chosenColor);
-					player.setCardInfo(i, player.getCardInfo(i) + color + " " + from + "\n");
-				} else if(useValue){
-					String value = "- is not " + chosenValue;
-					player.setCardInfo(i, player.getCardInfo(i) + value + " " + from + "\n");
-				}
-			}
-		}
-		if(useColor || useValue){
-			removeHint();
-		} else if(trashCard){
-			moveCardToTrash(selCardIndex);
-			addHint();
-		} else if(placeCard){
-			Card c = players[currentPlayer].getCard(selCardIndex);
-			int color = c.getColorInt();
-			int value = c.getValue();
-			int deckValue = deckCounter[color] + 1;
-			if(deckValue == value){ //place card possible
-				placeCard(c, color, value-1);
-			} else { //card too high or too low
-				addThunder();
-				moveCardToTrash(selCardIndex);
-			}
-			setWonOrLost();
-			if(lost) return;
-			updateCards(selCardIndex);
-		}
-		players[currentPlayer].activeCards();
-		printMessage("Player " + (currentPlayer+1) + " has finished his move!", MSG_TYPES.INFORMATION);
-		currentPlayer++;
-		if(currentPlayer == N_PLAYERS) currentPlayer = 0;
-		players[currentPlayer].deactiveCards();
-		resetMoveValues();
-	}
-	
-	protected void onColor(){
-		if(!hintAvailable()){
-			printMessage("No hints left!", MSG_TYPES.ERROR);
-			return;
-		}
-		if(selectedCards > 0){
-			printMessage("Please deselect all cards first", MSG_TYPES.ERROR);
-			return;
-		}
-		useColor = true;
-		useValue = false;
-		placeCard = false;
-		trashCard = false;
-	}
-		
-	protected void onValue(){
-		if(!hintAvailable()){
-			printMessage("No hints left!", MSG_TYPES.ERROR);
-			return;
-		}
-		if(selectedCards > 0){
-			printMessage("Please deselect all cards first", MSG_TYPES.ERROR);
-			return;
-		}
-		useValue = true;
-		useColor = false;
-		placeCard = false;
-		trashCard = false;
-	}
-	
-	protected void onTrash(){
-		if(selectedCards > 0){
-			printMessage("Please deselect all cards first", MSG_TYPES.ERROR);
-			return;
-		}
-		useColor = false;
-		useValue = false;
-		placeCard = false;
-		trashCard = true;
-	}
-	
-	protected void onPlace(){
-		if(selectedCards > 0){
-			printMessage("Please deselect all cards first", MSG_TYPES.ERROR);
-			return;
-		}
-		useColor = false;
-		useValue = false;
-		placeCard = true;
-		trashCard = false;
-	}
-	
-	protected abstract void showTrash();
-	
-	/**
-	 * Stores the current state of the game in the history
-	 * @param json the current state as json object
-	 */
-	protected void addToHistory(){
-		String json = "";
-		history.add(json);
-	}
-	
 	/**
 	 * Returns the state of the game at a given @param move index
 	 * @param move the index of the move you want to get.
@@ -410,7 +92,33 @@
 	 * Negative values are interpreted as index from the end (-1 is the last state).
 	 */
 	public List<String> getHistory(int move){
-		final int index = move >= 0 ? move : history.size()-1;
-		return  history.subList(0, index);
+		final int index = move>=0 ? move : history.size()+move;
+		return history.subList(0, index);
+	}
+	
+	protected abstract void receive();
+
+	class SocketListenerThread implements Runnable {
+		Socket socket;
+
+		public SocketListenerThread(Socket socket){
+			this.socket = socket;
+		}
+		
+		@Override
+		public void run() {
+			InputStream inStream = null;
+			int availableBytes = 0;
+			try {
+				inStream = socket.getInputStream();
+				availableBytes = inStream.available();
+				if(availableBytes > 0){
+					receive();
+				}
+			} catch (IOException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		}
 	}
 }
\ No newline at end of file
diff --git a/src/server/ClientGame.java b/src/server/ClientGame.java
index 19db676..90ba19a 100644
--- a/src/server/ClientGame.java
+++ b/src/server/ClientGame.java
@@ -1,32 +1,40 @@
 package server;
 
+import java.io.DataOutputStream;
 import java.io.File;
 import java.io.IOException;
 import java.net.MalformedURLException;
-import java.net.Socket;
+import java.util.ArrayList;
 
 import org.json.JSONException;
 import org.json.JSONObject;
 import org.json.JSONTokener;
 
-public class ClientGame extends BaseGame {
-	Socket socket;
-	
-	int selectedPlayer;
-	int selectedCards;
-	int chosenColor;
-	int chosenValue;
-	boolean useColor;
-	boolean useValue;
-	boolean placeCard;
-	boolean trashCard;
-	
+import card.Card;
+
+public abstract class ClientGame extends BaseGame {
+
+	public enum MSG_TYPES {ERROR, WARNING, INFORMATION, QUESTION};
+
 	//Options stuff
 	final File options = new File("options.json");
 	JSONObject root;
 	int difficulty;
 	int fontSize;
 	
+	@Override
+	protected void init() {
+		super.init();
+		loadOptions();
+		loadFont();
+
+		SocketListenerThread listenThread = new SocketListenerThread(socket);
+		listenThread.run();
+	}
+	@Override
+	protected void createHistory() {
+		history = new ArrayList<>();
+	}
 	protected void loadOptions(){
 		try {
 			JSONTokener tokener = new JSONTokener(options.toURI().toURL().openStream());
@@ -43,65 +51,74 @@
 			e.printStackTrace();
 		}
 	}
-	
-	public void resetMoveValues(){
-		selectedPlayer = -1;
-		chosenColor = -1;
-		chosenValue = -1;
-		selectedCards = 0;
-		useColor = useValue = trashCard = placeCard = false;
+
+	protected void movePlaceCard(Card c){
+		movePlaceCard(c, false);
 	}
 	
-	boolean checkValidMove(){
-		if(selectedCards == 0) return false;
-		if(!hintAvailable() && (useColor || useValue)) return false;
-		if((trashCard || placeCard) && selectedCards == 1) return true;
-		int countCards = 0;
-		for(int i=0; i<CARDS_PER_PLAYER; ++i){
-			AbstractPlayer p = players[selectedPlayer];
-			if(useColor){
-				if(p.getCard(i).getColorInt() == chosenColor) countCards++;
-			} else if(useValue){
-				if(p.getCard(i).getValue() == chosenValue) countCards++;
-			}
+	protected void movePlaceCard(Card c, boolean isDry) {
+		byte msgType = isDry ? MOVE_PLACE_CARD | MOVE_DRY : MOVE_PLACE_CARD;
+		send(msgType, c.toJson().toString());
+	}
+
+	protected void moveTrashCard(Card c){
+		movePlaceCard(c, false);
+	}
+
+	protected void moveTrashCard(Card c, boolean isDry) {
+		byte msgType = isDry ? MOVE_TRASH_CARD | MOVE_DRY : MOVE_TRASH_CARD;
+		send(msgType, c.toJson().toString());
+	}
+
+	protected void moveHint(Card c){
+		movePlaceCard(c, false);
+	}
+
+	protected void moveHint(Card c, boolean isDry) {
+		byte msgType = isDry ? MOVE_HINT | MOVE_DRY : MOVE_HINT;
+		send(msgType, c.toJson().toString());
+	}
+
+	private void send(byte msgType, String msg) {
+		DataOutputStream os = null;
+		try {
+			os = new DataOutputStream(socket.getOutputStream());
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
 		}
-		return countCards == selectedCards;
+		try {
+			os.write(MAGIC);
+			os.write(ServerGame.PROTOCOL.VIBE_DUMB.ordinal());
+			os.write(msgType);
+			os.write(new byte[]{ 0, 0 });
+			os.writeUTF(msg);
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
 	}
-	
+
+	public abstract void printMessage(String msg, MSG_TYPES type);
+
 	@Override
 	protected void createUI() {
 		// TODO Auto-generated method stub
-
 	}
-
-	@Override
-	protected void setNoCard(int index) {
-		// TODO Auto-generated method stub
-
+	
+	public int getDifficulty(){
+		return difficulty;
 	}
-
-	@Override
+	
 	public void loadFont() {
-		// TODO Auto-generated method stub
-
+		
 	}
-
-	@Override
+	public int getFontSize(){
+		return fontSize;
+	}
+	
 	public Object getFont() {
-		// TODO Auto-generated method stub
+		// TODO
 		return null;
 	}
-
-	@Override
-	public void printMessage(String msg, MSG_TYPES type) {
-		// TODO Auto-generated method stub
-
-	}
-
-	@Override
-	protected void showTrash() {
-		// TODO Auto-generated method stub
-
-	}
-
 }
diff --git a/src/server/ServerGame.java b/src/server/ServerGame.java
index a68f632..950c250 100644
--- a/src/server/ServerGame.java
+++ b/src/server/ServerGame.java
@@ -1,47 +1,443 @@
 package server;
 
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
 import java.net.ServerSocket;
+import java.net.Socket;
 import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import card.Card;
+import player.BasePlayer;
 
 public class ServerGame extends BaseGame {
-	ServerSocket socket;
-	ArrayList<Card> cards;
-	int roundsLeft;
+	ServerSocket server;
+
+	public enum PROTOCOL {
+		VIBE_DUMB
+	};
+
+	List<Card> cards;
+	long seed;
+	Random rand;
+
+	int movesLeft;
+	boolean won;
+	boolean lost;
+	
+	List<Socket> sockets;
+
+	public ServerGame() {
+	}
+
+	@Override
+	protected void init() {
+		super.init();
+		sockets = new ArrayList<>();
+		try {
+			while(nrOfPlayers < 2){ //TODO
+				socket = server.accept();
+				sockets.add(socket);
+				nrOfPlayers++;
+				// TODO do this somewhere else 
+				new Thread(new SocketListenerThread(socket)).start();
+			}
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			// TODO exit
+			e.printStackTrace();
+		}
+
+		seed = 0;
+		rand = new Random(seed);
+		movesLeft = -1;
+		createPlayers();
+		currentPlayer = 0;
+		// shuffleCards(); // TODO use this instead of addCards()
+		addCards();
+		dealCards();
+	}
+
+	protected void shuffleCards() {
+		cards = new ArrayList<>();
+		//TODO add cards
+		//TODO shuffle
+	}
+
+	// protected void onNext(){
+	// if(!checkValidMove()){
+	// printMessage("Please select all cards of the selected color/value",
+	// MSG_TYPES.ERROR);
+	// return;
+	// }
+	// if(roundsLeft >= 0) roundsLeft--;
+	// int selCardIndex = 0;
+	// AbstractPlayer player = players[selectedPlayer];
+	// for(int i=0; i<CARDS_PER_PLAYER; ++i){
+	// Card card = player.getCard(i);
+	// String from = "(from Player " + currentPlayer + ")";
+	// if(card.isSelected()){
+	// selCardIndex = i;
+	// card.setSelected(false);
+	// if(useColor){
+	// String color = "- " + Card.intColorToText(chosenColor);
+	// player.setCardInfo(i, player.getCardInfo(i) + color + " " + from + "\n");
+	// } else if(useValue){
+	// String value = "- is " + chosenValue;
+	// player.setCardInfo(i, player.getCardInfo(i) + value + " " + from + "\n");
+	// }
+	// } else {
+	// if(useColor){
+	// String color = "- not " + Card.intColorToText(chosenColor);
+	// player.setCardInfo(i, player.getCardInfo(i) + color + " " + from + "\n");
+	// } else if(useValue){
+	// String value = "- is not " + chosenValue;
+	// player.setCardInfo(i, player.getCardInfo(i) + value + " " + from + "\n");
+	// }
+	// }
+	// }
+	// if(useColor || useValue){
+	// removeHint();
+	// } else if(trashCard){
+	// moveCardToTrash(selCardIndex);
+	// addHint();
+	// } else if(placeCard){
+	// Card c = players[currentPlayer].getCard(selCardIndex);
+	// int color = c.getColorInt();
+	// int value = c.getValue();
+	// int deckValue = deckCounter[color] + 1;
+	// if(deckValue == value){ //place card possible
+	// placeCard(c, color, value-1);
+	// } else { //card too high or too low
+	// addThunder();
+	// moveCardToTrash(selCardIndex);
+	// }
+	// setWonOrLost();
+	// if(lost) return;
+	// updateCard(selCardIndex);
+	// }
+	// players[currentPlayer].activeCards();
+	// printMessage("Player " + (currentPlayer+1) + " has finished his move!",
+	// MSG_TYPES.INFORMATION);
+	// currentPlayer++;
+	// if(currentPlayer == N_PLAYERS) currentPlayer = 0;
+	// players[currentPlayer].deactiveCards();
+	// resetMoveValues();
+	// }
+
+	protected void receive() {
+		DataInputStream inStream = null;
+		byte[] magic = new byte[4];
+		PROTOCOL proto = null;
+		byte msgType = 0;
+		byte[] useless = new byte[2];
+		try {
+			inStream = new DataInputStream(socket.getInputStream());
+			inStream.read(magic);
+			//proto = inStream.readByte();
+			msgType = inStream.readByte();
+			inStream.read(useless);
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		
+		// TODO check Protocol
+		switch(proto){
+		case VIBE_DUMB:
+			break;
+		}
+		
+		String msg = null;
+		JSONObject jo = null;
+		boolean isValid = true;
+		boolean wasMove = false;
+		try {
+			msg = inStream.readUTF();
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		if(msg != null) jo = new JSONObject(msg);
+		// TODO MOVE_DRY
+		switch(msgType){
+		case MOVE_PLACE_CARD:
+			isValid = placeCard(new Card(jo));
+			wasMove = true;
+			break;
+		case MOVE_TRASH_CARD:
+			isValid = moveCardToTrash(new Card(jo));
+			wasMove = true;
+			break;
+		case MOVE_HINT:
+			int hintType = jo.getInt("type");
+			int value = jo.getInt("value");
+			int player = jo.getInt("player_id");
+			isValid = giveHint(hintType, value, player);
+			wasMove = true;
+			break;
+		}
+		if(!isValid) send(MOVE_INVALID);
+		if(wasMove){
+			currentPlayer++;
+			if(currentPlayer == nrOfPlayers) currentPlayer = 0;
+			// TODO notify players
+			if(movesLeft >= 0) movesLeft--;
+			send(MOVE_UPDATE, toJson().toString());
+		}
+	}
+
+	protected Card getRealCard(Card c, int[] index){
+		Card[] cards = getPlayer(currentPlayer).getCards();
+		for(int i=0; i<cards.length; ++i){
+			Card card = cards[i];
+			if(card.getId() == c.getId()){
+				if(card.getColorInt() == c.getColorInt() && card.getValue() == c.getValue()){
+					if(index != null) index[0] = i;
+					return card;
+				}
+			}
+		}
+		return null;
+	}
+	
+	protected boolean placeCard(Card c) {
+		int[] index = new int[1];
+		Card card = getRealCard(c, index);
+		if(card == null) return false;
+		int color = card.getColorInt();
+		int value = card.getValue();
+		
+
+		int deckValue = deckCounter[color];
+		if(deckValue == value){ //place card possible
+			deckCounter[color]++;
+			deck[color][value] = card;
+			if (value + 1 == 5) addHint();
+		} else { //card too high or too low
+			addFlash();
+			moveCardToTrash(card, true);
+		}
+		setWonOrLost();
+		dealCard(index[0], currentPlayer);
+		return true;
+	}
+	
+	protected boolean moveCardToTrash(Card c){
+		return moveCardToTrash(c, false);
+	}
+	
+	protected boolean moveCardToTrash(Card c, boolean receivedFlash) {
+		int[] index = new int[1];
+		Card card = getRealCard(c, index);
+		if(card == null) return false;
+		// TODO Fix clone removal
+		if(!receivedFlash) addHint();
+		trash.add(card);
+		dealCard(index[0], currentPlayer);
+		return true;
+	}
+	
+	protected boolean giveHint(int type, int value, int playerId){
+		if(!hintAvailable()) return false;
+		if(currentPlayer == playerId) return false;
+		Card[] cards = getPlayer(playerId).getCards();
+		for(Card c : cards){
+			boolean is = false;
+			if(type == HINT_COLOR) is = c.getColorInt() == value;
+			else if(type == HINT_VALUE) is = c.getValue() == value;
+			else throw new RuntimeException(); // TODO "vorerst"
+			c.addCardInfo(type, is, value, currentPlayer);
+		}
+		removeHint();
+		return true;
+	}
+
+	protected void createPlayers() {
+		players = new BasePlayer[nrOfPlayers];
+	}
+
+	protected void dealCards() {
+		for (int dealtCards =0; dealtCards < CARDS_PER_PLAYER; ++dealtCards) {
+			for (int i = 0; i < nrOfPlayers; ++i) {
+				int index = random(cardsInDeck--);
+				Card card = cards.remove(index);
+				players[i].setCard(dealtCards, card);
+				// TODO use this code as soon as the shuffle is implemented
+				// Card card = getCardFromDeck();
+				// players[i].setCard(dealtCards, card);
+			}
+		}
+	}
+
+	//FIXME no endless do-while...
+	private void addCards() {
+		cards = new ArrayList<>();
+		deck = new Card[COLORS][5];
+		deckCounter = new int[5];
+		for (int i = 0; i < 5; ++i) {
+			deckCounter[i] = 0;
+		}
+		trash = new ArrayList<>();
+		int[] dist = new int[] { 3, 2, 2, 2, 1 };
+		int[][] tmp_cards = new int[][] { dist.clone(), dist.clone(), dist.clone(), dist.clone(), dist.clone() };
+		for (int i = 0; i < N_CARDS; ++i) {
+			int[] p = new int[2];
+			do {
+				p = randomPosition();
+			} while (tmp_cards[p[0]][p[1]] == 0);
+			tmp_cards[p[0]][p[1]]--;
+			cards.add(new Card(p[0], (p[1] + 1), i));
+		}
+	}
+	
+	private int[] randomPosition(){
+		int[] p = new int[2];
+		p[0] = random(5);
+		p[1] = random(5);
+		return p;
+	}
+	
+	private int random(int max){
+		return rand.nextInt(max);
+	}
+
+	private void dealCard(int cardPos, int playerID) {
+		Card card;
+		if (cardsInDeck > 0) {
+			int index = random(cardsInDeck--);
+			card = cards.remove(index);
+			// TODO Use this code as soon as shuffle is implemented
+			// card = getCardFromDeck();
+		} else {
+			if (movesLeft == -1) movesLeft = nrOfPlayers;
+			card = Card.DUMMY_CARD;
+		}
+		players[playerID].setCard(cardPos, card);
+	}
+
+	void setWonOrLost() {
+		boolean won = true;
+		boolean lost = false;
+		for (int i = 0; i < COLORS; ++i) {
+			if (deckCounter[i] != 5) {
+				won = false;
+				break;
+			}
+		}
+		if (flashs == MAX_FLASHS) {
+			lost = true;
+			won = false;
+		}
+		if (movesLeft == 0)
+			lost = true;
+		if (won){
+			send(MOVE_WON);
+		}
+		else if (lost){
+			send(MOVE_LOST);
+		}
+		this.won = won;
+		this.lost = lost;
+	}
+	
+	protected void send(byte msgType){
+		send(msgType, null);
+	}
+	
+	protected void send(byte msgType, String msg){
+		DataOutputStream os = null;
+		try {
+			os = new DataOutputStream(socket.getOutputStream());
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		try {
+			os.write(MAGIC);
+			os.write(ServerGame.PROTOCOL.VIBE_DUMB.ordinal());
+			os.write(msgType);
+			os.write(new byte[]{ 0, 0 });
+			if(msg != null) os.writeUTF(msg);
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+
+	protected void removeHint() {
+		hints--;
+	}
+
+	protected void addHint() {
+		if (hints != MAX_HINTS) {
+			hints++;
+			if (hints > MAX_HINTS)
+				hints = MAX_HINTS;
+		}
+	}
+
+	protected void addFlash() {
+		flashs++;
+	}
 
 	@Override
 	protected void createUI() {
 		// TODO Auto-generated method stub
+	}
 
+	/**
+	 * Stores the current state of the game in the history
+	 * 
+	 * @param json
+	 *            the current state as json object
+	 */
+	protected void addToHistory(String json) {
+		history.add(json);
+	}
+	
+	protected JSONObject toJson(){
+		JSONObject root = new JSONObject();
+		root.put("movesLeft", movesLeft);
+		root.put("cardsInDeck", cardsInDeck);
+		root.put("hints", hints);
+		root.put("flashs", flashs);
+		root.put("movesLeft", movesLeft);
+		root.put("movesLeft", movesLeft);
+		root.put("movesLeft", movesLeft);
+		root.put("movesLeft", movesLeft);
+		root.put("movesLeft", movesLeft);
+		JSONArray trashArray = new JSONArray();
+		for(Card c : trash){
+			trashArray.put(c.toJson());
+		}
+		root.put("trash", trashArray);
+		
+		JSONObject deckRow = new JSONObject();
+		for(int i=0; i<deck.length; ++i){
+			JSONObject deckCol = new JSONObject();
+			for(int j=0; j<deck[i].length; ++j){
+				deckCol.put(String.valueOf(j), deck[i][j]);
+			}
+			deckRow.put(String.valueOf(i), deckCol);
+		}
+		JSONArray playerArray = new JSONArray();
+		for(BasePlayer p : players){
+			playerArray.put(p.toJson());
+		}
+		root.put("players", playerArray);
+		root.put("currentPlayer",  currentPlayer);
+		return root;
 	}
 
 	@Override
-	protected void setNoCard(int index) {
-		// TODO Auto-generated method stub
-
+	protected void createHistory() {
+		history = new ArrayList<>();
 	}
-
-	@Override
-	public void loadFont() {
-		// TODO Auto-generated method stub
-
-	}
-
-	@Override
-	public Object getFont() {
-		// TODO Auto-generated method stub
-		return null;
-	}
-
-	@Override
-	public void printMessage(String msg, MSG_TYPES type) {
-		// TODO Auto-generated method stub
-
-	}
-
-	@Override
-	protected void showTrash() {
-		// TODO Auto-generated method stub
-
-	}
-
 }