peet/Gruppe-01-fin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

reenvented the wheel (; , rewrite the canMove-logic, etc

Browse Source
This commit is contained in:
Benjamin Feyer
2024-12-09 04:32:55 +01:00
parent 521c7439c2
commit e05b057190
5 changed files with 291 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
Projekte/mdga/model/src/main/java/pp/mdga/game/Game.java
View File

@@ -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.
*

1
Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/TurnState.java
View File

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

200
Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/turn/choosepiece/ChoosePieceAutomatonState.java
View File

@@ -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<homeIdx+stepsInHome; i++){
if(logic.getGame().getActivePlayer().getHomeNodes()[i].isOccupied()) return true;
}
}
return false;
}
/**
* returns the index in the home, where the piece will go in the home
*
* @param piece the give piece
* @return the index in the home, where the piece will go
*/
protected int getHomeTargetIdx (Piece piece){
int steps = logic.getGame().getDiceModifier() * logic.getGame().getDiceEyes();
if(piece.getState()==PieceState.ACTIVE) {
//gets the id's
int pieceIdx = logic.getGame().getBoard().getInfieldIndexOfPiece(piece);
int startIdx = logic.getGame().getActivePlayer().getStartNodeIndex();
//normalize the idx
int normPieceIdx = (-startIdx+pieceIdx+40)%40;
//calculate the steps to the home
int stepsToHome = 39- normPieceIdx;
//calculates the rest-movement inside a home
int restMovement = steps-stepsToHome;
return restMovement;
}
else{
int pieceHomeIdx = logic.getGame().getActivePlayer().getHomeIndexOfPiece(piece);
return pieceHomeIdx + steps;
}
}
/**
* returns the target index inside the infield
*
* @param piece the piece given
* @return the index in the infield
*/
protected int getInfieldTarget(Piece piece){
int steps = logic.getGame().getDiceModifier() * logic.getGame().getDiceEyes();
int index = logic.getGame().getBoard().getInfieldIndexOfPiece(piece);
return (steps+index)%40;
}
protected int calculateTargetIndex(Piece piece){
int steps = logic.getGame().getDiceModifier() * logic.getGame().getDiceEyes();
if(canPieceMoveInHome(piece, steps)){
System.out.println("Server: ChoosePieceStateAutomaton: calculate index in home:"+getHomeTargetIdx(piece));
return getHomeTargetIdx(piece);
}
return getInfieldTarget(piece);
}
}

4
Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/turn/choosepiece/NoPieceState.java
View File

@@ -59,10 +59,14 @@ private void checkSelectPiece(Player activePlayer){
ArrayList<Piece> 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 {

102
Projekte/mdga/model/src/main/java/pp/mdga/server/automaton/game/turn/choosepiece/SelectPieceState.java
View File

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