diff --git a/.idea/misc.xml b/.idea/misc.xml
index accd629..132404b 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -8,7 +8,7 @@
-
+
\ No newline at end of file
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index f51e524..9eb994b 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -4,11 +4,20 @@
-
+
+
-
+
+
+
+
+
+
+
+
+
@@ -49,23 +58,26 @@
- {
- "keyToString": {
- "RunOnceActivity.OpenProjectViewOnStart": "true",
- "RunOnceActivity.ShowReadmeOnStart": "true",
- "SHARE_PROJECT_CONFIGURATION_FILES": "true",
- "codeWithMe.voiceChat.enabledByDefault": "false",
- "git-widget-placeholder": "william",
- "last_opened_file_path": "/home/william/Dev/Projects",
- "node.js.detected.package.eslint": "true",
- "node.js.detected.package.tslint": "true",
- "node.js.selected.package.eslint": "(autodetect)",
- "node.js.selected.package.tslint": "(autodetect)",
- "nodejs_package_manager_path": "npm",
- "settings.editor.selected.configurable": "reference.settings.ide.settings.new.ui",
- "vue.rearranger.settings.migration": "true"
+
+}]]>
@@ -198,7 +210,14 @@
1681237323963
-
+
+ 1681238632769
+
+
+
+ 1681238632769
+
+
@@ -212,17 +231,7 @@
-
-
-
-
-
-
- file://$PROJECT_DIR$/src/main/java/laboratoire4/strategies/MasterStrategy.java
- 20
-
-
-
-
+
+
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index 848b6ab..43ab20d 100644
--- a/pom.xml
+++ b/pom.xml
@@ -9,9 +9,24 @@
1.0-SNAPSHOT
- 11
- 11
+ 8
+ 8
UTF-8
+
+
+
+ org.apache.maven.plugins
+ maven-jar-plugin
+
+
+
+ laboratoire4.Main
+
+
+
+
+
+
diff --git a/src/main/java/laboratoire4/game/PusherGame.java b/src/main/java/laboratoire4/game/PusherGame.java
index 5f9a53e..2d39da9 100644
--- a/src/main/java/laboratoire4/game/PusherGame.java
+++ b/src/main/java/laboratoire4/game/PusherGame.java
@@ -6,9 +6,8 @@ import laboratoire4.pawns.Pawn;
import laboratoire4.pawns.PawnMovement;
import laboratoire4.pawns.Pushed;
import laboratoire4.pawns.Pusher;
-import laboratoire4.strategies.MasterStrategy;
-import laboratoire4.strategies.Strategy;
import laboratoire4.strategies.EvaluationResult;
+import laboratoire4.strategies.MasterStrategy;
public class PusherGame implements Game {
private final Player player;
@@ -47,11 +46,14 @@ public class PusherGame implements Game {
}
public String runNextMove() {
-// MiniMaxResult result = MiniMax.miniMax(this);
- EvaluationResult result = MasterStrategy.getInstance().getNextMove(this);
+ EvaluationResult result = MasterStrategy.getInstance(this).getNextMove();
+ if (result == null) {
+ // Ce n'est pas censé arriver, on réessaie
+ System.err.println("Aucune résultat n'a été retourné!");
+ result = MasterStrategy.getInstance(this).getNextMove();
+ }
Pawn pawn = board[result.getRow()][result.getCol()];
-// System.out.println(result.getScore());
String initialPosition = pawn.getPosition();
move(pawn, result.getMovement());
diff --git a/src/main/java/laboratoire4/pawns/PawnUtils.java b/src/main/java/laboratoire4/pawns/PawnUtils.java
index c4ee406..2eaba8b 100644
--- a/src/main/java/laboratoire4/pawns/PawnUtils.java
+++ b/src/main/java/laboratoire4/pawns/PawnUtils.java
@@ -136,10 +136,10 @@ public class PawnUtils {
}
public static Collection> getActions(Game game, boolean max) {
- return getActions(game, max, true);
+ return getActions(game, max, true, false);
}
- public static Collection> getActions(Game game, boolean max, boolean excludeDefense) {
+ public static Collection> getActions(Game game, boolean max, boolean excludeDefense, boolean excludeDanger) {
List> actions = new ArrayList<>();
PawnMovement[] movements = PawnMovement.values();
@@ -160,13 +160,23 @@ public class PawnUtils {
for (PawnMovement movement : movements) {
if (pawn.isMoveValid(game.getBoard(), movement)) {
+ if (excludeDanger && PawnUtils.canBeCaptured(game, pawn.getRow() + pawn.getDirection(), pawn.getCol() + movement.getMove(), pawn.getPlayer())) {
+ continue;
+ }
+
actions.add(new Action<>(pawn, movement));
}
}
}
- if (excludeDefense && actions.isEmpty()) {
- return getActions(game, max, false);
+ if (actions.isEmpty()) {
+ if (excludeDanger && excludeDefense) {
+ return getActions(game, max, true, false);
+ }
+
+ if (excludeDefense) {
+ return getActions(game, max, false, false);
+ }
}
Collections.shuffle(actions);
diff --git a/src/main/java/laboratoire4/strategies/AttackStrategy.java b/src/main/java/laboratoire4/strategies/AttackStrategy.java
index 474475d..6e65fca 100644
--- a/src/main/java/laboratoire4/strategies/AttackStrategy.java
+++ b/src/main/java/laboratoire4/strategies/AttackStrategy.java
@@ -9,22 +9,27 @@ import laboratoire4.pawns.PawnUtils;
import laboratoire4.pawns.SimulatedPawn;
import java.util.Collection;
-import java.util.stream.Collectors;
public class AttackStrategy extends MiniMaxStrategy {
private static final int ATTACK_DISTANCE_FROM_GOAL = 4;
- private long originalMinPawnCount;
+ private long originalMinPushedCount;
+ private long originalMinPusherCount;
private long originalMaxPusherCount;
+ protected AttackStrategy(Game game) {
+ super(game);
+ }
+
@Override
- public EvaluationResult getNextMove(Game game) {
- originalMinPawnCount = GameUtils.getMinPawnsAsStream(game.getBoard(), game.getPlayer()).count();
+ public EvaluationResult getNextMove() {
+ originalMinPushedCount = GameUtils.getMinPawnsAsStream(game.getBoard(), game.getPlayer()).filter(p -> !p.isPusher()).count();
+ originalMinPusherCount = GameUtils.getMinPawnsAsStream(game.getBoard(), game.getPlayer()).filter(IPawn::isPusher).count();
originalMaxPusherCount = GameUtils.getMaxPawnsAsStream(game.getBoard(), game.getPlayer())
.filter(IPawn::isPusher)
.count();
- return super.getNextMove(game);
+ return super.getNextMove();
}
@Override
@@ -35,40 +40,59 @@ public class AttackStrategy extends MiniMaxStrategy {
return Integer.MIN_VALUE;
}
- long pusherCount = getMaxPawns().stream().filter(IPawn::isPusher).count();
- if (pusherCount == 0) {
- return Integer.MIN_VALUE;
- }
- score -= Math.pow(originalMaxPusherCount - pusherCount, 2);
+ // region Pions max perdus
+ Collection maxPawns = getMaxPawns();
+ long pusherCount = maxPawns.stream().filter(IPawn::isPusher).count();
+ score -= Math.pow((originalMaxPusherCount - pusherCount) * 10, 2);
+ // endregion
- for (SimulatedPawn pawn : getMaxPawns()) {
- if (pawn.getRow() == pawn.getPlayer().getGoal()) {
- return Integer.MAX_VALUE;
+ // region Pions min capturés
+ long minPusherCount = getMinPawns().stream().filter(IPawn::isPusher).count();
+ long minPushedCount = getMinPawns().stream().filter(p -> !p.isPusher()).count();
+ score += (originalMinPushedCount - minPushedCount) * 5;
+ score += (originalMinPusherCount - minPusherCount) * 10;
+ // endregion
+
+ for (SimulatedPawn pawn : maxPawns) {
+ int distanceFromGoal = PawnUtils.distanceFromGoal(pawn);
+ if (distanceFromGoal <= ATTACK_DISTANCE_FROM_GOAL) {
+ score += ATTACK_DISTANCE_FROM_GOAL - distanceFromGoal + 1;
+
+ if (PawnUtils.hasEasyWinPath(game.getBoard(), pawn)) {
+ score += Integer.MAX_VALUE / distanceFromGoal;
+ }
}
- if (PawnUtils.hasEasyWinPath(game.getBoard(), pawn)) {
- return Integer.MAX_VALUE / 2;
+ int row = pawn.getRow();
+ int col = pawn.getCol();
+
+ if (row > 0 && row < 7) {
+ IPawn facingPawn = game.getBoard()[row + pawn.getDirection()][col];
+ if (facingPawn != null && !PawnUtils.areSamePlayers(pawn, facingPawn)) {
+ // On bloque potentiellement un pion adverse, qui ne peut pas nous attaquer
+ score += 10;
+ }
}
-// int distanceFromGoal = PawnUtils.distanceFromGoal(pawn);
-// if (distanceFromGoal <= ATTACK_DISTANCE_FROM_GOAL) {
-// score += ATTACK_DISTANCE_FROM_GOAL - distanceFromGoal + 1;
+// if (col > 0) {
+// IPawn leftPawn = game.getBoard()[row][col - 1];
+// if (leftPawn != null && !PawnUtils.areSamePlayers(pawn, leftPawn)) {
+// score += 5;
+// }
+// }
+// if (col < 7) {
+// IPawn rightPawn = game.getBoard()[row][col + 1];
+// if (rightPawn != null && !PawnUtils.areSamePlayers(pawn, rightPawn)) {
+// score += 5;
+// }
// }
-
- if (pawn.isPusher() && PawnUtils.canBeCaptured(game, pawn)) {
- score -= 10; // On ne veut pas nécessairement bouger où on peut être capturé facilement
- }
}
- int minPawnCount = getMinPawns().size();
- long capturedPawnCount = originalMinPawnCount - minPawnCount;
- score += Math.pow(capturedPawnCount, 2);
-
return score;
}
@Override
- public int getWeight(Game game) {
+ public int getWeight() {
Collection maxPawns = GameUtils.getMaxPawns(game.getBoard(), game.getPlayer());
int maxWeight = 0;
diff --git a/src/main/java/laboratoire4/strategies/DefenseStrategy.java b/src/main/java/laboratoire4/strategies/DefenseStrategy.java
index 88d7e2e..0870e0f 100644
--- a/src/main/java/laboratoire4/strategies/DefenseStrategy.java
+++ b/src/main/java/laboratoire4/strategies/DefenseStrategy.java
@@ -4,6 +4,7 @@ import laboratoire4.Action;
import laboratoire4.IPawn;
import laboratoire4.game.Game;
import laboratoire4.game.GameUtils;
+import laboratoire4.pawns.PawnMovement;
import laboratoire4.pawns.PawnUtils;
import laboratoire4.pawns.SimulatedPawn;
@@ -13,30 +14,32 @@ import java.util.Map;
import java.util.Optional;
public class DefenseStrategy extends MiniMaxStrategy {
- private static final int DEFENSE_DISTANCE_FROM_HOME = 3;
+ private static final int DEFENSE_DISTANCE_FROM_HOME = 2;
private static final int PAWN_DEFENSE_DISTANCE = 3;
- private final Map dangerousPawns = new HashMap<>();
+ private final Map dangerousPawns;
+
+ public DefenseStrategy(Game game) {
+ super(game);
+
+ dangerousPawns = getDangerousPawns(game);
+ }
@Override
- public EvaluationResult getNextMove(Game game) {
- for (IPawn pawn : GameUtils.getMinPawns(game.getBoard(), game.getPlayer())) {
- int distance = PawnUtils.distanceFromGoal(pawn);
-
- if (distance <= DEFENSE_DISTANCE_FROM_HOME) {
- dangerousPawns.put(pawn, DEFENSE_DISTANCE_FROM_HOME - distance + 1);
- }
- }
-
+ public EvaluationResult getNextMove() {
if (dangerousPawns.isEmpty()) {
return null;
}
- return super.getNextMove(game);
+ return super.getNextMove();
}
@Override
- public int getWeight(Game game) {
+ public int getWeight() {
+ if (dangerousPawns.isEmpty()) {
+ return 0;
+ }
+
Collection minPawns = GameUtils.getMinPawns(game.getBoard(), game.getPlayer());
Collection maxPawns = GameUtils.getMaxPawns(game.getBoard(), game.getPlayer());
int maxWeight = 0;
@@ -78,8 +81,11 @@ public class DefenseStrategy extends MiniMaxStrategy {
Collection minPawns = getMinPawns();
for (SimulatedPawn pawn : minPawns) {
- if (pawn.getRow() == pawn.getPlayer().getGoal()) {
- return Integer.MIN_VALUE;
+ for (PawnMovement movement : PawnMovement.values()) {
+ if (PawnUtils.canBeCaptured(game, pawn.getRow() + pawn.getDirection(), pawn.getCol() + movement.getMove(), pawn.getPlayer())) {
+ // Ce pion ennemi est aussi en danger s'il bouge !
+ score += 5;
+ }
}
}
@@ -88,7 +94,7 @@ public class DefenseStrategy extends MiniMaxStrategy {
.filter(p -> p.getOriginalRow() == dangerousPawn.getRow() && p.getOriginalCol() == dangerousPawn.getCol())
.findFirst();
- if (simulated.isEmpty()) {
+ if (!simulated.isPresent()) {
// Le pion a été capturé !
score += Math.pow(dangerousPawns.get(dangerousPawn), 3);
} else {
@@ -97,7 +103,9 @@ public class DefenseStrategy extends MiniMaxStrategy {
score -= Math.pow(DEFENSE_DISTANCE_FROM_HOME - distance + 1, 3);
for (SimulatedPawn pawn : maxPawns) {
- score += PAWN_DEFENSE_DISTANCE - distanceFromCapture(pawn, simulated.get()) * 5;
+ if (PawnUtils.distanceFromHome(pawn) <= DEFENSE_DISTANCE_FROM_HOME) { // On ne veut pas que nos attaquants s'approchent des pions ennemis
+ score += PAWN_DEFENSE_DISTANCE - distanceFromCapture(pawn, simulated.get()) * 5;
+ }
}
}
}
@@ -115,10 +123,16 @@ public class DefenseStrategy extends MiniMaxStrategy {
int col = pawn.getCol();
int row = pawn.getRow();
- if (col > 0 && PawnUtils.areSamePlayers(pawn, game.getBoard()[col - 1][row])) {
+ if (col > 0 && PawnUtils.areSamePlayers(pawn, game.getBoard()[row][col - 1])) {
score += 5;
}
- if (col < 7 && PawnUtils.areSamePlayers(pawn, game.getBoard()[col + 1][row])) {
+ if (col < 7 && PawnUtils.areSamePlayers(pawn, game.getBoard()[row][col + 1])) {
+ score += 5;
+ }
+ if (row > 0 && PawnUtils.areSamePlayers(pawn, game.getBoard()[row - 1][col])) {
+ score += 5;
+ }
+ if (row < 7 && PawnUtils.areSamePlayers(pawn, game.getBoard()[row + 1][col])) {
score += 5;
}
}
@@ -126,19 +140,6 @@ public class DefenseStrategy extends MiniMaxStrategy {
return score;
}
- @Override
- protected Collection> getActions(boolean max) {
- Collection pawns = max ? getMaxPawns() : getMinPawns();
-
- long defensivePawnCount = pawns.stream()
- .filter(IPawn::isPusher)
- .filter(p -> p.getRow() != p.getPlayer().getHome())
- .filter(p -> PawnUtils.distanceFromHome(p) <= DEFENSE_DISTANCE_FROM_HOME)
- .count();
-
- return PawnUtils.getActions(game, max, defensivePawnCount > 0);
- }
-
private int distanceFromCapture(IPawn max, IPawn min) {
int rowDistance = Math.abs(min.getRow() - max.getRow());
int colDistance = Math.abs(min.getCol() - max.getCol());
@@ -155,5 +156,23 @@ public class DefenseStrategy extends MiniMaxStrategy {
return rowDistance;
}
+ private static Map getDangerousPawns(Game game) {
+ Map dangerousPawns = new HashMap<>();
+ for (IPawn pawn : GameUtils.getMinPawns(game.getBoard(), game.getPlayer())) {
+ int distance = PawnUtils.distanceFromGoal(pawn);
+
+ if (distance <= DEFENSE_DISTANCE_FROM_HOME) {
+ // Les pions proches de nous qui ne peuvent pas bouger peuvent être ignorés
+ for (PawnMovement movement : PawnMovement.values()) {
+ if (pawn.isMoveValid(game.getBoard(), movement)) {
+ dangerousPawns.put(pawn, DEFENSE_DISTANCE_FROM_HOME - distance + 1);
+ break;
+ }
+ }
+ }
+ }
+
+ return dangerousPawns;
+ }
}
diff --git a/src/main/java/laboratoire4/strategies/ImmediateDefenseStrategy.java b/src/main/java/laboratoire4/strategies/ImmediateDefenseStrategy.java
index 88d37bc..8fe72e2 100644
--- a/src/main/java/laboratoire4/strategies/ImmediateDefenseStrategy.java
+++ b/src/main/java/laboratoire4/strategies/ImmediateDefenseStrategy.java
@@ -7,11 +7,17 @@ import laboratoire4.pawns.PawnMovement;
import laboratoire4.pawns.PawnUtils;
public class ImmediateDefenseStrategy implements Strategy {
- private static final int IMM_DEFENSE_DISTANCE_FROM_HOME = 1;
+ private static final int IMM_DEFENSE_DISTANCE_FROM_HOME = 2;
+
+ private final Game game;
+
+ public ImmediateDefenseStrategy(Game game) {
+ this.game = game;
+ }
@Override
- public EvaluationResult getNextMove(Game game) {
- // On utilise pas la méthode utilitaire, car on veut bouger la ligne de défense si nécessaire
+ public EvaluationResult getNextMove() {
+ // On n'utilise pas la méthode utilitaire, car on veut bouger la ligne de défense si nécessaire
for (IPawn pawn : GameUtils.getMaxPawns(game.getBoard(), game.getPlayer())) {
if (PawnUtils.distanceFromHome(pawn) > IMM_DEFENSE_DISTANCE_FROM_HOME) {
continue;
@@ -36,7 +42,7 @@ public class ImmediateDefenseStrategy implements Strategy {
}
@Override
- public int getWeight(Game game) {
+ public int getWeight() {
for (IPawn pawn : GameUtils.getMaxPawns(game.getBoard(), game.getPlayer())) {
if (PawnUtils.distanceFromHome(pawn) > IMM_DEFENSE_DISTANCE_FROM_HOME) {
continue;
diff --git a/src/main/java/laboratoire4/strategies/MasterStrategy.java b/src/main/java/laboratoire4/strategies/MasterStrategy.java
index e830f7e..8114008 100644
--- a/src/main/java/laboratoire4/strategies/MasterStrategy.java
+++ b/src/main/java/laboratoire4/strategies/MasterStrategy.java
@@ -5,25 +5,28 @@ import laboratoire4.game.Game;
public class MasterStrategy implements Strategy {
private static Strategy instance;
- public static Strategy getInstance() {
+ public static Strategy getInstance(Game game) {
if (instance == null) {
- instance = new MasterStrategy();
+ instance = new MasterStrategy(game);
}
return instance;
}
- private MasterStrategy() {
+ private final Game game;
+
+ private MasterStrategy(Game game) {
+ this.game = game;
}
@Override
- public EvaluationResult getNextMove(Game game) {
+ public EvaluationResult getNextMove() {
long startMs = System.currentTimeMillis();
- Strategy strategy = getBestStrategy(game);
+ Strategy strategy = getBestStrategy();
System.out.println(strategy.getClass().getSimpleName());
- EvaluationResult result = strategy.getNextMove(game);
+ EvaluationResult result = strategy.getNextMove();
long endMs = System.currentTimeMillis();
System.out.printf("Temps: %d ms\n", endMs - startMs);
@@ -31,19 +34,19 @@ public class MasterStrategy implements Strategy {
return result;
}
- private Strategy getBestStrategy(Game game) {
+ private Strategy getBestStrategy() {
Strategy[] strategies = new Strategy[]{
- new ImmediateDefenseStrategy(),
- new WinningStrategy(),
- new DefenseStrategy(),
- new AttackStrategy()
+ new ImmediateDefenseStrategy(game),
+ new WinningStrategy(game),
+ new DefenseStrategy(game),
+ new AttackStrategy(game)
};
int maxWeight = 0;
Strategy bestStrategy = null;
for (Strategy strategy : strategies) {
- int weight = strategy.getWeight(game);
+ int weight = strategy.getWeight();
if (weight == WEIGHT_MAX) {
return strategy;
}
@@ -58,11 +61,11 @@ public class MasterStrategy implements Strategy {
return bestStrategy;
}
- return new RandomStrategy();
+ return new RandomStrategy(game);
}
@Override
- public int getWeight(Game game) {
+ public int getWeight() {
return WEIGHT_MAX;
}
}
diff --git a/src/main/java/laboratoire4/strategies/MiniMaxStrategy.java b/src/main/java/laboratoire4/strategies/MiniMaxStrategy.java
index fb40606..84358ca 100644
--- a/src/main/java/laboratoire4/strategies/MiniMaxStrategy.java
+++ b/src/main/java/laboratoire4/strategies/MiniMaxStrategy.java
@@ -5,27 +5,31 @@ import laboratoire4.IPawn;
import laboratoire4.game.Game;
import laboratoire4.game.GameUtils;
import laboratoire4.game.SimulatedGame;
+import laboratoire4.pawns.Pawn;
import laboratoire4.pawns.PawnMovement;
import laboratoire4.pawns.PawnUtils;
import laboratoire4.pawns.SimulatedPawn;
import java.util.Collection;
+import java.util.stream.Collectors;
public abstract class MiniMaxStrategy implements Strategy {
private static final int MAX_DEPTH = 6;
- private static final long MAX_TIME_MS = 4500; // Moins de 5 secondes, car le tour n'est pas complètement fini
+ private static final long MAX_TIME_MS = 4800; // Moins de 5 secondes, car le tour n'est pas complètement fini
protected SimulatedGame game;
protected long startTimeMs;
- @Override
- public EvaluationResult getNextMove(Game game) {
- return miniMax(game);
+ protected MiniMaxStrategy(Game game) {
+ this.game = new SimulatedGame(game.getBoard(), game.getPlayer());
}
- private EvaluationResult miniMax(Game game) {
- this.game = new SimulatedGame(game.getBoard(), game.getPlayer());
+ @Override
+ public EvaluationResult getNextMove() {
+ return miniMax();
+ }
+ private EvaluationResult miniMax() {
EvaluationResult maxResult = null;
int maxScore = Integer.MIN_VALUE;
startTimeMs = System.currentTimeMillis();
@@ -89,7 +93,7 @@ public abstract class MiniMaxStrategy implements Strategy {
PawnMovement movement = action.getMovement();
game.move(pawn, movement);
- int score = max(depth + 1, alpha, Math.min(beta, minScore)) * -1;
+ int score = max(depth + 1, alpha, Math.min(beta, minScore));
game.revertMove();
if (score < minScore) {
@@ -119,7 +123,47 @@ public abstract class MiniMaxStrategy implements Strategy {
private int evaluate() {
int score = evaluateSimulation();
- // Logique générale
+ Collection maxPawns = getMaxPawns();
+
+ if (maxPawns.stream().noneMatch(IPawn::isPusher)) {
+ return Integer.MIN_VALUE;
+ }
+
+ if (getMinPawns().stream().anyMatch(p -> p.getRow() == p.getPlayer().getGoal())) {
+ return Integer.MIN_VALUE;
+ }
+
+ for (IPawn pawn : maxPawns) {
+ if (pawn.getRow() == pawn.getPlayer().getGoal()) {
+ return Integer.MAX_VALUE;
+ }
+
+ if (PawnUtils.canBeCaptured(game, pawn)) {
+ // On peut être capturé
+ score -= 10;
+ }
+
+ for (PawnMovement movement : PawnMovement.values()) {
+ if (pawn.isMoveValid(game.getBoard(), movement) && !PawnUtils.canBeCaptured(game, pawn.getRow() + pawn.getDirection(), pawn.getCol() + movement.getMove(), pawn.getPlayer())) {
+ // On ne peut pas être capturé en faisant ce mouvement
+ score += 5;
+ }
+ }
+ }
+
+ // region Lignes ennemies
+ for (IPawn pawn : getMinPawns()) {
+ int row = pawn.getRow();
+ int col = pawn.getCol();
+
+ if (row > 0 && PawnUtils.areSamePlayers(pawn, game.getBoard()[row - 1][col])) {
+ score -= 5;
+ }
+ if (row < 0 && PawnUtils.areSamePlayers(pawn, game.getBoard()[row + 1][col])) {
+ score -= 5;
+ }
+ }
+ // endregion
return score;
}
diff --git a/src/main/java/laboratoire4/strategies/RandomStrategy.java b/src/main/java/laboratoire4/strategies/RandomStrategy.java
index 3176f7f..13390b9 100644
--- a/src/main/java/laboratoire4/strategies/RandomStrategy.java
+++ b/src/main/java/laboratoire4/strategies/RandomStrategy.java
@@ -16,10 +16,16 @@ import java.util.stream.Collectors;
*/
public class RandomStrategy implements Strategy {
private static final int PAWN_TO_MOVE = 2;
+
private final Random random = new Random();
+ private final Game game;
+
+ public RandomStrategy(Game game) {
+ this.game = game;
+ }
@Override
- public EvaluationResult getNextMove(Game game) {
+ public EvaluationResult getNextMove() {
Collection outsideHomePushers = GameUtils.getMaxPawnsAsStream(game.getBoard(), game.getPlayer())
.filter(IPawn::isPusher)
.filter(p -> p.getRow() != p.getPlayer().getHome())
@@ -38,7 +44,7 @@ public class RandomStrategy implements Strategy {
}
@Override
- public int getWeight(Game game) {
+ public int getWeight() {
return 0;
}
diff --git a/src/main/java/laboratoire4/strategies/Strategy.java b/src/main/java/laboratoire4/strategies/Strategy.java
index 2163beb..1a80054 100644
--- a/src/main/java/laboratoire4/strategies/Strategy.java
+++ b/src/main/java/laboratoire4/strategies/Strategy.java
@@ -9,11 +9,11 @@ import java.util.*;
import java.util.stream.Collectors;
public interface Strategy {
- public static final int WEIGHT_MAX = 10;
+ int WEIGHT_MAX = 10;
- EvaluationResult getNextMove(Game game);
+ EvaluationResult getNextMove();
- int getWeight(Game game);
+ int getWeight();
static List> getValidActions(Game game) {
List maxPawns = Arrays.stream(game.getBoard())
diff --git a/src/main/java/laboratoire4/strategies/WinningStrategy.java b/src/main/java/laboratoire4/strategies/WinningStrategy.java
index eabbb0a..1a6e824 100644
--- a/src/main/java/laboratoire4/strategies/WinningStrategy.java
+++ b/src/main/java/laboratoire4/strategies/WinningStrategy.java
@@ -13,8 +13,16 @@ import java.util.stream.Collectors;
public class WinningStrategy implements Strategy {
private Action winningAction;
+ public WinningStrategy(Game game) {
+ winningAction = findImmediateWinningAction(game);
+ if (winningAction == null) {
+ // On cherche un chemin où on peut gagner quoi qu'il arrive
+ winningAction = findWinningPath(game);
+ }
+ }
+
@Override
- public EvaluationResult getNextMove(Game game) {
+ public EvaluationResult getNextMove() {
if (winningAction == null) {
return null;
}
@@ -24,13 +32,7 @@ public class WinningStrategy implements Strategy {
}
@Override
- public int getWeight(Game game) {
- winningAction = findImmediateWinningAction(game);
- if (winningAction == null) {
- // On cherche un chemin où on peut gagner quoi qu'il arrive
- winningAction = findWinningPath(game);
- }
-
+ public int getWeight() {
if (winningAction != null) {
return WEIGHT_MAX;
}