quentinlegot/turn-based-strategy-game
1
0
Fork 0
Code Issues Pull Requests Projects Releases Activity

add comments to Grid package, delete arguments to GridFacotryBuilder's methods where it's unnecessary

Browse Source
This commit is contained in:
Quentin Legot 2021-12-08 17:18:11 +01:00
parent 03be6c2a78
commit ea07ca0c6a
5 changed files with 161 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
server/src/main/java/fr/lnl/game/server/games/grid/Grid.java
View File

@ -1,4 +1,5 @@
package fr.lnl.game.server.games.grid;
import fr.lnl.game.server.games.grid.elements.*;
import fr.lnl.game.server.games.player.Player;
import fr.lnl.game.server.utils.Pair;
@ -8,7 +9,9 @@ import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
/**
* Class managing the board
*/
public class Grid {
private final HashMap<Point, Pair<Player, Box>> board;
private final int row;
@ -22,18 +25,32 @@ public class Grid {
board = new HashMap<>();
}
/**
* @see Grid#boardPositionIsValid(int, int)
*/
public boolean boardPositionIsValid(int row, int deltaRow, int column, int deltaColumn){
return boardPositionIsValid(row + deltaRow, column + deltaColumn);
}
/**
* Check if given position is in grid area
* @return true if position is valid, false otehrwise
*/
public boolean boardPositionIsValid(int row, int column) {
return row >= 0 && column >= 0 && row < this.row && column < this.column;
}
/**
* @see Grid#boardPositionIsValid(int, int)
*/
public boolean boardPositionIsValid(Point point) {
return boardPositionIsValid(point.getA(), point.getB());
}
/**
* @return the number of neutral box
* @see Grid#isNeutralBox(Box)
*/
public int getNumberNeutralBox(){
int countBox = 0;
for (int i = 1; i < row - 1; i++) {
@ -47,10 +64,21 @@ public class Grid {
return countBox;
}
/**
*
* @param box the box we'll look state
* @return true if {@code box} isn't a {@link Wall} or a {@link EnergyBall}
*/
public boolean isNeutralBox(Box box){
return !(box instanceof Wall) && !(box instanceof EnergyBall);
}
/**
* Given a string representation of the board.<br>
* Some characters in given string are in UTF-8 and can be poorly displayed if using an incompatible encoding, like
* on Windows where french regional encoding is {@code windows-1252}
* @return a string view of a board
*/
@Override
public String toString() {
StringBuilder str = new StringBuilder();

57
server/src/main/java/fr/lnl/game/server/games/grid/build/AbstractGridFactoryBuilder.java
View File

@ -17,35 +17,64 @@ public abstract class AbstractGridFactoryBuilder implements GridFactoryBuilder {
}
/**
* @param probability wall probability, which will be used by
* {@link AbstractGridFactoryBuilder#initPlaceInternWall()} when calling {@link GridFactoryBuilder#build()}
* @return {@code this}
* @see GridFactoryBuilder#wallProbability(float)
*/
public GridFactoryBuilder wallProbability(float probability) {
this.wallProbability = probability;
return this;
}
/**
* @param probability energy probability, which will be used by
* {@link AbstractGridFactoryBuilder#initPlaceEnergyBall()} when calling {@link GridFactoryBuilder#build()}
* @return {@code this}
* @see GridFactoryBuilder#energyProbability(float)
*/
public GridFactoryBuilder energyProbability(float probability) {
this.energyProbability = probability;
return this;
}
/**
*
* @param row row grid's size
* @param columns columns grid's size
* @return {@code this}
* @see GridFactoryBuilder#gridDimensions(int, int)
*/
public GridFactoryBuilder gridDimensions(int row, int columns) {
this.row = row;
this.columns = columns;
return this;
}
/**
* @param players list a players
* @return {@code this}
* @see GridFactoryBuilder#playersList(List)
*/
public GridFactoryBuilder playersList(List<Player> players) {
this.players = players;
return this;
}
/**
* Call this method after you call {{@link GridFactoryBuilder#energyProbability(float)}},
* {@link GridFactoryBuilder#wallProbability(float)}, {@link GridFactoryBuilder#gridDimensions(int, int)} and
* {@link GridFactoryBuilder#playersList(List)}. It'll instantiate a new {@link Grid} and initialize his components
* like border walls, intern walls, and energy using parameters given previously
* @return an instance of {@link Grid}
*/
@Override
public Grid build() {
this.grid = new Grid(row, columns, players);
initGrid();
initPlaceInternWall(wallProbability);
initPlaceEnergyBall(energyProbability);
initPlaceInternWall();
initPlaceEnergyBall();
return grid;
}
@ -53,9 +82,25 @@ public abstract class AbstractGridFactoryBuilder implements GridFactoryBuilder {
return grid;
}
/**
* abstract method used to initialize grid<br>
* We let implementation of this class the way to initialize the grid
*/
protected abstract void initGrid();
protected abstract void initPlaceEnergyBall(float probability);
protected abstract void initPlaceInternWall(float probability);
/**
* abstract method used to place energy ball<br>
* We let implementation of this class the way to initialize the grid<br>
* Implementation need to use {@link AbstractGridFactoryBuilder#energyProbability} to place energy balls
*/
protected abstract void initPlaceEnergyBall();
/**
* abstract method used to place intern walls(namely not border walls)<br>
* We let implementation of this class the way to initialize the grid.<br>
* Implementation need to use {@link AbstractGridFactoryBuilder#wallProbability} to place energy balls
*/
protected abstract void initPlaceInternWall();

47
server/src/main/java/fr/lnl/game/server/games/grid/build/GridFactoryBuilder.java
View File

@ -5,13 +5,56 @@ import fr.lnl.game.server.games.player.Player;
import java.util.List;
/**
* Factory pattern
*/
public interface GridFactoryBuilder {
Grid build();
void initPlacePlayers();
/**
* Set energy probability<br>
* @param probability energy probability, which will be used by
* {@link AbstractGridFactoryBuilder#initPlaceEnergyBall()} when calling {@link GridFactoryBuilder#build()}
* @return {@code this}
*/
GridFactoryBuilder energyProbability(float probability);
/**
* Set wall probability<br>
* @param probability wall probability, which will be used by
* {@link AbstractGridFactoryBuilder#initPlaceInternWall()} when calling {@link GridFactoryBuilder#build()}
* @return {@code this}
*/
GridFactoryBuilder wallProbability(float probability);
/**
* set grid dimensions.
* Arguments are given when instancing {@link Grid} when using {@link GridFactoryBuilder#build()}
* @param row row grid's size
* @param columns columns grid's size
* @return {@code this}
*/
GridFactoryBuilder gridDimensions(int row, int columns);
/**
* set players list.
* Argument given to {@link Grid} when calling {@link GridFactoryBuilder#build()}
* @param players list a players
* @return {@code this}
*/
GridFactoryBuilder playersList(List<Player> players);
/**
* Call this method after you call {{@link GridFactoryBuilder#energyProbability(float)}},
* {@link GridFactoryBuilder#wallProbability(float)}, {@link GridFactoryBuilder#gridDimensions(int, int)} and
* {@link GridFactoryBuilder#playersList(List)}, It'll instantiate a new {@link Grid} and initialize his components
* like border walls, intern walls, and energy using parameters given previously
* @return an instance of {@link Grid}
*/
Grid build();
/**
* call when initializing the game, it'll place player depending on the strategy used by its implementation
*/
void initPlacePlayers();
}

38
server/src/main/java/fr/lnl/game/server/games/grid/build/LockGridFactoryBuilder.java
View File

@ -13,14 +13,25 @@ import java.util.Random;
public class LockGridFactoryBuilder extends AbstractGridFactoryBuilder {
/**
* this method is protected to avoid new instance outside of {@link GridFactoryBuilder} context
*/
protected LockGridFactoryBuilder() {
}
/**
* @return a new instance of {@link LockGridFactoryBuilder} used to construct a {@link Grid}
*/
public static GridFactoryBuilder create() {
return new LockGridFactoryBuilder();
}
/**
* Method used to initialize grid<br>
* We place walls on every border, and we initialize board value as null where there is no need o border walls
* @see AbstractGridFactoryBuilder#initGrid()
*/
@Override
protected void initGrid() {
for (int i = 0; i < getGrid().getRow(); i++) {
@ -50,11 +61,16 @@ public class LockGridFactoryBuilder extends AbstractGridFactoryBuilder {
}
}
/**
* Method used to initialize energy balls, we place energy balls using a random value and a probability and where
* there is no walls
* @see AbstractGridFactoryBuilder#initPlaceEnergyBall()
*/
@Override
protected void initPlaceEnergyBall(float probability) {
protected void initPlaceEnergyBall() {
for (int i = 1; i < getGrid().getRow() - 1; i++) {
for (int j = 1; j < getGrid().getColumn() - 1; j++) {
if(Math.random() >= probability){
if(Math.random() >= energyProbability){
Point point = new Point(i,j);
if(!(getGrid().getBoard().get(point).getB() instanceof Wall)){
getGrid().getBoard().get(point).setB(new EnergyBall());
@ -64,11 +80,16 @@ public class LockGridFactoryBuilder extends AbstractGridFactoryBuilder {
}
}
/**
* Method used to place intern walls (opposite of border walls), we place walls using a random value and a
* probability and where there is no walls or where the position haven't a lock
* @see LockGridFactoryBuilder#getIllusionNumberWallNeighbour(Point)
*/
@Override
protected void initPlaceInternWall(float probability) {
protected void initPlaceInternWall() {
for (int i = 1; i < getGrid().getRow() - 1; i++) {
for (int j = 1; j < getGrid().getColumn() - 1; j++) {
if(Math.random() >= probability){
if(Math.random() >= wallProbability){
Point point = new Point(i,j);
if(getIllusionNumberWallNeighbour(point) <= 3){
getGrid().getBoard().get(point).setB(new Wall(i,j));
@ -82,6 +103,9 @@ public class LockGridFactoryBuilder extends AbstractGridFactoryBuilder {
}
}
/**
* Simply place player randomly where it's possible
*/
@Override
public void initPlacePlayers() {
Random random = new Random();
@ -102,6 +126,12 @@ public class LockGridFactoryBuilder extends AbstractGridFactoryBuilder {
}
}
/**
* A locked place is used to try to avoid player to be blocked when playing,
* A locked place can't have a wall on it
* @param point the position where we want to place a new wall
* @return number of walls and locked place around {@code position}
*/
public int getIllusionNumberWallNeighbour(Point point){
int countWall = 0;
for (int deltaRow = -1; deltaRow <= 1; deltaRow++){

4
server/src/test/java/fr/lnl/game/server/mock/MockGridFactoryBuilder.java
View File

@ -18,13 +18,13 @@ public class MockGridFactoryBuilder extends LockGridFactoryBuilder {
}
@Override
protected void initPlaceEnergyBall(float probability) {
protected void initPlaceEnergyBall() {
grid.getBoard().get(new Point(2,3)).setB(new EnergyBall());
grid.getBoard().get(new Point(8,10)).setB(new EnergyBall());
}
@Override
protected void initPlaceInternWall(float probability) {
protected void initPlaceInternWall() {
grid.getBoard().get(new Point(3,6)).setB(new Wall(3,6));
grid.getBoard().get(new Point(7,14)).setB(new Wall(7,14));
grid.getBoard().get(new Point(10,7)).setB(new Wall(10,7));