Arsenii

.gitignore

@@ -1,2 +1,5 @@
 target
 .Makefile.swp
+.idea/
+.aider.*
+.DS_Store

README.md

@@ -1,3 +1,45 @@
-# Stone Age
+# Assignment - Stone Age game
 
-This is the Java version of the semestral project from Principles of Software Design (1) course on FMFI UK, 2024/25. 
+Your task is to construct a component implementing the logic of board game Stone Age. These are the [rules](https://images.zmangames.com/filer_public/ee/88/ee888bec-5000-4566-9fb0-8c6475e706a0/zm7260_stone_age_rules.pdf).
+
+[!Classes Description!](https://github.com/sdeffff/pts24-java/blob/main/src/task/classes.md)
+
+
+## Design
+
+I prepared a [design](pts24.png) template for your implementation. Besides that I prepared [simple description of the classes](classes.md) with estimations 
+
+Note that the design is by no means complete. Most notably
+- You have to add appropriate constructors. Chose your constructors in a way that enables good testing. E.g. card deck and building stacks do not need to be full.
+- You have to add interfaces that separate classes that need to be separated.
+- You probably want to do something with Bag class to handle the randomness involved better.
+Also, it is highly likely, that I overlooked something and there are some issues that need to be resolved. Feel free to do necessary changes and adjustments.
+
+I recommend to stick to the following timeline
+- 11. 11. create teams, understand game rules, understand the design (so we can have a meaningful discussion on the lecture).
+- 20. 11. the common part of the project is finished 
+- 27. 11. you are done
+
+## Implementation remarks
+
+You should build your project either in Python or in Java. I started the projects for you, including several tools that might help you. See [pts24-python](https://github.com/relatko/pts1-23-python) and [pts24-java](https://github.com/relatko/pts1-23-java). Note that if you use Python, your code should be type annotated and mypy --strict should show no errors. Do not use any except for when handling json.
+
+This is a fairly large project and it would take too long to implement. Thus you will collaborate while implementing the project.
+
+* Create groups of, ideally, six to eight people. and fork the repository you agree to use. Green classes are provided in the project (Java GamePhaseController will be implemented soonish).
+* Collaboratively implement the elements marked white (trivial) and blue, including factories and integration tests for two components. For blue elements create a PR (typically one PR per element, but you may merge several very trivial ones into one PR), discuss it and merge it into the master (I recommend main branch protection requiring PR with at least 1 approval). Blue classes are not of particular interest to me. The amount of points given here is quite limited (up to 20 points including non-coding aspects of common work like like making and reviewing PRs), so do not overthink stuff, but make it sound enough so you actually can write working integration tests. This also implies that the test coverage does not have to be great in these classes. While collaborating create new features in own branches and merge it to main with a PR after code review is done. Turn on branch protection. Try to keep CI green (you can enforce this by branch protection rules). You may use github issues to your the progress. You may split large task into smaller tasks. You may want to meet one time before you start your work. Splitting L tasks is a good thing to do.
+It is expected that everybody prepares and reviews 3-5 PRs. 
+* After this, you should add your own implementation of the red classes (including unit tests) and prepare two integration tests. To reduce the amount of work necessary, it is sufficient to create one end to end scenario for each of these integration test. 
+
+Unit tests for Game should be solitary. Do a sociable unit test of CivilisationCardPlace that also uses CivilisationCardDeck. Tests of ResourceSource must be solitary. You can discuss technical aspects of the implementation, but everybody should implement the red classes and the red integration tests on his own. You can either work on local machine or use a private repository for your effort.
+
+You should use Git and produce a reasonable history of commits. Note that to work on the red classes you do not need the blue ones. You are also free to adjust the implementation of blue and green classes according to the needs of your project (but, the changes, hopefully should not be large, a good example is changing interface name, adding a new interface, ...).
+
+
+## Instructions for submitting your project
+
+Send your solution to [lukotka.pts@gmail.com](lukotka.pts@gmail.com). The deadline is 30.11.2022 23:59:59. The solutions sent later will be accepted, however the number of points awarded may be reduced.
+
+Send the solution to me either as compressed folders containing the whole repository (including the hidden .git files) or as a link to private repository with read access granted (GitHub handle `relatko`). Attach a link to the public repository for the team part of the project and link PRs you have made and PRs you have reviewed. 
+
+![UML of the task](https://github.com/sdeffff/pts24-java/blob/main/src/task/pts24.png?raw=true)

STONE_AGE.iml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module external.linked.project.id="$MODULE_DIR$/pom.xml" external.system.module.type="SINGLE_MODULE" external.system.module.version="223-2" org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_21">
+    <output url="file://$MODULE_DIR$/target/classes" />
+    <output-test url="file://$MODULE_DIR$/target/test-classes" />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/src/main/resources" type="java-resource" />
+      <sourceFolder url="file://$MODULE_DIR$/src/test/java" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/src/test/resources" type="java-test-resource" />
+      <excludeFolder url="file://$MODULE_DIR$/target" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" scope="TEST" name="Maven: junit:junit:4.11" level="project" />
+    <orderEntry type="library" scope="TEST" name="Maven: org.hamcrest:hamcrest-core:1.3" level="project" />
+    <orderEntry type="library" name="Maven: org.apache.commons:commons-lang3:3.9" level="project" />
+    <orderEntry type="library" name="Maven: org.apache.commons:commons-collections4:4.4" level="project" />
+    <orderEntry type="library" name="Maven: org.json:json:20190722" level="project" />
+  </component>
+</module>

pom.xml

@@ -13,7 +13,7 @@
 
   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    <maven.compiler.release>21</maven.compiler.release>
+    <maven.compiler.release>17</maven.compiler.release>
   </properties>
 
   <dependencies>

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

@@ -0,0 +1,40 @@
+package sk.uniba.fmph.dcs.game_board;
+
+import sk.uniba.fmph.dcs.stone_age.Effect;
+import java.util.Collection;
+import java.util.OptionalInt;
+
+public class ArbitraryBuilding implements Building {
+    private final int maxNumberOfResources;
+
+    public ArbitraryBuilding(int maxNumberOfResources) {
+        this.maxNumberOfResources = maxNumberOfResources;
+    }
+
+    @Override
+    public OptionalInt build(Collection<Effect> resources) {
+        if (resources.isEmpty() || resources.size() > maxNumberOfResources) {
+            return OptionalInt.empty();
+        }
+
+        // Verify all resources are valid
+        for (Effect resource : resources) {
+            if (!resource.isResource()) {
+                return OptionalInt.empty();
+            }
+        }
+
+        // Calculate points
+        int points = 0;
+        for (Effect resource : resources) {
+            points += resource.points();
+        }
+
+        return OptionalInt.of(points);
+    }
+
+    @Override
+    public String state() {
+        return String.format("ArbitraryBuilding[maxResources=%d]", maxNumberOfResources);
+    }
+}

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

@@ -4,6 +4,7 @@
 import java.util.OptionalInt;
 import sk.uniba.fmph.dcs.stone_age.Effect;
 
-interface Building {
+public interface Building {
     OptionalInt build(Collection<Effect> resources);
+    String state();
 }

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

@@ -0,0 +1,99 @@
+package sk.uniba.fmph.dcs.game_board;
+
+import sk.uniba.fmph.dcs.stone_age.PlayerOrder;
+import sk.uniba.fmph.dcs.stone_age.Effect;
+import sk.uniba.fmph.dcs.stone_age.Player;
+import sk.uniba.fmph.dcs.stone_age.HasAction;
+import sk.uniba.fmph.dcs.stone_age.ActionResult;
+
+import java.util.*;
+
+import org.json.JSONObject;
+
+public class BuildingTile implements InterfaceFigureLocationInternal {
+    private final Stack<Building> buildings;
+    private final ArrayList<PlayerOrder> figures;
+    private static final int MAX_FIGURES = 1;
+
+    public BuildingTile(List<Building> building) {
+        this.buildings = new Stack<>();
+        this.buildings.addAll(building);
+        this.figures = new ArrayList<>();
+    }
+
+    @Override
+    public boolean placeFigures(Player player, int figureCount) {
+        if (figureCount != MAX_FIGURES || !figures.isEmpty()) {
+            return false;
+        }
+        figures.add(player.playerOrder());
+        return true;
+    }
+
+    @Override
+    public HasAction tryToPlaceFigures(Player player, int count) {
+        if (count != MAX_FIGURES || !figures.isEmpty()) {
+            return HasAction.NO_ACTION_POSSIBLE;
+        }
+        if (!player.playerBoard().hasFigures(count)) {
+            return HasAction.NO_ACTION_POSSIBLE;
+        }
+        return HasAction.WAITING_FOR_PLAYER_ACTION;
+    }
+
+    @Override
+    public ActionResult makeAction(Player player, Effect[] inputResources, Effect[] outputResources) {
+        if (figures.isEmpty() || !figures.get(0).equals(player.playerOrder())) {
+            return ActionResult.FAILURE;
+        }
+
+        Collection<Effect> resources = List.of(inputResources);
+
+        if(buildings.isEmpty()){
+            return ActionResult.FAILURE;
+        }
+        OptionalInt points = buildings.pop().build(resources);
+
+        // Give points to player
+        List<Effect> pointsToGive = new ArrayList<>();
+        for(int i=0; i<points.getAsInt(); i++){
+            pointsToGive.add(Effect.POINT);
+        }
+        player.playerBoard().giveEffect(pointsToGive);
+        return ActionResult.ACTION_DONE;
+    }
+
+    @Override
+    public boolean skipAction(Player player) {
+        if (figures.isEmpty() || !figures.get(0).equals(player.playerOrder())) {
+            return false;
+        }
+        figures.clear();
+        return true;
+    }
+
+    @Override
+    public HasAction tryToMakeAction(Player player) {
+        if (figures.isEmpty() || !figures.get(0).equals(player.playerOrder())) {
+            return HasAction.NO_ACTION_POSSIBLE;
+        }
+        return HasAction.WAITING_FOR_PLAYER_ACTION;
+    }
+
+    @Override
+    public boolean newTurn() {
+        if(buildings.isEmpty()){
+            return true;
+        }
+        figures.clear();
+        return false;
+    }
+
+    public String state() {
+        Map<String, Object> state = Map.of(
+            "building", buildings,
+            "figures", figures.stream().map(PlayerOrder::getOrder).toList()
+        );
+        return new JSONObject(state).toString();
+    }
+}

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

@@ -0,0 +1,5 @@
+package sk.uniba.fmph.dcs.game_board;
+
+public class CivilisationCardDeck {
+
+}