resolved merge conflicts from merge with default-game

CheckersClient/core/src/com/mygdx/game/Constants.java

+package com.mygdx.game;
+
+import java.util.HashMap;
+
+public class Constants {
+    public static final int PLAYER_NAME_TEXT_FIELD_WIDTH = 340;
+    public static final int PLAYER_NAME_TEXT_FIELD_HEIGHT = 80;
+    public static final HashMap<Integer, String> AVAILABLEAVATARSHASHMAP = new HashMap<Integer, String>() {{
+        put(0, "RegularGuy");
+        put(1, "HipsterGirl");
+        put(2, "HighSchoolGuy");
+        put(3, "RocketGuy");
+        put(4, "AsianGirl");
+        put(5, "Grandma");
+    }};
+}

CheckersClient/core/src/com/mygdx/game/UniCheckersClient.java

@@ -10,22 +10,15 @@ import com.badlogic.gdx.scenes.scene2d.Stage;
 import com.badlogic.gdx.scenes.scene2d.ui.Skin;
 import com.badlogic.gdx.utils.viewport.FitViewport;
 import com.badlogic.gdx.utils.viewport.Viewport;
-import com.mygdx.game.controllers.GameController;
 import com.mygdx.game.controllers.NetworkController;
 import com.mygdx.game.controllers.PlayerController;
-import com.mygdx.game.model.DefaultBoard;
-import com.mygdx.game.model.Game;
-import com.mygdx.game.model.GameMode;
-import com.mygdx.game.model.GameState;
-import com.mygdx.game.model.gamemodes.rules.DefaultRules;
 import com.mygdx.game.views.GameViewManager;
