added files

src/Element.java

@@ -0,0 +1,14 @@
+package it.arnaldo.unibs.tamagolem;
+
+public enum Element { // da fare diventare meme
+    FUOCO,
+    ACQUA,
+    ELETTRICO,
+    VENTO,
+    TERRA,
+    LUCE,
+    OMBRA,
+    PSICHICO,
+    FOLLETTO,
+    DRAGO
+}

src/ElementGraph.java

@@ -0,0 +1,44 @@
+package it.arnaldo.unibs.tamagolem;
+
+import java.util.*;
+
+public class ElementGraph {
+    private final Set<GraphElement> elements;
+
+    public ElementGraph() {
+        this.elements = new HashSet<>();
+    }
+    public void addElement(GraphElement element) {
+        elements.add(element);
+    }
+
+    public int getValue(Element fromElement, Element toElement) {
+        for (GraphElement graphElement : elements) {
+            if (graphElement.getElement().equals(fromElement)) {
+                return graphElement.getLinkValue(toElement);
+            }
+        }
+        return 0;
+    }
+
+    public Set<GraphElement> getElements() {
+        return elements;
+    }
+
+    public void printGraph() {
+        for (GraphElement from : elements) {
+            Element fromElement = from.getElement();
+            System.out.println("[" + fromElement + "] →");
+
+            for (ElementLink link : from.getLinks()) {
+                Element toElement = link.getElement();
+                int value = link.getValue();
+                System.out.printf("   -> %s : %d\n", toElement, value);
+            }
+
+            System.out.println();
+        }
+    }
+
+
+}

src/ElementLink.java

