Merge branch 'master' of github.com:CAU-Kiel-Tech-Inf/socha

Author: SKoschnicke

plugin/src/shared/sc/plugin2019/Board.java

@@ -7,34 +7,56 @@
 import sc.shared.PlayerColor;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Collectors;
 
 import static sc.plugin2019.FieldState.OBSTRUCTED;
 
-/**
- * Spielbrett für Piranhas mit 10x10 Feldern.
- */
+/** Spielbrett für Piranhas mit {@link Constants#BOARD_SIZE}² Feldern. */
 @XStreamAlias(value = "board")
 public class Board implements IBoard {
 
   @XStreamImplicit(itemFieldName = "fields")
   private Field[][] fields;
 
   public Board() {
-    this.fields = new Field[Constants.BOARD_SIZE][Constants.BOARD_SIZE];
-    initialize();
+    this.fields = randomFields();
+  }
+
+  public Board(Board boardToClone) {
+    this.fields = emptyFields();
+    for(int x = 0; x < Constants.BOARD_SIZE; x++) {
+      for(int y = 0; y < Constants.BOARD_SIZE; y++) {
+        fields[x][y] = boardToClone.fields[x][y].clone();
+      }
+    }
+  }
+
+  @Override
+  public Board clone() {
+    return new Board(this);
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    return obj instanceof Board && Arrays.equals(((Board) obj).fields, this.fields);
+  }
+
+  private static Field[][] emptyFields() {
+   return new Field[Constants.BOARD_SIZE][Constants.BOARD_SIZE];
   }
 
   /** Erstellt eine zufälliges Spielbrett. */
-  private void initialize() {
-    for (int x = 0; x < Constants.BOARD_SIZE; x++) {
-      for (int y = 0; y < Constants.BOARD_SIZE; y++) {
+  private static Field[][] randomFields() {
+    Field[][] fields = emptyFields();
+    for(int x = 0; x < Constants.BOARD_SIZE; x++) {
+      for(int y = 0; y < Constants.BOARD_SIZE; y++) {
         fields[x][y] = new Field(x, y);
       }
     }
     // place piranhas
-    for (int index = 1; index < Constants.BOARD_SIZE - 1; index++) {
+    for(int index = 1; index < Constants.BOARD_SIZE - 1; index++) {
       fields[0][index].setPiranha(PlayerColor.RED);
       fields[Constants.BOARD_SIZE - 1][index].setPiranha(PlayerColor.RED);
       fields[index][0].setPiranha(PlayerColor.BLUE);
@@ -43,14 +65,12 @@ private void initialize() {
     // place obstacles
     // create a list of coordinates for fields which may be blocked
     List<Field> blockableFields = new ArrayList<>();
-    for (int x = Constants.OBSTACLES_START; x < Constants.OBSTACLES_END; x++) {
-      for (int y = Constants.OBSTACLES_START; y < Constants.OBSTACLES_END; y++) {
-        blockableFields.add(this.getField(x, y));
-      }
+    for(int x = Constants.OBSTACLES_START; x < Constants.OBSTACLES_END; x++) {
+      blockableFields.addAll(Arrays.asList(fields[x]).subList(Constants.OBSTACLES_START, Constants.OBSTACLES_END));
     }
     // set fields with randomly selected coordinates to blocked
     // coordinates may not lay on same horizontal, vertical or diagonal lines with other selected coordinates
-    for (int i = 0; i < Constants.NUM_OBSTACLES; i++) {
+    for(int i = 0; i < Constants.NUM_OBSTACLES; i++) {
       int indexOfFieldToBlock = (int) Math.floor(Math.random() * blockableFields.size());
       Field selectedField = blockableFields.get(indexOfFieldToBlock);
       selectedField.setState(OBSTRUCTED);
@@ -61,29 +81,14 @@ private void initialize() {
                       field.getX() + field.getY() == selectedField.getX() + selectedField.getY()))
       ).collect(Collectors.toList());
     }
-  }
-
-  /**
-   * erzeugt eine Deepcopy dieses Objekts
-   *
-   * @return ein neues Objekt mit gleichen Eigenschaften
-   */
-  @Override
-  public Board clone() {
-    Board clone = new Board();
-    for (int x = 0; x < Constants.BOARD_SIZE; x++) {
-      for (int y = 0; y < Constants.BOARD_SIZE; y++) {
-        clone.fields[x][y] = fields[x][y].clone();
-      }
-    }
-    return clone;
+    return fields;
   }
 
   @Override
   public String toString() {
     StringBuilder b = new StringBuilder("Board {");
-    for (int x = 0; x < Constants.BOARD_SIZE; x++) {
-      for (int y = 0; y < Constants.BOARD_SIZE; y++) {
+    for(int x = 0; x < Constants.BOARD_SIZE; x++) {
+      for(int y = 0; y < Constants.BOARD_SIZE; y++) {
         b.append(fields[x][y].getPiranha());
       }
     }

plugin/src/shared/sc/plugin2019/Field.java

@@ -10,8 +10,7 @@
 import static sc.plugin2019.FieldState.*;
 
 /**
- * Ein Feld des Spielfelds. Ein Spielfeld ist durch den index eindeutig identifiziert.
- * Das type Attribut gibt an, um welchen Feldtyp es sich handelt.
+ * Ein Feld des Spielfelds. Ein Spielfeld hat eine x- und y-Koordinate und einen {@link FieldState}.
  */
 @XStreamAlias(value = "field")
 public class Field implements IField {
@@ -25,37 +24,44 @@ public class Field implements IField {
   @XStreamAsAttribute
   private FieldState state;
 
-  public Field(int x, int y) {
+  public Field(int x, int y, FieldState state) {
     this.x = x;
     this.y = y;
-    this.state = EMPTY;
+    this.state = state;
   }
 
-  public Field(int x, int y, FieldState state) {
-    this(x, y);
-    this.state = state;
+  public Field(int x, int y) {
+    this(x, y, EMPTY);
   }
 
   public Field(int x, int y, PlayerColor piranha) {
-    this(x, y);
-    if (piranha == PlayerColor.RED)
-      this.state = RED;
-    else
-      this.state = BLUE;
+    this(x, y, FieldState.from(piranha));
   }
 
   public Field(int x, int y, boolean isObstructed) {
-    this(x, y);
-    if (isObstructed) {
-      this.state = OBSTRUCTED;
-    } else {
-      this.state = EMPTY;
-    }
+    this(x, y, isObstructed ? OBSTRUCTED : EMPTY);
+  }
+
+  public Field(Field fieldToClone) {
+    this(fieldToClone.x, fieldToClone.y, fieldToClone.state);
   }
 
   @Override
   public Field clone() {
-    return new Field(this.x, this.y, this.state);
+    return new Field(this);
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if(!(obj instanceof Field))
+      return false;
+    Field field = (Field) obj;
+    return x == field.x && y == field.y && state == field.state;
+  }
+
+  @Override
+  public String toString() {
+    return String.format("Field(%d|%d){%s}", x, y, state);
   }
 
   public int getX() {
@@ -75,9 +81,9 @@ void setY(int y) {
   }
 
   public Optional<PlayerColor> getPiranha() {
-    if (state == RED)
+    if(state == RED)
       return Optional.of(PlayerColor.RED);
-    else if (state == BLUE)
+    else if(state == BLUE)
       return Optional.of(PlayerColor.BLUE);
 
     return Optional.empty();
@@ -89,13 +95,7 @@ else if (state == BLUE)
    * @param piranha Farbe des Piranhas
    */
   public void setPiranha(PlayerColor piranha) {
-    if (piranha == PlayerColor.RED) {
-      state = RED;
-    } else if (piranha == PlayerColor.BLUE) {
-      state = BLUE;
-    } else {
-      throw new IllegalStateException("The given PlayerColor does not exist");
-    }
+    state = FieldState.from(piranha);
   }
 
   public boolean isObstructed() {
@@ -106,11 +106,6 @@ public FieldState getState() {
     return state;
   }
 
-  @Override
-  public String toString() {
-    return String.format("Field(%d|%d){%s}", x, y, state);
-  }
-
   public void setState(FieldState state) {
     this.state = state;
   }

plugin/src/shared/sc/plugin2019/FieldState.java

@@ -1,8 +1,16 @@
 package sc.plugin2019;
 
+import sc.shared.PlayerColor;
+
 public enum FieldState {
   RED,
   BLUE,
   OBSTRUCTED,
-  EMPTY
+  EMPTY;
+  public static FieldState from(PlayerColor color) {
+    if(color == PlayerColor.RED)
+      return RED;
+    else
+      return BLUE;
+  }
 }

plugin/src/shared/sc/plugin2019/GameState.kt

@@ -20,21 +20,21 @@ class GameState(
         startPlayerColor = state.startPlayerColor
     }
 
-    override fun clone() = GameState(this)
+    public override fun clone() = GameState(this)
 
     @XStreamAsAttribute
     override var turn = 0
         set(value) {
             val turnLimit = Constants.ROUND_LIMIT * 2
-            if (value > turnLimit) throw InvalidGameStateException("Turn $value exceeded maxTurn $turnLimit")
+            if(value > turnLimit) throw InvalidGameStateException("Turn $value exceeds turnLimit($turnLimit)")
             field = value
         }
 
     fun getField(x: Int, y: Int) = board.getField(x, y)
 
     /** wechselt den Spieler, der aktuell an der Reihe ist, anhand der Zugzahl [turn]  */
     fun switchCurrentPlayer() {
-        currentPlayerColor = if (turn % 2 == 0) PlayerColor.RED else PlayerColor.BLUE
+        currentPlayerColor = if(turn % 2 == 0) PlayerColor.RED else PlayerColor.BLUE
     }
 
     override fun getPointsForPlayer(playerColor: PlayerColor) = GameRuleLogic.greatestSwarmSize(board, playerColor)
@@ -49,7 +49,7 @@ class GameState(
      *
      */
     fun getPlayerStats(playerColor: PlayerColor): IntArray =
-            getGameStats()[if (playerColor == PlayerColor.RED) Constants.GAME_STATS_RED_INDEX else Constants.GAME_STATS_BLUE_INDEX]
+            getGameStats()[if(playerColor == PlayerColor.RED) Constants.GAME_STATS_RED_INDEX else Constants.GAME_STATS_BLUE_INDEX]
 
     /**
      * Liefert Statusinformationen zum Spiel. Diese sind ein Array der
@@ -74,9 +74,9 @@ class GameState(
      * Spielclient i.A. nicht aufgerufen werden!
      */
     fun addPlayer(player: Player) {
-        if (player.color == PlayerColor.RED) {
+        if(player.color == PlayerColor.RED) {
             red = player
-        } else if (player.color == PlayerColor.BLUE) {
+        } else if(player.color == PlayerColor.BLUE) {
             blue = player
         }
     }

plugin/src/shared/sc/plugin2019/util/Constants.java

@@ -5,6 +5,7 @@ public class Constants {
   public static final int ROUND_LIMIT = 30;
   public static final String WINNING_MESSAGE = "Das Spiel ist beendet.\nEin Spieler hat seinen Schwarm vereint.";
   public static final String ROUND_LIMIT_MESSAGE = "Das Rundenlimit wurde erreicht.";
+
   // for gamestats array
   public static final int GAME_STATS_SWARM_SIZE = 0;
   public static final int GAME_STATS_RED_INDEX = 0;

plugin/src/shared/sc/plugin2019/util/GameRuleLogic.java

@@ -64,12 +64,7 @@ public static boolean isValidToMove(GameState state, int x, int y, Direction dir
 
     List<Field> fieldsInDirection = getFieldsInDirection(board, x, y, direction);
 
-    FieldState opponentFieldColor;
-    if (state.getCurrentPlayerColor() == PlayerColor.RED) {
-      opponentFieldColor = FieldState.BLUE;
-    } else {
-      opponentFieldColor = FieldState.RED;
-    }
+    FieldState opponentFieldColor = FieldState.from(state.getCurrentPlayerColor().opponent());
 
     for (Field f : fieldsInDirection) {
       if (f.getState() == opponentFieldColor) {
@@ -139,7 +134,6 @@ private static Set<Field> getSwarm(Board board, Set<Field> found, Set<Field> swa
     if (swarm.size() != tmpSwarm.size())
       tmpSwarm = getSwarm(board, found, tmpSwarm);
 
-
     swarm.addAll(tmpSwarm);
 
     found.removeAll(swarm);

socha-sdk/src/server-api/sc/api/plugins/IBoard.java

@@ -1,5 +1,5 @@
 package sc.api.plugins;
 
-public interface IBoard {
+public interface IBoard extends Cloneable {
   IField getField(int x, int y);
 }

socha-sdk/src/server-api/sc/api/plugins/IField.java

@@ -1,4 +1,4 @@
 package sc.api.plugins;
 
-public interface IField {
+public interface IField extends Cloneable {
 }