Tests bis T075 überarbeitet

# Conflicts:
#   Projekte/monopoly/model/src/test/java/pp/monopoly/Testhandbuch.java

Projekte/battleship/client/src/main/java/pp/battleship/client/GameSound.java

@@ -34,6 +34,7 @@ public class GameSound extends AbstractAppState implements GameEventListener {
     private AudioNode splashSound;
     private AudioNode shipDestroyedSound;
     private AudioNode explosionSound;
+    private AudioNode shellFlyingSound;
 
     /**
      * Checks if sound is enabled in the preferences.
@@ -78,6 +79,7 @@ public class GameSound extends AbstractAppState implements GameEventListener {
         shipDestroyedSound = loadSound(app, "Sound/Effects/sunken.wav"); //NON-NLS
         splashSound = loadSound(app, "Sound/Effects/splash.wav"); //NON-NLS
         explosionSound = loadSound(app, "Sound/Effects/explosion.wav"); //NON-NLS
+        shellFlyingSound = loadSound(app, "Sound/Effects/shell_flying.wav");
     }
 
     /**
@@ -124,12 +126,27 @@ public class GameSound extends AbstractAppState implements GameEventListener {
             shipDestroyedSound.playInstance();
     }
 
+    /**
+     * Plays the shell flying sound effect.
+     */
+    public void shellFly() {
+        if (isEnabled() && shellFlyingSound != null) {
+            shellFlyingSound.playInstance();
+        }
+    }
+
+    /**
+     * Handles a recieved {@code SoundEvent} and plays the according sound.
+     * 
+     * @param event the Sound event to be processed
+     */
     @Override
     public void receivedEvent(SoundEvent event) {
         switch (event.sound()) {
             case EXPLOSION -> explosion();
             case SPLASH -> splash();
             case DESTROYED_SHIP -> shipDestroyed();
+            case SHELL_FLYING -> shellFly();
         }
     }
 }

Projekte/battleship/client/src/main/java/pp/battleship/client/Menu.java

@@ -7,22 +7,21 @@
 
 package pp.battleship.client;
 
+import java.io.File;
+import java.io.IOException;
+import java.util.prefs.Preferences;
+
 import com.simsilica.lemur.Button;
 import com.simsilica.lemur.Checkbox;
 import com.simsilica.lemur.Label;
 import com.simsilica.lemur.style.ElementId;
 
+import static pp.battleship.Resources.lookup;
 import pp.battleship.client.gui.GameMusic;
 import pp.battleship.client.gui.VolumeSlider;
 import pp.dialog.Dialog;
 import pp.dialog.StateCheckboxModel;
 import pp.dialog.TextInputDialog;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.prefs.Preferences;
-
-import static pp.battleship.Resources.lookup;
 import static pp.util.PreferencesUtils.getPreferences;
 
 /**
@@ -39,7 +38,7 @@ class Menu extends Dialog {
     private final VolumeSlider slider;
 
     /**
-     * Constructs the Menu dialog for the Battleship application.
+     * Constructs the Menu dialog for the Battleship application.+
      *
      * @param app the BattleshipApp instance
      */

Projekte/battleship/client/src/main/java/pp/battleship/client/gui/GameMusic.java

@@ -14,6 +14,9 @@ import com.jme3.asset.AssetNotFoundException;
 import com.jme3.audio.AudioData;
 import com.jme3.audio.AudioNode;
 
+/**
+ * Handles the background music beeing played. Is able to start and stop the music. Set the Volume of the Audio.
+ */
 public class GameMusic extends AbstractAppState{
     private static final Logger LOGGER = System.getLogger(GameMusic.class.getName());
     private static final Preferences PREFERENCES = getPreferences(GameMusic.class);

Projekte/battleship/client/src/main/java/pp/battleship/client/gui/MapView.java

@@ -28,7 +28,7 @@ import pp.util.Position;
  * and interaction between the model and the view.
  */
 class MapView {
-    private static final float FIELD_SIZE = 40f;
+    public static final float FIELD_SIZE = 40f;
     private static final float GRID_LINE_WIDTH = 2f;
     private static final float BACKGROUND_DEPTH = -4f;
     private static final float GRID_DEPTH = -1f;

Projekte/battleship/client/src/main/java/pp/battleship/client/gui/MapViewSynchronizer.java

@@ -7,14 +7,23 @@
 
 package pp.battleship.client.gui;
 
+import com.jme3.material.Material;
+import com.jme3.material.RenderState;
+import com.jme3.material.RenderState.BlendMode;
 import com.jme3.math.ColorRGBA;
 import com.jme3.scene.Geometry;
 import com.jme3.scene.Node;
 import com.jme3.scene.Spatial;
+import com.jme3.scene.shape.Sphere;
+
 import pp.battleship.model.Battleship;
+import pp.battleship.model.Shell;
 import pp.battleship.model.Shot;
 import pp.util.Position;
 
+import static com.jme3.material.Materials.UNSHADED;
+
+
 /**
  * Synchronizes the visual representation of the ship map with the game model.
  * It handles the rendering of ships and shots on the map view, updating the view
@@ -122,4 +131,24 @@ class MapViewSynchronizer extends ShipMapSynchronizer {
     private Geometry shipLine(float x1, float y1, float x2, float y2, ColorRGBA color) {
         return view.getApp().getDraw().makeFatLine(x1, y1, x2, y2, SHIP_DEPTH, color, SHIP_LINE_WIDTH);
     }
+
+        /**
+     * Creates and returns a Spatial representation of the given {@code Shell} object
+     * for 2D visualization in the game. The shell is represented as a circle.
+     *
+     * @param shell The {@code Shell} object to be visualized.
+     * @return A {@code Spatial} object representing the shell on the map.
+     */
+    @Override
+    public Spatial visit(Shell shell) {
+        final ColorRGBA color = ColorRGBA.Black;
+        Geometry ellipse = new Geometry("ellipse", new Sphere(50, 50, MapView.FIELD_SIZE / 2 * 0.8f));
+        Material mat = new Material(view.getApp().getAssetManager(), UNSHADED); //NON-NLS
+        mat.getAdditionalRenderState().setBlendMode(BlendMode.Alpha);
+        mat.getAdditionalRenderState().setFaceCullMode(RenderState.FaceCullMode.Off);
+        mat.setColor("Color", color);
+        ellipse.setMaterial(mat);
+        ellipse.addControl(new Shell2DControl(view, shell));
+        return ellipse;
+    }      
 }

Projekte/battleship/client/src/main/java/pp/battleship/client/gui/SeaSynchronizer.java

@@ -20,6 +20,7 @@ import com.jme3.scene.shape.Cylinder;
 import pp.battleship.client.BattleshipApp;
 import pp.battleship.model.Battleship;
 import pp.battleship.model.Rotation;
+import pp.battleship.model.Shell;
 import pp.battleship.model.ShipMap;
 import pp.battleship.model.Shot;
 
@@ -39,6 +40,7 @@ class SeaSynchronizer extends ShipMapSynchronizer {
     private static final String BOAT_SMALL_MODEL = "Models/BoatSmall/12219_boat_v2_L2.j3o"; //NON-NLS
     private static final String CV_MODEL = "Models/CV/CV.j3o"; //NON-NLS
     private static final String BATTLE_MODEL = "Models/Battle/Battle.j3o"; //NON-NLS
+    private static final String LIGHTING = "Common/MatDefs/Light/Lighting.j3md";
     private static final String COLOR = "Color"; //NON-NLS
     private static final String SHIP = "ship"; //NON-NLS
     private static final String SHOT = "shot"; //NON-NLS
@@ -352,4 +354,25 @@ class SeaSynchronizer extends ShipMapSynchronizer {
             case UP -> PI;
         };
     }
+
+    /**
+     * Creates and returns a 3D model representation of the given {@code Shell} object
+     * for visualization in the game.
+     *
+     * @param shell The {@code Shell} object to be visualized.
+     * @return A {@code Spatial} object representing the 3D model of the shell.
+     */
+    @Override
+    public Spatial visit(Shell shell) {
+        final Spatial model = app.getAssetManager().loadModel("Models/Shell/shell.j3o");
+        model.setLocalScale(.05f);
+        model.setShadowMode(ShadowMode.CastAndReceive);
+        Material mat = new Material(app.getAssetManager(), LIGHTING);
+        mat.setTexture("DiffuseMap", app.getAssetManager().loadTexture("Models/Shell/shell_color.png"));
+        mat.setReceivesShadows(true);
+        model.setMaterial(mat);
+
+        model.addControl(new ShellControl(shell));
+        return model;
+    }
 }

Projekte/battleship/client/src/main/java/pp/battleship/client/gui/Shell2DControl.java

@@ -0,0 +1,57 @@
+package pp.battleship.client.gui;
+
+import com.jme3.math.Vector3f;
+import com.jme3.renderer.RenderManager;
+import com.jme3.renderer.ViewPort;
+import com.jme3.scene.control.AbstractControl;
+import pp.battleship.model.Shell;
+import pp.util.Position;
+
+/**
+ * Controls the 2D representation of a {@code Shell} in the game, updating its position
+ * based on the shell's current state in the game model. The {@code Shell2DControl} class
+ * is responsible for translating the shell's 3D position to a 2D view position within
+ * the game's map view.
+ */
+public class Shell2DControl extends AbstractControl {
+    private final Shell shell;
+    private final MapView view;
+
+    /**
+     * Constructs a new {@code Shell2DControl} to manage the 2D visualization of the given {@code Shell}.
+     *
+     * @param view  The {@code MapView} used to get information about the map to display.
+     * @param shell The {@code Shell} being visualized.
+     */
+    public Shell2DControl(MapView view, Shell shell){
+        this.shell = shell;
+        this.view = view;
+    }
+
+    /**
+     * Updates the position of the shell's 2D representation based on the shell's current
+     * 3D position in the game model. The position is mapped from model space to view space
+     * coordinates and translated to the appropriate location within the {@code MapView}.
+     *
+     * @param tpf Time per frame, representing the time elapsed since the last frame.
+     */
+    @Override
+    protected void controlUpdate(float tpf) {
+        Vector3f shellPos = shell.getPosition();
+        Position viewPos = view.modelToView(shellPos.x, shellPos.z);
+        spatial.setLocalTranslation(viewPos.getX() + MapView.FIELD_SIZE / 2, viewPos.getY() + MapView.FIELD_SIZE / 2, 0);
+    }
+
+    /**
+     * This method is called during the rendering phase, but it does not perform any
+     * operations in this implementation as the control only influences the spatial's
+     * transformation, not its rendering process.
+     *
+     * @param rm the RenderManager rendering the controlled Spatial (not null)
+     * @param vp the ViewPort being rendered (not null)
+     */
+    @Override
+    protected void controlRender(RenderManager rm, ViewPort vp) {
+        // No rendering-specific behavior required for this control
+    }
+}

Projekte/battleship/client/src/main/java/pp/battleship/client/gui/ShellControl.java

@@ -0,0 +1,58 @@
+package pp.battleship.client.gui;
+
+import com.jme3.math.Vector3f;
+import com.jme3.renderer.RenderManager;
+import com.jme3.renderer.ViewPort;
+import com.jme3.scene.control.AbstractControl;
+import pp.battleship.model.Shell;
+
+import static pp.util.FloatMath.PI;
+
+/**
+ * Controls the 3D representation of a {@code Shell} in the game, updating its position
+ * and rotation based on the shell's current state in the game model. The {@code ShellControl}
+ * class ensures that the spatial associated with the shell is positioned and oriented correctly
+ * within the world.
+ */
+public class ShellControl extends AbstractControl {
+    private final Shell shell;
+
+    /**
+     * Constructs a new {@code ShellControl} to manage the 3D visualization of the given {@code Shell}.
+     *
+     * @param shell The {@code Shell} being visualized and controlled.
+     */
+    public ShellControl(Shell shell){
+        super();
+        this.shell = shell;
+    }
+
+    /**
+     * Updates the 3D position and rotation of the shell based on its current state.
+     * Converts map coordinates to world coordinates and applies the shell's orientation.
+     *
+     * @param tpf Time per frame, representing the elapsed time since the last update.
+     */
+    @Override
+    protected void controlUpdate(float tpf) {
+        Vector3f pos = shell.getPosition();
+        Vector3f fixed = new Vector3f(pos.z + 0.5f, pos.y, pos.x + 0.5f);
+        fixed.setY(pos.y);
+        spatial.setLocalTranslation(fixed);
+        spatial.setLocalRotation(shell.getRotation());
+        spatial.rotate(PI/2,0,0);
+    }
+
+    /**
+     * This method is called during the rendering phase, but it does not perform any
+     * operations in this implementation as the control only influences the spatial's
+     * transformation, not its rendering process.
+     *
+     * @param rm the RenderManager rendering the controlled Spatial (not null)
+     * @param vp the ViewPort being rendered (not null)
+     */
+    @Override
+    protected void controlRender(RenderManager rm, ViewPort vp) {
+        // No rendering-specific behavior required for this control
+    }
+}

Projekte/battleship/client/src/main/java/pp/battleship/client/gui/SinkingControl.java

@@ -46,6 +46,14 @@ class SinkingControl extends AbstractControl {
         }
     }
 
