Waiting for tool use

.gitignore

@@ -1,2 +1,3 @@
 target
 .Makefile.swp
+.idea/uiDesigner.xml

Makefile

@@ -1,9 +1,11 @@
+all: check_and_test lint format
+
 check_and_test: FORCE
 	mvn test
 
 lint: FORCE
 	mvn checkstyle:check
 
 format: FORCE
-	mvn googleformatter:format
+	mvn formatter:format
 FORCE: ;

README.md

@@ -1,3 +1,3 @@
 # Stone Age
 
-This is the Java version of the semestral project from Principles of Software Design (1) course on FMFI UK, 2024/25. 
+This is the Java version of the semestral project from Principles of Software Design (1) course on FMFI UK, 2024/25.

src/main/java/sk/uniba/fmph/dcs/game_board/AllPlayersTakeReward.java

@@ -0,0 +1,63 @@
+package sk.uniba.fmph.dcs.game_board;
+
+import sk.uniba.fmph.dcs.stone_age.Effect;
+import sk.uniba.fmph.dcs.stone_age.InterfaceGamePhaseController;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class AllPlayersTakeReward implements EvaluateCivilisationCardImmediateEffect {
+
+    private final RewardMenu menu;
+    private static final int WOODID = 1;
+    private static final int CLAYID = 2;
+    private static final int STONEID = 3;
+    private static final int GOLDID = 4;
+    private static final int TOOLID = 5;
+    private final InterfaceGamePhaseController controller;
+
+    /**
+     * @param menu
+     *            RewardMenu that is already existing
+     * @param controller
+     *            controller to call in performEffect
+     */
+    public AllPlayersTakeReward(final RewardMenu menu, final InterfaceGamePhaseController controller) {
+        this.menu = menu;
+        this.controller = controller;
+        int n = menu.getPlayersCount();
+        int[] t = Throw.hod(n);
+        List<Effect> m = new ArrayList<>();
+        for (var i : t) {
+            if (i == WOODID) {
+                m.add(Effect.WOOD);
+            } else if (i == CLAYID) {
+                m.add(Effect.CLAY);
+            } else if (i == STONEID) {
+                m.add(Effect.STONE);
+            } else if (i == GOLDID) {
+                m.add(Effect.GOLD);
+            } else if (i == TOOLID) {
+                m.add(Effect.TOOL);
+            } else {
+                m.add(Effect.FIELD);
+            }
+        }
+        menu.initiate(m);
+    }
+
+    /**
+     * call controller.
+     *
+     * @param player
+     *            player that takes from menu
+     * @param choice
+     *            resource to take from menu
+     *
+     * @return true if resource was successfully taken
+     */
+    @Override
+    public boolean performEffect(final Player player, final Effect choice) {
+        return controller.makeAllPlayersTakeARewardChoice(player.playerOrder(), choice);
+    }
+}

src/main/java/sk/uniba/fmph/dcs/game_board/ArbitraryBuilding.java

@@ -0,0 +1,34 @@
+package sk.uniba.fmph.dcs.game_board;
+
+import org.json.JSONObject;
+import sk.uniba.fmph.dcs.stone_age.Effect;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.OptionalInt;
+
+public final class ArbitraryBuilding implements Building {
+    private final int numberOfResources;
+
+    public ArbitraryBuilding(final int numberOfResources) {
+        this.numberOfResources = numberOfResources;
+    }
+
+    @Override
+    public OptionalInt build(final Collection<Effect> resources) {
+        if (resources.size() > numberOfResources) {
+            return OptionalInt.empty();
+        }
+        int sum = 0;
+        for (Effect resource : resources) {
+            sum += resource.points();
+        }
+        return OptionalInt.of(sum);
+    }
+
+    @Override
+    public String state() {
+        Map<String, String> state = Map.of("numberOfResources", Integer.toString(numberOfResources));
+        return new JSONObject(state).toString();
+    }
+}

src/main/java/sk/uniba/fmph/dcs/game_board/Building.java

@@ -1,9 +1,12 @@
 package sk.uniba.fmph.dcs.game_board;
 
+import sk.uniba.fmph.dcs.stone_age.Effect;
+
 import java.util.Collection;
 import java.util.OptionalInt;
-import sk.uniba.fmph.dcs.stone_age.Effect;
 
 interface Building {
     OptionalInt build(Collection<Effect> resources);
+
+    String state();
 }

src/main/java/sk/uniba/fmph/dcs/game_board/CivilizationCardDeck.java

@@ -0,0 +1,15 @@
+package sk.uniba.fmph.dcs.game_board;
+
+import sk.uniba.fmph.dcs.stone_age.CivilisationCard;
+
+import java.util.Optional;
+
+public final class CivilizationCardDeck {
+    public Optional<CivilisationCard> getTop() {
+        return Optional.empty();
+    }
+
+    public String state() {
+        return "TODO";
+    }
+}

