diff --git a/Projekte/mdga/model/src/main/java/pp/mdga/game/Game.java b/Projekte/mdga/model/src/main/java/pp/mdga/game/Game.java index b5ac8ff3..9d854c94 100644 --- a/Projekte/mdga/model/src/main/java/pp/mdga/game/Game.java +++ b/Projekte/mdga/model/src/main/java/pp/mdga/game/Game.java @@ -85,7 +85,7 @@ public Game() { gameStatistics = new Statistic(); initializeDrawPile(); board = new Board(); - die = new Die(2,5,6,3,6); + die = new Die(5,5,5,5,5,5,5,5,5,1,1,6,2,4,6,5,5,5,5,5); } /** @@ -208,6 +208,15 @@ public Player getPlayerByColor(Color color) { return null; } + /** + * This method will be used to the get the active player + * + * @return the active player + */ + public Player getActivePlayer(){ + return getPlayerByColor(activeColor); + } + /** * This method will be used to return all connected players as a list. * diff --git a/Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/TurnState.java b/Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/TurnState.java index c135410e..a752ca15 100644 --- a/Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/TurnState.java +++ b/Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/TurnState.java @@ -190,6 +190,7 @@ public void setCurrentState(TurnAutomatonState state) { if (this.currentState != null) { this.currentState.exit(); } + System.out.println("Server: the server entered:"+state); this.currentState = state; this.currentState.enter(); } diff --git a/Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/turn/choosepiece/ChoosePieceAutomatonState.java b/Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/turn/choosepiece/ChoosePieceAutomatonState.java index b4d5c679..b395d7fa 100644 --- a/Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/turn/choosepiece/ChoosePieceAutomatonState.java +++ b/Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/turn/choosepiece/ChoosePieceAutomatonState.java @@ -1,5 +1,6 @@ package pp.mdga.server.automaton.game.turn.choosepiece; +import com.jme3.util.SortUtil; import pp.mdga.game.*; import pp.mdga.message.client.AnimationEndMessage; import pp.mdga.server.ServerGameLogic; @@ -17,20 +18,21 @@ public abstract class ChoosePieceAutomatonState extends ServerState { * Constructs a server state of the specified game logic. * * @param choosePieceAutomaton as the automaton of the choose piece state as a ChoosePieceState object. - * @param logic the game logic + * @param logic the game logic */ public ChoosePieceAutomatonState(ChoosePieceState choosePieceAutomaton, ServerGameLogic logic) { super(logic); this.choosePieceAutomaton = choosePieceAutomaton; } - protected boolean canMove(Piece piece){ + /* + protected boolean canMove(Piece piece) { int steps = logic.getGame().getDiceModifier() * logic.getGame().getDiceEyes(); - if (piece.getState().equals(PieceState.HOME)){ + if (piece.getState().equals(PieceState.HOME)) { return canHomeMove(piece, steps); } else { int homeMoves = getHomeMoves(piece, steps); - if (homeMoves > 0){ + if (homeMoves > 0) { return canHomeMove(piece, homeMoves); } else { return canInfieldMove(piece, steps); @@ -38,52 +40,60 @@ protected boolean canMove(Piece piece){ } } - protected int getHomeMoves(Piece piece, int steps){ + */ + /* + protected int getHomeMoves(Piece piece, int steps) { int pieceIndex = logic.getGame().getBoard().getInfieldIndexOfPiece(piece); Color color = piece.getColor(); int startIndex = logic.getGame().getPlayerByColor(color).getStartNodeIndex(); int moveIndex = pieceIndex + steps; - if (moveIndex > logic.getGame().getBoard().getInfield().length){ - if (startIndex > pieceIndex){ - return steps - (startIndex - pieceIndex -1); + if (moveIndex > logic.getGame().getBoard().getInfield().length) { + if (startIndex > pieceIndex) { + return steps - (startIndex - pieceIndex - 1); } moveIndex %= logic.getGame().getBoard().getInfield().length; - if (moveIndex >= startIndex){ + if (moveIndex >= startIndex) { return moveIndex - startIndex + 1; } return 0; } - if (pieceIndex < startIndex && startIndex <= moveIndex){ + if (pieceIndex < startIndex && startIndex <= moveIndex) { return moveIndex - startIndex + 1; } return 0; } - private boolean canInfieldMove(Piece piece, int steps){ + */ + /* + + + private boolean canInfieldMove(Piece piece, int steps) { int pieceIndex = logic.getGame().getBoard().getInfieldIndexOfPiece(piece); int moveIndex = (pieceIndex + steps) % logic.getGame().getBoard().getInfield().length; Piece occupant = logic.getGame().getBoard().getInfield()[moveIndex].getOccupant(); - if (occupant != null){ + if (occupant != null) { return occupant.getColor() != piece.getColor(); } return true; } - private boolean canHomeMove(Piece piece, int moveIndex){ + */ + /* + private boolean canHomeMove(Piece piece, int moveIndex) { Color color = piece.getColor(); Player player = logic.getGame().getPlayerByColor(color); Node[] homeNodes = player.getHomeNodes(); int index; - if (player.pieceInsideOfHome(piece)){ + if (player.pieceInsideOfHome(piece)) { index = player.getHomeIndexOfPiece(piece); } else { index = 0; } - if (index + moveIndex >= homeNodes.length){ + if (index + moveIndex >= homeNodes.length) { return false; } else { - for (int i = index; i <= index + moveIndex; i++){ - if(homeNodes[i].isOccupied()){ + for (int i = index; i <= index + moveIndex; i++) { + if (homeNodes[i].isOccupied()) { return false; } } @@ -91,9 +101,163 @@ private boolean canHomeMove(Piece piece, int moveIndex){ } } - protected int calculateTargetIndex(Piece piece){ + */ + /* + protected int calculateTargetIndex(Piece piece) { int steps = logic.getGame().getDiceModifier() * logic.getGame().getDiceEyes(); return (logic.getGame().getBoard().getInfieldIndexOfPiece(piece) + steps) % logic.getGame().getBoard().getInfield().length; } + + */ + + + /** + * returns true, if the piece can move inside the home or infield or move from the infield to the home + * + * @param piece the piece that will be checked + * @return true, if the piece can move + */ + protected boolean canMove(Piece piece){ + System.out.println("Server: ChoosePieceStateMachine: canMove: piece.getState()"+piece.getState()); + int steps = logic.getGame().getDiceModifier() * logic.getGame().getDiceEyes(); + System.out.println("Server: ChoosePieceStateAutomaton: canMove:"+canPieceMoveInHome(piece,steps)); + if(canPieceMoveInHome(piece,steps)){ + System.out.println("Server: ChoosePieceStateMachine:canMove: entered canMove/canPieceMoveInHome"); + return true; + } + int pieceIdx = logic.getGame().getBoard().getInfieldIndexOfPiece(piece); + System.out.println("ChoosePieceAutomaton: pieceIndex:"+ pieceIdx); + int startIdx = logic.getGame().getActivePlayer().getStartNodeIndex(); + int normPieceIdx = (-startIdx+pieceIdx+40)%40; + int targetIdx = normPieceIdx+steps; + if(40> targetIdx){ + Color activeColor = logic.getGame().getActiveColor(); + System.out.println("ChoosePieceAutomaton: targetindex:"+ (pieceIdx+steps)%40); + Node tartgetNode =logic.getGame().getBoard().getInfield()[(pieceIdx+steps)%40]; + if(!tartgetNode.isOccupied(activeColor)){ + if(!tartgetNode.isOccupied()||tartgetNode.getOccupant().getShield() != ShieldState.ACTIVE){ + return true; + } + } + return true; + } + return false; + } + + /** + * tests if the piece can move in the home or inside the home + * @param piece + * @param steps + * @return false, if the piece can't move in the home + */ + protected boolean canPieceMoveInHome(Piece piece, int steps){ + //tests if the piece can move inside the home + System.out.println("Server: ChoosePieceStateMachine: canPieceMoveInHome: pieceState:" +piece.getState()); + if(piece.getState()==PieceState.HOME){ + System.out.println("Server: ChoosePieceStateMachine: canPieceMoveInHome: pieceState:reached if(piece.getState()==PieceState.HOME)"); + int homeIdx =logic.getGame().getActivePlayer().getHomeIndexOfPiece(piece); + if((4-homeIdx)>steps){ + System.out.println("Server: canPieceMoveInHome: !jumpOver"+ !jumpOver(steps,homeIdx,false)); + return !jumpOver(steps,homeIdx,false); + } + } + //tests if the piece can move in the home + if(piece.getState()==PieceState.ACTIVE){ + int pieceIdx = logic.getGame().getBoard().getInfieldIndexOfPiece(piece); + int startIdx = logic.getGame().getActivePlayer().getStartNodeIndex(); + int normPieceIdx = (-startIdx+pieceIdx+40)%40; + int targetIdx = normPieceIdx+steps; + System.out.println("Server: ChoosePieceStateMachine: canPieceMoveInHome: pieceIndex:" +pieceIdx); + System.out.println("Server: ChoosePieceStateMachine: canPieceMoveInHome: targetIdx:" +targetIdx); + if(targetIdx >= 40){ + int stepsToHome = 39- normPieceIdx; + int restMovement = steps-stepsToHome; + System.out.println("Server: ChoosePieceStateMachine: canPieceMoveInHome: stepsToHome:" +stepsToHome); + System.out.println("Server: ChoosePieceStateMachine: canPieceMoveInHome: restMovement:" +restMovement); + System.out.println("Server: ChoosePieceStateMachine: canPieceMoveInHome: jumpOver:" +jumpOver(restMovement,0,true)); + if(4> restMovement){ + System.out.println("Server: ChoosePieceStateMachine: canPieceMoveInHome: return:" +true); + return !jumpOver(restMovement,0,true); + } + } + } + System.out.println("Server: ChoosePieceStateMachine: canPieceMoveInHome: return:" +false); + return false; + } + + /** + * tests if the piece, when moved in or inside a home, must jump over another piece + * + * @param stepsInHome the steps walked inside the home + * @param homeIdx the index of the piece inside, or 0 if come from outside + * @param outside a boolean, if the piece moves inside a house or in a house + * @return false, if there is no piece to jump over + */ + private boolean jumpOver(int stepsInHome,int homeIdx,boolean outside){ + //tests if the piece comes from the outside in the home + if(outside){ + for(int i =0;i < stepsInHome;i++){ + if(logic.getGame().getActivePlayer().getHomeNodes()[i].isOccupied()) return true; + } + } + //tests if the piece jumps over a piece inside the home + else{ + for(int i = 1+homeIdx; i moveablePieces = new ArrayList<>(); for (Piece piece : activePlayer.getPieces()){ if (piece.getState().equals(PieceState.ACTIVE) || piece.getState().equals(PieceState.HOME)){ + System.out.println("Server: NoPieceState: movablePieces.size()"+piece.getState()); moveablePieces.add(piece); } } + System.out.println("Server: NoPieceState: movablePieces.size()"+moveablePieces.size()); + System.out.println("Server: NoPiece: piece.getState"+moveablePieces.get(0).getState()); moveablePieces.removeIf(piece -> !canMove(piece)); + System.out.println("Server: NoPieceState: movablePieces.size(): after deletion:"+moveablePieces.size()); if (moveablePieces.isEmpty()) { this.choosePieceAutomaton.setCurrentState(this.choosePieceAutomaton.getNoTurnState()); } else { diff --git a/Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/turn/choosepiece/SelectPieceState.java b/Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/turn/choosepiece/SelectPieceState.java index 9aca4089..a49f34c9 100644 --- a/Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/turn/choosepiece/SelectPieceState.java +++ b/Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/turn/choosepiece/SelectPieceState.java @@ -1,9 +1,6 @@ package pp.mdga.server.automaton.game.turn.choosepiece; -import pp.mdga.game.Node; -import pp.mdga.game.Piece; -import pp.mdga.game.PieceState; -import pp.mdga.game.ShieldState; +import pp.mdga.game.*; import pp.mdga.message.client.RequestMoveMessage; import pp.mdga.message.server.MoveMessage; import pp.mdga.message.server.SelectPieceMessage; @@ -39,6 +36,7 @@ public void setMoveablePieces(ArrayList moveablePieces) { /** * This method will be used whenever this state will be entered. */ + /* @Override public void enter() { LOGGER.log(System.Logger.Level.DEBUG, "Entered SelectPieceState state."); @@ -55,18 +53,103 @@ public void enter() { } logic.getServerSender().send(logic.getGame().getActivePlayerId(), new SelectPieceMessage(moveablePieces, isHomeMove, targetIndex)); } + */ + + @Override + public void enter(){ + LOGGER.log(System.Logger.Level.DEBUG, "Entered SelectPieceState state in the Server."); + int steps = logic.getGame().getDiceModifier() * logic.getGame().getDiceEyes(); + for (Piece piece : moveablePieces) { + + if(canPieceMoveInHome(piece,steps)){ + int target= getHomeTargetIdx(piece); + System.out.println("Server: SelectPieceState: enter in canPieceMoveInHome: targetIndex:"+target); + targetIndex.add(target); + isHomeMove.add(true); + } + else{ + int target = getInfieldTarget(piece); + System.out.println("Server: SelectPieceState: enter in else: targetIndex:"+target); + targetIndex.add(target); + isHomeMove.add(false); + } + } + System.out.println("Server: SelectPiece: enter: send: "+moveablePieces.get(0)+isHomeMove.get(0)+targetIndex.get(0)); + logic.getServerSender().send(logic.getGame().getActivePlayerId(), new SelectPieceMessage(moveablePieces, isHomeMove, targetIndex)); + } @Override public void received(RequestMoveMessage msg, int from){ if(!moveablePieces.contains(msg.getPiece())){ throw new RuntimeException("invalid Piece"); } - int indexOfPiece = moveablePieces.indexOf(msg.getPiece()); - Piece movePiece = moveablePieces.get(indexOfPiece); + int steps = logic.getGame().getDiceModifier() * logic.getGame().getDiceEyes(); + Piece piece = moveablePieces.get(indexOfPiece); + if(canPieceMoveInHome(piece,steps)){ + System.out.println("Server: SelectPieceState: canPieceMoveInHome(piece,steps)"); + if(piece.getState()==PieceState.HOME) { + System.out.println("Server: SelectPieceState: piece.getState()==PieceState.HOME"); + //gets the oldNode + int homeIndex = logic.getGame().getActivePlayer().getHomeIndexOfPiece(piece); + Node oldNode = logic.getGame().getActivePlayer().getHomeNodes()[homeIndex]; + //gets the targetNode + int targetHomeIdx = getHomeTargetIdx(piece); + Node targetNode = logic.getGame().getActivePlayer().getHomeNodes()[targetHomeIdx]; + + oldNode.clearOccupant(); + targetNode.setOccupant(piece); + if (targetHomeIdx == 3) { + piece.setState(PieceState.HOMEFINISHED); + } + else{ + piece.setState(PieceState.HOME); + } + } + else{ + System.out.println("Server: SelectPieceState: entered else"); + int oldNoteIdx = logic.getGame().getBoard().getInfieldIndexOfPiece(piece); + Node oldNode = logic.getGame().getBoard().getInfield()[oldNoteIdx]; + + //gets the targetNode + int targetHomeIdx = getHomeTargetIdx(piece); + Node targetNode = logic.getGame().getActivePlayer().getHomeNodes()[targetHomeIdx]; + + oldNode.clearOccupant(); + targetNode.setOccupant(piece); + + if (targetHomeIdx == 3) { + piece.setState(PieceState.HOMEFINISHED); + } + piece.setState(PieceState.HOME); + System.out.println("Server: SelectPieceMessage: received(RequestMoveMessage): setPiece(Home)"+piece.getState()); + } + } + else{ + int oldNoteIdx = logic.getGame().getBoard().getInfieldIndexOfPiece(piece); + Node oldNode = logic.getGame().getBoard().getInfield()[oldNoteIdx]; + + int targetIndex = (oldNoteIdx+steps)%40; + Node targetNode = logic.getGame().getBoard().getInfield()[targetIndex]; + + oldNode.clearOccupant(); + targetNode.setOccupant(piece); + + Piece occ = targetNode.getOccupant(); + if (occ != null) { + logic.getGame().getPlayerByColor(occ.getColor()).addWaitingPiece(occ); + } + + if(targetNode instanceof StartNode){ + if(piece.getShield()== ShieldState.ACTIVE) piece.setShield(ShieldState.SUPPRESSED); + } + + } + + System.out.println("Server: SelectPieceMessage: received(RequestMoveMessage): pieceState: wichtig"+piece.getState()); boolean homeMove = isHomeMove.get(indexOfPiece); int targIdx = targetIndex.get(indexOfPiece); - + /* Node oldNode = logic.getGame().getBoard().getInfield()[logic.getGame().getBoard().getInfieldIndexOfPiece(movePiece)]; oldNode.clearOccupant(); if (homeMove) { @@ -88,7 +171,10 @@ public void received(RequestMoveMessage msg, int from){ } targetNode.setOccupant(msg.getPiece()); } - logic.getServerSender().broadcast(new MoveMessage(movePiece, homeMove, targIdx)); + + */ + logic.getServerSender().broadcast(new MoveMessage(piece, homeMove, targIdx)); + System.out.println("Server changes from SelectPieceState to movePieceState"); this.choosePieceAutomaton.getTurnAutomaton().setCurrentState(this.choosePieceAutomaton.getTurnAutomaton().getMovePieceState()); }