+    /**
+     * This method is called during the rendering phase, but it does not perform any
+     * operations in this implementation as the control only influences the spatial's
+     * transformation, not its rendering process.
+     *
+     * @param rm the RenderManager rendering the controlled Spatial (not null)
+     * @param vp the ViewPort being rendered (not null)
+     */
     @Override
     protected void controlRender(RenderManager rm, ViewPort vp) {
         // No rendering-related code needed

Projekte/battleship/client/src/main/java/pp/battleship/server/BattleshipServer.java

@@ -18,6 +18,7 @@ import pp.battleship.BattleshipConfig;
 import pp.battleship.game.server.Player;
 import pp.battleship.game.server.ServerGameLogic;
 import pp.battleship.game.server.ServerSender;
+import pp.battleship.message.client.AnimationFinishedMessage;
 import pp.battleship.message.client.ClientMessage;
 import pp.battleship.message.client.MapMessage;
 import pp.battleship.message.client.ShootMessage;
@@ -115,6 +116,7 @@ public class BattleshipServer implements MessageListener<HostedConnection>, Conn
         Serializer.registerClass(MapMessage.class);
         Serializer.registerClass(ShootMessage.class);
         Serializer.registerClass(EffectMessage.class);
+        Serializer.registerClass(AnimationFinishedMessage.class);
         Serializer.registerClass(Battleship.class);
         Serializer.registerClass(IntPoint.class);
         Serializer.registerClass(Shot.class);
@@ -123,6 +125,7 @@ public class BattleshipServer implements MessageListener<HostedConnection>, Conn
     private void registerListeners() {
         myServer.addMessageListener(this, MapMessage.class);
         myServer.addMessageListener(this, ShootMessage.class);
+        myServer.addMessageListener(this, AnimationFinishedMessage.class);
         myServer.addConnectionListener(this);
     }
 

Projekte/battleship/converter/src/main/java/pp/battleship/exporter/ModelExporter.java

@@ -45,7 +45,12 @@ public class ModelExporter extends SimpleApplication {
         export("Models/BoatSmall/12219_boat_v2_L2.obj", "BoatSmall.j3o"); //NON-NLS
         export("Models/Battle/14084_WWII_Ship_German_Type_II_U-boat_v2_L1.obj", "Battle.j3o"); //NON-NLS
         export("Models/CV/essex_scb-125_generic.obj", "CV.j3o"); //NON-NLS
-
+        export("Models/Figures/Würfel_blau.obj", "Würfel_blau.j30");
+        export("Models/Figures/Würfel_gelb.obj", "Würfel_gelb.j30");
+        export("Models/Figures/Würfel_grün.obj", "Würfel_grün.j30");
+        export("Models/Figures/Würfel_rosa.obj", "Würfel_rosa.j30");
+        export("Models/Figures/Würfel_rot.obj", "Würfel_rot.j30");
+        export("Models/Figures/Würfel_schwarz.obj", "Würfel_schwarz.j30");
         stop();
     }
 

Projekte/battleship/model/src/main/java/pp/battleship/game/client/BattleState.java

@@ -10,6 +10,7 @@ package pp.battleship.game.client;
 import pp.battleship.message.client.ShootMessage;
 import pp.battleship.message.server.EffectMessage;
 import pp.battleship.model.IntPoint;
+import pp.battleship.model.Shell;
 import pp.battleship.model.ShipMap;
 import pp.battleship.notification.Sound;
 
@@ -53,16 +54,13 @@ class BattleState extends ClientState {
     @Override
     public void receivedEffect(EffectMessage msg) {
         ClientGameLogic.LOGGER.log(Level.INFO, "report effect: {0}", msg); //NON-NLS
-        playSound(msg);
+
         myTurn = msg.isMyTurn();
         logic.setInfoText(msg.getInfoTextKey());
-        affectedMap(msg).add(msg.getShot());
+        Shell shell = new Shell(msg.getShot());
-        if (destroyedOpponentShip(msg))
+        affectedMap(msg).add(shell);
-            logic.getOpponentMap().add(msg.getDestroyedShip());
+        logic.playSound(Sound.SHELL_FLYING);
-        if (msg.isGameOver()) {
+        logic.setState(new ShootingState(logic, shell, myTurn, msg));
-            msg.getRemainingOpponentShips().forEach(logic.getOpponentMap()::add);
-            logic.setState(new GameOverState(logic));
-        }
     }
 
     /**
@@ -74,29 +72,4 @@ class BattleState extends ClientState {
     private ShipMap affectedMap(EffectMessage msg) {
         return msg.isOwnShot() ? logic.getOpponentMap() : logic.getOwnMap();
     }
-
-    /**
-     * Checks if the opponent's ship was destroyed by the player's shot.
-     *
-     * @param msg the effect message received from the server
-     * @return true if the shot destroyed an opponent's ship, false otherwise
-     */
-    private boolean destroyedOpponentShip(EffectMessage msg) {
-        return msg.getDestroyedShip() != null && msg.isOwnShot();
-    }
-
-    /**
-     * Plays a sound based on the outcome of the shot. Different sounds are played for a miss, hit,
-     * or destruction of a ship.
-     *
-     * @param msg the effect message containing the result of the shot
-     */
-    private void playSound(EffectMessage msg) {
-        if (!msg.getShot().isHit())
-            logic.playSound(Sound.SPLASH);
-        else if (msg.getDestroyedShip() == null)
-            logic.playSound(Sound.EXPLOSION);
-        else
-            logic.playSound(Sound.DESTROYED_SHIP);
-    }
 }

Projekte/battleship/model/src/main/java/pp/battleship/game/client/ShootingState.java

@@ -0,0 +1,114 @@
+package pp.battleship.game.client;
+
+import pp.battleship.message.client.AnimationFinishedMessage;
+import pp.battleship.message.server.EffectMessage;
+import pp.battleship.model.Battleship;
+import pp.battleship.model.Shell;
+import pp.battleship.model.ShipMap;
+import pp.battleship.notification.Sound;
+
+/**
+ * Represents the shooting state of the game where a shell is fired at the opponent.
+ */
+public class ShootingState extends ClientState {
+    private float shootValue;
+    private final static float SHELL_SPEED = 0.3f;
+    private final Shell shell;
+    private final boolean myTurn;
+    private final EffectMessage msg;
+
+    /**
+     * Constructs a shooting state with the specified game logic.
+     *
+     * @param logic  the game logic
+     * @param shell  the shell being shot
+     * @param myTurn indicates if it is the player's turn
+     * @param msg    the effect message associated with the shooting action
+     */
+    public ShootingState(ClientGameLogic logic, Shell shell, boolean myTurn, EffectMessage msg) {
+        super(logic);
+        this.msg = msg;
+        this.myTurn = myTurn;
+        this.shell = shell;
+        this.shootValue = 0;
+        shell.move(shootValue);
+    }
+
+    @Override
+    public boolean showBattle() {
+        return true;
+    }
+
+    /**
+     * Updates the shooting state by moving the shell based on the elapsed time.
+     *
+     * @param delta the time in seconds since the last update
+     */
+    @Override
+    void update(float delta) {
+        super.update(delta);
+        if (shootValue > 1) {
+            endState();
+        }
+        else {
+            shootValue += delta * SHELL_SPEED;
+            shell.move(shootValue);
+        }
+    }
+
+    /**
+     * Ends the shooting state and processes the effects of the shot.
+     */
+    private void endState() {
+        playSound(msg);
+        affectedMap(msg).add(msg.getShot());
+        affectedMap(msg).remove(shell);
+
+        if (destroyedOpponentShip(msg))
+            logic.getOpponentMap().add(msg.getDestroyedShip());
+        if (msg.isGameOver()) {
+            for (Battleship ship : msg.getRemainingOpponentShips()) {
+                logic.getOpponentMap().add(ship);
+            }
+            logic.setState(new GameOverState(logic));
+            return;
+        }
+        logic.send(new AnimationFinishedMessage());
+        logic.setState(new BattleState(logic, myTurn));
+    }
+
+    /**
+     * Checks if an opponent's ship was destroyed by the shot.
+     *
+     * @param msg the effect message containing the shot details
+     * @return true if an opponent's ship was destroyed, false otherwise
+     */
+    private boolean destroyedOpponentShip(EffectMessage msg) {
+        return msg.getDestroyedShip() != null && msg.isOwnShot();
+    }
+
+    /**
+     * Retrieves the affected map based on whether the shot was owned by the player or the opponent.
+     *
+     * @param msg the effect message containing shot details
+     * @return the ShipMap that was affected by the shot
+     */
+    private ShipMap affectedMap(EffectMessage msg) {
+        return msg.isOwnShot() ? logic.getOpponentMap() : logic.getOwnMap();
+    }
+
+    /**
+     * Plays a sound based on the outcome of the shot. Different sounds are played for a miss, hit,
+     * or destruction of a ship.
+     *
+     * @param msg the effect message containing the result of the shot
+     */
+    private void playSound(EffectMessage msg) {
+        if (!msg.getShot().isHit())
+            logic.playSound(Sound.SPLASH);
+        else if (msg.getDestroyedShip() == null)
+            logic.playSound(Sound.EXPLOSION);
+        else
+            logic.playSound(Sound.DESTROYED_SHIP);
+    }
+}

Projekte/battleship/model/src/main/java/pp/battleship/game/server/ServerGameLogic.java

@@ -8,8 +8,8 @@
 package pp.battleship.game.server;
 
 import pp.battleship.BattleshipConfig;
+import pp.battleship.message.client.AnimationFinishedMessage;
 import pp.battleship.message.client.ClientInterpreter;
-import pp.battleship.message.client.ClientMessage;
 import pp.battleship.message.client.MapMessage;
 import pp.battleship.message.client.ShootMessage;
 import pp.battleship.message.server.EffectMessage;
@@ -39,6 +39,7 @@ public class ServerGameLogic implements ClientInterpreter {
     private final ServerSender serverSender;
     private Player activePlayer;
     private ServerState state = ServerState.WAIT;
+    private Set<Player> waitPlayers = new HashSet<>();
 
     /**
      * Constructs a ServerGameLogic with the specified sender and configuration.
@@ -135,7 +136,6 @@ public class ServerGameLogic implements ClientInterpreter {
 
     /**
      * Handles the reception of a MapMessage.
-     * Also tests if Map is in correct format
      *
      * @param msg  the received MapMessage
      * @param from the ID of the sender client
@@ -144,60 +144,75 @@ public class ServerGameLogic implements ClientInterpreter {
     public void received(MapMessage msg, int from) {
         if (state != ServerState.SET_UP)
             LOGGER.log(Level.ERROR, "playerReady not allowed in {0}", state); //NON-NLS
+        else {
+            if (checkMap(msg.getShips())) {
+                playerReady(getPlayerById(from), msg.getShips());
+            }
+            else {
+                LOGGER.log(Level.WARNING, "Invalid Map sent from player {0}", from); //NON-NLS
+                send(players.get(from), new GameDetails(config));
+            }
+        }
+    }
 
-        Player cp = getPlayerById(from);
+    /**
-        List<Battleship> ships = msg.getShips();
+     * Handles the reception of a AnimationFinishedMessage.
-
+     *
-        if (!validateShips(ships)) {
+     * @param msg  the received MapMessage
-            LOGGER.log(Level.ERROR, "Invalid ship placement by player {0}", from);
+     * @param from the ID of the sender client
-            send(cp, null );
+     */
+    @Override
+    public void received(AnimationFinishedMessage msg, int from) {
+        if (state != ServerState.ANIMATION) {
+            LOGGER.log(Level.ERROR, "animation finished not allowed in {0}", state);
+        }
+        else {
+            LOGGER.log(Level.DEBUG, "anim received from {0}", getPlayerById(from));
+            Player player = getPlayerById(from);
+            if (!waitPlayers.add(player)) {
+                LOGGER.log(Level.ERROR, "{0} already sent animation finished", player); //NON-NLS
                 return;
             }
-
+            if (waitPlayers.size() == 2) {
-        playerReady(cp, ships);
+                waitPlayers = new HashSet<>();
+                setState(ServerState.BATTLE);
+            }
+        }
     }
 
-
     /**
-     * Validates a list of ships.
+     * Validates the placement of battleships on the map.
-     * Validates the list, that no ships are out of bounds or overlap with each other
+     * Ensures that:
+     * <ul>
+     *   <li>The number of ships matches the configuration.</li>
+     *   <li>Ships are within the map's boundaries.</li>
+     *   <li>Ships do not overlap.</li>
+     * </ul>
      *
-     * @param ships list of ships to validate
+     * @param ships the list of {@link Battleship} objects to validate
-     * @return {@code true} if all ships positions are valid, {@code false} otherwise
+     * @return {@code true} if all ships are placed correctly; {@code false} otherwise
      */
-    private boolean validateShips(List<Battleship> ships) {
+    private boolean checkMap(List<Battleship> ships) {
-        Set<IntPoint> occupiedPoints = new HashSet<>();
+        int numShips = config.getShipNums().values().stream().mapToInt(Integer::intValue).sum();
+        if (numShips != ships.size()) return false;
 
-        for (Battleship ship : ships) {
+        List<IntPoint> occupied = new ArrayList<>();
-            if (!isWithinBounds(ship)) {
-                return false;
-            }
 
-            for (int x = ship.getMinX(); x <= ship.getMaxX(); x++) {
+        for (Battleship battleship : ships) {
-                for (int y = ship.getMinY(); y <= ship.getMaxY(); y++) {
+            int x = battleship.getX();
-                    IntPoint point = new IntPoint(x, y);
+            int y = battleship.getY();
-                    if (!occupiedPoints.add(point)) {
+            for (int i = 0; i < battleship.getLength(); i++) {
-                        return false;
+                if (x >= 0 && x < config.getMapWidth() && y >= 0 && y < config.getMapHeight() && !occupied.contains(new IntPoint(x, y))) {
+                    occupied.add(new IntPoint(x, y));
+                    x += battleship.getRot().dx();
+                    y += battleship.getRot().dy();
+                }
+                else return false;
             }
         }
-            }
-        }
-        
         return true;
     }
 
-
-    /**
-     * Test if a ship is inside the map
-     * @param ship the ship to validate
-     * @return {@code true} if a ship is within bounds, {@code false} otherwise
-     */
-    private boolean isWithinBounds(Battleship ship) {
-        return ship.getMinX() >= 0 && ship.getMaxX() < config.getMapWidth() &&
-               ship.getMinY() >= 0 && ship.getMaxY() < config.getMapHeight();
-    }
-    
-
     /**
      * Handles the reception of a ShootMessage.
      *
@@ -208,10 +223,13 @@ public class ServerGameLogic implements ClientInterpreter {
     public void received(ShootMessage msg, int from) {
         if (state != ServerState.BATTLE)
             LOGGER.log(Level.ERROR, "shoot not allowed in {0}", state); //NON-NLS
-        else
+        else{
+            setState(ServerState.ANIMATION);
             shoot(getPlayerById(from), msg.getPosition());
         }
 
+    }
+
     /**
      * Marks the player as ready and sets their ships.
      * Transitions the state to PLAY if both players are ready.

Projekte/battleship/model/src/main/java/pp/battleship/game/server/ServerState.java

@@ -26,6 +26,11 @@ enum ServerState {
      */
     BATTLE,
 
+    /**
+     * The server is waiting for all clients to finish the shoot animation.
+     */
+    ANIMATION,
+
     /**
      * The game has ended because all the ships of one player have been destroyed.
      */

Projekte/battleship/model/src/main/java/pp/battleship/game/singlemode/Copycat.java

@@ -7,6 +7,7 @@
 
 package pp.battleship.game.singlemode;
 
+import pp.battleship.message.client.AnimationFinishedMessage;
 import pp.battleship.message.client.ClientInterpreter;
 import pp.battleship.message.client.ClientMessage;
 import pp.battleship.message.client.MapMessage;
@@ -63,6 +64,11 @@ class Copycat implements ClientInterpreter {
         copiedMessage = new MapMessage(msg.getShips().stream().map(Copycat::copy).toList());
     }
 
+    @Override
+    public void received(AnimationFinishedMessage msg, int from) {
+        copiedMessage = msg;
+    }
+
     /**
      * Creates a copy of the provided {@link Battleship}.
      *

Projekte/battleship/model/src/main/java/pp/battleship/game/singlemode/RobotClient.java

@@ -1,6 +1,7 @@
 package pp.battleship.game.singlemode;
 
 import pp.battleship.game.client.BattleshipClient;
+import pp.battleship.message.client.AnimationFinishedMessage;
 import pp.battleship.message.client.MapMessage;
 import pp.battleship.message.client.ShootMessage;
 import pp.battleship.message.server.EffectMessage;
@@ -71,6 +72,7 @@ class RobotClient implements ServerInterpreter {
      * Makes the RobotClient take a shot by sending a ShootMessage with the target position.
      */
     private void robotShot() {
+
         connection.sendRobotMessage(new ShootMessage(getShotPosition()));
     }
 
@@ -121,6 +123,7 @@ class RobotClient implements ServerInterpreter {
     @Override
     public void received(EffectMessage msg) {
         LOGGER.log(Level.INFO, "Received EffectMessage: {0}", msg); //NON-NLS
+        connection.sendRobotMessage(new AnimationFinishedMessage());
         if (msg.isMyTurn())
             shoot();
     }

Projekte/battleship/model/src/main/java/pp/battleship/message/client/AnimationFinishedMessage.java

@@ -0,0 +1,24 @@
+package pp.battleship.message.client;
+
+import com.jme3.network.serializing.Serializable;
+
+/**
+ * Represents a message indicating that an animation has finished on the client side.
+ */
+@Serializable
+public class AnimationFinishedMessage extends ClientMessage {
+    public AnimationFinishedMessage() {
+        super();
+    }
+
+    /**
+     * Accepts a visitor to process this message.
+     *
+     * @param interpreter the visitor to process this message
+     * @param from        the connection ID from which the message was received
+     */
+    @Override
+    public void accept(ClientInterpreter interpreter, int from) {
+        interpreter.received(this, from);
+    }
+}

Projekte/battleship/model/src/main/java/pp/battleship/message/client/ClientInterpreter.java

@@ -26,4 +26,12 @@ public interface ClientInterpreter {
      * @param from the connection ID from which the message was received
      */
     void received(MapMessage msg, int from);
+
+    /**
+     * Processes a received AnimationFinishedMessage.
+     *
+     * @param msg  the MapMessage to be processed
+     * @param from the connection ID from which the message was received
+     */
+    void received(AnimationFinishedMessage msg, int from);
 }

Projekte/battleship/model/src/main/java/pp/battleship/model/Shell.java

@@ -0,0 +1,125 @@
+package pp.battleship.model;
+
+import com.jme3.math.Quaternion;
+import com.jme3.math.Vector3f;
+
+/**
+ * The {@code Shell} class represents a projectile fired by a ship in the Battleship game.
+ * It models the position and rotation of the projectile and allows for its movement along
+ * a Bezier curve.
+ */
+public class Shell implements Item {
+    /**
+     * Initial position of the shell
+     */
+    private final static Vector3f INIT_POS = new Vector3f(-3, 7, -3);
+    /**
+     * The overshot difference vector used to get a shallower flight path
+     */
+    private final static Vector3f OVER_SHOT_DIFF = new Vector3f(-1, -1, -1);
+    // Target shot position
+    private final Vector3f shotPosition;
+    // Position on top of shotPosition used for Bezier curve
+    private final Vector3f overShotPosition;
+    // Current position of the shell
+    private Vector3f position;
+    // Current rotation of the shell
+    private final Quaternion rotation;
+
+    /**
+     * Constructs a new {@code Shell} object using the given {@code Shot} target.
+     * The initial position, target position, and overshot position are calculated.
+     *
+     * @param shot The target {@code Shot} object containing the destination coordinates.
+     */
+    public Shell(Shot shot) {
+        this.shotPosition = new Vector3f(shot.getX(), 0, shot.getY());
+        this.overShotPosition = new Vector3f(shotPosition.x, INIT_POS.y, shotPosition.z).add(OVER_SHOT_DIFF);
+        this.position = INIT_POS;
+        this.rotation = new Quaternion();
+    }
+
+    /**
+     * Gets the current position of the shell.
+     *
+     * @return The current position as a {@code Vector3f}.
+     */
+    public Vector3f getPosition() {
+        return this.position;
+    }
+
+    /**
+     * Gets the current rotation of the shell.
+     *
+     * @return The current rotation as a {@code Quaternion}.
+     */
+    public Quaternion getRotation() {
+        return this.rotation;
+    }
+
+    /**
+     * Moves the shell along a Bezier curve based on the given time factor {@code t}.
+     * The position and rotation of the shell are updated.
+     *
+     * @param t The time factor between 0 and 1, representing the progress of the shell's flight.
+     */
+    public void move(float t) {
+        if (t > 1f) t = 1f;
+        Vector3f newPosition = bezInt(INIT_POS, overShotPosition, shotPosition, t);
+        updateRotation(position, newPosition);
+        this.position = newPosition;
+    }
+
+    /**
+     * Performs a quadratic Bezier interpolation between three points based on the time factor {@code t}.
+     *
+     * @param p1 The start position.
+     * @param p2 The overshot position.
+     * @param p3 The target position.
+     * @param t  The time factor for interpolation.
+     * @return The interpolated position as a {@code Vector3f}.
+     */
+    private Vector3f bezInt(Vector3f p1, Vector3f p2, Vector3f p3, float t) {
+        Vector3f inA = linInt(p1, p2, t);
+        Vector3f inB = linInt(p2, p3, t);
+        return linInt(inA, inB, t);
+    }
+
+    /**
+     * Performs linear interpolation between two points {@code p1} and {@code p2} based on the time factor {@code t}.
+     *
+     * @param p1 The start position.
+     * @param p2 The end position.
+     * @param t  The time factor for interpolation.
+     * @return The interpolated position as a {@code Vector3f}.
+     */
+    private Vector3f linInt(Vector3f p1, Vector3f p2, float t) {
+        float x = p1.getX() + t * (p2.getX() - p1.getX());
+        float y = p1.getY() + t * (p2.getY() - p1.getY());
+        float z = p1.getZ() + t * (p2.getZ() - p1.getZ());
+        return new Vector3f(x, y, z);
+    }
+
+    /**
+     * Updates the rotation of the shell to face the new position along its flight path.
+     *
+     * @param oldPos The previous position of the shell.
+     * @param newPos The new position of the shell.
+     */
+    private void updateRotation(Vector3f oldPos, Vector3f newPos) {
+        Vector3f direction = newPos.subtract(oldPos).normalize();
+        if (direction.lengthSquared() > 0) {
+            this.rotation.lookAt(direction, Vector3f.UNIT_Y);
+        }
+    }
+
+    @Override
+    public <T> T accept(Visitor<T> visitor) {
+        return visitor.visit(this);
+    }
+
+    @Override
+    public void accept(VoidVisitor visitor) {
+        visitor.visit(this);
+    }
+}

Projekte/battleship/model/src/main/java/pp/battleship/model/ShipMap.java

@@ -78,6 +78,15 @@ public class ShipMap {
         addItem(ship);
     }
 
+    /**
+     * Registers a shot on the map and triggers an item addition event.
+     *
+     * @param shell the shell to be registered on the map
+     */
+    public void add(Shell shell) {
+        addItem(shell);
+    }
+
     /**
      * Registers a shot on the map, updates the state of the affected ship (if any),
      * and triggers an item addition event.

Projekte/battleship/model/src/main/java/pp/battleship/model/Visitor.java

@@ -28,4 +28,12 @@ public interface Visitor<T> {
      * @return the result of visiting the Battleship element
      */
     T visit(Battleship ship);
+
+    /**
+     * Visits a Shell element
+     * 
+     * @param shell the Shell element to visit
+     * @return the result of visitung the Battleship element
+     */
+    T visit(Shell shell);
 }

Projekte/battleship/model/src/main/java/pp/battleship/model/VoidVisitor.java

@@ -25,4 +25,10 @@ public interface VoidVisitor {
      * @param ship the Battleship element to visit
      */
     void visit(Battleship ship);
+
+    /**
+     * Visits a Shell element
+     * @param shell the Shell element to visit
+     */
+    void visit(Shell shell);
 }

Projekte/battleship/model/src/main/java/pp/battleship/notification/Sound.java

@@ -22,5 +22,9 @@ public enum Sound {
     /**
      * Sound of a ship being destroyed.
      */
-    DESTROYED_SHIP
+    DESTROYED_SHIP,
+    /**
+     * Sound of a shell flying
+     */
+    SHELL_FLYING
 }

Projekte/battleship/server/src/main/java/pp/battleship/server/BattleshipServer.java

@@ -18,6 +18,7 @@ import pp.battleship.BattleshipConfig;
 import pp.battleship.game.server.Player;
 import pp.battleship.game.server.ServerGameLogic;
 import pp.battleship.game.server.ServerSender;
+import pp.battleship.message.client.AnimationFinishedMessage;
 import pp.battleship.message.client.ClientMessage;
 import pp.battleship.message.client.MapMessage;
 import pp.battleship.message.client.ShootMessage;
@@ -115,6 +116,7 @@ public class BattleshipServer implements MessageListener<HostedConnection>, Conn
         Serializer.registerClass(MapMessage.class);
         Serializer.registerClass(ShootMessage.class);
         Serializer.registerClass(EffectMessage.class);
+        Serializer.registerClass(AnimationFinishedMessage.class);
         Serializer.registerClass(Battleship.class);
         Serializer.registerClass(IntPoint.class);
         Serializer.registerClass(Shot.class);
@@ -123,6 +125,7 @@ public class BattleshipServer implements MessageListener<HostedConnection>, Conn
     private void registerListeners() {
         myServer.addMessageListener(this, MapMessage.class);
         myServer.addMessageListener(this, ShootMessage.class);
+        myServer.addMessageListener(this, AnimationFinishedMessage.class);
         myServer.addConnectionListener(this);
     }
 

Projekte/jme-common/src/main/java/pp/dialog/DialogManager.java

@@ -111,7 +111,7 @@ public class DialogManager {
      *
      * @param dialog the dialog to open
      */
-    void open(Dialog dialog) {
+    public void open(Dialog dialog) {
         dialogStack.push(dialog);
         dialog.update();
         app.getGuiNode().attachChild(dialog);
@@ -133,7 +133,7 @@ public class DialogManager {
      * @param dialog the dialog to close
      * @throws IllegalArgumentException if the specified dialog is not the top dialog
      */
-    void close(Dialog dialog) {
+    public void close(Dialog dialog) {
         if (!isTop(dialog))
             throw new IllegalArgumentException(dialog + " is not the top dialog");
         dialogStack.pop();

Projekte/jme-common/src/main/resources/Interface/Lemur/pp-styles.groovy

@@ -1,7 +1,8 @@
 // Styling of Lemur components
-// For documentation, see
+// For documentation, see:
 // https://github.com/jMonkeyEngine-Contributions/Lemur/wiki/Styling
-
+import com.simsilica.lemur.*
+import com.simsilica.lemur.component.QuadBackgroundComponent
 import com.simsilica.lemur.Button
 import com.simsilica.lemur.Button.ButtonAction
 import com.simsilica.lemur.Command
@@ -10,14 +11,19 @@ import com.simsilica.lemur.Insets3f
 import com.simsilica.lemur.component.QuadBackgroundComponent
 import com.simsilica.lemur.component.TbtQuadBackgroundComponent
 
-def bgColor = color(0.25, 0.5, 0.5, 1)
+def bgColor = color(1, 1, 1, 1)
-def buttonEnabledColor = color(0.8, 0.9, 1, 1)
+def buttonEnabledColor = color(0, 0, 0, 1)
 def buttonDisabledColor = color(0.8, 0.9, 1, 0.2)
-def buttonBgColor = color(0, 0.75, 0.75, 1)
+def buttonBgColor = color(1, 1, 1, 1)
 def sliderColor = color(0.6, 0.8, 0.8, 1)
 def sliderBgColor = color(0.5, 0.75, 0.75, 1)
 def gradientColor = color(0.5, 0.75, 0.85, 0.5)
 def tabbuttonEnabledColor = color(0.4, 0.45, 0.5, 1)
+def solidWhiteBackground = new QuadBackgroundComponent(color(1, 1, 1, 1)) // Solid white
+def greyBackground = color(0.8, 0.8, 0.8, 1)  // Grey background color
+def redBorderColor = color(1, 0, 0, 1)        // Red border color
+
+
 
 def gradient = TbtQuadBackgroundComponent.create(
         texture(name: "/com/simsilica/lemur/icons/bordered-gradient.png",
@@ -29,6 +35,13 @@ def doubleGradient = new QuadBackgroundComponent(gradientColor)
 doubleGradient.texture = texture(name: "/com/simsilica/lemur/icons/double-gradient-128.png",
         generateMips: false)
 
+def orangeBorder = TbtQuadBackgroundComponent.create(
+        texture(name: "/com/simsilica/lemur/icons/bordered-gradient.png", // Replace with an appropriate texture if needed
+                generateMips: false),
+        1, 1, 1, 126, 126,
+        1f, false)
+orangeBorder.color = color(1, 0.5, 0, 1) // Orange color
+
 selector("pp") {
     font = font("Interface/Fonts/Metropolis/Metropolis-Regular-32.fnt")
 }
@@ -46,10 +59,26 @@ selector("header", "pp") {
 }
 
 selector("container", "pp") {
-    background = gradient.clone()
+    background = solidWhiteBackground.clone()
     background.setColor(bgColor)
 }
 
+selector("toolbar") {
+    // Set the grey background
+    background = new QuadBackgroundComponent(greyBackground)
+
+    // Add a red border using a TbtQuadBackgroundComponent
+    def redBorder = TbtQuadBackgroundComponent.create(
+            texture(name: "/com/simsilica/lemur/icons/bordered-gradient.png",
+                    generateMips: false),
+            1, 1, 1, 1, 1,
+            1f, false)
+    redBorder.color = redBorderColor
+    background = greyBackground
+
+    // Optional: Set padding inside the toolbar
+    insets = new Insets3f(10, 10, 10, 10)
+}
 selector("slider", "pp") {
     background = gradient.clone()
     background.setColor(bgColor)
@@ -123,11 +152,14 @@ selector("title", "pp") {
 
 
 selector("button", "pp") {
-    background = gradient.clone()
+    def outerBackground = new QuadBackgroundComponent(color(1, 0.5, 0, 1)) // Orange border
-    color = buttonEnabledColor
+    def innerBackground = new QuadBackgroundComponent(buttonBgColor) // Inner button background
-    background.setColor(buttonBgColor)
-    insets = new Insets3f(2, 2, 2, 2)
 
+    // Apply the outer border as the main background
+    background = outerBackground
+
+    // Use insets to create a margin/padding effect for the inner background
+    insets = new Insets3f(3, 3, 3, 3) // Adjust the border thickness
     buttonCommands = stdButtonCommands
 }
 
@@ -176,6 +208,7 @@ selector("slider.down.button", "pp") {
 
 selector("checkbox", "pp") {
     color = buttonEnabledColor
+    fontSize = 20
 }
 
 selector("rollup", "pp") {
@@ -192,10 +225,14 @@ selector("tabbedPanel.container", "pp") {
 }
 
 selector("tab.button", "pp") {
-    background = gradient.clone()
+    background = solidWhiteBackground.clone()
     background.setColor(bgColor)
     color = tabbuttonEnabledColor
     insets = new Insets3f(4, 2, 0, 2)
 
     buttonCommands = stdButtonCommands
 }
+selector("settings-title", "pp") {
+    fontSize = 48 // Set font size
+    background = new QuadBackgroundComponent(color(0.4157f, 0.4235f, 0.4392f, 1.0f)) // Grey background
+ }

Projekte/monopoly/client/build.gradle

@@ -0,0 +1,23 @@
+plugins {
+    id 'buildlogic.jme-application-conventions'
+}
+
+description = 'Monopoly Client'
+
+dependencies {
+    implementation project(":jme-common")
+    implementation project(":monopoly:model")
+    implementation project(":monopoly:server")
+
+    implementation libs.jme3.desktop
+
+    runtimeOnly libs.jme3.awt.dialogs
+    runtimeOnly libs.jme3.plugins
+    runtimeOnly libs.jme3.jogg
+    runtimeOnly libs.jme3.testdata
+}
+
+application {
+    mainClass = 'pp.monopoly.client.MonopolyApp'
+    applicationName = 'monopoly'
+}

Projekte/monopoly/client/client.properties

@@ -0,0 +1,73 @@
+########################################
+## Programming project code
+## UniBw M, 2022, 2023, 2024
+## www.unibw.de/inf2
+## (c) Mark Minas (mark.minas@unibw.de)
+########################################
+#
+# Battleship client configuration
+#
+# Specifies the map used by the opponent in single mode.
+# Single mode is activated if this property is set.
+#map.opponent=maps/map2.json
+#
+# Specifies the map used by the player in single mode.
+# The player must define their own map if this property is not set.
+map.own=maps/map1.json
+#
+# Coordinates of the shots fired by the RobotClient in the order listed.
+# Example:
+#   2, 0,\
+#   2, 1,\
+#   2, 2,\
+#   2, 3
+#  defines four shots, namely at the coordinates
+#  (x=2, y=0), (x=2, y=1), (x=2, y=2), and (x=2, y=3)
+robot.targets=2, 0,\
+              2, 1,\
+              2, 2,\
+              2, 3
+#
+# Delay in milliseconds between each shot fired by the RobotClient.
+robot.delay=500
+#
+# The dimensions of the game map used in single mode.
+# 'map.width' defines the number of columns, and 'map.height' defines the number of rows.
+map.width=10
+map.height=10
+#
+# The number of ships of each length available in single mode.
+# The value is a comma-separated list where each element corresponds to the number of ships
+# with a specific length. For example:
+# ship.nums=4, 3, 2, 1
+# This configuration means:
+#   - 4 ships of length 1
+#   - 3 ships of length 2
+#   - 2 ships of length 3
+#   - 1 ship of length 4
+ship.nums=4, 3, 2, 1
+#
+# Screen settings
+#
+# Color of the text displayed at the top of the overlay.
+# The format is (red, green, blue, alpha) where each value ranges from 0 to 1.
+overlay.top.color=1, 1, 1, 1
+#
+# Application settings configuration
+# Determines whether the settings window is shown at startup.
+settings.show=false
+#
+# Specifies the width of the application window in pixels.
+settings.resolution.width=1200
+#
+# Specifies the height of the application window in pixels.
+settings.resolution.height=800
+#
+# Determines whether the application runs in full-screen mode.
+settings.full-screen=false
+#
+# Enables or disables gamma correction to improve color accuracy.
+settings.use-gamma-correction=true
+#
+# Indicates whether the statistics window is displayed during gameplay.
+statistics.show=false

Projekte/monopoly/client/logging.properties

@@ -0,0 +1,8 @@
+handlers=java.util.logging.ConsoleHandler
+.level=INFO
+pp.level=FINE
+com.jme3.network.level=INFO
+;com.jme3.util.TangentBinormalGenerator.level=SEVERE
+java.util.logging.ConsoleHandler.level=FINER
+java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter
+;java.util.logging.SimpleFormatter.format=[%4$s %2$s] %5$s%n

Projekte/monopoly/client/src/main/java/pp/monopoly/client/GameSound.java

@@ -0,0 +1,129 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.client;
+
+import java.lang.System.Logger;
+import java.lang.System.Logger.Level;
+import java.util.prefs.Preferences;
+
+import com.jme3.app.Application;
+import com.jme3.app.state.AbstractAppState;
+import com.jme3.app.state.AppStateManager;
+import com.jme3.asset.AssetLoadException;
+import com.jme3.asset.AssetNotFoundException;
+import com.jme3.audio.AudioData;
+import com.jme3.audio.AudioNode;
+
+import pp.monopoly.notification.GameEventListener;
+import pp.monopoly.notification.SoundEvent;
+import static pp.util.PreferencesUtils.getPreferences;
+
+/**
+ * An application state that plays sounds.
+ */
+public class GameSound extends AbstractAppState implements GameEventListener {
+    private static final Logger LOGGER = System.getLogger(GameSound.class.getName());
+    private static final Preferences PREFERENCES = getPreferences(GameSound.class);
+    private static final String ENABLED_PREF = "enabled"; //NON-NLS
+
+    private AudioNode splashSound;
+    private AudioNode shipDestroyedSound;
+    private AudioNode explosionSound;
+
+    /**
+     * Checks if sound is enabled in the preferences.
+     *
+     * @return {@code true} if sound is enabled, {@code false} otherwise.
+     */
+    public static boolean enabledInPreferences() {
+        return PREFERENCES.getBoolean(ENABLED_PREF, true);
+    }
+
+    /**
+     * Toggles the game sound on or off.
+     */
+    public void toggleSound() {
+        setEnabled(!isEnabled());
+    }
+
+    /**
+     * Sets the enabled state of this AppState.
+     * Overrides {@link com.jme3.app.state.AbstractAppState#setEnabled(boolean)}
+     *
+     * @param enabled {@code true} to enable the AppState, {@code false} to disable it.
+     */
+    @Override
+    public void setEnabled(boolean enabled) {
+        if (isEnabled() == enabled) return;
+        super.setEnabled(enabled);
+        LOGGER.log(Level.INFO, "Sound enabled: {0}", enabled); //NON-NLS
+        PREFERENCES.putBoolean(ENABLED_PREF, enabled);
+    }
+
+    /**
+     * Initializes the sound effects for the game.
+     * Overrides {@link AbstractAppState#initialize(AppStateManager, Application)}
+     *
+     * @param stateManager The state manager
+     * @param app          The application
+     */
+    @Override
+    public void initialize(AppStateManager stateManager, Application app) {
+        super.initialize(stateManager, app);
+    }
+
+    /**
+     * Loads a sound from the specified file.
+     *
+     * @param app  The application
+     * @param name The name of the sound file.
+     * @return The loaded AudioNode.
+     */
+    private AudioNode loadSound(Application app, String name) {
+        try {
+            final AudioNode sound = new AudioNode(app.getAssetManager(), name, AudioData.DataType.Buffer);
+            sound.setLooping(false);
+            sound.setPositional(false);
+            return sound;
+        }
+        catch (AssetLoadException | AssetNotFoundException ex) {
+            LOGGER.log(Level.ERROR, ex.getMessage(), ex);
+        }
+        return null;
+    }
+
+    /**
+     * Plays the splash sound effect.
+     */
+    public void splash() {
+        if (isEnabled() && splashSound != null)
+            splashSound.playInstance();
+    }
+
+    /**
+     * Plays the explosion sound effect.
+     */
+    public void explosion() {
+        if (isEnabled() && explosionSound != null)
+            explosionSound.playInstance();
+    }
+
+    /**
+     * Plays sound effect when a ship has been destroyed.
+     */
+    public void shipDestroyed() {
+        if (isEnabled() && shipDestroyedSound != null)
+            shipDestroyedSound.playInstance();
+    }
+
+    @Override
+    public void receivedEvent(SoundEvent event) {
+        switch (event.sound()) {
+        }
+    }
+}

Projekte/monopoly/client/src/main/java/pp/monopoly/client/Menu.java

@@ -0,0 +1,51 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.client;
+
+import java.util.prefs.Preferences;
+
+import pp.dialog.Dialog;
+import static pp.util.PreferencesUtils.getPreferences;
+
+/**
+ * The Menu class represents the main menu in the Battleship game application.
+ * It extends the Dialog class and provides functionalities for loading, saving,
+ * returning to the game, and quitting the application.
+ */
+class Menu extends Dialog {
+    private static final Preferences PREFERENCES = getPreferences(Menu.class);
+    private static final String LAST_PATH = "last.file.path";
+    private final MonopolyApp app;
+
+
+    /**
+     * Constructs the Menu dialog for the Battleship application.
+     *
+     * @param app the BattleshipApp instance
+     */
+    public Menu(MonopolyApp app) {
+        super(app.getDialogManager());
+        this.app = app;
+    }
+
+    /**
+     * Updates the state of the load and save buttons based on the game logic.
+     */
+    @Override
+    public void update() {
+
+    }
+
+    /**
+     * As an escape action, this method closes the menu if it is the top dialog.
+     */
+    @Override
+    public void escape() {
+        close();
+    }
+}

Projekte/monopoly/client/src/main/java/pp/monopoly/client/MonopolyApp.java

@@ -0,0 +1,235 @@
+package pp.monopoly.client;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import com.jme3.app.SimpleApplication;
+import com.jme3.font.BitmapFont;
+import com.jme3.font.BitmapText;
+import com.jme3.input.KeyInput;
+import com.jme3.input.controls.ActionListener;
+import com.jme3.input.controls.KeyTrigger;
+
+import com.jme3.system.AppSettings;
+import com.simsilica.lemur.GuiGlobals;
+import com.simsilica.lemur.Label;
+import com.simsilica.lemur.style.BaseStyles;
+
+import pp.dialog.DialogBuilder;
+import pp.dialog.DialogManager;
+import pp.graphics.Draw;
+import pp.monopoly.client.gui.SettingsMenu;
+import pp.monopoly.client.gui.TestWorld;
+import pp.monopoly.game.client.ClientGameLogic;
+import pp.monopoly.game.client.MonopolyClient;
+import pp.monopoly.game.client.ServerConnection;
+import pp.monopoly.notification.GameEventListener;
+import pp.monopoly.notification.InfoTextEvent;
+import pp.monopoly.server.MonopolyServer;
+
+public class MonopolyApp extends SimpleApplication implements MonopolyClient, GameEventListener {
+    private BitmapText topText;
+    private final ServerConnection serverConnection;
+    private final ClientGameLogic logic;
+    private final MonopolyAppConfig config;
+    private final ActionListener escapeListener = (name, isPressed, tpf) -> handleEscape(isPressed);
+    private final DialogManager dialogManager = new DialogManager(this);
+    private final ExecutorService executor = Executors.newCachedThreadPool();
+    private final Draw draw;
+    private SettingsMenu settingsMenu;
+    private TestWorld testWorld;
+    private boolean isSettingsMenuOpen = false;
+    private boolean inputBlocked = false;
+    private MonopolyServer monopolyServer;
+
+    /**
+     * Path to the styles script for GUI elements.
+     */
+    private static final String STYLES_SCRIPT = "Interface/Lemur/pp-styles.groovy"; //NON-NLS
+    /**
+     * Path to the font resource used in the GUI.
+     */
+    private static final String FONT = "Interface/Fonts/Default.fnt"; //NON-NLS
+
+
+    public static void main(String[] args) {
+        new MonopolyApp().start();
+    }
+
+    public MonopolyApp() {
+        this.draw = new Draw(assetManager);
+        config = new MonopolyAppConfig();
+        serverConnection = new NetworkSupport(this);
+        logic = new ClientGameLogic(serverConnection);
+        logic.addListener(this);
+        setShowSettings(config.getShowSettings());
+        setSettings(makeSettings());
+    }
+
+    @Override
+    public MonopolyAppConfig getConfig() {
+        return config;
+    }
+
+    @Override
+    public ClientGameLogic getGameLogic() {
+        return logic;
+    }
+
+    private AppSettings makeSettings() {
+        final AppSettings settings = new AppSettings(true);
+        settings.setTitle("Monopoly Game");
+        settings.setResolution(config.getResolutionWidth(), config.getResolutionHeight());
+        settings.setFullscreen(config.fullScreen());
+        return settings;
+    }
+
+    @Override
+    public void simpleInitApp() {
+        GuiGlobals.initialize(this);
+        BaseStyles.loadStyleResources(STYLES_SCRIPT);
+        GuiGlobals.getInstance().getStyles().setDefaultStyle("pp"); //NON-NLS
+        final BitmapFont normalFont = assetManager.loadFont(FONT); //NON-NLS
+
+        setupInput();
+        setupGui();
+
+        // Zeige das Startmenü
+        StartMenu.createStartMenu(this);
+    }
+
+
+
+
+
+    private void setupGui() {
+        BitmapFont normalFont = assetManager.loadFont("Interface/Fonts/Default.fnt");
+        topText = new BitmapText(normalFont);
+        topText.setLocalTranslation(10, settings.getHeight() - 10, 0);
+        guiNode.attachChild(topText);
+    }
+
+    private void setupInput() {
+        inputManager.deleteMapping(INPUT_MAPPING_EXIT);
+        inputManager.setCursorVisible(true);
+        inputManager.addMapping("ESC", new KeyTrigger(KeyInput.KEY_ESCAPE));
+        inputManager.addListener(escapeListener, "ESC");
+    }
+
+    void handleEscape(boolean isPressed) {
+        if (isPressed) {
+            if (settingsMenu != null && isSettingsMenuOpen) {
+                // Schließe das SettingsMenu
+                System.out.println("Schließe SettingsMenu...");
+                settingsMenu.close();
+                settingsMenu = null;
+                setSettingsMenuOpen(false);
+            } else {
+                // Öffne das SettingsMenu
+                System.out.println("Öffne SettingsMenu...");
+                settingsMenu = new SettingsMenu(this);
+                settingsMenu.open();
+                setSettingsMenuOpen(true);
+            }
+        }
+    }
+    
+    
+
+    private void blockInputs() {
+        if (!inputBlocked) {
+            System.out.println("Blockiere Eingaben...");
+            inputManager.setCursorVisible(true); // Cursor sichtbar machen
+            inputManager.clearMappings();       // Alle Mappings entfernen
+            inputBlocked = true;
+        }
+    }
+    
+    public void unblockInputs() {
+        if (inputBlocked) {
+            System.out.println("Aktiviere Eingaben...");
+            setupInput(); // Standard-Eingaben neu registrieren
+            inputBlocked = false;
+        }
+    }
+
+    public void setInfoText(String text) {
+        topText.setText(text);
+    }
+
+    @Override
+    public void receivedEvent(InfoTextEvent event) {
+        setInfoText(event.key());
+    }
+
+    @Override
+    public void stop(boolean waitFor) {
+        if (executor != null) executor.shutdownNow();
+        serverConnection.disconnect();
+        super.stop(waitFor);
+    }
+
+    public DialogManager getDialogManager() {
+        return dialogManager;
+    }
+
+    public Draw getDraw() {
+        return draw;
+    }
+
+    public ExecutorService getExecutor() {
+        return executor;
+    }
+
+    public void closeApp() {
+        stop();
+    }
+
+    public void errorDialog(String errorMessage) {
+        DialogBuilder.simple(dialogManager)
+                .setTitle("Fehler")
+                .setText(errorMessage)
+                .setOkButton("OK")
+                .build()
+                .open();
+    }
+
+    public void setSettingsMenuOpen(boolean isOpen) {
+        this.isSettingsMenuOpen = isOpen;
+    }
+
+    @Override
+    public void simpleUpdate(float tpf) {
+        if (testWorld != null) {
+            testWorld.update(tpf); // Aktualisiere die Kamera in der TestWorld
+        }
+    }
+
+    public void startTestWorld() {
+        guiNode.detachAllChildren(); // Entferne GUI
+        testWorld = new TestWorld(this); // Erstelle eine Instanz von TestWorld
+        testWorld.initializeScene();     // Initialisiere die Szene
+    }
+
+    public void returnToMenu() {
+        guiNode.detachAllChildren(); // Entferne die GUI
+        StartMenu.createStartMenu(this); // Zeige das Startmenü erneut
+    }
+
+    /**
+     * Startet den Server in einem neuen Thread.
+     */
+    public void startServer() {
+        new Thread(() -> {
+            try {
+                monopolyServer = new MonopolyServer(); // Erstelle Serverinstanz
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }).start();
+    }
+
+    public MonopolyServer getMonopolyServer() {
+        return monopolyServer;
+    }
+}

Projekte/monopoly/client/src/main/java/pp/monopoly/client/MonopolyAppConfig.java

@@ -0,0 +1,190 @@
+package pp.monopoly.client;
+
+import com.jme3.math.ColorRGBA;
+
+import pp.monopoly.game.client.MonopolyClientConfig;
+
+/**
+ * Provides access to the Monopoly application configuration.
+ * Extends {@link MonopolyClientConfig} to include additional properties specific to the client,
+ * particularly those related to screen settings and visual customization.
+ * <p>
+ * <b>Note:</b> Attributes of this class should not be marked as {@code final}
+ * to ensure proper functionality when reading from a properties file.
+ * </p>
+ */
+public class MonopolyAppConfig extends MonopolyClientConfig {
+
+    /**
+     * Converts a string value found in the properties file into an object of the specified type.
+     * Extends the superclass method to support conversion to {@link ColorRGBA}.
+     *
+     * @param value      the string value to be converted
+     * @param targetType the target type into which the value string is converted
+     * @return the converted object of the specified type
+     */
+    @Override
+    protected Object convertToType(String value, Class<?> targetType) {
+        if (targetType == ColorRGBA.class)
+            return makeColorRGBA(value);
+        return super.convertToType(value, targetType);
+    }
+
+    /**
+     * Converts the specified string value to a corresponding {@link ColorRGBA} object.
+     *
+     * @param value the color in the format "red, green, blue, alpha" with all values in the range [0..1]
+     * @return a {@link ColorRGBA} object representing the color
+     * @throws IllegalArgumentException if the input string is not in the expected format
+     */
+    private static ColorRGBA makeColorRGBA(String value) {
+        String[] split = value.split(",", -1);
+        try {
+            if (split.length == 4)
+                return new ColorRGBA(Float.parseFloat(split[0]),
+                                     Float.parseFloat(split[1]),
+                                     Float.parseFloat(split[2]),
+                                     Float.parseFloat(split[3]));
+        }
+        catch (NumberFormatException e) {
+            // deliberately left empty
+        }
+        throw new IllegalArgumentException(value + " should consist of exactly 4 numbers");
+    }
+
+    /**
+     * The width of the game view resolution in pixels.
+     */
+    @Property("settings.resolution.width") //NON-NLS
+    private int resolutionWidth = 1200;
+
+    /**
+     * The height of the game view resolution in pixels.
+     */
+    @Property("settings.resolution.height") //NON-NLS
+    private int resolutionHeight = 800;
+
+    /**
+     * Specifies whether the game should start in full-screen mode.
+     */
+    @Property("settings.full-screen") //NON-NLS
+    private boolean fullScreen = false;
+
+    /**
+     * Specifies whether gamma correction should be enabled.
+     * If enabled, the main framebuffer is configured for sRGB colors,
+     * and sRGB images are linearized.
+     * <p>
+     * Requires a GPU that supports GL_ARB_framebuffer_sRGB; otherwise, this setting will be ignored.
+     * </p>
+     */
+    @Property("settings.use-gamma-correction") //NON-NLS
+    private boolean useGammaCorrection = true;
+
+    /**
+     * Specifies whether full resolution framebuffers should be used on Retina displays.
+     * This setting is ignored on non-Retina platforms.
+     */
+    @Property("settings.use-retina-framebuffer") //NON-NLS
+    private boolean useRetinaFrameBuffer = false;
+
+    /**
+     * Specifies whether the settings window should be shown for configuring the game.
+     */
+    @Property("settings.show") //NON-NLS
+    private boolean showSettings = false;
+
+    /**
+     * Specifies whether the JME statistics window should be shown in the lower left corner of the screen.
+     */
+    @Property("statistics.show") //NON-NLS
+    private boolean showStatistics = false;
+
+    /**
+     * The color of the top text during gameplay, represented as a {@link ColorRGBA} object.
+     */
+    @Property("overlay.top.color") //NON-NLS
+    private ColorRGBA topColor = ColorRGBA.White;
+
+    /**
+     * Creates a default {@code MonopolyAppConfig} with predefined values.
+     */
+    public MonopolyAppConfig() {
+        // Default constructor
+    }
+
+    /**
+     * Returns the width of the game view resolution in pixels.
+     *
+     * @return the width of the game view resolution in pixels
+     */
+    public int getResolutionWidth() {
+        return resolutionWidth;
+    }
+
+    /**
+     * Returns the height of the game view resolution in pixels.
+     *
+     * @return the height of the game view resolution in pixels
+     */
+    public int getResolutionHeight() {
+        return resolutionHeight;
+    }
+
+    /**
+     * Returns whether the game should start in full-screen mode.
+     *
+     * @return {@code true} if the game should start in full-screen mode; {@code false} otherwise
+     */
+    public boolean fullScreen() {
+        return fullScreen;
+    }
+
+    /**
+     * Returns whether gamma correction is enabled.
+     * If enabled, the main framebuffer is configured for sRGB colors,
+     * and sRGB images are linearized.
+     *
+     * @return {@code true} if gamma correction is enabled; {@code false} otherwise
+     */
+    public boolean useGammaCorrection() {
+        return useGammaCorrection;
+    }
+
+    /**
+     * Returns whether full resolution framebuffers should be used on Retina displays.
+     * This setting is ignored on non-Retina platforms.
+     *
+     * @return {@code true} if full resolution framebuffers should be used on Retina displays; {@code false} otherwise
+     */
+    public boolean useRetinaFrameBuffer() {
+        return useRetinaFrameBuffer;
+    }
+
+    /**
+     * Returns whether the settings window should be shown for configuring the game.
+     *
+     * @return {@code true} if the settings window should be shown; {@code false} otherwise
+     */
+    public boolean getShowSettings() {
+        return showSettings;
+    }
+
+    /**
+     * Returns whether the JME statistics window should be shown in the lower left corner of the screen.
+     *
+     * @return {@code true} if the statistics window should be shown; {@code false} otherwise
+     */
+    public boolean getShowStatistics() {
+        return showStatistics;
+    }
+
+    /**
+     * Returns the color of the top text during gameplay as a {@link ColorRGBA} object.
+     *
+     * @return the color of the top text during gameplay
+     */
+    public ColorRGBA getTopColor() {
+        return topColor;
+    }
+}

Projekte/monopoly/client/src/main/java/pp/monopoly/client/MonopolyAppState.java

@@ -0,0 +1,84 @@
+package pp.monopoly.client;
+
+import com.jme3.app.Application;
+import com.jme3.app.state.AbstractAppState;
+import com.jme3.app.state.AppStateManager;
+
+import pp.monopoly.game.client.ClientGameLogic;
+
+/**
+ * Abstract class representing a state in the Monopoly game.
+ * Extends the AbstractAppState from jMonkeyEngine to manage state behavior.
+ */
+public abstract class MonopolyAppState extends AbstractAppState {
+    private MonopolyApp app;
+
+    /**
+     * Creates a new MonopolyAppState that is initially disabled.
+     */
+    protected MonopolyAppState() {
+        setEnabled(false);
+    }
+
+    /**
+     * Initializes the state manager and application.
+     *
+     * @param stateManager The state manager
+     * @param application  The application instance
+     */
+    @Override
+    public void initialize(AppStateManager stateManager, Application application) {
+        super.initialize(stateManager, application);
+        this.app = (MonopolyApp) application;
+        if (isEnabled()) {
+            enableState();
+        }
+    }
+
+    /**
+     * Returns the MonopolyApp instance associated with this MonopolyAppState.
+     *
+     * @return The MonopolyApp instance.
+     */
+    public MonopolyApp getApp() {
+        return app;
+    }
+
+    /**
+     * Returns the client game logic handler.
+     *
+     * @return the client game logic handler
+     */
+    public ClientGameLogic getGameLogic() {
+        return app.getGameLogic();
+    }
+
+    /**
+     * Sets the enabled state of the MonopolyAppState.
+     * If the new state is the same as the current state, the method returns.
+     *
+     * @param enabled The new enabled state.
+     */
+    @Override
+    public void setEnabled(boolean enabled) {
+        if (isEnabled() == enabled) return;
+        super.setEnabled(enabled);
+        if (app != null) {
+            if (enabled) {
+                enableState();
+            } else {
+                disableState();
+            }
+        }
+    }
+
+    /**
+     * Called when the state is enabled. Override to define specific behavior.
+     */
+    protected abstract void enableState();
+
+    /**
+     * Called when the state is disabled. Override to define specific behavior.
+     */
+    protected abstract void disableState();
+}

Projekte/monopoly/client/src/main/java/pp/monopoly/client/NetworkDialog.java

@@ -0,0 +1,146 @@
+package pp.monopoly.client;
+
+import java.lang.System.Logger;
+import java.lang.System.Logger.Level;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
+import com.simsilica.lemur.Button;
+import com.simsilica.lemur.Container;
+import com.simsilica.lemur.Label;
+import com.simsilica.lemur.TextField;
+
+import pp.dialog.Dialog;
+import pp.dialog.DialogBuilder;
+import pp.dialog.SimpleDialog;
+
+/**
+ * Represents a dialog for setting up a network connection in the Monopoly game.
+ * Allows users to specify the host and port for connecting to a game server.
+ */
+class NetworkDialog extends SimpleDialog {
+    private static final Logger LOGGER = System.getLogger(NetworkDialog.class.getName());
+    private static final String LOCALHOST = "localhost";
+    private static final String DEFAULT_PORT = "1234";
+    private final NetworkSupport network;
+    private final TextField host = new TextField(LOCALHOST);
+    private final TextField port = new TextField(DEFAULT_PORT);
+    private String hostname;
+    private int portNumber;
+    private Future<Object> connectionFuture;
+    private Dialog progressDialog;
+
+    /**
+     * Constructs a new NetworkDialog.
+     *
+     * @param network The NetworkSupport instance to be used for network operations.
+     */
+    NetworkDialog(NetworkSupport network) {
+        super(network.getApp().getDialogManager());
+        this.network = network;
+        initializeDialog();
+    }
+
+    /**
+     * Initializes the dialog with input fields and connection buttons.
+     */
+    private void initializeDialog() {
+        final MonopolyApp app = network.getApp();
+        Container inputContainer = new Container();
+
+        // Titel und Eingabefelder für Host und Port
+        inputContainer.addChild(new Label("Server-Adresse"));
+        inputContainer.addChild(host);
+
+        inputContainer.addChild(new Label("Port"));
+        inputContainer.addChild(port);
+
+        Button connectButton = inputContainer.addChild(new Button("Verbinden"));
+        connectButton.addClickCommands(source -> connect());
+
+        Button cancelButton = inputContainer.addChild(new Button("Abbrechen"));
+        cancelButton.addClickCommands(source -> app.closeApp());
+
+        app.getGuiNode().attachChild(inputContainer);
+    }
+
+    /**
+     * Initiates the connection attempt based on the entered host and port.
+     */
+    private void connect() {
+        LOGGER.log(Level.INFO, "Connecting to host={0}, port={1}", host, port);
+        try {
+            hostname = host.getText().trim().isEmpty() ? LOCALHOST : host.getText();
+            portNumber = Integer.parseInt(port.getText());
+            openProgressDialog();
+            connectionFuture = network.getApp().getExecutor().submit(this::initNetwork);
+        } catch (NumberFormatException e) {
+            network.getApp().errorDialog("Port muss eine Zahl sein.");
+        }
+    }
+
+    /**
+     * Opens a progress dialog while connecting.
+     */
+    private void openProgressDialog() {
+        progressDialog = DialogBuilder.simple(network.getApp().getDialogManager())
+                                      .setText("Verbinde zum Server...")
+                                      .build();
+        progressDialog.open();
+    }
+
+    /**
+     * Attempts to initialize the network connection.
+     *
+     * @throws RuntimeException If an error occurs when creating the client.
+     */
+    private Object initNetwork() {
+        try {
+            network.initNetwork(hostname, portNumber);
+            return null;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Updates the connection status and handles completion or failure.
+     */
+    @Override
+    public void update(float delta) {
+        if (connectionFuture != null && connectionFuture.isDone()) {
+            try {
+                connectionFuture.get();
+                onSuccess();
+            } catch (ExecutionException e) {
+                onFailure(e.getCause());
+            } catch (InterruptedException e) {
+                LOGGER.log(Level.WARNING, "Connection interrupted.", e);
+                Thread.currentThread().interrupt();
+            }
+        }
+    }
+
+    /**
+     * Handles a successful connection to the game server.
+     */
+    private void onSuccess() {
+        connectionFuture = null;
+        progressDialog.close();
+        this.close();
+        network.getApp().setInfoText("Warte auf einen Gegner...");
+    }
+
+    /**
+     * Handles a failed connection attempt.
+     *
+     * @param e The cause of the failure.
+     */
+    private void onFailure(Throwable e) {
+        connectionFuture = null;
+        progressDialog.close();
+        network.getApp().errorDialog("Verbindung zum Server fehlgeschlagen.");
+        network.getApp().setInfoText(e.getLocalizedMessage());
+    }
+    
+}

Projekte/monopoly/client/src/main/java/pp/monopoly/client/NetworkSupport.java

@@ -0,0 +1,144 @@
+package pp.monopoly.client;
+
+import java.io.IOException;
+import java.lang.System.Logger;
+import java.lang.System.Logger.Level;
+
+import com.jme3.network.Client;
+import com.jme3.network.ClientStateListener;
+import com.jme3.network.Message;
+import com.jme3.network.MessageListener;
+import com.jme3.network.Network;
+
+import pp.monopoly.game.client.ServerConnection;
+import pp.monopoly.message.client.ClientMessage;
+import pp.monopoly.message.server.ServerMessage;
+
+/**
+ * Manages the network connection for the Monopoly application.
+ * Handles connecting to and disconnecting from the server, and sending messages.
+ */
+class NetworkSupport implements MessageListener<Client>, ClientStateListener, ServerConnection {
+    private static final Logger LOGGER = System.getLogger(NetworkSupport.class.getName());
+    private final MonopolyApp app;
+    private Client client;
+
+    /**
+     * Constructs a NetworkSupport instance for the Monopoly application.
+     *
+     * @param app The Monopoly application instance.
+     */
+    public NetworkSupport(MonopolyApp app) {
+        this.app = app;
+    }
+
+    /**
+     * Returns the Monopoly application instance.
+     *
+     * @return Monopoly application instance
+     */
+    MonopolyApp getApp() {
+        return app;
+    }
+
+    /**
+     * Checks if there is a connection to the game server.
+     *
+     * @return true if there is a connection to the game server, false otherwise.
+     */
+    @Override
+    public boolean isConnected() {
+        return client != null && client.isConnected();
+    }
+
+    /**
+     * Attempts to join the game if there is no connection yet.
+     * Opens a dialog for the user to enter the host and port information.
+     */
+    @Override
+    public void connect() {
+        if (client == null) {
+            new NetworkDialog(this).open();
+        }
+    }
+
+    /**
+     * Closes the client connection.
+     */
+    @Override
+    public void disconnect() {
+        if (client == null) return;
+        client.close();
+        client = null;
+        LOGGER.log(Level.INFO, "Client connection closed.");
+    }
+
+    /**
+     * Initializes the network connection.
+     *
+     * @param host The server's address.
+     * @param port The server's port.
+     * @throws IOException If an I/O error occurs when creating the client.
+     */
+    void initNetwork(String host, int port) throws IOException {
+        if (client != null) {
+            throw new IllegalStateException("Already connected to the game server.");
+        }
+        client = Network.connectToServer(host, port);
+        client.start();
+        client.addMessageListener(this);
+        client.addClientStateListener(this);
+    }
+
+    /**
+     * Called when a message is received from the server.
+     *
+     * @param client  The client instance that received the message.
+     * @param message The message received from the server.
+     */
+    @Override
+    public void messageReceived(Client client, Message message) {
+        LOGGER.log(Level.INFO, "Message received from server: {0}", message);
+        if (message instanceof ServerMessage serverMessage) {
+            app.enqueue(() -> serverMessage.accept(app.getGameLogic()));
+        }
+    }
+
+    /**
+     * Called when the client has successfully connected to the server.
+     *
+     * @param client The client that connected to the server.
+     */
+    @Override
+    public void clientConnected(Client client) {
+        LOGGER.log(Level.INFO, "Successfully connected to server: {0}", client);
+    }
+
+    /**
+     * Called when the client is disconnected from the server.
+     *
+     * @param client         The client that was disconnected.
+     * @param disconnectInfo Information about the disconnection.
+     */
+    @Override
+    public void clientDisconnected(Client client, DisconnectInfo disconnectInfo) {
+        LOGGER.log(Level.INFO, "Disconnected from server: {0}", disconnectInfo);
+        this.client = null;
+        app.enqueue(() -> app.setInfoText("Verbindung zum Server verloren."));
+    }
+
+    /**
+     * Sends the specified message to the server.
+     *
+     * @param message The message to be sent to the server.
+     */
+    @Override
+    public void send(ClientMessage message) {
+        LOGGER.log(Level.INFO, "Sending message to server: {0}", message);
+        if (client == null) {
+            app.errorDialog("Verbindung zum Server verloren.");
+        } else {
+            client.send(message);
+        }
+    }
+}

Projekte/monopoly/client/src/main/java/pp/monopoly/client/StartMenu.java

@@ -0,0 +1,181 @@
+package pp.monopoly.client;
+
+import com.jme3.material.Material;
+import com.jme3.math.Vector3f;
+import com.jme3.scene.Geometry;
+import com.jme3.scene.shape.Quad;
+import com.jme3.texture.Texture;
+import com.simsilica.lemur.Axis;
+import com.simsilica.lemur.Button;
+import com.simsilica.lemur.Container;
+import com.simsilica.lemur.HAlignment;
+import com.simsilica.lemur.component.QuadBackgroundComponent;
+import com.simsilica.lemur.component.SpringGridLayout;
+
+import pp.dialog.Dialog;
+import pp.monopoly.client.gui.CreateGameMenu;
+import pp.monopoly.client.gui.SettingsMenu;
+
+/**
+ * Constructs the startup menu dialog for the Monopoly application.
+import pp.monopoly.client.gui.GameMenu;
+ */
+public class StartMenu extends Dialog {
+    private final MonopolyApp app;
+    private Container logoContainer;
+    private Container unibwLogoContainer;
+
+    /**
+     * Constructs the Startup Menu dialog for the Monopoly application.
+     *
+     * @param app the MonopolyApp instance
+     */
+    public StartMenu(MonopolyApp app) {
+        super(app.getDialogManager());
+        this.app = app;
+    }
+
+    /**
+     * Creates and displays the Start Menu with buttons for starting the game,
+     * opening settings, and quitting the application.
+     */
+    public static void createStartMenu(MonopolyApp app) {
+        int screenWidth = app.getContext().getSettings().getWidth();
+        int screenHeight = app.getContext().getSettings().getHeight();
+
+        // Set up the background image
+        Texture backgroundImage = app.getAssetManager().loadTexture("Pictures/unibw-Bib2.png");
+        Quad quad = new Quad(screenWidth, screenHeight);
+        Geometry background = new Geometry("Background", quad);
+        Material backgroundMaterial = new Material(app.getAssetManager(), "Common/MatDefs/Misc/Unshaded.j3md");
+        backgroundMaterial.setTexture("ColorMap", backgroundImage);
+        background.setMaterial(backgroundMaterial);
+        background.setLocalTranslation(0, 0, -1); // Ensure it is behind other GUI elements
+        app.getGuiNode().attachChild(background);
+
+        createMonopolyLogo(app);
+        createUnibwLogo(app);
+
+        // Center container for title and play button
+        Container centerMenu = new Container(new SpringGridLayout(Axis.Y, Axis.X));
+
+        Button startButton = new Button("Spielen");
+        startButton.setPreferredSize(new Vector3f(190, 60, 0)); // Increase button size (width, height)
+        startButton.setFontSize(40); // Set the font size for the button text
+        startButton.setTextHAlignment(HAlignment.Center); // Center the text horizontally
+
+        startButton.addClickCommands(source -> startGame(app));
+        centerMenu.addChild(startButton);
+
+        // Position the center container in the middle of the screen
+        centerMenu.setLocalTranslation(new Vector3f(screenWidth / 2f - centerMenu.getPreferredSize().x / 2f,
+                                                    screenHeight / 2f - 280 + centerMenu.getPreferredSize().y / 2f,
+                                                    0));
+        app.getGuiNode().attachChild(centerMenu);
+
+        // Lower-left container for "Spiel beenden" button
+        Container lowerLeftMenu = new Container();
+        lowerLeftMenu.setLocalTranslation(new Vector3f(100, 90, 0));
+        Button quitButton = new Button("Spiel beenden");
+        quitButton.setPreferredSize(new Vector3f(130, 40, 0)); // Increase button size slightly (width, height)
+        quitButton.setFontSize(18);
+        quitButton.addClickCommands(source -> quitGame());
+        lowerLeftMenu.addChild(quitButton);
+        app.getGuiNode().attachChild(lowerLeftMenu);
+
+        // Lower-right container for "Einstellungen" button
+        Container lowerRightMenu = new Container();
+        lowerRightMenu.setLocalTranslation(new Vector3f(screenWidth - 200, 90, 0));
+        Button settingsButton = new Button("Einstellungen");
+        settingsButton.setPreferredSize(new Vector3f(130, 40, 0)); // Increase button size slightly (width, height)
+        settingsButton.setFontSize(18); // Increase the font size for the text
+        settingsButton.addClickCommands(source -> openSettings(app));
+        lowerRightMenu.addChild(settingsButton);
+        app.getGuiNode().attachChild(lowerRightMenu);
+    }
+
+    /**
+     * Creates and positions the Monopoly logo container in the center of the screen.
+     */
+    private static void createMonopolyLogo(MonopolyApp app) {
+        int screenWidth = app.getContext().getSettings().getWidth();
+        int screenHeight = app.getContext().getSettings().getHeight();
+
+        // Load the Monopoly logo as a texture
+        Texture logoTexture = app.getAssetManager().loadTexture("Pictures/logo-monopoly.png");
+
+        // Create a container for the logo
+        Container logoContainer = new Container();
+        QuadBackgroundComponent logoBackground = new QuadBackgroundComponent(logoTexture);
+        logoContainer.setBackground(logoBackground);
+
+        // Set the size of the container to fit the logo
+        float logoWidth = 512;  // Adjust these values based on the logo dimensions
+        float logoHeight = 128; // Adjust these values based on the logo dimensions
+        logoContainer.setPreferredSize(new Vector3f(logoWidth, logoHeight, 0));
+
+        // Position the container at the center of the screen
+        logoContainer.setLocalTranslation(new Vector3f(
+                screenWidth / 2f - logoWidth / 2f,
+                screenHeight / 2f + 200, // Adjust this value for vertical position
+                0
+        ));
+
+        // Attach the container to the GUI node
+        app.getGuiNode().attachChild(logoContainer);
+    }
+
+    /**
+     * Creates and positions the Unibw logo container in the center of the screen.
+     */
+    private static void createUnibwLogo(MonopolyApp app) {
+        int screenWidth = app.getContext().getSettings().getWidth();
+        int screenHeight = app.getContext().getSettings().getHeight();
+
+        // Load the Unibw logo as a texture
+        Texture unibwTexture = app.getAssetManager().loadTexture("Pictures/logo-unibw.png");
+
+        // Create a container for the Unibw logo
+        Container unibwContainer = new Container();
+        QuadBackgroundComponent unibwBackground = new QuadBackgroundComponent(unibwTexture);
+        unibwContainer.setBackground(unibwBackground);
+
+        // Set the size of the container to fit the Unibw logo
+        float unibwWidth = 512;  // Adjust these values based on the logo dimensions
+        float unibwHeight = 128; // Adjust these values based on the logo dimensions
+        unibwContainer.setPreferredSize(new Vector3f(unibwWidth, unibwHeight, 0));
+
+        // Position the container slightly below the Monopoly logo
+        unibwContainer.setLocalTranslation(new Vector3f(
+                screenWidth / 2f - unibwWidth / 2f,
+                screenHeight / 2f + 100, // Adjust this value for vertical position
+                0
+        ));
+
+        // Attach the container to the GUI node
+        app.getGuiNode().attachChild(unibwContainer);
+    }
+
+    /**
+     * Starts the game by transitioning to the CreateGameMenu.
+     */
+    private static void startGame(MonopolyApp app) {
+        app.getGuiNode().detachAllChildren();
+        new CreateGameMenu(app);
+    }
+
+    /**
+     * Opens the settings menu.
+     */
+    private static void openSettings(MonopolyApp app) {
+        app.getGuiNode().detachAllChildren();
+        new SettingsMenu(app);
+    }
+
+    /**
+     * Quits the game application.
+     */
+    private static void quitGame() {
+        System.exit(0);
+    }
+}

Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/BoardSynchronizer.java

@@ -0,0 +1,74 @@
+package pp.monopoly.client.gui;
+
+import com.jme3.scene.Node;
+import com.jme3.scene.Spatial;
+
+import pp.monopoly.model.Board;
+import pp.monopoly.model.Item;
+import pp.monopoly.model.Visitor;
+import pp.monopoly.notification.GameEventListener;
+import pp.monopoly.notification.ItemAddedEvent;
+import pp.monopoly.notification.ItemRemovedEvent;
+import pp.view.ModelViewSynchronizer;
+
+/**
+ * Abstract base class for synchronizing the visual representation of a {@link Board} with its model state.
+ * This class handles the addition and removal of items from the map, ensuring that changes in the model
+ * are accurately reflected in the view.
+ */
+abstract class BoardSynchronizer extends ModelViewSynchronizer<Item> implements Visitor<Spatial>, GameEventListener {
+    protected final Board board;
+
+    /**
+     * Constructs a new BoardSynchronizer.
+     *
+     * @param board the game board to synchronize
+     * @param root  the root node to which the view representations of the board items are attached
+     */
+    protected BoardSynchronizer(Board board, Node root) {
+        super(root);
+        this.board = board;
+    }
+
+    /**
+     * Translates a model item into its corresponding visual representation.
+     *
+     * @param item the item from the model to be translated
+     * @return the visual representation of the item as a {@link Spatial}
+     */
+    @Override
+    protected Spatial translate(Item item) {
+        return item.accept(this);
+    }
+
+    /**
+     * Adds the existing items from the board to the view during initialization.
+     */
+    protected void addExisting() {
+        board.getItems().forEach(this::add);
+    }
+
+    /**
+     * Handles the event when an item is removed from the board.
+     *
+     * @param event the event indicating that an item has been removed from the board
+     */
+    @Override
+    public void receivedEvent(ItemRemovedEvent event) {
+        if (board == event.getBoard()) {
+            delete(event.getItem());
+        }
+    }
+
+    /**
+     * Handles the event when an item is added to the board.
+     *
+     * @param event the event indicating that an item has been added to the board
+     */
+    @Override
+    public void receivedEvent(ItemAddedEvent event) {
+        if (board == event.getBoard()) {
+            add(event.getItem());
+        }
+    }
+}

Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/GameMenu.java

@@ -0,0 +1,51 @@
+package pp.monopoly.client.gui;
+
+
+import com.jme3.math.ColorRGBA;
+import com.simsilica.lemur.Button;
+import com.simsilica.lemur.Label;
+import com.simsilica.lemur.style.ElementId;
+
+import pp.dialog.Dialog;
+import pp.monopoly.client.MonopolyApp;
+
+public class GameMenu extends Dialog {
+    private final MonopolyApp app;
+
+    /**
+     * Constructs the SettingsMenu dialog for the Monopoly application.
+     *
+     * @param app the MonopolyApp instance
+     */
+    public GameMenu(MonopolyApp app) {
+        super(app.getDialogManager());
+        this.app = app;
+
+        // Add a title label for Settings
+        Label settingsTitle = new Label("Einstellungen", new ElementId("settings-title"));
+        settingsTitle.setFontSize(48);  // Set font size for the title
+        settingsTitle.setColor(ColorRGBA.White);
+
+        // Add any settings-related components here, such as volume control, toggles, etc.
+
+        // Add a back button to return to StartMenu
+        Button backButton = new Button("Zurück", new ElementId("menu-button"));
+        backButton.setColor(ColorRGBA.White);
+        backButton.setFontSize(24);
+        backButton.addClickCommands(source -> returnToStartMenu());
+
+        // Add components to this dialog
+        addChild(settingsTitle);
+        addChild(backButton);
+
+        // You can add more settings components here, like checkboxes or sliders.
+    }
+
+    /**
+     * Returns to the StartMenu when the back button is clicked.
+     */
+    private void returnToStartMenu() {
+        app.getDialogManager().close(this); // Close the current settings dialog
+        //TODO return zum Ausgangsmenü
+    }
+}

Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/MapView.java

@@ -0,0 +1,75 @@
+package pp.monopoly.client.gui;
+
+import com.jme3.material.Material;
+import com.jme3.material.RenderState.BlendMode;
+import com.jme3.math.ColorRGBA;
+import com.jme3.scene.Geometry;
+import com.jme3.scene.Node;
+import com.jme3.scene.Spatial.CullHint;
+import com.jme3.scene.shape.Quad;
+
+import pp.monopoly.client.MonopolyApp;
+import pp.monopoly.model.Board;
+
+/**
+ * Represents the visual view of a {@link Board}, used to display the map structure and elements.
+ * This class handles the graphical representation of the board, including background setup and grid lines.
+ */
+class MapView {
+    private static final float FIELD_SIZE = 40f;
+    private static final float BACKGROUND_DEPTH = -4f;
+    private static final ColorRGBA BACKGROUND_COLOR = new ColorRGBA(0, 0.05f, 0.05f, 0.5f);
+
+    private final MonopolyApp app;
+    private final Node mapNode = new Node("map");
+    private final Board board;
+    private final MapViewSynchronizer synchronizer;
+
+    /**
+     * Constructs a new MapView for a given {@link Board} and {@link MonopolyApp}.
+     *
+     * @param board the board to visualize
+     * @param app   the main application instance
+     */
+    MapView(Board board, MonopolyApp app) {
+        this.board = board;
+        this.app = app;
+        this.synchronizer = new MapViewSynchronizer(this);
+        setupBackground();
+        app.getGameLogic().addListener(synchronizer);
+    }
+
+    /**
+     * Unregisters the {@link MapViewSynchronizer} from listening to board changes.
+     */
+    void unregister() {
+        app.getGameLogic().removeListener(synchronizer);
+    }
+
+    /**
+     * Sets up the background of the map view using a quad geometry.
+     */
+    private void setupBackground() {
+        Material mat = new Material(app.getAssetManager(), "Common/MatDefs/Misc/Unshaded.j3md");
+        mat.setColor("Color", BACKGROUND_COLOR);
+        mat.getAdditionalRenderState().setBlendMode(BlendMode.Alpha);
+        Geometry background = new Geometry("MapBackground", new Quad(board.getWidth() * FIELD_SIZE, board.getHeight() * FIELD_SIZE));
+        background.setMaterial(mat);
+        background.setLocalTranslation(0f, 1f, BACKGROUND_DEPTH);
+        background.setCullHint(CullHint.Never);
+        mapNode.attachChild(background);
+    }
+
+    /**
+     * Gets the root node containing all visual elements in this map view.
+     *
+     * @return the root node for the map view
+     */
+    public Node getNode() {
+        return mapNode;
+    }
+
+    public Board getBoard() {
+        return board;
+    }
+}

Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/MapViewSynchronizer.java

@@ -0,0 +1,45 @@
+package pp.monopoly.client.gui;
+
+import com.jme3.scene.Spatial;
+
+import pp.monopoly.model.Figure;
+
+/**
+ * Synchronizes the visual representation of the board with the game model.
+ * Handles updates for items on the board.
+ */
+class MapViewSynchronizer extends BoardSynchronizer {
+    private final MapView view;
+
+    /**
+     * Constructs a new MapViewSynchronizer for the given MapView.
+     *
+     * @param view the MapView to synchronize with the game model
+     */
+    public MapViewSynchronizer(MapView view) {
+        super(view.getBoard(), view.getNode());
+        this.view = view;
+        addExisting();
+    }
+
+    /**
+     * Enables the state by performing initial setup, such as adding any items to the view.
+     */
+    
+    protected void enableState() {
+        // Platz für zusätzliche Initialisierungen
+    }
+
+    /**
+     * Disables the state by clearing the view.
+     */
+    
+    protected void disableState() {
+        view.getNode().detachAllChildren(); // Entfernt alle visuellen Elemente vom Knoten
+    }
+
+    
+    public Spatial visit(Figure figure) {
+        return figure.accept(this);
+    }
+}

Projekte/monopoly/model/build.gradle

@@ -0,0 +1,15 @@
+plugins {
+    id 'buildlogic.java-library-conventions'
+}
+
+description = 'Monopoly common model'
+
+dependencies {
+    api project(":common")
+    api libs.jme3.networking
+    testImplementation libs.mockito.core
+
+    testImplementation project(":monopoly:client")
+    testImplementation project(":monopoly:model")
+    testImplementation project(":monopoly:server")
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/MonopolyConfig.java

@@ -0,0 +1,79 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly;
+
+import static java.lang.Math.max;
+
+import pp.util.config.Config;
+
+/**
+ * Provides access to the configuration settings for the Monopoly game.
+ * <p>
+ * This class allows for loading configuration settings from a properties file,
+ * including the server port, map dimensions
+ * </p>
+ * <p>
+ * <b>Note:</b> Attributes of this class are not marked as {@code final} to allow
+ * for proper initialization when reading from a properties file.
+ * </p>
+ */
+public class MonopolyConfig extends Config {
+
+    /**
+     * The default port number for the Monopoly server.
+     */
+    @Property("port")
+    private int port = 42069;
+
+    /**
+     * The width of the game map in terms of grid units.
+     */
+    @Property("map.width")
+    private int mapWidth = 10;
+
+    /**
+     * The height of the game map in terms of grid units.
+     */
+    @Property("map.height")
+    private int mapHeight = 10;
+
+    /**
+     * Creates an instance of {@code MonopolyConfig} with default settings.
+     */
+    public MonopolyConfig() {
+        // Default constructor
+    }
+
+    /**
+     * Returns the port number configured for the Monopoly server.
+     *
+     * @return the port number
+     */
+    public int getPort() {
+        return port;
+    }
+
+    /**
+     * Returns the width of the game map. The width is guaranteed to be at least 2 units.
+     *
+     * @return the width of the game map
+     */
+    public int getMapWidth() {
+        return max(mapWidth, 2);
+    }
+
+    /**
+     * Returns the height of the game map. The height is guaranteed to be at least 2 units.
+     *
+     * @return the height of the game map
+     */
+    public int getMapHeight() {
+        return max(mapHeight, 2);
+    }
+
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/Resources.java

@@ -0,0 +1,40 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly;
+
+import java.util.ResourceBundle;
+
+/**
+ * Provides access to the resource bundle of the game.
+ *
+ * @see #BUNDLE
+ */
+public class Resources {
+    /**
+     * The resource bundle for the Monopoly game.
+     */
+    public static final ResourceBundle BUNDLE = ResourceBundle.getBundle("monopoly"); //NON-NLS
+
+    /**
+     * Gets a string for the given key from the resource bundle in {@linkplain #BUNDLE}.
+     *
+     * @param key the key for the desired string
+     * @return the string for the given key
+     * @throws NullPointerException               if {@code key} is {@code null}
+     * @throws java.util.MissingResourceException if no object for the given key can be found
+     * @throws ClassCastException                 if the object found for the given key is not a string
+     */
+    public static String lookup(String key) {
+        return BUNDLE.getString(key);
+    }
+
+    /**
+     * Private constructor to prevent instantiation.
+     */
+    private Resources() { /* do not instantiate */ }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/game/client/ClientGameLogic.java

@@ -0,0 +1,260 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.game.client;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.System.Logger;
+import java.lang.System.Logger.Level;
+import java.util.ArrayList;
+import java.util.List;
+
+import pp.monopoly.message.client.ClientMessage;
+import pp.monopoly.message.server.BuyPropertyResponse;
+import pp.monopoly.message.server.DiceResult;
+import pp.monopoly.message.server.EventDrawCard;
+import pp.monopoly.message.server.GameOver;
+import pp.monopoly.message.server.GameStart;
+import pp.monopoly.message.server.JailEvent;
+import pp.monopoly.message.server.PlayerStatusUpdate;
+import pp.monopoly.message.server.ServerInterpreter;
+import pp.monopoly.message.server.TimeOutWarning;
+import pp.monopoly.message.server.TradeReply;
+import pp.monopoly.message.server.TradeRequest;
+import pp.monopoly.message.server.ViewAssetsResponse;
+import pp.monopoly.model.Board;
+import pp.monopoly.model.IntPoint;
+import pp.monopoly.notification.ClientStateEvent;
+import pp.monopoly.notification.GameEvent;
+import pp.monopoly.notification.GameEventBroker;
+import pp.monopoly.notification.GameEventListener;
+import pp.monopoly.notification.InfoTextEvent;
+import pp.monopoly.notification.Sound;
+import pp.monopoly.notification.SoundEvent;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.System.Logger;
+import java.lang.System.Logger.Level;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Controls the client-side game logic for Monopoly.
+ * Manages the player's placement, interactions with the map, and response to server messages.
+ */
+public class ClientGameLogic implements ServerInterpreter, GameEventBroker {
+    static final Logger LOGGER = System.getLogger(ClientGameLogic.class.getName());
+    private final ClientSender clientSender;
+    private final List<GameEventListener> listeners = new ArrayList<>();
+    private Board board;
+
+    private ClientState state = new ClientState(this) {
+        
+    };
+
+    /**
+     * Constructs a ClientGameLogic with the specified sender object.
+     *
+     * @param clientSender the object used to send messages to the server
+     */
+    public ClientGameLogic(ClientSender clientSender) {
+        this.clientSender = clientSender;
+    }
+
+    /**
+     * Returns the current state of the game logic.
+     */
+    ClientState getState() {
+        return state;
+    }
+
+    /**
+     * Sets the current state of the game logic.
+     *
+     * @param newState the new state to be set
+     */
+    void setState(ClientState newState) {
+        LOGGER.log(Level.DEBUG, "state transition {0} --> {1}", state.getName(), newState.getName()); //NON-NLS
+        state = newState;
+        notifyListeners(new ClientStateEvent());
+        state.entry();
+    }
+
+    /**
+     * Returns the player's own map.
+     *
+     * @return the player's own map
+     */
+    public Board getBoard() {
+        return board;
+    }
+
+    /**
+     * Moves the preview figure to the specified position.
+     *
+     * @param pos the new position for the preview figure
+     */
+    public void movePreview(IntPoint pos) {
+        state.movePreview(pos);
+    }
+
+    /**
+     * Sets the informational text to be displayed to the player.
+     *
+     * @param key the key for the info text
+     */
+    void setInfoText(String key) {
+        notifyListeners(new InfoTextEvent(key));
+    }
+
+    /**
+     * Emits an event to play the specified sound.
+     *
+     * @param sound the sound to be played.
+     */
+    public void playSound(Sound sound) {
+        notifyListeners(new SoundEvent(sound));
+    }
+
+    /**
+     * Loads a map from the specified file.
+     *
+     * @param file the file to load the map from
+     * @throws IOException if an I/O error occurs
+     */
+    public void loadMap(File file) throws IOException {
+        state.loadMap(file);
+    }
+
+    /**
+     * Sends a message to the server.
+     *
+     * @param msg the message to be sent
+     */
+    void send(ClientMessage msg) {
+        if (clientSender == null)
+            LOGGER.log(Level.ERROR, "trying to send {0} with sender==null", msg); //NON-NLS
+        else
+            clientSender.send(msg);
+    }
+
+    /**
+     * Adds a listener to receive game events.
+     *
+     * @param listener the listener to add
+     */
+    public synchronized void addListener(GameEventListener listener) {
+        listeners.add(listener);
+    }
+
+    /**
+     * Removes a listener from receiving game events.
+     *
+     * @param listener the listener to remove
+     */
+    public synchronized void removeListener(GameEventListener listener) {
+        listeners.remove(listener);
+    }
+
+    /**
+     * Notifies all listeners of a game event.
+     *
+     * @param event the game event to notify listeners of
+     */
+    @Override
+    public void notifyListeners(GameEvent event) {
+        final List<GameEventListener> copy;
+        synchronized (this) {
+            copy = new ArrayList<>(listeners);
+        }
+        for (GameEventListener listener : copy)
+            event.notifyListener(listener);
+    }
+
+    /**
+     * Called once per frame by the update loop.
+     *
+     * @param delta time in seconds since the last update call
+     */
+    public void update(float delta) {
+        state.update(delta);
+    }
+
+    @Override
+    public void received(BuyPropertyResponse msg) {
+        if (msg.isSuccessful()) {
+            setInfoText("You successfully bought " + msg.getPropertyName() + "!");
+            playSound(Sound.MONEY_LOST);
+        } else {
+            setInfoText("Unable to buy " + msg.getPropertyName() + ". Reason: " + msg.getReason());
+        }
+    }
+    
+    @Override
+    public void received(DiceResult msg) {
+        setInfoText("You rolled a " + msg.calcTotal() + "!");
+        playSound(Sound.DICE_ROLL);
+    }
+    
+    @Override
+    public void received(EventDrawCard msg) {
+        setInfoText("Event card drawn: " + msg.getCardDescription());
+        playSound(Sound.EVENT_CARD);
+    }
+    
+    @Override
+    public void received(GameOver msg) {
+        if (msg.isWinner()) {
+            setInfoText("Congratulations! You have won the game!");
+            playSound(Sound.WINNER);
+        } else {
+            setInfoText("Game over. Better luck next time!");
+            playSound(Sound.LOSER);
+        }
+    }
+    
+    @Override
+    public void received(GameStart msg) {
+        setInfoText("The game has started! Good luck!");
+    }
+    
+    @Override
+    public void received(JailEvent msg) {
+        if (msg.isGoingToJail()) {
+            setInfoText("You are sent to jail!");
+            playSound(Sound.GULAG);
+        } else {
+            setInfoText("You are out of jail!");
+        }
+    }
+    
+    @Override
+    public void received(PlayerStatusUpdate msg) {
+        setInfoText("Player " + msg.getPlayerName() + " status updated: " + msg.getStatus());
+    }
+    
+    @Override
+    public void received(TimeOutWarning msg) {
+        setInfoText("Warning! Time is running out. You have " + msg.getRemainingTime() + " seconds left.");
+    }
+    
+    @Override
+    public void received(ViewAssetsResponse msg) {
+        setInfoText("Your current assets are being displayed.");
+    }
+    
+    @Override
+    public void received(TradeReply msg) {
+    }
+    
+    @Override
+    public void received(TradeRequest msg) {
+    }
+    
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/game/client/ClientSender.java

@@ -0,0 +1,22 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.game.client;
+
+import pp.monopoly.message.client.ClientMessage;
+
+/**
+ * Interface for sending messages to the server.
+ */
+public interface ClientSender {
+    /**
+     * Send the specified message to the server.
+     *
+     * @param message the message
+     */
+    void send(ClientMessage message);
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/game/client/ClientState.java

@@ -0,0 +1,85 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.game.client;
+import pp.monopoly.model.IntPoint;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.System.Logger.Level;
+
+/**
+ * Defines the behavior and state transitions for the client-side game logic.
+ * Different states of the game logic implement this interface to handle various game events and actions.
+ */
+abstract class ClientState {
+    /**
+     * The game logic object.
+     */
+    final ClientGameLogic logic;
+
+    /**
+     * Constructs a client state of the specified game logic.
+     *
+     * @param logic the game logic
+     */
+    ClientState(ClientGameLogic logic) {
+        this.logic = logic;
+    }
+
+    /**
+     * Method to be overridden by subclasses for post-transition initialization.
+     * By default, it does nothing, but it can be overridden in derived states.
+     */
+    void entry() {
+        // Default implementation does nothing
+    }
+
+    /**
+     * Returns the name of the current state.
+     *
+     * @return the name of the current state
+     */
+    String getName() {
+        return getClass().getSimpleName();
+    }
+
+    /**
+     * Checks if the battle state should be shown.
+     *
+     * @return true if the battle state should be shown, false otherwise
+     */
+    boolean showTurn() {
+        return false;
+    }
+
+    /**
+     * Moves the preview figure to the specified position.
+     *
+     * @param pos the new position for the preview figure
+     */
+    void movePreview(IntPoint pos) {
+        ClientGameLogic.LOGGER.log(Level.DEBUG, "movePreview has no effect in {0}", getName()); //NON-NLS
+    }
+
+    /**
+     * Loads a map from the specified file.
+     *
+     * @param file the file to load the map from
+     * @throws IOException if the map cannot be loaded in the current state
+     */
+    void loadMap(File file) throws IOException {
+        throw new IOException("You are not allowed to load a map in this state of the game");
+    }
+
+    /**
+     * Called once per frame by the update loop if this state is active.
+     *
+     * @param delta time in seconds since the last update call
+     */
+    void update(float delta) { /* do nothing by default */ }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/game/client/MonopolyClient.java

@@ -0,0 +1,36 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.game.client;
+
+/**
+ * Interface representing a Monopoly client.
+ * Provides methods to access game logic, configuration, and to enqueue tasks.
+ */
+public interface MonopolyClient {
+
+    /**
+     * Returns the game logic associated with this client.
+     *
+     * @return the ClientGameLogic instance
+     */
+    ClientGameLogic getGameLogic();
+
+        /**
+     * Returns the configuration associated with this client.
+     *
+     * @return the MonopolyConfig instance
+     */
+    MonopolyClientConfig getConfig();
+
+    /**
+     * Enqueues a task to be executed by the client.
+     *
+     * @param runnable the task to be executed
+     */
+    void enqueue(Runnable runnable);
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/game/client/MonopolyClientConfig.java

@@ -0,0 +1,48 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.game.client;
+
+import java.io.File;
+
+import pp.monopoly.MonopolyConfig;
+
+/**
+ * Class providing access to the Monopoly client configuration.
+ * Extends {@link MonopolyConfig} to include additional properties specific to the client.
+ * This class manages configuration settings related to the RobotClient's behavior
+ * and the game maps used in single mode.
+ * <p>
+ * <b>Note:</b> Attributes of this class should not be marked as {@code final}
+ * to ensure proper functionality when reading from a properties file.
+ * </p>
+ */
+public class MonopolyClientConfig extends MonopolyConfig {
+
+    /**
+     * Path to the file representing the map.
+     */
+    @Property("map")
+    private String map;
+
+
+    /**
+     * Creates a default {@code MonopolyClientConfig} with predefined values.
+     */
+    public MonopolyClientConfig() {
+        // Default constructor
+    }
+
+    /**
+     * Returns the file representing the opponent's map.
+     *
+     * @return the opponent's map file, or {@code null} if not set.
+     */
+    public File getMap() {
+        return map == null ? null : new File(map);
+    }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/game/client/ServerConnection.java

@@ -0,0 +1,32 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.game.client;
+
+/**
+ * Interface representing a connection to the server.
+ * Extends ClientSender to allow sending messages to the server.
+ */
+public interface ServerConnection extends ClientSender {
+
+    /**
+     * Checks if the client is currently connected to the server.
+     *
+     * @return true if connected, false otherwise.
+     */
+    boolean isConnected();
+
+    /**
+     * Establishes a connection to the server.
+     */
+    void connect();
+
+    /**
+     * Disconnects from the server.
+     */
+    void disconnect();
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/game/server/Player.java

@@ -0,0 +1,487 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.game.server;
+
+import java.util.List;
+import java.util.Random;
+
+import pp.monopoly.message.server.DiceResult;
+import pp.monopoly.model.FieldVisitor;
+import pp.monopoly.model.Figure;
+import pp.monopoly.model.card.DeckHelper;
+import pp.monopoly.model.fields.BuildingProperty;
+import pp.monopoly.model.fields.EventField;
+import pp.monopoly.model.fields.FineField;
+import pp.monopoly.model.fields.FoodField;
+import pp.monopoly.model.fields.GateField;
+import pp.monopoly.model.fields.GoField;
+import pp.monopoly.model.fields.GulagField;
+import pp.monopoly.model.fields.PropertyField;
+import pp.monopoly.model.fields.TestStreckeField;
+import pp.monopoly.model.fields.WacheField;
+
+/**
+ * Class representing a player
+ */
+public class Player implements FieldVisitor<Void>{
+    private final int id;
+    private String name;
+    private PlayerColor color;
+    private int accountBalance = 0;
+    private Figure figure;
+    private List<PropertyField> properties;
+    private int getOutOfJailCard;
+    private int fieldID;
+    private DiceResult rollResult;
+    private final PlayerHandler handler;
+    private PlayerState state = new LobbyState();
+
+    /**
+     * Constructs a player with the speciefied params
+     * @param id the id of the player
+     * @param name the name of the player
+     * @param handler the PlayerHandler thispalyer is a part of
+     */
+    public Player(int id, String name, PlayerHandler handler) {
+        this.name = name;
+        this.id = id;
+        this.handler = handler;
+    }
+
+    /**
+     * Constructs a player with the specified id
+     * @param id the id of the player
+     * @param handler the PlayerHandler this player is a part of
+     */
+    public Player(int id, PlayerHandler handler) {
+        this.id = id;
+        this.handler = handler;
+    }
+
+    /**
+     * Set the name of the Player
+     * @param name the new name
+     */
+    void setName(String name) {
+        this.name = name;
+    }
+
+    /**
+     * Set the PlayerColor
+     * @param color the color to be set to
+     */
+    void setColor(PlayerColor color) {
+        this.color = color;
+    }
+
+    /**
+     * Returns this players id
+     * @return th eid of this player
+     */
+    public int getId() {
+        return id;
+    }
+
+    /**
+     * Returns the current position of the player
+     * @return the current position of this player
+     */
+    public int getFieldID() {
+        return fieldID;
+    }
+
+    /**
+     * Moves by the specified amount of steps
+     * @param steps the number of steps to move
+     * @return the new position
+     */
+    public int move(int steps){
+        return movePos(fieldID+steps);
+    }
+
+    /**
+     * Moves the player to the specified Position on the board
+     * @param position the position to move to
+     * @return the new position
+     */
+    public int movePos(int position){
+        fieldID = fieldID+position;
+        if(fieldID >= 40) {
+            fieldID = fieldID%40;
+            earnMoney(2000);
+        }
+        return fieldID;
+    }
+
+    /**
+     * Gets all the properties owned by this player
+     * @return List of all properties owned by this player
+     */
+    public List<PropertyField> getProperties() {
+        return properties;
+    }
+
+    /**
+     * Buy the speciefied property.
+     * Properties can olny be bought when they are not sold yet and you have enough money left to buy
+     * @param property to property to be bought
+     */
+    public void buyProperty(PropertyField property) {
+        if (property.getOwner() == null && accountBalance >= property.getPrice()) {
+            properties.add(property);
+            pay(property.getPrice());
+        }
+    }
+
+    /**
+     * Sell the property
+     * @param property the property to be sold
+     */
+    public void sellProperty(PropertyField property) {
+        if (property.getOwner() == this) {
+            properties.remove(property);
+            property.setOwner(null);
+        }
+    }
+
+    /**
+     * Gets this players current accountBalanece
+     * @return the amount of money currently owned by this player
+     */
+    public int getAccountBalance() {
+        return accountBalance;
+    }
+
+    /**
+     * Removed the speciefied amount of money to this players accountabalance
+     * @param amount the amount to be removed
+     */
+    public void pay(int amount) {
+        accountBalance -= amount;
+    }
+
+    /**
+     * Add the speciefied amount of money to this players accountabalance
+     * @param amount the amount to be added
+     */
+    public void earnMoney(int amount) {
+        accountBalance += amount;
+    }
+
+    /**
+     * Return the players name
+     * @return the name of this player
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Return the number of GEtOutOfJailCards owned by this player
+     * @return
+     */
+    public int getNumJailCard() {
+        return getOutOfJailCard;
+    }
+
+    /**
+     * Adds a GetOutOfJailCard
+     */
+    public void addJailCard() {
+        getOutOfJailCard++;
+    }
+
+    /**
+     * Removes a GetOutOfJailCard.
+     * Removes one single card per call, to a minimum of 0 cards
+     */
+    public void removeJailCard() {
+        if (getOutOfJailCard ==0) {
+            throw new IllegalStateException("Has no JailCard to remove");
+        }
+        getOutOfJailCard--;
+    }
+
+    /**
+     * Handles the logic of paying the jail bail
+     */
+    public void payBail() {
+        state.payBail();
+    }
+
+    /**
+     * Handles the logic of using a GetOutOfJailCard
+     */
+    public void useJailCard() {
+        state.useJailCard();
+    }
+
+    @Override
+    public Void visit(BuildingProperty field) {
+        int rent = field.calcRent();
+
+        field.getOwner().earnMoney(rent);
+        pay(rent);
+        return null;
+    }
+
+    @Override
+    public Void visit(FoodField field) {
+        int factor = 4;
+        if (field.getOwner().getNumProp(field) == 2) {
+            factor = 10;
+        }
+        field.getOwner().earnMoney(rollResult.calcTotal()*factor);
+        pay(rollResult.calcTotal()*factor);
+        return null;
+    }
+
+    @Override
+    public Void visit(GateField field) {
+        int rent = field.calcRent() * field.getOwner().getNumProp(field);
+
+        field.getOwner().earnMoney(rent);
+        pay(rent);
+        return null;
+    }
+
+    @Override
+    public Void visit(GulagField field) {
+        state = new JailState();
+        return null;
+    }
+
+    @Override
+    public Void visit(TestStreckeField field) {
+        earnMoney(field.collectMoney());
+        return null;
+    }
+
+    @Override
+    public Void visit(EventField field) {
+        DeckHelper.drawCard();
+        return null;
+    }
+
+    @Override
+    public Void visit(WacheField field) {
+        movePos(10);
+        return null;
+    }
+
+    @Override
+    public Void visit(GoField field) {
+        earnMoney(2000);
+        GulagField res = (GulagField) handler.getLogic().getBoardManager().getFieldAtIndex(10);
+        res.accept(this);
+        return null;
+    }
+
+    @Override
+    public Void visit(FineField field) {
+        int amount = field.getFine();
+        pay(amount);
+        TestStreckeField res =(TestStreckeField) handler.getLogic().getBoardManager().getFieldAtIndex(20);
+        res.addMoney(amount);
+        return null;
+    }
+
+    /**
+     * Return the number of Properties of the speciefied fild type
+     * @param field the type of field to search for
+     * @return the number of the fields owned with the specified type
+     */
+    public int getNumProp(PropertyField field) {
+        int count = 0;
+        for (PropertyField propertyField : properties) {
+            if (propertyField.getClass() == field.getClass()) {
+                count++;
+            }
+        }
+
+        return count;
+    }
+
+    /**
+     * Inner class for dice functionality in the game.
+     * Rolls random dice values.
+     */
+    private class Dice {
+        private static Random random = new Random();
+
+        /**
+         * Rolls a single die and returns a random value from 1 to 6.
+         *
+         * @return the result of a dice roll (1 to 6)
+         */
+        private static int rollDice() {
+            return random.nextInt(6) + 1;
+        }
+    }
+
+    /**
+     * Rolls two dice and returns a list with the results.
+     *
+     * @return a List of two integers representing the dice roll results
+     */
+    DiceResult rollDice() {
+        return state.rollDice();
+    }
+
+    /**
+     * A interface representing the PlayerStates
+     */
+    private interface PlayerState {
+        /**
+         * Handles the logic for rolling Dice
+         * @return the {@link DiceResult} of this the DiceRoll
+         */
+        DiceResult rollDice();
+
+        /**
+         * Handles the logic for paying the Jail Bail
+         */
+        void payBail();
+
+        /**
+         * Handles the action of using a GetOutOfJail Card
+         */
+        void useJailCard();
+    }
+
+
+    /**
+     * Class to represent the Active PlayerState
+     * This class is set when it is the Players turn to do actions
+     */
+    private class ActiveState implements PlayerState {
+
+        @Override
+        public DiceResult rollDice() {
+            List<Integer> roll = List.of(Dice.rollDice(), Dice.rollDice());
+            rollResult = new DiceResult(roll);
+            return rollResult;
+        }
+
+        @Override
+        public void payBail() {
+            // do nothing
+        }
+
+        @Override
+        public void useJailCard() {
+            // do nothings
+        }
+    }
+
+
+    /**
+     * A class to represent the Lobby PlayerState
+     * Set when in Lobby
+     */
+    private class LobbyState implements PlayerState{
+
+        @Override
+        public DiceResult rollDice() {
+            //do nothing
+            return null;
+        }
+
+        @Override
+        public void payBail() {
+            //do nothing
+        }
+
+        @Override
+        public void useJailCard() {
+            // do nothing
+        }
+
+    }
+
+
+    /**
+     * A class to represent the Jailed PlayerState
+     * Set when in Gulag
+     */
+    private class JailState implements PlayerState {
+
+        private int DoubletsCounter = 3;
+
+        @Override
+        public DiceResult rollDice() {
+            List<Integer> roll = List.of(Dice.rollDice(), Dice.rollDice());
+            rollResult = new DiceResult(roll);
+            if (rollResult.isDoublets()) {
+                state = new ActiveState();
+            } else if (DoubletsCounter == 0) {
+
+            } else {
+                DoubletsCounter--;
+            }
+            return rollResult;
+        }
+
+        @Override
+        public void payBail() {
+            pay(500);
+            state = new ActiveState();
+        }
+
+        @Override
+        public void useJailCard() {
+            getOutOfJailCard--;
+            state = new ActiveState();
+        }
+
+    }
+
+    private class BankruptState implements PlayerState {
+
+        @Override
+        public DiceResult rollDice() {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'rollDice'");
+        }
+
+        @Override
+        public void payBail() {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'payBail'");
+        }
+
+        @Override
+        public void useJailCard() {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'useJailCard'");
+        }
+
+    }
+
+    private class WaitForTurnState implements PlayerState {
+
+        @Override
+        public DiceResult rollDice() {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'rollDice'");
+        }
+
+        @Override
+        public void payBail() {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'payBail'");
+        }
+
+        @Override
+        public void useJailCard() {
+            // TODO Auto-generated method stub
+            throw new UnsupportedOperationException("Unimplemented method 'useJailCard'");
+        }
+
+    }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/game/server/PlayerColor.java

@@ -0,0 +1,35 @@
+package pp.monopoly.game.server;
+
+import com.jme3.math.ColorRGBA;
+
+/**
+ * Enum representing six distinct colors for players in the game.
+ */
+public enum PlayerColor {
+    GREEN_LIGHT(new ColorRGBA(0 / 255f, 204 / 255f, 0 / 255f, 1)),   // Hex: 00cc00
+    RED(new ColorRGBA(255 / 255f, 0 / 255f, 0 / 255f, 1)),           // Hex: ff0000
+    BLUE(new ColorRGBA(0 / 255f, 0 / 255f, 204 / 255f, 1)),          // Hex: 0000cc
+    PINK(new ColorRGBA(255 / 255f, 77 / 255f, 166 / 255f, 1)),       // Hex: ff4da6
+    GREEN_DARK(new ColorRGBA(0 / 255f, 102 / 255f, 0 / 255f, 1)),    // Hex: 006600
+    YELLOW(new ColorRGBA(255 / 255f, 255 / 255f, 0 / 255f, 1));      // Hex: ffff00
+
+    private final ColorRGBA color;
+
+    /**
+     * Constructs a PlayerColor with the specified ColorRGBA value.
+     *
+     * @param color the ColorRGBA value associated with the player color
+     */
+    PlayerColor(ColorRGBA color) {
+        this.color = color;
+    } 
+
+    /**
+     * Gets the ColorRGBA value of the player color.
+     *
+     * @return the ColorRGBA value
+     */
+    public ColorRGBA getColor() {
+        return color;
+    }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/game/server/PlayerHandler.java

@@ -0,0 +1,137 @@
+package pp.monopoly.game.server;
+
+import java.util.LinkedList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Set;
+/**
+ * A class for helping with player actions and managing thier turns
+ */
+public class PlayerHandler {
+    private List<Player> players = new LinkedList<>();
+    private Set<Player> readyPlayers = new HashSet<>();
+    private ServerGameLogic logic;
+
+    /**
+     * Contructs a PlayerHandler
+     * @param logic the {@link ServerGameLogic} this PlayerHandler is a part of
+     */
+    PlayerHandler(ServerGameLogic logic) {
+        this.logic = logic;
+    }
+
+    /**
+     * Contructs a PlayerHandler
+     * @param logic the {@link ServerGameLogic} this PlayerHandler is a part of
+     * @param p1 a Player to be added
+     */
+    PlayerHandler(ServerGameLogic logic, Player p1) {
+        this(logic);
+        players.add(p1);
+    }
+
+    /**
+     * Contructs a PlayerHandler
+     * @param logic the {@link ServerGameLogic} this PlayerHandler is a part of
+     * @param players a Collection of Players to be added
+     */
+    PlayerHandler(ServerGameLogic logic, Collection<Player> players) {
+        this(logic);
+        players.addAll(players);
+    }
+
+    /**
+     * Return the number of players
+     * @return number of players in the game
+     */
+    public int getPlayerCount() {
+        return players.size();
+    }
+
+    /**
+     * Chechs if all players are ready to start the game
+     * @return {@code true} if all players are ready, otherwise {@code false}
+     */
+    public boolean allPlayersReady() {
+        if (readyPlayers.size() == players.size()) return true;
+        return false;
+    }
+
+    /**
+     * Sets a players Ready status
+     * @param player the player to alter
+     * @param ready the new Status
+     */
+    void setPlayerReady(Player player, boolean ready) {
+        if (!players.contains(player)) {
+            throw new IllegalArgumentException("Player does not belong to this PlayerHandler");
+        } else {
+            if (ready) {
+                readyPlayers.add(player);
+            } else {
+                readyPlayers.remove(player);
+            }
+        }
+    }
+
+    /**
+     * Adds a player to the Queue
+     * @param player the player to be added to the queue
+     */
+    void addPlayer(Player player) {
+        if (players.contains(player)) {
+            throw new IllegalArgumentException("Player already registered");
+        }
+        players.add(player);
+    }
+
+    /**
+     * Removes the specified Player from the Queue
+     * @param player the player to be removed
+     */
+    void removePlayer(Player player) {
+        players.remove(player);
+    }
+
+    /**
+     * Gets Player based on their id in the Queue
+     * @param index the index of the queue
+     * @return the Player at the required index
+     */
+    Player getPlayerAtIndex(int index) {
+        return players.get(index);
+    }
+
+    /**
+     * Completes a player turn and return the next player
+     * @return the next players who is active
+     */
+    Player nextPlayer() {
+        Player tmp = players.get(0);
+        players.remove(0);
+        players.add(tmp);
+        return players.get(0);
+    }
+
+    /**
+     * Returns the {@link ServerGameLogic} of this PlayerHandler
+     * @return the {@link ServerGameLogic} of this PlayerHandler
+     */
+    ServerGameLogic getLogic() {
+        return logic;
+    }
+
+    /**
+     * Gets a player based on their id
+     * @param id the id to be searched for
+     * @return the player with the required id
+     */
+    Player getPlayerById(int id) {
+        for (Player player : players) {
+            if (player.getId() == id) return player;
+        }
+        throw new NoSuchElementException("Player mit id "+id+" existiert nicht");
+    }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/game/server/ServerGameLogic.java

@@ -0,0 +1,259 @@
+package pp.monopoly.game.server;
+
+import pp.monopoly.MonopolyConfig;
+import pp.monopoly.message.client.*;
+import pp.monopoly.message.server.ServerMessage;
+import pp.monopoly.message.server.TradeReply;
+import pp.monopoly.message.server.TradeRequest;
+import pp.monopoly.message.server.ViewAssetsResponse;
+import pp.monopoly.model.fields.BoardManager;
+import pp.monopoly.model.fields.PropertyField;
+
+import java.lang.System.Logger;
+import java.lang.System.Logger.Level;
+
+import pp.monopoly.MonopolyConfig;
+import pp.monopoly.message.client.ClientInterpreter;
+import pp.monopoly.message.server.ServerMessage;
+
+/**
+ * Controls the server-side game logic for Monopoly.
+ * Manages game states, player interactions, and message handling.
+ */
+public class ServerGameLogic implements ClientInterpreter {
+    private static final Logger LOGGER = System.getLogger(ServerGameLogic.class.getName());
+
+    private final MonopolyConfig config;
+    private final PlayerHandler playerHandler = new PlayerHandler(this);
+    private final ServerSender serverSender;
+    private ServerState state = ServerState.CREATEGAME;
+    private static final int MAX_PLAYERS = 6;
+    private BoardManager boardManager = new BoardManager();
+
+    /**
+     * Constructs a ServerGameLogic instance with the specified sender and configuration.
+     *
+     * @param serverSender the sender used to send messages to clients
+     * @param config       the game configuration
+     */
+    public ServerGameLogic(ServerSender serverSender, MonopolyConfig config) {
+        this.serverSender = serverSender;
+        this.config = config;
+    }
+
+    /**
+     * Retrieves the current state of the game.
+     *
+     * @return the current ServerState
+     */
+    ServerState getState() {
+        return state;
+    }
+
+    /**
+     * Sets a new state for the game and logs the state transition.
+     *
+     * @param newState the new ServerState to transition to
+     */
+    void setState(ServerState newState) {
+        LOGGER.log(Level.DEBUG, "State transition {0} --> {1}", state, newState);
+        state = newState;
+    }
+
+    /**
+     * Sends a message to a specified player.
+     *
+     * @param player the Player to whom the message is sent
+     * @param msg    the ServerMessage to send
+     */
+    void send(Player player, ServerMessage msg) {
+        if (player != null && msg != null) {
+            serverSender.send(player.getId(), msg);
+            LOGGER.log(Level.DEBUG, "Message sent to player {0}: {1}", player.getName(), msg.getClass().getSimpleName());
+        } else {
+            LOGGER.log(Level.WARNING, "Attempted to send a null message or to a null player");
+        }
+    }
+
+    /**
+     * Adds a new player to the game if the game is in the LOBBY state and the maximum
+     * player limit has not been reached.
+     *
+     * @param player the Player to add to the game
+     * @return the added Player, or null if the player could not be added
+     */
+    public Player addPlayer(Player player) {
+        if (state != ServerState.LOBBY) {
+            LOGGER.log(Level.WARNING, "Cannot add player; game is not in LOBBY state.");
+            return null;
+        }
+
+        if (playerHandler.getPlayerCount() >= MAX_PLAYERS) {
+            LOGGER.log(Level.WARNING, "Cannot add player; maximum player limit reached.");
+            return null;
+        }
+
+        playerHandler.addPlayer(player);
+        LOGGER.log(Level.DEBUG, "Player added: {0}", player.getId());
+
+        return player;
+    }
+
+    /**
+     * Adds a new player to the game if the game is in the LOBBY state and the maximum
+     * player limit has not been reached.
+     *
+     * @param id the id of the player to add to the game
+     * @return the added Player, or null if the player could not be added
+     */
+    public Player addPlayer(int id) {
+        Player player = new Player(id, playerHandler);
+        if (state != ServerState.LOBBY) {
+            LOGGER.log(Level.WARNING, "Cannot add player; game is not in LOBBY state.");
+            return null;
+        }
+
+        if (playerHandler.getPlayerCount() >= MAX_PLAYERS) {
+            LOGGER.log(Level.WARNING, "Cannot add player; maximum player limit reached.");
+            return null;
+        }
+
+        playerHandler.addPlayer(player);
+        LOGGER.log(Level.DEBUG, "Player added: {0}", player.getId());
+
+        return player;
+    }
+
+    /**
+     * Handles a BuyPropertyRequest from a player, allowing the player to purchase a property
+     * if it is unowned and they have sufficient funds.
+     *
+     * @param msg  the BuyPropertyRequest received from the player
+     * @param from the connection ID of the player who sent the request
+     */
+    @Override
+    public void received(BuyPropertyRequest msg, int from) {
+        Player player = playerHandler.getPlayerById(from);
+        if (player != null && state == ServerState.INGAME) {
+            PropertyField property = (PropertyField) boardManager.getFieldAtIndex(player.move(0)); // Assuming player position for property
+            
+            if (property.getOwner() == null && player.getAccountBalance() >= property.getPrice()) {
+                player.buyProperty(property);
+                property.setOwner(player);
+                player.earnMoney(-property.getPrice());
+                LOGGER.log(Level.INFO, "Player {0} bought property {1}", player.getName(), property.getName());
+            } else {
+                LOGGER.log(Level.WARNING, "Player {0} cannot buy property {1}", player.getName(), property.getName());
+            }
+        }
+    }
+
+    /**
+     * Handles an EndTurn request, ending the player's turn and advancing to the next player.
+     *
+     * @param msg  the EndTurn message received from the player
+     * @param from the connection ID of the player who sent the request
+     */
+    @Override
+    public void received(EndTurn msg, int from) {
+        Player player = playerHandler.getPlayerById(from);
+        if (player != null && state == ServerState.INGAME) {
+            LOGGER.log(Level.DEBUG, "Ending turn for player {0}", player.getName());
+            playerHandler.nextPlayer();
+        }
+    }
+
+    /**
+     * Handles a PlayerReady message, marking the player as ready.
+     *
+     * @param msg  the PlayerReady message received from the player
+     * @param from the connection ID of the player who sent the request
+     */
+    @Override
+    public void received(PlayerReady msg, int from) {
+        Player player = playerHandler.getPlayerById(from);
+        if (player != null) {
+            player.setName(msg.getName());
+            player.setColor(msg.getColor());
+            player.setName(msg.getName());
+            LOGGER.log(Level.DEBUG, "Player {0} is ready", player.getName());
+        }
+    }
+
+    /**
+     * Handles a RollDice message, rolling dice for the player and moving them on the board.
+     *
+     * @param msg  the RollDice message received from the player
+     * @param from the connection ID of the player who sent the request
+     */
+    @Override
+    public void received(RollDice msg, int from) {
+        Player player = playerHandler.getPlayerById(from);
+        if (player != null && state == ServerState.INGAME) {
+            send(player, player.rollDice());
+        }
+    }
+
+    /**
+     * Handles a TradeOffer message by forwarding the trade offer to the receiving player.
+     *
+     * @param msg  the TradeOffer message received from the initiating player
+     * @param from the connection ID of the player who sent the offer
+     */
+    @Override
+    public void received(TradeOffer msg, int from) {
+        Player sender = playerHandler.getPlayerById(from);
+        Player receiver = playerHandler.getPlayerById(msg.getReceiverId());
+        
+        if (sender != null && receiver != null) {
+            LOGGER.log(Level.INFO, "Player {0} offers a trade to player {1}", sender.getName(), receiver.getName());
+            send(playerHandler.getPlayerById(msg.getReceiverId()), new TradeRequest(msg.getReceiverId(), msg.getTradeHandler()));
+        }
+    }
+
+    /**
+     * Handles a TradeResponse message by forwarding the response back to the initiating player.
+     *
+     * @param msg  the TradeResponse message received from the receiving player
+     * @param from the connection ID of the player who sent the response
+     */
+    @Override
+    public void received(TradeResponse msg, int from) {
+        Player responder = playerHandler.getPlayerById(from);
+        Player initiator = playerHandler.getPlayerById(msg.getInitiatorId());
+        
+        if (responder != null && initiator != null) {
+            LOGGER.log(Level.INFO, "Player {0} responded to trade with player {1}", responder.getName(), initiator.getName());
+            send(initiator, new TradeReply(msg.getInitiatorId(), msg.getTradeHandler()));
+        }
+    }
+
+    /**
+     * Handles a ViewAssetsRequest message, sending the player a response containing their assets.
+     *
+     * @param msg  the ViewAssetsRequest message received from the player
+     * @param from the connection ID of the player who sent the request
+     */
+    @Override
+    public void received(ViewAssetsRequest msg, int from) {
+        Player player = playerHandler.getPlayerById(from);
+        if (player != null) {
+            LOGGER.log(Level.DEBUG, "Processing ViewAssetsRequest for player {0}", player.getName());
+            
+            send(player, new ViewAssetsResponse(player.getProperties(), player.getAccountBalance(), player.getNumJailCard()));
+        }
+    }
+
+    /**
+     * Retrieves the board manager, which manages the game board.
+     *
+     * @return the BoardManager instance managing the game board
+     */
+    public BoardManager getBoardManager() {
+        return boardManager;
+    }
+
+    public Player getPlayerById(int id) {
+        return playerHandler.getPlayerById(id);
+    }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/game/server/ServerSender.java

@@ -0,0 +1,23 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.game.server;
+
+import pp.monopoly.message.server.ServerMessage;
+
+/**
+ * Interface for sending messages to a client.
+ */
+public interface ServerSender {
+    /**
+     * Send the specified message to the client.
+     *
+     * @param id      the id of the client that shall receive the message
+     * @param message the message
+     */
+    void send(int id, ServerMessage message);
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/game/server/ServerState.java

@@ -0,0 +1,33 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.game.server;
+
+/**
+ * Represents the different states of the Monopoly server during the game lifecycle.
+ */
+enum ServerState {
+    /**
+     * The server is waiting for clients to connect.
+     */
+    CREATEGAME,
+
+    /**
+     * The server is waiting for clients to set up their status to ready
+     */
+    LOBBY,
+
+    /**
+     * The battle of the game where players take turns
+     */
+    INGAME,
+
+    /**
+     * The game has ended because all the players went bankrupt
+     */
+    GAMEOVER
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/client/BuyPropertyRequest.java

@@ -0,0 +1,31 @@
+package pp.monopoly.message.client;
+
+/**
+ * Represents a request from a player to buy a property.
+ */
+public class BuyPropertyRequest extends ClientMessage{
+    private int propertyId;
+
+    /**
+     * Constructs a BuyPropertyRequest with the specified property ID.
+     *
+     * @param propertyId the ID of the property to buy
+     */
+    public BuyPropertyRequest(int propertyId) {
+        this.propertyId = propertyId;
+    }
+
+    /**
+     * Gets the ID of the property to buy.
+     *
+     * @return the property ID
+     */
+    public int getPropertyId() {
+        return propertyId;
+    }
+
+    @Override
+    public void accept(ClientInterpreter interpreter, int from) {
+        interpreter.received(this, from);
+    }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/client/ClientInterpreter.java

@@ -0,0 +1,69 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.message.client;
+
+/**
+ * Visitor interface for processing all client messages.
+ */
+public interface ClientInterpreter {
+    /**
+     * Processes a received BuyPropertyRequest.
+     *
+     * @param msg  the BuyPropertyRequest to be processed
+     * @param from the connection ID from which the message was received
+     */
+    void received(BuyPropertyRequest msg, int from);
+
+    /**
+     * Processes a received EndTurn.
+     *
+     * @param msg  the EndTurn to be processed
+     * @param from the connection ID from which the message was received
+     */
+    void received(EndTurn msg, int from);
+
+    /**
+     * Processes a received PlayerReady.
+     *
+     * @param msg  the PlayerReady to be processed
+     * @param from the connection ID from which the message was received
+     */
+    void received(PlayerReady msg, int from);
+
+    /**
+     * Processes a received RollDice.
+     *
+     * @param msg  the RollDice to be processed
+     * @param from the connection ID from which the message was received
+     */
+    void received(RollDice msg, int from);
+
+    /**
+     * Processes a received TradeOffer.
+     *
+     * @param msg  the TradeOffer to be processed
+     * @param from the connection ID from which the message was received
+     */
+    void received(TradeOffer msg, int from);
+
+    /**
+     * Processes a received TradeResponse.
+     *
+     * @param msg  the TradeResponse to be processed
+     * @param from the connection ID from which the message was received
+     */
+    void received(TradeResponse msg, int from);
+
+    /**
+     * Processes a received ViewAssetsRequest.
+     *
+     * @param msg  the ViewAssetsRequest to be processed
+     * @param from the connection ID from which the message was received
+     */
+    void received(ViewAssetsRequest msg, int from);
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/client/ClientMessage.java

@@ -0,0 +1,32 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.message.client;
+
+import com.jme3.network.AbstractMessage;
+
+/**
+ * An abstract base class for client messages used in network transfer.
+ * It extends the AbstractMessage class provided by the jme3-network library.
+ */
+public abstract class ClientMessage extends AbstractMessage {
+
+    /**
+     * Constructs a new ClientMessage instance.
+     */
+    protected ClientMessage() {
+        super(true);
+    }
+
+    /**
+     * Accepts a visitor for processing this message.
+     *
+     * @param interpreter the visitor to be used for processing
+     * @param from        the connection ID of the sender
+     */
+    public abstract void accept(ClientInterpreter interpreter, int from);
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/client/EndTurn.java

@@ -0,0 +1,12 @@
+package pp.monopoly.message.client;
+/**
+ * Represents a message indicating the player wants to end their turn.
+ */
+public class EndTurn extends ClientMessage{
+
+    @Override
+    public void accept(ClientInterpreter interpreter, int from) {
+        interpreter.received(this, from);
+    }
+
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/client/PlayerReady.java

@@ -0,0 +1,52 @@
+package pp.monopoly.message.client;
+
+import pp.monopoly.game.server.PlayerColor;
+
+/**
+ * Represents a message indicating the player is ready to play.
+ */
+public class PlayerReady extends ClientMessage{
+    private boolean isReady;
+    private String name;
+    private PlayerColor color;
+
+    /**
+     * Constructs a PlayerReady message.
+     *
+     * @param isReady true if the player is ready, false otherwise
+     */
+    public PlayerReady(boolean isReady) {
+        this.isReady = isReady;
+    }
+
+    /**
+     * Getter for the Name
+     * @return the Name
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Getter for the Playercolor
+     * @return the Playercolor
+     */
+    public PlayerColor getColor() {
+        return color;
+    }
+
+    /**
+     * Checks if the player is ready.
+     *
+     * @return true if ready, false otherwise
+     */
+    public boolean isReady() {
+        return isReady;
+    }
+
+
+    @Override
+    public void accept(ClientInterpreter interpreter, int from) {
+        interpreter.received(this, from);
+    }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/client/RollDice.java

@@ -0,0 +1,12 @@
+package pp.monopoly.message.client;
+/**
+ * Represents a message requesting to roll the dice.
+ */
+public class RollDice extends ClientMessage{
+
+    @Override
+    public void accept(ClientInterpreter interpreter, int from) {
+        interpreter.received(this, from);
+    }
+
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/client/TradeOffer.java

@@ -0,0 +1,32 @@
+package pp.monopoly.message.client;
+
+import pp.monopoly.model.TradeHandler;
+
+/**
+ * Represents a trade Request message from one player to another.
+ */
+public class TradeOffer extends ClientMessage{
+    private int receiverId;
+    private TradeHandler tradehandler;
+
+
+    /**
+     * Constructs a TradeOffer with the specified details.
+     *
+     * @param receiverId the ID of the player receiving the Request
+     * @param tradehandler the tradehandler
+     */
+    public TradeOffer(int receiverId, TradeHandler tradehandler) {
+        this.receiverId = receiverId;
+        this.tradehandler = tradehandler;
+    }
+
+    public int getReceiverId() { return receiverId; }
+    public TradeHandler getTradeHandler() { return tradehandler; }
+
+    @Override
+    public void accept(ClientInterpreter interpreter, int from) {
+        interpreter.received(this, from);
+    }
+
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/client/TradeResponse.java

@@ -0,0 +1,32 @@
+package pp.monopoly.message.client;
+
+import pp.monopoly.model.TradeHandler;
+
+/**
+ * Represents a response to a trade offer.
+ */
+public class TradeResponse extends ClientMessage{
+    private int initiatorId;
+    private TradeHandler tradeHandler;
+
+    /**
+     * Constructs a TradeResponse with the specified response details.
+     *
+     * @param initiatorId the ID of the player who initiated the trade
+     * @param accepted true if the offer is accepted, false if declined
+     */
+    public TradeResponse(int initiatorId, TradeHandler tradeHandler) {
+        this.initiatorId = initiatorId;
+        this.tradeHandler = tradeHandler;
+    }
+
+    public int getInitiatorId() { return initiatorId; }
+    public TradeHandler getTradeHandler() {
+        return tradeHandler;
+    }
+
+    @Override
+    public void accept(ClientInterpreter interpreter, int from) {
+        interpreter.received(this, from);
+    }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/client/ViewAssetsRequest.java

@@ -0,0 +1,12 @@
+package pp.monopoly.message.client;
+/**
+ * Represents a request from a player to view their assets.
+ */
+public class ViewAssetsRequest extends ClientMessage{
+
+    @Override
+    public void accept(ClientInterpreter interpreter, int from) {
+        interpreter.received(this, from);
+    }
+
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/server/BuyPropertyResponse.java

@@ -0,0 +1,39 @@
+package pp.monopoly.message.server;
+
+/**
+ * Represents the server's response to a player's request to buy a property.
+ */
+public class BuyPropertyResponse extends ServerMessage{
+    private final boolean successful;
+    private final String propertyName;
+    private final String reason; // Reason for failure, if any
+
+    public BuyPropertyResponse(boolean successful, String propertyName, String reason) {
+        this.successful = successful;
+        this.propertyName = propertyName;
+        this.reason = reason;
+    }
+
+    public boolean isSuccessful() {
+        return successful;
+    }
+
+    public String getPropertyName() {
+        return propertyName;
+    }
+
+    public String getReason() {
+        return reason;
+    }
+
+    @Override
+    public void accept(ServerInterpreter interpreter) {
+        interpreter.received(this);
+    }
+
+    @Override
+    public String getInfoTextKey() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getInfoTextKey'");
+    }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/server/DiceResult.java

@@ -0,0 +1,35 @@
+package pp.monopoly.message.server;
+
+import java.util.List;
+
+public class DiceResult extends ServerMessage{
+
+    private List<Integer> rollResult;
+
+    public DiceResult(List<Integer> rollResult) {
+        this.rollResult = rollResult;
+    }
+
+    public List<Integer> getRollResult() {
+        return rollResult;
+    }
+
+    @Override
+    public void accept(ServerInterpreter interpreter) {
+        interpreter.received(this);
+    }
+
+    @Override
+    public String getInfoTextKey() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getInfoTextKey'");
+    }
+
+    public boolean isDoublets() {
+        return rollResult.get(0) == rollResult.get(1);
+    }
+
+    public int calcTotal() {
+        return rollResult.get(0)+rollResult.get(1);
+    }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/server/EventDrawCard.java

@@ -0,0 +1,25 @@
+package pp.monopoly.message.server;
+
+public class EventDrawCard extends ServerMessage{
+    private final String cardDescription;
+
+    public EventDrawCard(String cardDescription) {
+        this.cardDescription = cardDescription;
+    }
+
+    @Override
+    public void accept(ServerInterpreter interpreter) {
+        interpreter.received(this);
+    }
+
+    @Override
+    public String getInfoTextKey() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getInfoTextKey'");
+    }
+
+    public String getCardDescription() {
+        return cardDescription;
+    }
+
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/server/GameOver.java

@@ -0,0 +1,25 @@
+package pp.monopoly.message.server;
+
+public class GameOver extends ServerMessage{
+    private final boolean isWinner;
+
+    public GameOver(boolean isWinner) {
+        this.isWinner = isWinner;
+    }
+
+    public boolean isWinner() {
+        return isWinner;
+    }
+
+    @Override
+    public void accept(ServerInterpreter interpreter) {
+        interpreter.received(this);
+    }
+
+    @Override
+    public String getInfoTextKey() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getInfoTextKey'");
+    }
+
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/server/GameStart.java

@@ -0,0 +1,16 @@
+package pp.monopoly.message.server;
+
+public class GameStart extends ServerMessage{
+
+    @Override
+    public void accept(ServerInterpreter interpreter) {
+        interpreter.received(this);
+    }
+
+    @Override
+    public String getInfoTextKey() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getInfoTextKey'");
+    }
+
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/server/JailEvent.java

@@ -0,0 +1,26 @@
+package pp.monopoly.message.server;
+
+public class JailEvent extends ServerMessage{
+
+    private final boolean goingToJail;
+
+    public JailEvent(boolean goingToJail) {
+        this.goingToJail = goingToJail;
+    }
+
+    public boolean isGoingToJail() {
+        return goingToJail;
+    }
+
+    @Override
+    public void accept(ServerInterpreter interpreter) {
+        interpreter.received(this);
+    }
+
+    @Override
+    public String getInfoTextKey() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getInfoTextKey'");
+    }
+
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/server/PlayerStatusUpdate.java

@@ -0,0 +1,40 @@
+package pp.monopoly.message.server;
+
+import pp.monopoly.game.server.PlayerColor;
+
+public class PlayerStatusUpdate extends ServerMessage{
+
+    private final String playerName;
+    private final String status;
+    private final PlayerColor color;
+
+    public PlayerStatusUpdate(String playerName, String status, PlayerColor color) {
+        this.playerName = playerName;
+        this.status = status;
+        this.color = color;
+    }
+
+    public String getPlayerName() {
+        return playerName;
+    }
+
+    public String getStatus() {
+        return status;
+    }
+
+    public PlayerColor getColor() {
+        return color;
+    }
+
+    @Override
+    public void accept(ServerInterpreter interpreter) {
+        interpreter.received(this);
+    }
+
+    @Override
+    public String getInfoTextKey() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getInfoTextKey'");
+    }
+
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/server/ServerInterpreter.java

@@ -0,0 +1,92 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.message.server;
+
+/**
+ * An interface for processing server messages.
+ * Implementations of this interface can be used to handle different types of server messages.
+ */
+public interface ServerInterpreter {
+
+    /**
+     * Handles a BuyPropertyResponse message received from the server.
+     *
+     * @param msg the BuyPropertyResponse message received
+     */
+    void received(BuyPropertyResponse msg);
+
+    /**
+     * Handles a DiceResult message received from the server.
+     *
+     * @param msg the DiceResult message received
+     */
+    void received(DiceResult msg);
+
+    /**
+     * Handles a EventDrawCard message received from the server.
+     *
+     * @param msg the EventDrawCard message received
+     */
+    void received(EventDrawCard msg);
+
+    /**
+     * Handles a GameOver message received from the server.
+     *
+     * @param msg the GameOver message received
+     */
+    void received(GameOver msg);
+
+    /**
+     * Handles a GameStart message received from the server.
+     *
+     * @param msg the GameStart message received
+     */
+    void received(GameStart msg);
+
+    /**
+     * Handles a JailEvent message received from the server.
+     *
+     * @param msg the JailEvent message received
+     */
+    void received(JailEvent msg);
+
+    /**
+     * Handles a PlayerStatusUpdate message received from the server.
+     *
+     * @param msg the PlayerStatusUpdate message received
+     */
+    void received(PlayerStatusUpdate msg);
+
+    /**
+     * Handles a TimeOutWarning message received from the server.
+     *
+     * @param msg the TimeOutWarning message received
+     */
+    void received(TimeOutWarning msg);
+
+    /**
+     * Handles a ViewAssetsResponse message received from the server.
+     *
+     * @param msg the ViewAssetsResponse message received
+     */
+    void received(ViewAssetsResponse msg);
+
+    /**
+     * Handles a TradeReply message received from the server.
+     *
+     * @param msg the TradeReply message received
+     */
+    void received(TradeReply msg);
+            
+    /**
+     * Handles a TradeRequest message received from the server.
+     *
+     * @param msg the TradeRequest message received
+     */
+    void received(TradeRequest msg);
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/server/ServerMessage.java

@@ -0,0 +1,39 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.message.server;
+
+import com.jme3.network.AbstractMessage;
+
+/**
+ * An abstract base class for server messages used in network transfer.
+ * It extends the AbstractMessage class provided by the jme3-network library.
+ */
+public abstract class ServerMessage extends AbstractMessage {
+
+    /**
+     * Constructs a new ServerMessage instance.
+     */
+    protected ServerMessage() {
+        super(true);
+    }
+
+    /**
+     * Accepts a visitor for processing this message.
+     *
+     * @param interpreter the visitor to be used for processing
+     */
+    public abstract void accept(ServerInterpreter interpreter);
+
+    /**
+     * Gets the bundle key of the informational text to be shown at the client.
+     * This key is used to retrieve the appropriate localized text for display.
+     *
+     * @return the bundle key of the informational text
+     */
+    public abstract String getInfoTextKey();
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/server/TimeOutWarning.java

@@ -0,0 +1,26 @@
+package pp.monopoly.message.server;
+
+public class TimeOutWarning extends ServerMessage{
+
+    private final int remainingTime;
+
+    public TimeOutWarning(int remainingTime) {
+        this.remainingTime = remainingTime;
+    }
+
+    public int getRemainingTime() {
+        return remainingTime;
+    }
+
+    @Override
+    public void accept(ServerInterpreter interpreter) {
+        interpreter.received(this);
+    }
+
+    @Override
+    public String getInfoTextKey() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getInfoTextKey'");
+    }
+
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/server/TradeReply.java

@@ -0,0 +1,39 @@
+package pp.monopoly.message.server;
+
+import pp.monopoly.model.TradeHandler;
+
+/**
+ * Represents a response to a trade offer.
+ */
+public class TradeReply extends ServerMessage{
+    private int initiatorId;
+    private TradeHandler tradeHandler;
+
+    /**
+     * Constructs a TradeResponse with the specified response details.
+     *
+     * @param initiatorId the ID of the player who initiated the trade
+     * @param accepted true if the offer is accepted, false if declined
+     */
+    public TradeReply(int initiatorId, TradeHandler tradeHandler) {
+        this.initiatorId = initiatorId;
+        this.tradeHandler = tradeHandler;
+    }
+
+    public int getInitiatorId() { return initiatorId; }
+    public TradeHandler getTradeHandler() {
+        return tradeHandler;
+    }
+
+    @Override
+    public void accept(ServerInterpreter interpreter) {
+        interpreter.received(this);
+    }
+
+    @Override
+    public String getInfoTextKey() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getInfoTextKey'");
+    }
+
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/server/TradeRequest.java

@@ -0,0 +1,39 @@
+package pp.monopoly.message.server;
+
+import pp.monopoly.model.TradeHandler;
+
+/**
+ * Represents a trade Request message from one player to another.
+ */
+public class TradeRequest extends ServerMessage{
+    private int receiverId;
+    private TradeHandler tradehandler;
+
+
+    /**
+     * Constructs a TradeRequest with the specified details.
+     *
+     * @param receiverId the ID of the player receiving the Request
+     * @param tradehandler the tradehandler
+     */
+    public TradeRequest(int receiverId, TradeHandler tradehandler) {
+        this.receiverId = receiverId;
+        this.tradehandler = tradehandler;
+    }
+
+    public int getReceiverId() { return receiverId; }
+    public TradeHandler getTradeHandler() { return tradehandler; }
+
+
+    @Override
+    public void accept(ServerInterpreter interpreter) {
+        interpreter.received(this);
+    }
+
+    @Override
+    public String getInfoTextKey() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getInfoTextKey'");
+    }
+
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/message/server/ViewAssetsResponse.java

@@ -0,0 +1,50 @@
+package pp.monopoly.message.server;
+
+import java.util.List;
+
+import pp.monopoly.model.fields.PropertyField;
+/**
+ * Represents a response containing the player's assets.
+ */
+public class ViewAssetsResponse extends ServerMessage{
+
+    private final List<PropertyField> properties;
+    private final int accountBalance;
+    private final int jailCards;
+
+    /**
+     * Constructs a ViewAssetsResponse with the specified properties and account balance.
+     *
+     * @param properties    a List of PropertyField objects representing the player's properties
+     * @param accountBalance the player's current account balance
+     */
+    public ViewAssetsResponse(List<PropertyField> properties, int accountBalance, int jailCards) {
+        this.properties = properties;
+        this.accountBalance = accountBalance;
+        this.jailCards = jailCards;
+    }
+
+    @Override
+    public void accept(ServerInterpreter interpreter) {
+        interpreter.received(this);
+    }
+
+    @Override
+    public String getInfoTextKey() {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'getInfoTextKey'");
+    }
+
+    public List<PropertyField> getProperties() {
+        return properties;
+    }
+
+    public int getAccountBalance() {
+        return accountBalance;
+    }
+
+    public int getJailCards() {
+        return jailCards;
+    }
+
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/model/Board.java

@@ -0,0 +1,169 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.model;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Stream;
+
+import pp.monopoly.notification.GameEvent;
+import pp.monopoly.notification.GameEventBroker;
+import pp.monopoly.notification.ItemAddedEvent;
+import pp.monopoly.notification.ItemRemovedEvent;
+
+/**
+ * Represents a rectangular map that holds figures and registers houses, hotels
+ * It also supports event notification for game state changes such as item addition or removal.
+ * Valid positions on this map have x-coordinates in the range of 0 to width-1 and y-coordinates
+ * in the range of 0 to height-1.
+ *
+ * @see #getWidth()
+ * @see #getHeight()
+ */
+public class Board {
+    /**
+     * A list of items (figure, house, etc.) placed on the map.
+     */
+    private final List<Item> items = new ArrayList<>();
+
+    /**
+     * The broker responsible for notifying registered listeners of events
+     * (such as when an item is added or removed from the map).
+     * Can be null, in which case no notifications will be sent.
+     */
+    private final GameEventBroker eventBroker;
+
+    private final int width;
+    private final int height;
+
+    /**
+     * Constructs an empty map with the given dimensions. The specified event broker
+     * will handle the notification of changes in the map state, such as adding or removing items.
+     * Passing null as the event broker is allowed, but in that case, no notifications will occur.
+     *
+     * @param width       the number of columns (width) of the map
+     * @param height      the number of rows (height) of the map
+     * @param eventBroker the event broker used for notifying listeners, or null if event distribution is not needed
+     */
+    public Board(int width, int height, GameEventBroker eventBroker) {
+        if (width < 1 || height < 1)
+            throw new IllegalArgumentException("Invalid map size");
+        this.width = width;
+        this.height = height;
+        this.eventBroker = eventBroker;
+        addItem(new Figure(5, 5, 5, Rotation.LEFT));
+    }
+
+    /**
+     * Adds an item (e.g., a figure or a house) to the map and triggers the appropriate event.
+     *
+     * @param item the item to be added to the map
+     */
+    private void addItem(Item item) {
+        items.add(item);
+        notifyListeners((GameEvent) new ItemAddedEvent(item, null));
+    }
+
+    /**
+     * Removes an item from the map and triggers an item removal event.
+     *
+     * @param item the item to be removed from the map
+     */
+    public void remove(Item item) {
+        items.remove(item);
+        notifyListeners((GameEvent) new ItemRemovedEvent(item, null)); // Falls es ein entsprechendes ItemRemovedEvent gibt
+    }
+
+    /**
+     * Removes all items from the map and triggers corresponding removal events for each.
+     */
+    public void clear() {
+        new ArrayList<>(items).forEach(this::remove);
+    }
+
+    /**
+     * Returns a stream of items of a specified type (class).
+     *
+     * @param clazz the class type to filter items by
+     * @param <T>   the type of items to return
+     * @return a stream of items matching the specified class type
+     */
+    private <T extends Item> Stream<T> getItems(Class<T> clazz) {
+        return items.stream().filter(clazz::isInstance).map(clazz::cast);
+    }
+
+    /**
+     * Returns an unmodifiable list of all items currently on the map.
+     *
+     * @return an unmodifiable list of all items
+     */
+    public List<Item> getItems() {
+        return Collections.unmodifiableList(items);
+    }
+
+    /**
+     * Returns the width (number of columns) of the map.
+     *
+     * @return the width of the map
+     */
+    public int getWidth() {
+        return width;
+    }
+
+    /**
+     * Returns the height (number of rows) of the map.
+     *
+     * @return the height of the map
+     */
+    public int getHeight() {
+        return height;
+    }
+
+    /**
+     * Validates whether the specified position is within the map boundaries.
+     *
+     * @param pos the position to validate
+     * @return true if the position is within the map, false otherwise
+     */
+    public boolean isValid(IntPosition pos) {
+        return isValid(pos.getX(), pos.getY());
+    }
+
+    /**
+     * Checks if the specified coordinates are within the map boundaries.
+     *
+     * @param x the x-coordinate to validate
+     * @param y the y-coordinate to validate
+     * @return true if the coordinates are valid, false otherwise
+     */
+    public boolean isValid(int x, int y) {
+        return x >= 0 && x < width &&
+               y >= 0 && y < height;
+    }
+
+    /**
+     * Returns a string representation of the map.
+     *
+     * @return a string representation of the map
+     */
+    @Override
+    public String toString() {
+        return "Board:{" + items + '}'; //NON-NLS
+    }
+
+    /**
+     * Notifies all registered listeners about a game event if the event broker is available.
+     *
+     * @param event the event to be distributed to listeners
+     */
+    private void notifyListeners(GameEvent event) {
+        if (eventBroker != null)
+            eventBroker.notifyListeners(event);
+    }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/model/CardVisitor.java

@@ -0,0 +1,7 @@
+package pp.monopoly.model;
+
+import pp.monopoly.model.card.Card;
+
+public interface CardVisitor<T> {
+    T visit(Card c);
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/model/FieldVisitor.java

@@ -0,0 +1,23 @@
+package pp.monopoly.model;
+
+import pp.monopoly.model.fields.BuildingProperty;
+import pp.monopoly.model.fields.EventField;
+import pp.monopoly.model.fields.FineField;
+import pp.monopoly.model.fields.FoodField;
+import pp.monopoly.model.fields.GateField;
+import pp.monopoly.model.fields.GoField;
+import pp.monopoly.model.fields.GulagField;
+import pp.monopoly.model.fields.TestStreckeField;
+import pp.monopoly.model.fields.WacheField;
+
+public interface FieldVisitor<T> {
+    T visit(BuildingProperty field);
+    T visit(FoodField field);
+    T visit(GateField field);
+    T visit(GulagField field);
+    T visit(TestStreckeField field);
+    T visit(EventField field);
+    T visit(WacheField field);
+    T visit(GoField field);
+    T visit(FineField field);
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/model/Figure.java

@@ -0,0 +1,309 @@
+package pp.monopoly.model;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import static java.lang.Math.max;
+import static java.lang.Math.min;
+
+public class Figure implements Item{
+    /**
+     * Enumeration representing the different statuses a Figure can have during the game.
+     */
+    public enum Status {
+        /**
+         * The ship is in its normal state, not being previewed for placement.
+         */
+        NORMAL,
+
+        /**
+         * The ship is being previewed in a valid position for placement.
+         */
+        VALID_PREVIEW,
+
+        /**
+         * The ship is being previewed in an invalid position for placement.
+         */
+        INVALID_PREVIEW
+    }
+
+    private final int length; // The length of the Figure
+    private int x;            // The x-coordinate of the Figure's position
+    private int y;            // The y-coordinate of the Figure's position
+    private Rotation rot;     // The rotation of the Figure
+    private Status status;    // The current status of the Figure
+    private final Set<IntPoint> damaged = new HashSet<>(); // The set of positions that have been hit on this ship
+
+    /**
+     * Default constructor for serialization. Initializes a Figure with length 0,
+     * at position (0, 0), with a default rotation of RIGHT.
+     */
+    private Figure() {
+        this(0, 0, 0, Rotation.RIGHT);
+    }
+
+    /**
+     * Constructs a new Figure with the specified length, position, and rotation.
+     *
+     * @param length the length of the Figure
+     * @param x      the x-coordinate of the Figure's initial position
+     * @param y      the y-coordinate of the Figure's initial position
+     * @param rot    the rotation of the Figure
+     */
+    public Figure(int length, int x, int y, Rotation rot) {
+        this.x = x;
+        this.y = y;
+        this.rot = rot;
+        this.length = length;
+        this.status = Status.NORMAL;
+    }
+
+    /**
+     * Returns the current x-coordinate of the Figure's position.
+     *
+     * @return the x-coordinate of the Figure
+     */
+    public int getX() {
+        return x;
+    }
+
+    /**
+     * Returns the current y-coordinate of the Figure's position.
+     *
+     * @return the y-coordinate of the Figure
+     */
+    public int getY() {
+        return y;
+    }
+
+    /**
+     * Moves the Figure to the specified coordinates.
+     *
+     * @param x the new x-coordinate of the Figure's position
+     * @param y the new y-coordinate of the Figure's position
+     */
+    public void moveTo(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    /**
+     * Moves the Figure to the specified position.
+     *
+     * @param pos the new position of the Figure
+     */
+    public void moveTo(IntPosition pos) {
+        moveTo(pos.getX(), pos.getY());
+    }
+
+    /**
+     * Returns the current status of the Figure.
+     *
+     * @return the status of the Figure
+     */
+    public Status getStatus() {
+        return status;
+    }
+
+    /**
+     * Sets the status of the Figure.
+     *
+     * @param status the new status to be set for the Figure
+     */
+    public void setStatus(Status status) {
+        this.status = status;
+    }
+
+    /**
+     * Returns the length of the Figure.
+     *
+     * @return the length of the Figure
+     */
+    public int getLength() {
+        return length;
+    }
+
+    /**
+     * Returns the minimum x-coordinate that the Figure occupies based on its current position and rotation.
+     *
+     * @return the minimum x-coordinate of the Figure
+     */
+    public int getMinX() {
+        return x + min(0, (length - 1) * rot.dx());
+    }
+
+    /**
+     * Returns the maximum x-coordinate that the Figure occupies based on its current position and rotation.
+     *
+     * @return the maximum x-coordinate of the Figure
+     */
+    public int getMaxX() {
+        return x + max(0, (length - 1) * rot.dx());
+    }
+
+    /**
+     * Returns the minimum y-coordinate that the Figure occupies based on its current position and rotation.
+     *
+     * @return the minimum y-coordinate of the Figure
+     */
+    public int getMinY() {
+        return y + min(0, (length - 1) * rot.dy());
+    }
+
+    /**
+     * Returns the maximum y-coordinate that the Figure occupies based on its current position and rotation.
+     *
+     * @return the maximum y-coordinate of the Figure
+     */
+    public int getMaxY() {
+        return y + max(0, (length - 1) * rot.dy());
+    }
+
+    /**
+     * Returns the current rotation of the Figure.
+     *
+     * @return the rotation of the Figure
+     */
+    public Rotation getRot() {
+        return rot;
+    }
+
+    /**
+     * Sets the rotation of the Figure.
+     *
+     * @param rot the new rotation to be set for the Figure
+     */
+    public void setRotation(Rotation rot) {
+        this.rot = rot;
+    }
+
+    /**
+     * Rotates the Figure by 90 degrees clockwise.
+     */
+    public void rotated() {
+        setRotation(rot.rotate());
+    }
+
+    /**
+     * Attempts to hit the Figure at the specified position.
+     * If the position is part of the Figure, the hit is recorded.
+     *
+     * @param x the x-coordinate of the position to hit
+     * @param y the y-coordinate of the position to hit
+     * @return true if the position is part of the Figure, false otherwise
+     * @see #contains(int, int)
+     */
+    public boolean hit(int x, int y) {
+        if (!contains(x, y))
+            return false;
+        damaged.add(new IntPoint(x, y));
+        return true;
+    }
+
+    /**
+     * Attempts to hit the Figure at the specified position.
+     * If the position is part of the Figure, the hit is recorded.
+     * This is a convenience method for {@linkplain #hit(int, int)}.
+     *
+     * @param position the position to hit
+     * @return true if the position is part of the Figure, false otherwise
+     */
+    public boolean hit(IntPosition position) {
+        return hit(position.getX(), position.getY());
+    }
+
+    /**
+     * Returns the positions of this Figure that have been hit.
+     *
+     * @return a set of positions that have been hit
+     * @see #hit(int, int)
+     */
+    public Set<IntPoint> getDamaged() {
+        return Collections.unmodifiableSet(damaged);
+    }
+
+    /**
+     * Checks whether the specified position is covered by the Figure. This method does
+     * not record a hit, only checks coverage.
+     * This is a convenience method for {@linkplain #contains(int, int)}.
+     *
+     * @param pos the position to check
+     * @return true if the position is covered by the Figure, false otherwise
+     */
+    public boolean contains(IntPosition pos) {
+        return contains(pos.getX(), pos.getY());
+    }
+
+    /**
+     * Checks whether the specified position is covered by the Figure. This method does
+     * not record a hit, only checks coverage.
+     *
+     * @param x the x-coordinate of the position to check
+     * @param y the y-coordinate of the position to check
+     * @return true if the position is covered by the Figure, false otherwise
+     */
+    public boolean contains(int x, int y) {
+        return getMinX() <= x && x <= getMaxX() &&
+               getMinY() <= y && y <= getMaxY();
+    }
+
+    /**
+     * Determines if the Figure has been completely destroyed. A Figure is considered
+     * destroyed if all of its positions have been hit.
+     *
+     * @return true if the Figure is destroyed, false otherwise
+     * @see #hit(int, int)
+     */
+    public boolean isDestroyed() {
+        return damaged.size() == length;
+    }
+
+    /**
+     * Checks whether this Figure collides with another Figure. Two Figures collide
+     * if any of their occupied positions overlap.
+     *
+     * @param other the other Figure to check collision with
+     * @return true if the Figures collide, false otherwise
+     */
+    public boolean collidesWith(Figure other) {
+        return other.getMaxX() >= getMinX() && getMaxX() >= other.getMinX() &&
+               other.getMaxY() >= getMinY() && getMaxY() >= other.getMinY();
+    }
+
+    /**
+     * Returns a string representation of the Figure, including its length, position,
+     * and rotation.
+     *
+     * @return a string representation of the Figure
+     */
+    @Override
+    public String toString() {
+        return "Ship{length=" + length + ", x=" + x + ", y=" + y + ", rot=" + rot + '}';  //NON-NLS
+    }
+
+    /**
+     * Accepts a visitor that returns a value of type {@code T}. This method is part of the
+     * Visitor design pattern.
+     *
+     * @param visitor the visitor to accept
+     * @param <T>     the type of the value returned by the visitor
+     * @return the value returned by the visitor
+     */
+    @Override
+    public <T> T accept(Visitor<T> visitor) {
+        return visitor.visit(this);
+    }
+
+    /**
+     * Accepts a visitor that does not return a value. This method is part of the
+     * Visitor design pattern.
+     *
+     * @param visitor the visitor to accept
+     */
+    @Override
+    public void accept(VoidVisitor visitor) {
+        visitor.visit(this);
+    }
+
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/model/IntPoint.java

@@ -0,0 +1,94 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.model;
+
+import java.util.Objects;
+
+import com.jme3.network.serializing.Serializable;
+
+/**
+ * Represents a point in the two-dimensional plane with integer coordinates.
+ */
+@Serializable
+public final class IntPoint implements IntPosition {
+    private int x;
+    private int y;
+
+    /**
+     * Default constructor for serialization purposes.
+     */
+    private IntPoint() { /* do nothing */ }
+
+    /**
+     * Constructs a new IntPoint with the specified coordinates.
+     *
+     * @param x the x-coordinate of the point
+     * @param y the y-coordinate of the point
+     */
+    public IntPoint(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    /**
+     * Gets the x-coordinate of the point.
+     *
+     * @return the x-coordinate
+     */
+    @Override
+    public int getX() {
+        return x;
+    }
+
+    /**
+     * Gets the y-coordinate of the point.
+     *
+     * @return the y-coordinate
+     */
+    @Override
+    public int getY() {
+        return y;
+    }
+
+    /**
+     * Indicates whether some other object is "equal to" this one.
+     *
+     * @param obj the reference object with which to compare
+     * @return true if this object is the same as the obj argument; false otherwise
+     */
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) return true;
+        if (obj == null || obj.getClass() != this.getClass()) return false;
+        var that = (IntPoint) obj;
+        return this.x == that.x &&
+               this.y == that.y;
+    }
+
+    /**
+     * Returns a hash code value for the IntPoint.
+     *
+     * @return a hash code value for this object
+     */
+    @Override
+    public int hashCode() {
+        return Objects.hash(x, y);
+    }
+
+    /**
+     * Returns a string representation of the IntPoint.
+     *
+     * @return a string representation of the object
+     */
+    @Override
+    public String toString() {
+        return "IntPoint[" + //NON-NLS
+               "x=" + x + ", " + //NON-NLS
+               "y=" + y + ']'; //NON-NLS
+    }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/model/IntPosition.java

@@ -0,0 +1,28 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.model;
+
+/**
+ * Interface representing a position with X and Y coordinates.
+ */
+public interface IntPosition {
+
+    /**
+     * Returns the X coordinate of this position.
+     *
+     * @return the X coordinate.
+     */
+    int getX();
+
+    /**
+     * Returns the Y coordinate of this position.
+     *
+     * @return the Y coordinate.
+     */
+    int getY();
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/model/Item.java

@@ -0,0 +1,31 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.model;
+
+/**
+ * An interface representing any item on a board
+ * It extends the IntPosition interface to provide position information.
+ */
+public interface Item {
+
+    /**
+     * Accepts a visitor to perform operations on the item.
+     *
+     * @param visitor the visitor performing operations on the item
+     * @param <T>     the type of result returned by the visitor
+     * @return the result of the visitor's operation on the item
+     */
+    <T> T accept(Visitor<T> visitor);
+
+    /**
+     * Accepts a visitor to perform operations on the item without returning a result.
+     *
+     * @param visitor the visitor performing operations on the item
+     */
+    void accept(VoidVisitor visitor);
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/model/Rotation.java

@@ -0,0 +1,67 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.model;
+
+import java.io.Serializable;
+
+/**
+ * Represents the rotation of a Item and provides functionality related to rotation.
+ */
+public enum Rotation implements Serializable {
+    /**
+     * Represents the item facing upwards.
+     */
+    UP,
+    /**
+     * Represents the item facing rightwards.
+     */
+    RIGHT,
+    /**
+     * Represents the item facing downwards.
+     */
+    DOWN,
+    /**
+     * Represents the item facing leftwards.
+     */
+    LEFT;
+
+    /**
+     * Gets the change in x-coordinate corresponding to this rotation.
+     *
+     * @return the change in x-coordinate
+     */
+    public int dx() {
+        return switch (this) {
+            case UP, DOWN -> 0;
+            case RIGHT -> 1;
+            case LEFT -> -1;
+        };
+    }
+
+    /**
+     * Gets the change in y-coordinate corresponding to this rotation.
+     *
+     * @return the change in y-coordinate
+     */
+    public int dy() {
+        return switch (this) {
+            case UP -> 1;
+            case LEFT, RIGHT -> 0;
+            case DOWN -> -1;
+        };
+    }
+
+    /**
+     * Rotates the orientation clockwise and returns the next rotation.
+     *
+     * @return the next rotation after rotating clockwise
+     */
+    public Rotation rotate() {
+        return values()[(ordinal() + 1) % values().length];
+    }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/model/TradeHandler.java

@@ -0,0 +1,183 @@
+package pp.monopoly.model;
+
+import pp.monopoly.game.server.Player;
+import pp.monopoly.model.fields.PropertyField;
+
+import java.util.List;
+
+/**
+ * Helper class that handles the trade logic between two players.
+ * Manages trade initiation, validation, acceptance, and rejection involving multiple properties, money, and jail cards.
+ */
+public class TradeHandler {
+
+    /**
+     * Initiates a trade offer between two players involving properties, money, and jail cards.
+     *
+     * @param sender             the Player who is initiating the trade
+     * @param receiver           the Player who is the target of the trade offer
+     * @param offeredAmount      the amount of money the sender offers
+     * @param offeredProperties  the list of properties the sender offers
+     * @param offeredJailCards   the number of jail cards the sender offers
+     * @param requestedAmount    the amount of money the sender requests from the receiver
+     * @param requestedProperties the list of properties the sender requests from the receiver
+     * @param requestedJailCards the number of jail cards the sender requests from the receiver
+     * @return true if the trade offer is valid and initiated, false otherwise
+     */
+    public boolean initiateTrade(Player sender, Player receiver, int offeredAmount, List<PropertyField> offeredProperties,
+                                 int offeredJailCards, int requestedAmount, List<PropertyField> requestedProperties, int requestedJailCards) {
+        // Validate the trade offer
+        if (!validateTrade(sender, offeredAmount, offeredProperties, offeredJailCards, receiver, requestedAmount, requestedProperties, requestedJailCards)) {
+            System.out.println("Trade offer is invalid.");
+            return false;
+        }
+
+        // Notify the receiver about the trade offer (this would be an actual message in a real implementation)
+        System.out.println("Trade offer initiated by " + sender.getName() + " to " + receiver.getName());
+        return true;
+    }
+
+    /**
+     * Accepts the trade offer and completes the trade between two players.
+     *
+     * @param sender             the Player who initiated the trade
+     * @param receiver           the Player who accepted the trade
+     * @param offeredAmount      the amount of money to transfer from the sender to the receiver
+     * @param offeredProperties  the list of properties to transfer from the sender to the receiver
+     * @param offeredJailCards   the number of jail cards to transfer from the sender to the receiver
+     * @param requestedAmount    the amount of money to transfer from the receiver to the sender
+     * @param requestedProperties the list of properties to transfer from the receiver to the sender
+     * @param requestedJailCards the number of jail cards to transfer from the receiver to the sender
+     */
+    public void acceptTrade(Player sender, Player receiver, int offeredAmount, List<PropertyField> offeredProperties,
+                            int offeredJailCards, int requestedAmount, List<PropertyField> requestedProperties, int requestedJailCards) {
+        // Transfer money
+        sender.earnMoney(-offeredAmount);  // Deduct money from the sender
+        receiver.earnMoney(offeredAmount); // Add money to the receiver
+
+        receiver.earnMoney(-requestedAmount); // Deduct money from the receiver
+        sender.earnMoney(requestedAmount);    // Add money to the sender
+
+        // Transfer ownership of the properties from sender to receiver
+        if (offeredProperties != null) {
+            for (PropertyField property : offeredProperties) {
+                transferProperty(sender, receiver, property);
+            }
+        }
+
+        // Transfer ownership of the properties from receiver to sender
+        if (requestedProperties != null) {
+            for (PropertyField property : requestedProperties) {
+                transferProperty(receiver, sender, property);
+            }
+        }
+
+        // Transfer jail cards
+        transferJailCards(sender, receiver, offeredJailCards);
+        transferJailCards(receiver, sender, requestedJailCards);
+
+        System.out.println("Trade accepted. " + sender.getName() + " and " + receiver.getName() + " completed the trade.");
+    }
+
+    /**
+     * Rejects the trade offer.
+     *
+     * @param receiver the Player who is rejecting the trade
+     */
+    public void rejectTrade(Player receiver) {
+        System.out.println("Trade rejected by " + receiver.getName());
+    }
+
+    /**
+     * Validates a trade offer by checking if the sender and receiver own the properties involved,
+     * have sufficient funds for the money involved in the trade, and have enough jail cards.
+     *
+     * @param sender             the Player initiating the trade
+     * @param offeredAmount      the amount of money the sender is offering
+     * @param offeredProperties  the list of properties the sender is offering
+     * @param offeredJailCards   the number of jail cards the sender is offering
+     * @param receiver           the Player receiving the trade offer
+     * @param requestedAmount    the amount of money the sender is requesting
+     * @param requestedProperties the list of properties the sender is requesting from the receiver
+     * @param requestedJailCards the number of jail cards the sender is requesting from the receiver
+     * @return true if the trade offer is valid, false otherwise
+     */
+    private boolean validateTrade(Player sender, int offeredAmount, List<PropertyField> offeredProperties, int offeredJailCards,
+                                  Player receiver, int requestedAmount, List<PropertyField> requestedProperties, int requestedJailCards) {
+        // Check if sender has enough money to offer
+        if (sender.getAccountBalance() < offeredAmount) {
+            System.out.println("Sender does not have enough balance to make this offer.");
+            return false;
+        }
+
+        // Check if receiver has enough money to offer
+        if (receiver.getAccountBalance() < requestedAmount) {
+            System.out.println("Receiver does not have enough balance to fulfill requested amount.");
+            return false;
+        }
+
+        // Check if sender owns all the offered properties
+        if (offeredProperties != null) {
+            for (PropertyField property : offeredProperties) {
+                if (!sender.getProperties().contains(property)) {
+                    System.out.println("Sender does not own the property " + property.getName() + " being offered.");
+                    return false;
+                }
+            }
+        }
+
+        // Check if receiver owns all the requested properties
+        if (requestedProperties != null) {
+            for (PropertyField property : requestedProperties) {
+                if (!receiver.getProperties().contains(property)) {
+                    System.out.println("Receiver does not own the property " + property.getName() + " requested.");
+                    return false;
+                }
+            }
+        }
+
+        // Check if sender has enough jail cards to offer
+        if (sender.getNumJailCard() < offeredJailCards) {
+            System.out.println("Sender does not have enough jail cards to offer.");
+            return false;
+        }
+
+        // Check if receiver has enough jail cards to fulfill the request
+        if (receiver.getNumJailCard() < requestedJailCards) {
+            System.out.println("Receiver does not have enough jail cards to fulfill the request.");
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Transfers a property from one player to another.
+     *
+     * @param from     the Player transferring the property
+     * @param to       the Player receiving the property
+     * @param property the PropertyField being transferred
+     */
+    private void transferProperty(Player from, Player to, PropertyField property) {
+        from.sellProperty(property);
+        to.buyProperty(property);
+        property.setOwner(to); // Update the property's owner
+
+        System.out.println("Property " + property.getName() + " transferred from " + from.getName() + " to " + to.getName());
+    }
+
+    /**
+     * Transfers jail cards between players.
+     *
+     * @param from the Player transferring jail cards
+     * @param to   the Player receiving jail cards
+     * @param numCards the number of jail cards to transfer
+     */
+    private void transferJailCards(Player from, Player to, int numCards) {
+        for (int i = 0; i < numCards; i++) {
+            from.removeJailCard();
+            to.addJailCard();
+        }
+        System.out.println("Transferred " + numCards + " jail card(s) from " + from.getName() + " to " + to.getName());
+    }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/model/Visitor.java

@@ -0,0 +1,25 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.model;
+
+/**
+ * An interface for implementing the Visitor pattern for different types of elements in the Monopoly model.
+ *
+ * @param <T> the type of result returned by the visit methods
+ */
+public interface Visitor<T> {
+
+    /**
+     * Visits a Figure element.
+     *
+     * @param figure the figure element to visit
+     * @return the result of visiting the figure element
+     */
+    T visit(Figure figure);
+
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/model/VoidVisitor.java

@@ -0,0 +1,22 @@
+////////////////////////////////////////
+// Programming project code
+// UniBw M, 2022, 2023, 2024
+// www.unibw.de/inf2
+// (c) Mark Minas (mark.minas@unibw.de)
+////////////////////////////////////////
+
+package pp.monopoly.model;
+
+/**
+ * An interface for implementing the Visitor pattern for different types of elements in the Monopoly model
+ * without returning any result.
+ */
+public interface VoidVisitor {
+    /**
+     * Visits a Figure element.
+     *
+     * @param figure the Figure element to visit
+     */
+    void visit(Figure figure);
+
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/model/card/Card.java

@@ -0,0 +1,23 @@
+package pp.monopoly.model.card;
+
+public class Card {
+    private final String description;
+    private final String keyword;
+
+    Card(String description, String keyword) {
+        this.description = description;
+        this.keyword = keyword;
+    }
+
+    public void accept(DeckHelper visitor) {
+        visitor.visit(this);
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    String getKeyword() {
+        return keyword;
+    }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/model/card/DeckHelper.java

@@ -0,0 +1,34 @@
+package pp.monopoly.model.card;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Queue;
+
+import pp.monopoly.model.CardVisitor;
+
+public class DeckHelper implements CardVisitor<Void>{
+
+    private static Queue<Card> cards;
+
+    private DeckHelper() {
+        
+    }
+
+    @Override
+    public Void visit(Card c) {
+        // TODO Auto-generated method stub
+        throw new UnsupportedOperationException("Unimplemented method 'visit'");
+    }
+
+    private void shuffle() {
+        List<Card> cardList = new ArrayList<>(cards);
+        Collections.shuffle(cardList);
+        cards.clear();
+        cards.addAll(cardList);
+    }
+
+    public static Card drawCard() {
+        return cards != null ? cards.poll() : null;
+    }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/model/fields/BoardManager.java

@@ -0,0 +1,91 @@
+package pp.monopoly.model.fields;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+/**
+ * Simple Manager class responsible for managing the GameBoard of Monopoly
+ */
+public class BoardManager {
+
+    private List<Field> board;
+
+    /**
+     * Constructs a BoardManager
+     */
+    public BoardManager() {
+        board = createBoard();
+    }
+
+    /**
+     * Creates a Monopoly GameBoard
+     * @return the List of Fields in correct  Order
+     */
+    private static List<Field> createBoard() {
+        ArrayList<Field> fields = new ArrayList<>();
+
+        fields.add(new GoField());
+        fields.add(new BuildingProperty("Gym", 1, 600, 20));
+        fields.add(new EventField("Hausfeier", 2));
+        fields.add(new BuildingProperty("Sportplatz", 3, 600, 40));
+        fields.add(new FineField("Diszi", 4, 2000));
+        fields.add(new GateField("Südtor", 5));
+        fields.add(new BuildingProperty("Studium+", 6, 1000, 60));
+        fields.add(new EventField("Üvas", 7));
+        fields.add(new BuildingProperty("PhysikHörsaal", 8, 1000, 60));
+        fields.add(new BuildingProperty("Audimax", 9, 1200, 80));
+        fields.add(new GulagField());
+        fields.add(new BuildingProperty("99er", 11, 1400, 100));
+        fields.add(new FoodField("Brandl", 12));
+        fields.add(new BuildingProperty("12er", 13, 1400, 100));
+        fields.add(new BuildingProperty("23er", 14, 1600, 120));
+        fields.add(new GateField("HauptWache", 15));
+        fields.add(new BuildingProperty("Schwimmhalle", 16, 1800, 140));
+        fields.add(new BuildingProperty("CISM-Bahn", 17, 1800, 140));
+        fields.add(new EventField("Marine-Welcome-Party", 18));
+        fields.add(new BuildingProperty("Kletterturm", 19, 2000, 160));
+        fields.add(new TestStreckeField());
+        fields.add(new BuildingProperty("StudFBer C", 21, 2200, 180));
+        fields.add(new EventField("Üvas", 22));
+        fields.add(new BuildingProperty("StudFBer B", 23, 2200, 180));
+        fields.add(new BuildingProperty("StudFBer A", 24, 2400, 200));
+        fields.add(new GateField("Nordtor", 25));
+        fields.add(new BuildingProperty("Cascada", 26, 2600, 220));
+        fields.add(new BuildingProperty("Fakultätsgebäude", 27, 2600, 220));
+        fields.add(new FoodField("Truppenküche", 28));
+        fields.add(new BuildingProperty("Prüfungsamt", 29, 2800, 240));
+        fields.add(new WacheField());
+        fields.add(new BuildingProperty("Feuerwehr", 31, 3000, 260));
+        fields.add(new BuildingProperty("SanZ", 32, 300, 260));
+        fields.add(new EventField("Maibock", 33));
+        fields.add(new BuildingProperty("Rechenzentrum", 34, 3200, 280));
+        fields.add(new GateField("Osttor", 35));
+        fields.add(new EventField("Üvas", 36));
+        fields.add(new BuildingProperty("2er", 37, 3500, 350));
+        fields.add(new FineField("EZM", 38, 1000));
+        fields.add(new BuildingProperty("20er", 39, 4000, 500));
+
+        return fields;
+    }
+
+
+    /**
+     * Method to find the Field at specific index
+     * @param index the index for which to find the field
+     * @return the field at the index
+     */
+    public Field getFieldAtIndex(int index) {
+        return board.get(index);
+    }
+
+    /**
+     * Method to find the index of a Monopoly field
+     * @param field the Field to get the Index of
+     * @return the Index of the field
+     */
+    public int getIndexOfField(Field field) {
+        if (board.contains(field)) return field.getId();
+        else throw new NoSuchElementException();
+    }
+}

Projekte/monopoly/model/src/main/java/pp/monopoly/model/fields/BuildingProperty.java

@@ -0,0 +1,70 @@
+package pp.monopoly.model.fields;
+
+import pp.monopoly.game.server.Player;
+
+public class BuildingProperty extends PropertyField {
+
+    private int houses;
+    private boolean hotel = false;
+
+    BuildingProperty(String name, int id, int price, int rent) {
+        super(name, id, price, rent);
+    }
+
+    @Override
+    public int calcRent() {
+        if (hotel) {
+            return (int) Math.round(rent*70/10)*10;
+        }
+        switch (houses) {
+            case 1:
+                return (int) Math.round(rent*5/10)*10;
+            case 2:
+                return (int) Math.round(rent*15/10)*10;
+            case 3:
+                return (int) Math.round(rent*40/10)*10;
+            case 4:
+            return (int) Math.round(rent*55/10)*10;
+
+            default:
+                return rent;
+        }
+    }
+
+    public boolean buildHouse() {
+        if (houses < 4) {
+            houses++;
+            return true;
+        }
+        return false;
+    }
+
+    public boolean buildHotel() {
+        if (hotel) {
+            return false;
+        }
+        hotel = true;
+        return true;
+    }
+    
+    public boolean removeHouse() {
+        if (houses == 0) {
+            return false;
+        }
+        houses--;
+        return true;
+    }
+
+    public boolean removeHotel() {
+        if (!hotel) {
+            return false;
+        }
+        hotel = false;
+        return true;
+    }
+
+    @Override
+    public void accept(Player player) {
+        player.visit(this);
+    }
+}