-import com.mygdx.game.views.PlayView;
+import com.mygdx.game.views.LoadingView;
 import java.util.ArrayList;
 
 public class UniCheckersClient extends ApplicationAdapter {
 
 	PlayerController playerController;
-	GameController gameController;
 
 	private GameViewManager gvm;
 	private SpriteBatch sb;
@@ -46,9 +39,7 @@ public class UniCheckersClient extends ApplicationAdapter {
 		stage = new Stage(viewport);
 		Gdx.input.setInputProcessor(stage);
 
-		// Initialize Models..
-		// Temporary model with default board and rules
-		Game model = new Game(new GameState(new GameMode(new DefaultRules(), new DefaultBoard())));
+		// Initialize Models.. // TODO: remove?
 
 		// Initialize controllers..
 		NetworkController networkController = new NetworkController();
@@ -61,13 +52,7 @@ public class UniCheckersClient extends ApplicationAdapter {
 		skin = new Skin(Gdx.files.internal("UISkins/glassy/skin/glassy-ui.json"));
 		gvm = new GameViewManager();
 
-		//gvm.push(new LoadingView(gvm, playerController, assetManager, stage, skin));
-		//gvm.push(new CinematicView(gvm, playerController, assetManager, stage, skin));
-		PlayView playView = new PlayView(gvm, playerController, assetManager, stage, skin, null);
-		gameController = new GameController(model, playView);
-		playView.setGameController(gameController);
-
-		gvm.push(playView);
+		gvm.push(new LoadingView(gvm, playerController, assetManager, stage, skin));
 	}
 
 	@Override

CheckersClient/core/src/com/mygdx/game/controllers/GameController.java

 package com.mygdx.game.controllers;
 
 import com.badlogic.gdx.math.Vector3;
+import com.mygdx.game.controllers.commands.cPlayerPieceMove;
 import com.mygdx.game.model.Game;
-import com.mygdx.game.views.Constants;
+import com.mygdx.game.model.Player;
 import com.mygdx.game.views.PlayView;
 import com.mygdx.game.views.tokens.StarPiece;
 
+import java.util.List;
+
 public class GameController {
 
     private final Game model;
@@ -13,18 +16,29 @@ public class GameController {
 
     private StarPiece activePiece;             // Previously clicked piece
     private Vector3 previousCoordinateClicked; // Previously clicked coordinate
+    private final PlayerController playerController;
+    private final List<List<Float>> playerNameTextFieldCoordinates;
 
-    public GameController(Game model, PlayView view) {
+    public GameController(Game model, PlayView view, PlayerController playerController) {
         this.model = model;
         this.view = view;
+        this.playerController = playerController;
+
         this.activePiece = null;
         this.previousCoordinateClicked = null;
 
+        // Get used boardslots and coordinates to place name of players
+        List<Integer> usedBoardSlots = this.model.getUsedBoardSlots();
+        playerNameTextFieldCoordinates = this.model.getPlayerNameCoordinates(this.view.hex_side_length);
+
+        // Initialize pieces, place playernames and place turn-indicator
         this.view.initializePieces(this.model.getStartFieldCoordinates());
+        this.view.placePlayerNames(usedBoardSlots, playerNameTextFieldCoordinates);
+        this.view.placeTurnIndicator(playerNameTextFieldCoordinates.get(this.model.getPlayerTurnSlot()));
     }
 
     public void handleClick(float x, float y) {
-        Vector3 cubeCoordinates = UtilsKt.pixelToCube(x, y, Constants.HEX_SIDE_LENGTH);
+        Vector3 cubeCoordinates = UtilsKt.pixelToCube(x, y, this.view.hex_side_length);
 
         // If field exists at clicked coordinates
         if (this.model.fieldExists(cubeCoordinates)) {
@@ -34,26 +48,57 @@ public class GameController {
                 if (activePiece != null) {
                     activePiece.setRotateHead(false);
                 }
-                // TODO: Check if the piece is owned by this player
+                // If clicked piece is owned by player and player is not finished, activate piece
+                if(this.model.getPieceOwnerId(cubeCoordinates) == playerController.getPlayer().getID() && !this.model.isPlayerFinished(playerController.getPlayer().getID())) {
                     activePiece = this.view.getPiece(cubeCoordinates);
-                System.out.print(this.model.getGameState().getGameMode().getPossibleMoves(cubeCoordinates));
                     activePiece.setRotateHead(true);
                     previousCoordinateClicked = cubeCoordinates;
+                }
+
             } else { // Field does NOT have piece
                 if (activePiece != null) {
-                    // TODO: Check if it is the players turn (could be done in model)
-                    // Try to move piece in model, if successful, move piece in view
-                    if (this.model.movePiece(previousCoordinateClicked, cubeCoordinates)) {
+                    // Try to move piece in model. If successful, move piece in view
+                    if (this.model.movePiece(previousCoordinateClicked, cubeCoordinates, playerController.getPlayer().getID(), this)) {
                         this.view.movePiece(activePiece, cubeCoordinates);
                         activePiece.setRotateHead(false);
                         activePiece = null;
+                        playerController.getNetWorkController().sendToServer(new cPlayerPieceMove(previousCoordinateClicked, cubeCoordinates, playerController.getLobby().getID(), playerController.getPlayer().getID()));
                         previousCoordinateClicked = null;
-                        // TODO: Check if all pieces of the player are in goal? (model.isPlayerFinished)
+
+                        this.view.placeTurnIndicator(playerNameTextFieldCoordinates.get(this.model.getPlayerTurnSlot()));
                     } else {
-                        // TODO: Give feedback (move was not valid/not executed)
+                        System.out.println("Move was not allowed"); // TODO: Give feedback (move was not valid/not executed)
+                    }
                 }
             }
         }
     }
+
+
+    public void playerMovedPiece(Vector3 fromCoordinates, Vector3 toCoordinates, int playerId) {
+        if (this.model.movePiece(fromCoordinates, toCoordinates, playerId, this)) {
+            this.view.moveOtherPlayerPiece(fromCoordinates, toCoordinates);
+            this.view.placeTurnIndicator(playerNameTextFieldCoordinates.get(this.model.getPlayerTurnSlot()));
+        } else {
+            System.out.println("ERROR: Could not execute moving of other players piece"); // TODO: Give feedback
+        }
+    }
+
+    public void setPlayerFinished(int playerId, int place) {
+
+        int playerIndex;
+        List<Player> players = playerController.getLobby().getPlayers();
+
+        for (Player player: players) {
+            if (player.getID() == playerId) {
+                playerIndex = players.indexOf(player);
+                this.view.setPlayerFinished(playerIndex, place);
+            }
+        }
+    }
+
+    public void setGameFinished() {
+        this.view.removeTurnIndicator();
+        this.view.placeHomeButton();
     }
 }

CheckersClient/core/src/com/mygdx/game/controllers/NetworkController.java

 package com.mygdx.game.controllers;
 
+import com.badlogic.gdx.math.Vector3;
 import com.esotericsoftware.kryo.Kryo;
 import com.esotericsoftware.kryonet.Client;
 import com.mygdx.game.controllers.commands.Command;
@@ -9,6 +10,7 @@ import com.mygdx.game.model.Player;
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Arrays;
 
 public class NetworkController {
 
@@ -21,7 +23,7 @@ public class NetworkController {
         this.client = new Client();
         client.start();
         try {
-            String IP4_LAN_ADDRESS = "192.168.0.136"; //"192.168.87.20";
+            String IP4_LAN_ADDRESS = "192.168.0.136"; //122 //"192.168.87.20";
             client.connect(10000, IP4_LAN_ADDRESS, 54555, 54777);
         } catch (IOException e) {
             e.printStackTrace();
@@ -50,6 +52,7 @@ public class NetworkController {
         kryo.register(cSetPlayerReady.class, 26);
         kryo.register(cSetPlayerName.class, 27);
         kryo.register(cStartGame.class, 28);
+        kryo.register(Vector3.class, 29);
     }
 
     public Client getClient() { return client; }

CheckersClient/core/src/com/mygdx/game/controllers/PlayerController.java

 package com.mygdx.game.controllers;
 
-import com.badlogic.gdx.utils.Null;
 import com.esotericsoftware.kryonet.Connection;
 import com.esotericsoftware.kryonet.Listener;
 import com.mygdx.game.controllers.commands.*;
@@ -20,6 +19,7 @@ public class PlayerController {
     private Player player;               //This is the current player
     private Lobby lobby;                 //Current lobby
     private ArrayList<Lobby> lobbies;    //List of all lobbies
+    private GameController gameController;
 
     public PlayerController(NetworkController networkController){
         net = networkController;
@@ -103,5 +103,11 @@ public class PlayerController {
 
     public Command getLastCommand(){ return receivedCommands.getFirst(); }
 
+    public void setGameController(GameController gameController) {
+        this.gameController = gameController;
+    }
 
+    public GameController getGameController() {
+        return gameController;
+    }
 }

CheckersClient/core/src/com/mygdx/game/controllers/commands/cPlayerPieceMove.java

 package com.mygdx.game.controllers.commands;
 
+import com.badlogic.gdx.math.Vector3;
 import com.esotericsoftware.kryonet.Connection;
-import com.mygdx.game.controllers.NetworkController;
 import com.mygdx.game.controllers.PlayerController;
 
+import java.util.ArrayList;
+import java.util.List;
+
 public class cPlayerPieceMove extends Command {
 
+    Vector3 fromCoordinates;
+    Vector3 toCordinates;
+    int lobby_id;
+    int playerId;
+
     public cPlayerPieceMove() {
         super("cPlayerPieceMove");
     }
 
+    public cPlayerPieceMove(Vector3 fromCoordinates, Vector3 toCoordinates, int lobbyId, int playerId) {
+        super("cPlayerPieceMove");
+
+        this.fromCoordinates = fromCoordinates;
+        this.toCordinates = toCoordinates;
+        this.lobby_id = lobbyId;
+        this.playerId = playerId;
+
+        ArrayList<Object> data = new ArrayList<Object>();
+        data.add(fromCoordinates);
+        data.add(toCoordinates);
+        data.add(playerId);
+
+        this.data = data;
+    }
+
     @Override
     public void execute(PlayerController playerController, Connection connection){
-        //SERVER LOGIC
-        System.out.println("Execute on client. Update model on both-, with views, animations and assets on client side.");
+        if (data instanceof ArrayList) {
+            List<Object> receivedData = (ArrayList<Object>) data;
+
+            Vector3 fromCoordinates = (Vector3) receivedData.get(0);
+            Vector3 toCoordinates = (Vector3) receivedData.get(1);
+            int playerId = (int) receivedData.get(2);
+
+            playerController.getGameController().playerMovedPiece(fromCoordinates, toCoordinates, playerId);
+            System.out.printf("Received move from other player. Player ID = %d \n", playerId);
+        }
     }
 }

CheckersClient/core/src/com/mygdx/game/model/Game.kt

 package com.mygdx.game.model
 
 import com.badlogic.gdx.math.Vector3
+import com.mygdx.game.controllers.GameController
 
-//Logic of the game, holds a GameState, operations
-//(((Controller???))) Model can change its own data, but has to be told by controller
-
-class Game(gameState: GameState) {
+class Game(gameState: GameState, playerIds: LinkedHashSet<Int>) {
 
     private var gameState: GameState
+    private var playerIds: LinkedHashSet<Int>
+    private var playerTurnId: Int
+    private var playerTurnIndex: Int = 0 // TODO: Random from server
+    private var playerTurnSlot: Int
+    private var playerFinishedIds: List<Int> = listOf()
+    private var usedBoardSlots: List<Int>
 
     init {
         this.gameState = gameState
+        this.playerIds = playerIds
+        this.gameState.getBoardState().placePiecesAtStart(this.gameState.getRules(), this.playerIds)
+
+        usedBoardSlots =  this.gameState.getRules().getUsedBoardSlots(playerIds.size)
+        playerTurnSlot = usedBoardSlots[0]
+        playerTurnId = playerIds.elementAt(playerTurnIndex)
     }
 
-    fun getStartFieldCoordinates(): List<List<Vector3>>? {
-        return this.gameState.getRules()?.generateStartFields()
+    fun getStartFieldCoordinates(): List<List<Vector3>> {
+        return this.gameState.getRules().generateStartFields(playerIds.size)
     }
 
     fun fieldExists(cubeCoordinates: Vector3): Boolean {
-        return this.gameState.getBoardState()?.fieldExists(cubeCoordinates) ?: false
+        return this.gameState.getBoardState().fieldExists(cubeCoordinates)
     }
 
     fun fieldHasPiece(cubeCoordinates: Vector3): Boolean {
-        print(this.gameState.getBoardState()?.fields?.get(cubeCoordinates)?.hasPiece())
-        return this.gameState.getBoardState()?.fields?.get(cubeCoordinates)?.hasPiece() == true
+        return this.gameState.getBoardState().fields[cubeCoordinates]?.hasPiece() == true
     }
 
-    fun movePiece(fromCoordinates: Vector3, toCoordinates: Vector3): Boolean {
+    fun movePiece(fromCoordinates: Vector3, toCoordinates: Vector3, playerId: Int, gameController: GameController): Boolean {
+        // Check if players turn
+        if (playerId == playerTurnId) {
             // TODO: Check if valid move
-        return this.gameState.getBoardState()?.movePiece(fromCoordinates, toCoordinates) ?: false
+            val pieceMoved: Boolean = this.gameState.getBoardState().movePiece(fromCoordinates, toCoordinates)
+
+            if (pieceMoved) {
+                if (isPlayerFinished(playerId)) {
+                    playerFinishedIds = playerFinishedIds + playerId
+                    gameController.setPlayerFinished(playerId, playerFinishedIds.size)
+
+                    // First player finished, he/she wins
+                    if (playerFinishedIds.size == 1) {
+                        this.gameState.setWinner(playerId)
+                    }
+                    // All players are finished
+                    if (playerFinishedIds.size == playerIds.size) {
+                        gameController.setGameFinished()
+                        this.gameState.setFinished()
+                    }
+                }
+                nextPlayer()
+            }
+
+            return pieceMoved
+        } else {
+            return false
+        }
+    }
+
+    fun getPlayerTurnId(): Int {
+        return playerTurnId
+    }
+
+    fun getPlayerTurnSlot(): Int {
+        return usedBoardSlots[playerTurnIndex]
     }
 
-    fun isPlayerFinished(player: Player): Boolean {
-        val targetFields = this.gameState.getRules()?.getPlayerTargetFields(player.id)
+    private fun nextPlayer() {
+        do {
+            playerTurnIndex++
+            if (playerTurnIndex == playerIds.size) {
+                playerTurnIndex = 0
+            }
+            playerTurnId = playerIds.elementAt(playerTurnIndex)
+        } while (playerFinishedIds.contains(playerTurnId) && playerFinishedIds.size < playerIds.size)
+    }
+
+    fun getPieceOwnerId(coordinates: Vector3): Int {
+
+        return gameState.getBoardState().fields[coordinates]?.getPiece()?.getOwnerId() ?: -1
+    }
+
+    fun isPlayerFinished(playerId: Int): Boolean {
+        if (playerFinishedIds.contains(playerId)) {
+            return true
+        }
+
+        val boardSlot = usedBoardSlots[playerIds.indexOf(playerId)];
+        val targetFields = this.gameState.getRules().getPlayerTargetFields(boardSlot)
 
-        if (targetFields != null) {
         for (targetField: Vector3 in targetFields) {
-                if (this.gameState.getBoardState()?.fields?.get(targetField)?.getPiece()?.getOwner()?.id != player.id) {
+            if (this.gameState.getBoardState().fields[targetField]?.getPiece()?.getOwnerId() != playerId) {
                 return false
             }
         }
-        }
+
         return true
     }
 
     fun getGameState(): GameState? {
         return this.gameState
     }
+
+    fun getUsedBoardSlots(): List<Int> {
+        return usedBoardSlots
+    }
+
+    fun getPlayerNameCoordinates(hex_side_length: Float): List<List<Float>> {
+        return gameState.getRules().getPlayerNameCoordinates(hex_side_length)
+    }
 }
\ No newline at end of file

CheckersClient/core/src/com/mygdx/game/model/GameMode.kt

@@ -4,10 +4,10 @@ import com.badlogic.gdx.math.Vector3
 
 //Holds a ruleset and a board
 
-class GameMode(rules:AbstractRules? = null, board:AbstractBoard? = null) {
+class GameMode(rules:AbstractRules, board:AbstractBoard) {
 
-    private var rules: AbstractRules?
-    private var board: AbstractBoard?
+    private var rules: AbstractRules
+    private var board: AbstractBoard
 
     init {
         this.rules = rules
@@ -18,7 +18,7 @@ class GameMode(rules:AbstractRules? = null, board:AbstractBoard? = null) {
         this.board = board
     }
 
-    fun getBoard(): AbstractBoard? {
+    fun getBoard(): AbstractBoard {
         return this.board
     }
 
@@ -26,7 +26,7 @@ class GameMode(rules:AbstractRules? = null, board:AbstractBoard? = null) {
         this.rules = rules
     }
 
-    fun getRules(): AbstractRules? {
+    fun getRules(): AbstractRules {
         return this.rules
     }
 
@@ -119,7 +119,7 @@ class GameMode(rules:AbstractRules? = null, board:AbstractBoard? = null) {
 
     fun getPossibleMoves(position: Vector3): ArrayList<Vector3> {
         var possibleMoves: ArrayList<Vector3> = arrayListOf()
-        zigzagAlgorithm(position, possibleMoves, this.rules?.moveRange ?: 1, this.rules?.jumpRange ?: 1)
+        zigzagAlgorithm(position, possibleMoves, this.rules.moveRange , this.rules?.jumpRange)
         return possibleMoves
     }
 }

CheckersClient/core/src/com/mygdx/game/model/GameState.kt

@@ -5,38 +5,28 @@ import com.mygdx.game.model.gamemodes.rules.DefaultRules
 /*
 Holds the state of the game and all data related to this.
 */
-class GameState(gameMode: GameMode? = null) {
+class GameState(gameMode: GameMode) {
 
-    private var gameMode: GameMode?
-    private var boardState:AbstractBoard?
-    private var rules:AbstractRules?
+    private var gameMode: GameMode
+    private var boardState: AbstractBoard
+    private var rules: AbstractRules
     private var isStarted: Boolean
-    private var winner: Player?
+    private var winner: Int?
+    private var isFinished: Boolean = false
 
     init {
         this.gameMode = gameMode
-        if (gameMode == null) {
-            this.rules = null
-            this.boardState = null
-        } else {
         this.rules = gameMode.getRules()
         this.boardState = gameMode.getBoard()
-            this.rules?.let { this.boardState?.placePiecesAtStart(this.rules!!, it.generateStartFields()) }
-        }
         this.isStarted = false
         this.winner = null
     }
 
-    fun setBoardState(boardState: AbstractBoard) {
-        this.boardState = boardState
-        this.rules?.let { this.boardState!!.placePiecesAtStart(this.rules!!, it.generateStartFields()) }
-    }
-
-    fun getBoardState(): AbstractBoard? {
+    fun getBoardState(): AbstractBoard {
         return boardState
     }
 
-    fun getRules(): AbstractRules? {
+    fun getRules(): AbstractRules {
         return rules
     }
 
@@ -53,17 +43,18 @@ class GameState(gameMode: GameMode? = null) {
     }
 
     fun isFinished(): Boolean {
-        if (this.winner != null) {
-            return true
-        }
-        return false
+        return isFinished
     }
 
-    fun getWinner(): Player? {
+    fun getWinner(): Int? {
         return this.winner
     }
 
-    fun setWinner(winner: Player) {
+    fun setWinner(winner: Int) {
         this.winner = winner
     }
+
+    fun setFinished() {
+        isFinished = true
+    }
 }
\ No newline at end of file

CheckersClient/core/src/com/mygdx/game/model/Lobby.java

@@ -2,6 +2,7 @@ package com.mygdx.game.model;
 
 import java.util.ArrayList;
 import java.util.HashSet;
+import java.util.LinkedHashSet;
 
 public class Lobby {
 
@@ -61,8 +62,8 @@ public class Lobby {
         return players;
     }
 
-    public HashSet<Integer> getPlayersID(){
-        HashSet set = new HashSet();
+    public LinkedHashSet<Integer> getPlayersID(){
+        LinkedHashSet<Integer> set = new LinkedHashSet<Integer>();
         for(Player player : players){
             set.add((Integer) player.getID());
         }

CheckersClient/core/src/com/mygdx/game/model/Lobby.kt

 //Wich players are int the game, holds a Game
 //Controller?
+// TODO: remove? Replaced by Lobby.java
\ No newline at end of file

CheckersClient/core/src/com/mygdx/game/model/Piece.kt

 package com.mygdx.game.model
 
-class Piece(owner: Player) {
+class Piece(ownerId: Int) {
 
-    private var owner: Player
+    private var ownerId: Int = ownerId
 
-    init {
-        this.owner = owner
+    fun getOwnerId(): Int {
+        return this.ownerId
     }
-
-    fun getOwner(): Player {
-        return this.owner
-    }
-
 }

CheckersClient/core/src/com/mygdx/game/model/gamemodes/boards/AbstractBoard.kt

@@ -8,6 +8,6 @@ abstract class AbstractBoard {
 
     abstract fun computeFields() // Computes all fields on the board
     abstract fun fieldExists(coordinates: Vector3): Boolean
-    abstract fun placePiecesAtStart(rules: AbstractRules, startFieldCoordinates: List<List<Vector3>>)
+    abstract fun placePiecesAtStart(rules: AbstractRules, playerIds: HashSet<Int>)
     abstract fun movePiece(fromCoordinates: Vector3, toCoordinates: Vector3): Boolean
 }
\ No newline at end of file

CheckersClient/core/src/com/mygdx/game/model/gamemodes/boards/DefaultBoard.kt

@@ -27,14 +27,13 @@ class DefaultBoard: AbstractBoard() {
         }
     }
 
-    override fun placePiecesAtStart(rules: AbstractRules, startFieldCoordinates: List<List<Vector3>>) {
-        var playerId = 0
+    override fun placePiecesAtStart(rules: AbstractRules, playerIds: HashSet<Int>) {
 
-        for (coordinateSet: List<Vector3> in startFieldCoordinates) {
-            val player = Player(playerId++)
+        val startFields: List<List<Vector3>> = rules.generateStartFields(playerIds.size)
 
+        for ((playerIndex, coordinateSet: List<Vector3>) in startFields.withIndex()) {
             for (coordinate: Vector3 in coordinateSet) {
-                val piece = Piece(player)
+                val piece = Piece(playerIds.elementAt(playerIndex))
                 fields[coordinate]?.setPiece(piece)
             }
         }
@@ -46,6 +45,7 @@ class DefaultBoard: AbstractBoard() {
 
     override fun movePiece(fromCoordinates: Vector3, toCoordinates: Vector3): Boolean {
         val piece = fields[fromCoordinates]?.getPiece()
+
         if (piece != null) {
             fields[toCoordinates]?.setPiece(piece)
             fields[fromCoordinates]?.removePiece()

CheckersClient/core/src/com/mygdx/game/model/gamemodes/rules/AbstractRules.kt

@@ -5,10 +5,14 @@ import com.badlogic.gdx.math.Vector3
 abstract class AbstractRules {
 
     abstract var startFields: List<List<Vector3>> // List containing list of startfields for each player
+
     abstract var moveRange: Int // How far a piece can be moved
     abstract var jumpRange: Int // How many pieces a piece can jump over
 
-    abstract fun getPlayerStartfields(playerId: Int) : List<Vector3>  // Returns a list of startfields for a given player
-    abstract fun getPlayerTargetFields(playerId: Int) : List<Vector3> // Returns a list of targetfields for a given player
-    abstract fun generateStartFields(): List<List<Vector3>>           // Returns a list with lists of startfields
+
+    abstract fun getPlayerStartfields(boardSlot: Int) : List<Vector3>                // Returns a list of startfields for a given player
+    abstract fun getPlayerTargetFields(boardSlot: Int) : List<Vector3>               // Returns a list of targetfields for a given player
+    abstract fun generateStartFields(playerCount: Int = 6): List<List<Vector3>>      // Returns a list with lists of startfields
+    abstract fun getUsedBoardSlots(playerCount: Int): List<Int>                      // Returns a list with used boardslots
+    abstract fun getPlayerNameCoordinates(hex_side_length: Float): List<List<Float>> // Returns a list with lists of coordinates for playernames
 }
\ No newline at end of file

CheckersClient/core/src/com/mygdx/game/model/gamemodes/rules/DefaultRules.kt

 package com.mygdx.game.model.gamemodes.rules
 
+import com.badlogic.gdx.Gdx
 import com.badlogic.gdx.math.Vector3
+import com.mygdx.game.Constants
 import com.mygdx.game.model.AbstractRules
-import com.mygdx.game.model.Field
 
 class DefaultRules: AbstractRules() {
-    // Sequence: top, upperright, lowerright, bottom, lowerleft, upperleft
     override var startFields = generateStartFields()
     override var moveRange = 1
     override var jumpRange = 2
 
-    override fun getPlayerStartfields(playerId: Int): List<Vector3> {
-        return startFields[playerId]
+    override fun getPlayerStartfields(boardSlot: Int): List<Vector3> {
+        return startFields[boardSlot]
     }
 
-    override fun getPlayerTargetFields(playerId: Int): List<Vector3> {
-        var index = playerId
+    override fun getPlayerTargetFields(boardSlot: Int): List<Vector3> {
+        var slot = boardSlot
 
         for (i in 0..2) {
-            index++
+            slot++
             // Wrap around to first player
-            if(index == 6) {
-                index = 0
+            if(slot == 6) {
+                slot = 0
             }
         }
-        return startFields[index]
+        return startFields[slot]
     }
 
-    override fun generateStartFields(): List<List<Vector3>> {
-        return(listOf(
+    // Sequence: top, upperright, lowerright, bottom, lowerleft, upperleft
+    override fun generateStartFields(playerCount: Int): List<List<Vector3>> {
+        val startFields: MutableList<List<Vector3>> = mutableListOf()
+        val allStartFields: List<List<Vector3>> = listOf(
                 listOf(Vector3(1F, 4F, -5F), Vector3(2F, 3F, -5F), Vector3(3F, 2F, -5F), Vector3(4F, 1F, -5F),
                         Vector3(2F, 4F, -6F), Vector3(3F, 3F, -6F), Vector3(4F, 2F, -6F), Vector3(3F, 4F, -7F),
                         Vector3(4F, 3F, -7F), Vector3(4F, 4F, -8F)
@@ -38,7 +40,7 @@ class DefaultRules: AbstractRules() {
                         Vector3(7F, -4F, -3F), Vector3(8F, -4F, -4F)
                 ),
                 listOf(Vector3(4F, -5F, 1F), Vector3(3F, -5F, 2F), Vector3(2F, -5F, 3F), Vector3(1F, -5F, 4F),
-                            Vector3(4F,6F,2F), Vector3(3F,-6F,3F), Vector3(2F,-6F,4F), Vector3(4F,-7F,3F),
+                        Vector3(4F, -6F, 2F), Vector3(3F, -6F, 3F), Vector3(2F, -6F, 4F), Vector3(4F, -7F, 3F),
                         Vector3(3F, -7F, 4F), Vector3(4F, -8F, 4F)
                 ),
                 listOf(Vector3(-4F, -1F, 5F), Vector3(-3F, -2F, 5F), Vector3(-2F, -3F, 5F), Vector3(-1F, -4F, 5F),
@@ -54,6 +56,49 @@ class DefaultRules: AbstractRules() {
                         Vector3(-4F, 7F, -3F), Vector3(-4F, 8F, -4F)
                 )
         )
+
+        when (playerCount) {
+            2 -> {
+                startFields.add(allStartFields[0])
+                startFields.add(allStartFields[3])
+            }
+            4 -> {
+                startFields.add(allStartFields[1])
+                startFields.add(allStartFields[2])
+                startFields.add(allStartFields[4])
+                startFields.add(allStartFields[5])
+            }
+            6 -> startFields.addAll(allStartFields)
+            else -> {
+                print("ERROR: DefaultBoard needs 2, 4 or 6 players.")
+            }
+        }
+
+        return startFields
+    }
+
+    override fun getUsedBoardSlots(playerCount: Int): List<Int> {
+        return when (playerCount) {
+            2 -> {
+                listOf(0, 3)
+            }
+            4 -> {
+                listOf(1, 2, 4, 5)
+            }
+            else -> {
+                listOf(0, 1, 2, 3, 4, 5)
+            }
+        }
+    }
+
+    override fun getPlayerNameCoordinates(hex_side_length: Float): List<List<Float>> {
+        return listOf(
+                listOf(Gdx.graphics.width / 2f - Constants.PLAYER_NAME_TEXT_FIELD_WIDTH - 2.5f * hex_side_length, Gdx.graphics.height - Constants.PLAYER_NAME_TEXT_FIELD_HEIGHT - 1.5f * hex_side_length),
+                listOf(Gdx.graphics.width / 2f + Constants.PLAYER_NAME_TEXT_FIELD_WIDTH + 4f * hex_side_length, Gdx.graphics.height / 2f + 4 * hex_side_length),
+                listOf(Gdx.graphics.width / 2f + Constants.PLAYER_NAME_TEXT_FIELD_WIDTH + 4f * hex_side_length, Gdx.graphics.height / 2f - 5 * hex_side_length),
+                listOf(Gdx.graphics.width / 2f - Constants.PLAYER_NAME_TEXT_FIELD_WIDTH - 2.5f * hex_side_length, 1.5f * hex_side_length),
+                listOf(Gdx.graphics.width / 2f - Constants.PLAYER_NAME_TEXT_FIELD_WIDTH - 12f * hex_side_length, Gdx.graphics.height / 2f - 5 * hex_side_length),
+                listOf(Gdx.graphics.width / 2f - Constants.PLAYER_NAME_TEXT_FIELD_WIDTH - 12f * hex_side_length, Gdx.graphics.height / 2f + 4 * hex_side_length)
         )
     }
 }

CheckersClient/core/src/com/mygdx/game/views/CinematicView.java

@@ -12,7 +12,13 @@ import com.badlogic.gdx.graphics.g2d.TextureRegion;
 import com.badlogic.gdx.scenes.scene2d.Stage;
 import com.badlogic.gdx.scenes.scene2d.ui.Image;
 import com.badlogic.gdx.scenes.scene2d.ui.Skin;
+import com.mygdx.game.controllers.GameController;
 import com.mygdx.game.controllers.PlayerController;
+import com.mygdx.game.model.DefaultBoard;
+import com.mygdx.game.model.Game;
+import com.mygdx.game.model.GameMode;
+import com.mygdx.game.model.GameState;
+import com.mygdx.game.model.gamemodes.rules.DefaultRules;
 import com.mygdx.game.views.enums.CharacterAssets;
 import com.mygdx.game.views.enums.CinematicAssets;
 import com.mygdx.game.views.enums.LobbyAssets;
@@ -161,7 +167,7 @@ public class CinematicView extends View{
         else{
             updateSpritesTimer+= dt;
             if(0<= timer && timer <= keyframe1){
-                System.out.println("KEYFRAME 1!!");
+                //System.out.println("KEYFRAME 1!!");
                 for(AnimatedSprite lobbyAvatar : lobbyAvatars){
                     if(updateSpritesTimer >= updateAvatarFrequency) {
                         lobbyAvatar.updateTexture();
@@ -170,7 +176,7 @@ public class CinematicView extends View{
                 }
             }
             if(keyframe1 <= timer &&  timer <= keyframe2){
-                System.out.println("KEYFRAME 2!!");
+                //System.out.println("KEYFRAME 2!!");
                 if(onlyOnce1){
                     cloudSprite.setAlpha(1);
                     countDownAnimationSprite.updateTexture();
@@ -192,7 +198,7 @@ public class CinematicView extends View{
                 rocketImage.setPosition(rocketImage.getX(), rocketImage.getY()+3);
                 exhaustImage.setPosition(exhaustImage.getX(), exhaustImage.getY()+3);
                 cam.position.set(rocketImage.getX(), rocketImage.getY(), 0);
-                System.out.println("KEYFRAME 3!!");
+                //System.out.println("KEYFRAME 3!!");
             }
             if(keyframe3 <= timer &&  timer <= keyframe4){
                 if(onlyOnce3) {
@@ -201,7 +207,7 @@ public class CinematicView extends View{
                 }
                 rocketImage.setPosition(rocketImage.getX(), rocketImage.getY()+50);
                 exhaustImage.setPosition(exhaustImage.getX(), exhaustImage.getY()+50);
-                System.out.println("KEYFRAME 4!!");
+                //System.out.println("KEYFRAME 4!!");
                 cloudSpriteAlpha -= dt*2;
                 cloudSprite.setAlpha(cloudSpriteAlpha);
             }
@@ -269,7 +275,15 @@ public class CinematicView extends View{
         if(fadeOutAlpha >= 1){
             stage.clear();
             startFadeout = false;
-            gvm.set(new PlayView(gvm, playerController, assetManager, stage, skin, lobbyAvatars));
+
+            // Initialize model and set PlayView
+            Game model = new Game(new GameState(new GameMode(new DefaultRules(), new DefaultBoard())), playerController.getLobby().getPlayersID());
+            PlayView playView = new PlayView(gvm, playerController, assetManager, stage, skin, lobbyAvatars);
+            GameController gameController = new GameController(model, playView, playerController);
+            playerController.setGameController(gameController);
+            playView.setGameController(gameController);
+
+            gvm.set(playView);
         }
     }
 

CheckersClient/core/src/com/mygdx/game/views/Constants.java

-package com.mygdx.game.views;
-
-public class Constants {
-    public static final Float SCALE_FACTOR_BOARD = 0.19F;
-    public static final Float SCALE_FACTOR_PIECE = 0.035F;
-    public static final Float HEX_SIDE_LENGTH = 28F;
-}

CheckersClient/core/src/com/mygdx/game/views/LobbyView.java

@@ -97,8 +97,15 @@ public class LobbyView extends View{
 
         this.portraitAtlas = (TextureAtlas) assetManager.get(CharacterAssets.PortraitsAtlas.path, CharacterAssets.PortraitsAtlas.classType);
 
+        if (currentSong == null) {
+            this.currentSong = Gdx.audio.newMusic(Gdx.files.internal(MenuAssets.LOOP_AUDIO.path));
+            this.currentSong.setVolume(1);
+            this.currentSong.setLooping(true);
+            this.currentSong.play();
+        } else {
             this.currentSong = currentSong;
-        fadeOutVolume = currentSong.getVolume();
+        }
+        fadeOutVolume = this.currentSong.getVolume();
 
         buttonClickAudio = (Sound) assetManager.get(MenuAssets.BUTTON_CLICK_AUDIO.path, MenuAssets.BUTTON_CLICK_AUDIO.classType);
         this.camera = stage.getCamera();
@@ -199,7 +206,7 @@ public class LobbyView extends View{
         lobbyCreateTextField.setPosition(lobbyListRefreshButton.getX(), lobbyListRefreshButton.getY()+row_height*1.25f);
 
         lobbyCreateSizeSelectBox =new SelectBox<>(skin);
-        lobbyCreateSizeSelectBox.setItems(2, 4, 6, 8);
+        lobbyCreateSizeSelectBox.setItems(2, 4, 6);
         lobbyCreateSizeSelectBox.setPosition(lobbyListBackButton.getX(), lobbyCreateTextField.getY());
         lobbyCreateSizeSelectBox.setSize(lobbyListBackButton.getWidth(), lobbyListBackButton.getHeight());
 
@@ -575,8 +582,8 @@ public class LobbyView extends View{
             for(int i = 0; i<lobby.getPlayers().size(); i++){
                 Player player = lobby.getPlayers().get(i);
 
-                System.out.println("Finding avatar with index:  " + player.getIndexAvatar());
-                System.out.println("Name is:  " + availableAvatarsHashMap.get(player.getIndexAvatar()));
+                //System.out.println("Finding avatar with index:  " + player.getIndexAvatar());
+                //System.out.println("Name is:  " + availableAvatarsHashMap.get(player.getIndexAvatar()));
 
                 String path = Enum.valueOf(CharacterAssets.class, availableAvatarsHashMap.get(player.getIndexAvatar())+"Atlas").path;
                 Class classType = Enum.valueOf(CharacterAssets.class, availableAvatarsHashMap.get(player.getIndexAvatar())+"Atlas").classType;
@@ -592,16 +599,17 @@ public class LobbyView extends View{
                 int remX = i%4;
                 int remY = mod(2, i+2);
                 int xPad = 10;
-                System.out.printf("remX: %d\tremY: %d\n", remX, remY);
+                //System.out.printf("remX: %d\tremY: %d\n", remX, remY);
                 animatedSprite.setPosition(lobbyImage.getX()-xPad+remX*((lobbyImage.getWidth()-xPad)/4), lobbyImage.getY()-remY*(lobbyImage.getHeight()/7.5f));
                 animatedSprite.setScale(0.3f+0.025f*remY, 0.3f+0.025f*remY);
                 lobbyAvatars.add(animatedSprite);
 
-                Label label = new Label("Player"+i+":\t%d" + player.getPlayerName() + "\t", skin, "black");
+                Label label = new Label("Player"+i+":\t" + player.getPlayerName() + "\t", skin, "black");
                 label.setColor(Color.BLACK);
                 label.scaleBy(2f);
-                label.setPosition(lobbyListBubbleImage.getX()+xpad, lobbyListBubbleImage.getY()+lobbyListBubbleImage.getHeight()*(0.9f-label.getHeight()*i-i*0.05f));
+                label.setPosition(lobbyListBubbleImage.getX()+xpad, lobbyListBubbleImage.getY()+lobbyListBubbleImage.getHeight() - (i + 1) * (label.getHeight() * 2.5F)); //(0.9f-label.getHeight()*i-i*0.05f));
 
+                stage.addActor(label);
                 lobbyLabels.add(label);
 
                 if(player.getIsPlayerReady()) {
@@ -612,7 +620,6 @@ public class LobbyView extends View{
                 else{
                     System.out.println("Player is not ready..");
                 }
-                stage.addActor(lobbyLabels.get(i));
             }
             for (Image image : playerReadyImages){
                 stage.addActor(image);
@@ -716,7 +723,6 @@ public class LobbyView extends View{
         if(Gdx.input.justTouched()){
             lastTouch[0] = Gdx.input.getX();
             lastTouch[1] = stage.getViewport().getScreenHeight()-Gdx.input.getY();
-            System.out.println("Only once");
         }
         if(Gdx.input.isTouched()){
             float camXPos = camera.position.x + (lastTouch[0]-Gdx.input.getX())* touchSensitivity; //camera.position.x + (Gdx.input.getX()-lastTouch[0])*sensitivity;
@@ -726,7 +732,6 @@ public class LobbyView extends View{
             float b = MathUtils.clamp(camYPos, camera.viewportHeight/2, backgroundImage.getImageHeight()-camera.viewportHeight/2);
 
             camera.position.set(a, b, 0);
-            System.out.println("Multiple times");
         }
     }