diff --git a/Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/TestWorld.java b/Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/TestWorld.java index ab4c3f8..f08c9e2 100644 --- a/Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/TestWorld.java +++ b/Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/TestWorld.java @@ -12,13 +12,14 @@ import com.jme3.texture.Texture; import pp.monopoly.client.MonopolyApp; /** - * TestWorld zeigt eine einfache Szene mit einem texturierten Quadrat und einem kleinen Würfel. - * Die Kamera wird durch den CameraController gesteuert, und die Koordinaten des Würfels werden angezeigt. + * TestWorld zeigt eine einfache Szene mit einem texturierten Quadrat und einem Würfel. + * Die Kamera wird durch den CameraController gesteuert. */ public class TestWorld { private final MonopolyApp app; private CameraController cameraController; // Steuert die Kamera + private Toolbar toolbar; // Toolbar-Instanz /** * Konstruktor für TestWorld. @@ -37,15 +38,16 @@ public class TestWorld { app.getRootNode().detachAllChildren(); // Entferne andere Szenenobjekte createBoard(); // Erstelle das Spielfeld - createCube(); // Füge den Würfel hinzu + Geometry cube = createCube(); // Erstelle den Würfel und speichere ihn + toolbar = new Toolbar(app, cube); // Erstelle die Toolbar und übergebe den Würfel // Übergib die Kamerasteuerung an CameraController cameraController = new CameraController( app.getCamera(), // Die Kamera der App Vector3f.ZERO, // Fokus auf die Mitte des Spielfelds - 5, // Radius des Kreises - 3, // Höhe der Kamera - 0.5f // Geschwindigkeit der Bewegung + 3, // Radius des Kreises + 2, // Höhe der Kamera + 0.05f // Geschwindigkeit der Bewegung ); } @@ -80,31 +82,23 @@ public class TestWorld { /** * Füge einen kleinen blauen 3D-Würfel hinzu und zeige seine Koordinaten an. */ - private void createCube() { + private Geometry createCube() { // Erstelle einen kleinen 3D-Würfel - Box cube = new Box(0.1f, 0.1f, 0.1f); // Sehr kleine Kantenlänge + Box cube = new Box(0.04f, 0.04f, 0.04f); // Sehr kleine Kantenlänge Geometry cubeGeom = new Geometry("PlayerPiece", cube); - + // Erstelle ein Material mit einer blauen Farbe Material cubeMat = new Material(app.getAssetManager(), "Common/MatDefs/Misc/Unshaded.j3md"); cubeMat.setColor("Color", ColorRGBA.Blue); // Blaue Farbe cubeGeom.setMaterial(cubeMat); - + // Positioniere den Würfel - float boardWidth = 1; // Breite des Bretts (aus `createBoard`) - float boardDepth = 1; // Tiefe des Bretts (aus `createBoard`) - Vector3f cubePosition = new Vector3f( - boardWidth + 0.3f, // Verschiebe den Würfel nach rechts - 0.1f, // Höhe knapp über dem Brett - boardDepth - 0.3f // Position in Richtung der unteren rechten Ecke - ); - cubeGeom.setLocalTranslation(cubePosition); - + cubeGeom.setLocalTranslation(0.9f, 0.01f, -0.9f); + // Füge den Würfel zur Szene hinzu app.getRootNode().attachChild(cubeGeom); - - // Zeige die Koordinaten des Würfels an - displayCubeCoordinates(cubePosition); + + return cubeGeom; // Rückgabe des Würfels } /** diff --git a/Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/Toolbar.java b/Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/Toolbar.java new file mode 100644 index 0000000..c205e80 --- /dev/null +++ b/Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/Toolbar.java @@ -0,0 +1,116 @@ +package pp.monopoly.client.gui; + +import com.jme3.math.Vector3f; +import com.jme3.scene.Geometry; +import com.simsilica.lemur.Button; +import com.simsilica.lemur.Container; +import com.simsilica.lemur.component.SpringGridLayout; + +import pp.monopoly.client.MonopolyApp; + +/** + * Toolbar Klasse, die am unteren Rand der Szene angezeigt wird. + * Die Buttons bewegen den Würfel auf dem Spielfeld. + */ +public class Toolbar { + + private final MonopolyApp app; + private final Container toolbarContainer; + private final Geometry cube; // Referenz auf den Würfel + private final float boardLimit = 0.95f; // Grenzen des Bretts (leicht angepasst) + private final float stepSize = 0.18f; // Schrittgröße pro Bewegung + private int currentPosition = 0; // Aktuelle Position auf dem Spielfeld + private final int positionsPerSide = 10; // Anzahl der Positionen pro Seite + + /** + * Konstruktor für die Toolbar. + * + * @param app Die Hauptanwendung (MonopolyApp) + * @param cube Der Würfel, der bewegt werden soll + */ + public Toolbar(MonopolyApp app, Geometry cube) { + this.app = app; + this.cube = cube; + + // Erstelle die Toolbar + toolbarContainer = new Container(new SpringGridLayout()); + + // Setze die Position am unteren Rand und die Breite + toolbarContainer.setLocalTranslation( + 0, // Links bündig + 100, // Höhe über dem unteren Rand + 0 // Z-Ebene + ); + toolbarContainer.setPreferredSize(new Vector3f(app.getCamera().getWidth(), 100, 0)); // Volle Breite + + // Füge Buttons zur Toolbar hinzu + initializeButtons(); + + // Füge die Toolbar zur GUI hinzu + app.getGuiNode().attachChild(toolbarContainer); + } + + /** + * Initialisiert die Buttons in der Toolbar. + */ + private void initializeButtons() { + addButton("Vorwärts", 1); // Bewegung nach vorne + addButton("Rückwärts", -1); // Bewegung nach hinten + } + + /** + * Fügt einen Button mit einer Bewegung hinzu. + * + * @param label Der Text des Buttons + * @param step Schrittweite (+1 für vorwärts, -1 für rückwärts) + */ + private void addButton(String label, int step) { + Button button = new Button(label); + button.setPreferredSize(new Vector3f(150, 50, 0)); // Größe der Buttons + button.addClickCommands(source -> moveCube(step)); + toolbarContainer.addChild(button); + } + + /** + * Bewegt den Würfel basierend auf der aktuellen Position auf dem Brett. + * + * @param step Schrittweite (+1 für vorwärts, -1 für rückwärts) + */ + private void moveCube(int step) { + currentPosition = (currentPosition + step + 4 * positionsPerSide) % (4 * positionsPerSide); + Vector3f newPosition = calculatePosition(currentPosition); + cube.setLocalTranslation(newPosition); + System.out.println("Würfelposition: " + newPosition); + } + + /** + * Berechnet die neue Position des Würfels basierend auf der aktuellen Brettseite und Position. + * + * @param position Aktuelle Position auf dem Spielfeld + * @return Die berechnete Position als Vector3f + */ + private Vector3f calculatePosition(int position) { + int side = position / positionsPerSide; // Seite des Bretts (0 = unten, 1 = rechts, 2 = oben, 3 = links) + int offset = position % positionsPerSide; // Position auf der aktuellen Seite + + switch (side) { + case 0: // Unten (positive x-Achse) + return new Vector3f(-boardLimit + offset * stepSize, 0.1f, -boardLimit + 0.05f); + case 1: // Rechts (positive z-Achse) + return new Vector3f(boardLimit - 0.05f, 0.1f, -boardLimit + offset * stepSize); + case 2: // Oben (negative x-Achse) + return new Vector3f(boardLimit - offset * stepSize, 0.1f, boardLimit - 0.05f); + case 3: // Links (negative z-Achse) + return new Vector3f(-boardLimit + 0.05f, 0.1f, boardLimit - offset * stepSize); + default: + throw new IllegalArgumentException("Ungültige Position: " + position); + } + } + + /** + * Entfernt die Toolbar. + */ + public void remove() { + app.getGuiNode().detachChild(toolbarContainer); + } +}