From 88ec2f43c009a4c25fe401244a9f9d4c9f176903 Mon Sep 17 00:00:00 2001 From: alberto brumana Date: Sat, 10 May 2025 13:12:46 +0200 Subject: [PATCH] added files --- src/Element.java | 14 ++++++ src/ElementGraph.java | 44 +++++++++++++++++ src/ElementLink.java | 19 +++++++ src/Game.java | 39 +++++++++++++++ src/GraphElement.java | 35 +++++++++++++ src/Player.java | 21 ++++++++ src/TamaGolem.java | 38 ++++++++++++++ src/TamaGolemMain.java | 8 +++ src/WorldBuilder.java | 110 +++++++++++++++++++++++++++++++++++++++++ 9 files changed, 328 insertions(+) create mode 100644 src/Element.java create mode 100644 src/ElementGraph.java create mode 100644 src/ElementLink.java create mode 100644 src/Game.java create mode 100644 src/GraphElement.java create mode 100644 src/Player.java create mode 100644 src/TamaGolem.java create mode 100644 src/TamaGolemMain.java create mode 100644 src/WorldBuilder.java diff --git a/src/Element.java b/src/Element.java new file mode 100644 index 0000000..78f409d --- /dev/null +++ b/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 +} diff --git a/src/ElementGraph.java b/src/ElementGraph.java new file mode 100644 index 0000000..d8f145e --- /dev/null +++ b/src/ElementGraph.java @@ -0,0 +1,44 @@ +package it.arnaldo.unibs.tamagolem; + +import java.util.*; + +public class ElementGraph { + private final Set 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 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(); + } + } + + +} diff --git a/src/ElementLink.java b/src/ElementLink.java new file mode 100644 index 0000000..f547e7c --- /dev/null +++ b/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; + } +} diff --git a/src/Game.java b/src/Game.java new file mode 100644 index 0000000..dce248c --- /dev/null +++ b/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()); + + } +} diff --git a/src/GraphElement.java b/src/GraphElement.java new file mode 100644 index 0000000..8053775 --- /dev/null +++ b/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 links; + + public GraphElement(Element element) { + this.element = element; + this.links = new HashSet<>(); + } + + public Element getElement() { + return element; + } + + public Set 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; + } +} diff --git a/src/Player.java b/src/Player.java new file mode 100644 index 0000000..201deae --- /dev/null +++ b/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 tamaGolems; + + public Player(String name) { + this.name = name; + this.tamaGolems = new ArrayList<>(); + } + + public String getName() { + return name; + } + + public ArrayList getTamaGolems() { + return tamaGolems; + } +} diff --git a/src/TamaGolem.java b/src/TamaGolem.java new file mode 100644 index 0000000..5f9e961 --- /dev/null +++ b/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 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; + } +} diff --git a/src/TamaGolemMain.java b/src/TamaGolemMain.java new file mode 100644 index 0000000..6cd5764 --- /dev/null +++ b/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(); + } +} \ No newline at end of file diff --git a/src/WorldBuilder.java b/src/WorldBuilder.java new file mode 100644 index 0000000..5811e32 --- /dev/null +++ b/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 selectedElements = new ArrayList<>(Arrays.asList(allElements)); + Collections.shuffle(selectedElements); + selectedElements = selectedElements.subList(0, numElements); + + ElementGraph world = new ElementGraph(); + + HashMap elementStrengthNumber = new HashMap<>(); + HashMap elementStrengthSum = new HashMap<>(); + HashMap elementWeaknessPointToAssign = new HashMap<>(); + HashMap 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 graphElementMap = new HashMap<>(); + for (Element el : selectedElements) { + GraphElement ge = new GraphElement(el); + world.addElement(ge); + graphElementMap.put(el, ge); + } + + // Pairing e bilanciamento + List 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 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; + } + +}