@@ -0,0 +1,19 @@
+package it.arnaldo.unibs.tamagolem;
+
+public class ElementLink {
+    private final int value;
+    private final Element element;
+
+    public ElementLink(int value, Element element) {
+        this.value = value;
+        this.element = element;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public Element getElement() {
+        return element;
+    }
+}

src/Game.java

@@ -0,0 +1,39 @@
+package it.arnaldo.unibs.tamagolem;
+
+public class Game {
+    private final Player player1;
+    private final Player player2;
+    private final ElementGraph worldBalance;
+
+    public Game(Player player1, Player player2, ElementGraph worldBalance) {
+        this.player1 = player1;
+        this.player2 = player2;
+        this.worldBalance = worldBalance;
+    }
+
+    public Player getPlayer1() {
+        return player1;
+    }
+
+    public Player getPlayer2() {
+        return player2;
+    }
+
+    public ElementGraph getWorldBalance() {
+        return worldBalance;
+    }
+
+    public void start() {
+        int numberOfElements = worldBalance.getElements().size();
+        int numberOfStones = Math.round((float) ((numberOfElements + 1)/3.0)) + 1;
+        int numberOfTamaGolems = Math.round((float) ((numberOfElements - 1) * (numberOfElements - 2) / (2 * numberOfStones)));
+        int totalNumberOfStones = Math.round((float) ((2 * numberOfTamaGolems * numberOfStones) / numberOfElements)) * numberOfElements;
+        int numberOfStonesPerElement = totalNumberOfStones / numberOfElements;
+
+        // deve essere uguale alla somma della potenza di tutti gli elementi
+        int totalPower = 0;
+        int lifePoints = (int)(Math.random() * 11) + 5;
+        System.out.println("Game started between " + player1.getName() + " and " + player2.getName());
+
+    }
+}

src/GraphElement.java

@@ -0,0 +1,35 @@
+package it.arnaldo.unibs.tamagolem;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class GraphElement {
+    private final Element element;
+    private final Set<ElementLink> links;
+
+    public GraphElement(Element element) {
+        this.element = element;
+        this.links = new HashSet<>();
+    }
+
+    public Element getElement() {
+        return element;
+    }
+
+    public Set<ElementLink> getLinks() {
+        return links;
+    }
+
+    public void addLink(ElementLink link) {
+        links.add(link);
+    }
+
+    public int getLinkValue(Element element) {
+        for (ElementLink link : links) {
+            if (link.getElement().equals(element)) {
+                return link.getValue();
+            }
+        }
+        return 0;
+    }
+}

src/Player.java

@@ -0,0 +1,21 @@
+package it.arnaldo.unibs.tamagolem;
+
+import java.util.ArrayList;
+
+public class Player {
+    private final String name;
+    private final ArrayList<TamaGolem> tamaGolems;
+
+    public Player(String name) {
+        this.name = name;
+        this.tamaGolems = new ArrayList<>();
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public ArrayList<TamaGolem> getTamaGolems() {
+        return tamaGolems;
+    }
+}

src/TamaGolem.java

@@ -0,0 +1,38 @@
+package it.arnaldo.unibs.tamagolem;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+public class TamaGolem {
+    private final Deque<Element> elementalStones;
+    private int lifePoints;
+
+    public TamaGolem(int lifePoints) {
+        this.lifePoints = lifePoints;
+        this.elementalStones = new ArrayDeque<>();
+    }
+
+    public void addElementalStone(Element stone) {
+        elementalStones.add(stone);
+    }
+
+    public Element useElementalStone() {
+        if (!elementalStones.isEmpty()) {
+            return elementalStones.poll();
+        }
+        return null;
+    }
+
+    public int getLifePoints() {
+        return lifePoints;
+    }
+
+    public boolean getDamage(int damage) {
+        lifePoints -= damage;
+        return lifePoints <= 0;
+    }
+
+    public boolean isAlive() {
+        return lifePoints > 0;
+    }
+}

src/TamaGolemMain.java

@@ -0,0 +1,8 @@
+package it.arnaldo.unibs.tamagolem;
+import java.util.*;
+public class TamaGolemMain {
+    public static void main(String[] args) {
+        System.out.println("TamaGolem");
+        WorldBuilder.buildWorld();
+    }
+}

src/WorldBuilder.java

@@ -0,0 +1,110 @@
+package it.arnaldo.unibs.tamagolem;
+
+import java.util.*;
+
+public class WorldBuilder {
+    public static ElementGraph buildWorld() {
+        Element[] allElements = Element.values();
+        Random rand = new Random();
+        // da cambiare il numero a 8
+        int numElements = 3 + rand.nextInt(3);
+        List<Element> selectedElements = new ArrayList<>(Arrays.asList(allElements));
+        Collections.shuffle(selectedElements);
+        selectedElements = selectedElements.subList(0, numElements);
+
+        ElementGraph world = new ElementGraph();
+
+        HashMap<Element, Integer> elementStrengthNumber = new HashMap<>();
+        HashMap<Element, Integer> elementStrengthSum = new HashMap<>();
+        HashMap<Element, Integer> elementWeaknessPointToAssign = new HashMap<>();
+        HashMap<Element, Integer> elementWeaknessPoint = new HashMap<>();
+
+        int numMaxOfPossibleStrength = (numElements * (numElements - 1) / 2) - numElements;
+        System.out.println(numMaxOfPossibleStrength);
+        int index = 0;
+        for (Element element : selectedElements) {
+            index++;
+            int randomNumber = rand.nextInt(numElements - 2);
+            if (numMaxOfPossibleStrength - randomNumber < 0) {
+                randomNumber = numMaxOfPossibleStrength;
+                numMaxOfPossibleStrength = 0;
+            } else {
+                numMaxOfPossibleStrength -= randomNumber;
+            }
+
+            if (index == numElements) {
+                randomNumber = numMaxOfPossibleStrength;
+            }
+            int strengthNumber = 1 + randomNumber;
+            int weaknessNumber = numElements - 1 - strengthNumber;
+            // int strengthSum = Math.max(strengthNumber, weaknessNumber) + rand.nextInt(10);
+            elementStrengthNumber.put(element, strengthNumber);
+            elementWeaknessPoint.put(element, weaknessNumber);
+        }
+
+
+        Map<Element, GraphElement> graphElementMap = new HashMap<>();
+        for (Element el : selectedElements) {
+            GraphElement ge = new GraphElement(el);
+            world.addElement(ge);
+            graphElementMap.put(el, ge);
+        }
+
+        // Pairing e bilanciamento
+        List<Element[]> possibleInteractions = new ArrayList<>();
+        for (Element attacker : selectedElements) {
+            for (Element defender : selectedElements) {
+                if (!attacker.equals(defender)) {
+                    possibleInteractions.add(new Element[]{attacker, defender});
+                }
+            }
+        }
+
+        Collections.shuffle(possibleInteractions);
+
+        Set<String> alreadyUsed = new HashSet<>();
+
+        for (Element[] pair : possibleInteractions) {
+            Element attacker = pair[0];
+            Element defender = pair[1];
+
+            String key = attacker.name() + "-" + defender.name();
+            String reverseKey = defender.name() + "-" + attacker.name();
+            if (alreadyUsed.contains(key) || alreadyUsed.contains(reverseKey)) continue;
+
+            int attackerRemaining = elementStrengthNumber.get(attacker);
+            int defenderRemaining = elementWeaknessPoint.get(defender);
+
+            int attackerPoints = elementStrengthSum.get(attacker);
+            int defenderPoints = elementWeaknessPointToAssign.get(defender);
+
+            if (attackerRemaining <= 0 || defenderRemaining <= 0) continue;
+
+            // Calcolo potenza massima assegnabile
+            int maxPower = Math.min(attackerPoints - (attackerRemaining - 1), defenderPoints - (defenderRemaining - 1));
+            if (maxPower < 1) continue;
+
+            int power = 1 + rand.nextInt(maxPower);
+
+            // Assegna collegamenti
+            graphElementMap.get(attacker).addLink(new ElementLink(power, defender));
+            graphElementMap.get(defender).addLink(new ElementLink(-power, attacker));
+            alreadyUsed.add(key);
+            alreadyUsed.add(reverseKey);
+
+            // Aggiorna contatori
+            elementStrengthNumber.put(attacker, attackerRemaining - 1);
+            elementStrengthSum.put(attacker, attackerPoints - power);
+
+            elementWeaknessPoint.put(defender, defenderRemaining - 1);
+            elementWeaknessPointToAssign.put(defender, defenderPoints - power);
+        }
+
+        System.out.println(numElements);
+
+        world.printGraph();
+
+        return world;
+    }
+
+}