src/main/java/sk/uniba/fmph/dcs/game_board/CurrentThrow.java

@@ -0,0 +1,30 @@
+package sk.uniba.fmph.dcs.game_board;
+
+import sk.uniba.fmph.dcs.stone_age.Effect;
+import sk.uniba.fmph.dcs.stone_age.InterfaceToolUse;
+
+public final class CurrentThrow implements InterfaceToolUse {
+
+    public CurrentThrow(final Effect throwsFor, final int throwResult) {
+        // todo
+    }
+
+    public void initiate(final Player player, final Effect effect, final int dices) {
+        return; // todo
+    }
+
+    @Override
+    public boolean useTool(final int idx) {
+        return false;
+    }
+
+    @Override
+    public boolean canUseTools() {
+        return false;
+    }
+
+    @Override
+    public boolean finishUsingTools() {
+        return false;
+    }
+}

src/main/java/sk/uniba/fmph/dcs/game_board/EvaluateCivilisationCardImmediateEffect.java

@@ -0,0 +1,7 @@
+package sk.uniba.fmph.dcs.game_board;
+
+import sk.uniba.fmph.dcs.stone_age.Effect;
+
+public interface EvaluateCivilisationCardImmediateEffect {
+    boolean performEffect(Player player, Effect choice);
+}

src/main/java/sk/uniba/fmph/dcs/game_board/GetCard.java

@@ -0,0 +1,36 @@
+package sk.uniba.fmph.dcs.game_board;
+
+import sk.uniba.fmph.dcs.stone_age.CivilisationCard;
+import sk.uniba.fmph.dcs.stone_age.Effect;
+
+import java.util.Optional;
+
+public class GetCard implements EvaluateCivilisationCardImmediateEffect {
+    private final CivilizationCardDeck deck;
+
+    /**
+     * @param deck
+     *            to draw cards from
+     */
+    public GetCard(final CivilizationCardDeck deck) {
+        this.deck = deck;
+    }
+
+    /**
+     * @param player
+     *            gives player top card of the deck
+     * @param choice
+     *            ignored
+     *
+     * @return true if card exists
+     */
+    @Override
+    public boolean performEffect(final Player player, final Effect choice) {
+        Optional<CivilisationCard> c = deck.getTop();
+        if (c.isEmpty()) {
+            return false;
+        }
+        player.playerBoard().giveEndOfGameEffect(c.get().endOfGameEffect());
+        return true;
+    }
+}

src/main/java/sk/uniba/fmph/dcs/game_board/GetChoice.java

@@ -0,0 +1,38 @@
+package sk.uniba.fmph.dcs.game_board;
+
+import sk.uniba.fmph.dcs.stone_age.Effect;
+
+public class GetChoice implements EvaluateCivilisationCardImmediateEffect {
+    private int numberOfResources;
+
+    /**
+     * @param numberOfResources
+     *            number of resources available to choose.
+     */
+    public GetChoice(final int numberOfResources) {
+        this.numberOfResources = numberOfResources;
+    }
+
+    /**
+     * gives one resource of any type.
+     *
+     * @param player
+     *            player to give resource to
+     * @param choice
+     *            resource wanted
+     *
+     * @return true if player can take resource, false otherwise
+     */
+    @Override
+    public boolean performEffect(final Player player, final Effect choice) {
+        if (!choice.isResource()) {
+            return false;
+        }
+        if (numberOfResources == 0) {
+            return false;
+        }
+        numberOfResources--;
+        player.playerBoard().giveEffect(new Effect[] {choice});
+        return true;
+    }
+}

src/main/java/sk/uniba/fmph/dcs/game_board/GetSomethingFixed.java

@@ -0,0 +1,36 @@
+package sk.uniba.fmph.dcs.game_board;
+
+import sk.uniba.fmph.dcs.stone_age.Effect;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class GetSomethingFixed implements EvaluateCivilisationCardImmediateEffect {
+    private final List<Effect> effects;
+
+    /**
+     * @param effect
+     *            list of effects that can be chosen.
+     */
+    public GetSomethingFixed(final List<Effect> effect) {
+        effects = new ArrayList<>();
+        effects.addAll(effect);
+    }
+
+    /**
+     * give all resources to player.
+     *
+     * @param player
+     *            player to give choice to
+     * @param choice
+     *            ignores
+     *
+     * @return true - it is always possible to give resources to player
+     */
+    @Override
+    public boolean performEffect(final Player player, final Effect choice) {
+        player.playerBoard().giveEffect(effects.toArray(new Effect[0]));
+        effects.clear();
+        return true;
+    }
+}