peet/Gruppe-02-clone
1
0
Fork 0
mirror of https://athene2.informatik.unibw-muenchen.de/progproj/gruppen-ht24/Gruppe-02.git synced 2025-04-17 12:40:59 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Compare commits

base: peet:645433610f093b81eb61f5fd603b8dcc1d025c9b
Branches Tags
peet:main
peet:gui
peet:demo
peet:reworkedGui
peet:Testhandbuch
peet:logic
peet:connect
peet:client_logic
peet:b_szepielewicz_filip
peet:b_puderbach_luca
peet:b_wilkening_simon
peet:b_schmidt_yvonne
peet:b_schmelz_johannes
peet:revert-f248a77c
peet:b_Mueller_Tamino
peet:b_malkmus_dennis
peet:revert-71a4ac8d
peet:b_Schmelz_Johannes
..
compare: peet:14c68f55d9d35358a2d918bf038c4e86cae94263
Branches Tags
peet:main
peet:gui
peet:demo
peet:reworkedGui
peet:Testhandbuch
peet:logic
peet:connect
peet:client_logic
peet:b_szepielewicz_filip
peet:b_puderbach_luca
peet:b_wilkening_simon
peet:b_schmidt_yvonne
peet:b_schmelz_johannes
peet:revert-f248a77c
peet:b_Mueller_Tamino
peet:b_malkmus_dennis
peet:revert-71a4ac8d
peet:b_Schmelz_Johannes

No commits in common. "645433610f093b81eb61f5fd603b8dcc1d025c9b" and "14c68f55d9d35358a2d918bf038c4e86cae94263" have entirely different histories.
645433610f ... 14c68f55d9

30 changed files with 1258 additions and 1222 deletions
Show Stats Expand all files Collapse all files

217
Projekte/monopoly/client/src/main/java/pp/monopoly/client/BoardAppState.java
View File

@ -1,217 +0,0 @@
package pp.monopoly.client;
import com.jme3.app.Application;
import com.jme3.app.state.AppStateManager;
import com.jme3.asset.AssetManager;
import com.jme3.light.AmbientLight;
import com.jme3.light.DirectionalLight;
import com.jme3.material.Material;
import com.jme3.math.ColorRGBA;
import com.jme3.math.FastMath;
import com.jme3.math.Quaternion;
import com.jme3.math.Vector2f;
import com.jme3.math.Vector3f;
import com.jme3.renderer.Camera;
import com.jme3.renderer.queue.RenderQueue.ShadowMode;
import com.jme3.scene.Geometry;
import com.jme3.scene.Node;
import com.jme3.scene.Spatial;
import com.jme3.scene.shape.Box;
import com.jme3.shadow.DirectionalLightShadowRenderer;
import com.jme3.shadow.EdgeFilteringMode;
import com.jme3.texture.Texture;
import com.jme3.util.SkyFactory;
import com.jme3.util.TangentBinormalGenerator;
import pp.monopoly.model.Board;
import pp.monopoly.client.gui.BobTheBuilder;
import pp.monopoly.client.gui.Toolbar;
import static pp.util.FloatMath.PI;
import static pp.util.FloatMath.TWO_PI;
import static pp.util.FloatMath.cos;
import static pp.util.FloatMath.sin;
import static pp.util.FloatMath.sqrt;
/**
* Manages the rendering and visual aspects of the sea and sky in the Battleship game.
* This state is responsible for setting up and updating the sea, sky, and lighting
* conditions, and controls the camera to create a dynamic view of the game environment.
*/
public class BoardAppState extends MonopolyAppState {
/**
* The path to the unshaded texture material.
*/
private static final String UNSHADED = "Common/MatDefs/Misc/Unshaded.j3md"; //NON-NLS
/**
* The path to the sea texture material.
*/
private static final String BoardTexture = "Pictures/board2.png"; //NON-NLS
/**
* The root node for all visual elements in this state.
*/
private final Node viewNode = new Node("view"); //NON-NLS
/**
* The node containing the scene elements, such as the sea surface.
*/
private final Node sceneNode = new Node("scene"); //NON-NLS
/**
* Synchronizes the buildings's visual representation with the game logic.
*/
private BobTheBuilder bobTheBuilder;
/**
* The pop-up manager for displaying messages and notifications.
*/
private PopUpManager popUpManager;;
/**
* Initializes the state by setting up the sky, lights, and other visual components.
* This method is called when the state is first attached to the state manager.
*
* @param stateManager the state manager
* @param application the application
*/
@Override
public void initialize(AppStateManager stateManager, Application application) {
super.initialize(stateManager, application);
popUpManager = new PopUpManager(getApp());
viewNode.attachChild(sceneNode);
setupLights();
setupSky();
}
/**
* Enables the sea and sky state, setting up the scene and registering any necessary listeners.
* This method is called when the state is set to active.
*/
@Override
protected void enableState() {
getApp().getRootNode().detachAllChildren();
getApp().getGuiNode().detachAllChildren();
new Toolbar(getApp()).open();
sceneNode.detachAllChildren();
setupScene();
if (bobTheBuilder == null) {
bobTheBuilder = new BobTheBuilder(getApp(), getApp().getRootNode());
System.out.println("LISTENER IS REGISTEDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD");
getGameLogic().addListener(bobTheBuilder);
}
getApp().getRootNode().attachChild(viewNode);
}
//TODO remove this only for camera testing
private static final float ABOVE_SEA_LEVEL = 10f;
private static final float INCLINATION = 2.5f;
private float cameraAngle;
/**
* Adjusts the camera position and orientation to create a circular motion around
* the center of the map. This provides a dynamic view of the sea and surrounding environment.
*/
private void adjustCamera() {
final Board board = getGameLogic().getBoard();
final float mx = 0.5f * board.getWidth();
final float my = 0.5f * board.getHeight();
final float radius = 2f * sqrt(mx * mx + my + my);
final float cos = radius * cos(cameraAngle);
final float sin = radius * sin(cameraAngle);
final float x = mx - cos;
final float y = my - sin;
final Camera camera = getApp().getCamera();
camera.setLocation(new Vector3f(x, ABOVE_SEA_LEVEL, y));
camera.lookAt(new Vector3f(0,0, 0),
Vector3f.UNIT_Y);
camera.update();
}
/**
* Disables the sea and sky state, removing visual elements from the scene and unregistering listeners.
* This method is called when the state is set to inactive.
*/
@Override
protected void disableState() {
getApp().getRootNode().detachChild(viewNode);
if (bobTheBuilder != null) {
getGameLogic().removeListener(bobTheBuilder);
bobTheBuilder = null;
}
}
/**
* Updates the state each frame, moving the camera to simulate it circling around the map.
*
* @param tpf the time per frame (seconds)
*/
@Override
public void update(float tpf) {
super.update(tpf);
//TODO remove this only for camera testing
cameraAngle += TWO_PI * 0.05f * tpf;
adjustCamera();
}
/**
* Sets up the lighting for the scene, including directional and ambient lights.
* Also configures shadows to enhance the visual depth of the scene.
*/
private void setupLights() {
final AssetManager assetManager = getApp().getAssetManager();
final DirectionalLightShadowRenderer shRend = new DirectionalLightShadowRenderer(assetManager, 2048, 3);
shRend.setLambda(0.55f);
shRend.setShadowIntensity(0.6f);
shRend.setEdgeFilteringMode(EdgeFilteringMode.Bilinear);
getApp().getViewPort().addProcessor(shRend);
final DirectionalLight sun = new DirectionalLight();
sun.setDirection(new Vector3f(-1f, -0.7f, -1f).normalizeLocal());
viewNode.addLight(sun);
shRend.setLight(sun);
final AmbientLight ambientLight = new AmbientLight(new ColorRGBA(1f, 1f, 1f, 1f));
viewNode.addLight(ambientLight);
}
/**
* Sets up the sky in the scene using a skybox with textures for all six directions.
* This creates a realistic and immersive environment for the sea.
*/
private void setupSky() {
final AssetManager assetManager = getApp().getAssetManager();
final Texture west = assetManager.loadTexture("Pictures/Backdrop/backdrop.jpg"); //NON-NLS
final Texture east = assetManager.loadTexture("Pictures/Backdrop/backdrop.jpg"); //NON-NLS
final Texture north = assetManager.loadTexture("Pictures/Backdrop/backdrop.jpg"); //NON-NLS
final Texture south = assetManager.loadTexture("Pictures/Backdrop/backdrop.jpg"); //NON-NLS
final Texture up = assetManager.loadTexture("Pictures/Backdrop/backdrop.jpg"); //NON-NLS
final Texture down = assetManager.loadTexture("Pictures/Backdrop/backdrop.jpg"); //NON-NLS
final Spatial sky = SkyFactory.createSky(assetManager, west, east, north, south, up, down);
// sky.rotate(0, PI, 0);
viewNode.attachChild(sky);
}
/**
* Sets up the sea surface in the scene. This includes creating the sea mesh,
* applying textures, and enabling shadows.
*/
private void setupScene() {
final Board board = getGameLogic().getBoard();
final float x = board.getWidth();
final float y = board.getHeight();
final Box seaMesh = new Box(y, 0.1f, x);
final Geometry seaGeo = new Geometry("sea", seaMesh); //NONs-NLS
seaGeo.setLocalTranslation(new Vector3f(0, -0.1f, 0));
Quaternion rotation = new com.jme3.math.Quaternion();
rotation.fromAngleAxis(FastMath.HALF_PI, com.jme3.math.Vector3f.UNIT_Y);
seaGeo.setLocalRotation(rotation);
final Material seaMat = new Material(getApp().getAssetManager(), "Common/MatDefs/Light/Lighting.j3md");
Texture texture = getApp().getAssetManager().loadTexture("Pictures/board2.png");
seaMat.setTexture("DiffuseMap", texture);
seaGeo.setMaterial(seaMat);
seaGeo.setShadowMode(ShadowMode.CastAndReceive);
TangentBinormalGenerator.generate(seaGeo);
sceneNode.attachChild(seaGeo);
}
}

99
Projekte/monopoly/client/src/main/java/pp/monopoly/client/GameAppState.java Normal file
View File

@ -0,0 +1,99 @@
////////////////////////////////////////
// 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 com.jme3.input.controls.ActionListener;
import com.jme3.scene.Node;
import pp.monopoly.client.gui.TestWorld;
/**
* Represents the state responsible for managing the battle interface within the Battleship game.
* This state handles the display and interaction of the battle map, including the opponent's map.
* It manages GUI components, input events, and the layout of the interface when this state is enabled.
*/
public class GameAppState extends MonopolyAppState {
private static final Logger LOGGER = System.getLogger(MonopolyAppState.class.getName());
/**
* A listener for handling click events in the battle interface.
* When a click is detected, it triggers the corresponding actions on the opponent's map.
*/
private final ActionListener clickListener = (name, isPressed, tpf) -> click(isPressed);
/**
* The root node for all GUI components in the battle state.
*/
private final Node battleNode = new Node("Game"); //NON-NLS
/**
* A view representing the opponent's map in the GUI.
*/
private TestWorld testWorld;
/**
* Enables the battle state by initializing, laying out, and adding GUI components.
* Attaches the components to the GUI node and registers input listeners.
*/
@Override
protected void enableState() {
LOGGER.log(Level.DEBUG, "Enabling game state");
battleNode.detachAllChildren();
initializeGuiComponents();
addGuiComponents();
getApp().getGuiNode().attachChild(battleNode);
}
/**
* Disables the battle state by removing GUI components and unregistering input listeners.
* Also handles cleanup of resources, such as the opponent's map view.
*/
@Override
protected void disableState() {
getApp().getGuiNode().detachChild(battleNode);
getApp().getInputManager().removeListener(clickListener);
}
/**
* Initializes the GUI components used in the battle state.
* Creates the opponent's map view and adds a grid overlay to it.
*/
private void initializeGuiComponents() {
// Initialisiere TestWorld mit Spielern
testWorld = new TestWorld(getApp());
testWorld.initializeScene();
}
/**
* Adds the initialized GUI components to the battle node.
* Currently, it attaches the opponent's map view to the node.
*/
private void addGuiComponents() {
}
/**
* Handles click events in the battle interface. If the event indicates a click (not a release),
* it translates the cursor position to the model's coordinate system and triggers the game logic
* for interacting with the opponent's map.
*
* @param isPressed whether the mouse button is currently pressed (true) or released (false)
*/
private void click(boolean isPressed) {
}
@Override
public void update(float tpf) {
super.update(tpf);
}
}

4
Projekte/monopoly/client/src/main/java/pp/monopoly/client/MonopolyApp.java
View File

@ -285,7 +285,7 @@ public class MonopolyApp extends SimpleApplication implements MonopolyClient, Ga
attachGameSound(); attachGameSound();
attachGameMusic(); attachGameMusic();
stateManager.attach(new BoardAppState()); stateManager.attach(new GameAppState());
} }
/** /**
@ -405,7 +405,7 @@ public class MonopolyApp extends SimpleApplication implements MonopolyClient, Ga
*/ */
@Override @Override
public void receivedEvent(ClientStateEvent event) { public void receivedEvent(ClientStateEvent event) {
stateManager.getState(BoardAppState.class).setEnabled(logic.isTurn()); stateManager.getState(GameAppState.class).setEnabled(true);
} }
/** /**

97
Projekte/monopoly/client/src/main/java/pp/monopoly/client/PopUpManager.java
View File

@ -1,97 +0,0 @@
package pp.monopoly.client;
import java.util.Timer;
import java.util.TimerTask;
import pp.monopoly.client.gui.popups.AcceptTrade;
import pp.monopoly.client.gui.popups.BuildingPropertyCard;
import pp.monopoly.client.gui.popups.ConfirmTrade;
import pp.monopoly.client.gui.popups.EventCardPopup;
import pp.monopoly.client.gui.popups.FoodFieldCard;
import pp.monopoly.client.gui.popups.GateFieldCard;
import pp.monopoly.client.gui.popups.Gulag;
import pp.monopoly.client.gui.popups.GulagInfo;
import pp.monopoly.client.gui.popups.LooserPopUp;
import pp.monopoly.client.gui.popups.NoMoneyWarning;
import pp.monopoly.client.gui.popups.ReceivedRent;
import pp.monopoly.client.gui.popups.RejectTrade;
import pp.monopoly.client.gui.popups.Rent;
import pp.monopoly.client.gui.popups.TimeOut;
import pp.monopoly.client.gui.popups.WinnerPopUp;
import pp.monopoly.message.server.NotificationMessage;
import pp.monopoly.message.server.TradeReply;
import pp.monopoly.model.fields.BuildingProperty;
import pp.monopoly.model.fields.FoodField;
import pp.monopoly.model.fields.GateField;
import pp.monopoly.notification.EventCardEvent;
import pp.monopoly.notification.GameEventListener;
import pp.monopoly.notification.PopUpEvent;
public class PopUpManager implements GameEventListener {
private final MonopolyApp app;
public PopUpManager(MonopolyApp app) {
this.app = app;
app.getGameLogic().addListener(this);
}
@Override
public void receivedEvent(PopUpEvent event) {
if (event.msg().equals("Buy")) {
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
app.enqueue(() -> {
int field = app.getGameLogic().getPlayerHandler().getPlayerById(app.getId()).getFieldID();
Object fieldObject = app.getGameLogic().getBoardManager().getFieldAtIndex(field);
if (fieldObject instanceof BuildingProperty) {
new BuildingPropertyCard(app).open();
} else if (fieldObject instanceof GateField) {
new GateFieldCard(app).open();
} else if (fieldObject instanceof FoodField) {
new FoodFieldCard(app).open();
}
});
}
}, 2500);
} else if (event.msg().equals("Winner")) {
new WinnerPopUp(app).open();
} else if (event.msg().equals("Looser")) {
new LooserPopUp(app).open();
} else if (event.msg().equals("timeout")) {
new TimeOut(app).open();
} else if (event.msg().equals("tradeRequest")) {
new ConfirmTrade(app).open();
} else if (event.msg().equals("goingToJail")) {
new Gulag(app).open();
} else if (event.msg().equals("NoMoneyWarning")) {
new NoMoneyWarning(app).open();
} else if(event.msg().equals("rent")) {
new Rent(app, ( (NotificationMessage) event.message()).getRentOwner(), ( (NotificationMessage) event.message()).getRentAmount() ).open();
} else if (event.msg().equals("jailtryagain")) {
new GulagInfo(app, 1).open();
} else if (event.msg().equals("jailpay")) {
new GulagInfo(app, 3).open();
} else if (event.msg().equals("tradepos")) {
new AcceptTrade(app, (TradeReply) event.message()).open();
} else if (event.msg().equals("tradeneg")) {
new RejectTrade(app, (TradeReply) event.message()).open();
} else if (event.msg().equals("ReceivedRent")) {
new ReceivedRent(app, ( (NotificationMessage) event.message()).getRentOwner(), ( (NotificationMessage) event.message()).getRentAmount() ).open();
}
}
@Override
public void receivedEvent(EventCardEvent event) {
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
app.enqueue(() -> new EventCardPopup(app, event.description()).open());
}
}, 2500);
}
}

74
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/BoardSynchronizer.java Normal file
View File

@ -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());
}
}
}

146
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/BobTheBuilder.java
View File

@ -1,146 +0,0 @@
package pp.monopoly.client.gui;
import com.jme3.material.Material;
import com.jme3.material.RenderState.BlendMode;
import com.jme3.math.ColorRGBA;
import com.jme3.renderer.queue.RenderQueue.ShadowMode;
import com.jme3.scene.Geometry;
import com.jme3.scene.Node;
import com.jme3.scene.Spatial;
import com.jme3.scene.shape.Box;
import pp.monopoly.client.MonopolyApp;
import pp.monopoly.model.Figure;
import pp.monopoly.model.Hotel;
import pp.monopoly.model.House;
import pp.monopoly.model.Item;
import pp.monopoly.notification.UpdatePlayerView;
public class BobTheBuilder extends GameBoardSynchronizer {
private static final String UNSHADED = "Common/MatDefs/Misc/Unshaded.j3md"; //NON-NLS
private static final String COLOR = "Color"; //NON-NLS
private static final String FIGURE = "figure"; //NON-NLS
private static final String HOUSE = "house"; //NON-NLS
private static final String HOTEL = "hotel"; //NON-NLS
private final MonopolyApp app;
public BobTheBuilder(MonopolyApp app, Node root) {
super(app.getGameLogic().getBoard(), root);
this.app = app;
addExisting();
}
@Override
public Spatial visit(Figure figure) {
final Node node = new Node(FIGURE);
node.attachChild(createFigure(figure));
// Setze die Position basierend auf der Feld-ID
node.setLocalTranslation(figure.getPos());
// Setze die Rotation basierend auf der Feld-ID
node.setLocalRotation(figure.getRot().toQuaternion());
node.addControl(new FigureControl(figure));
return node;
}
@Override
public Spatial visit(Hotel hotel) {
final Node node = new Node(HOTEL);
node.attachChild(createHotel(hotel));
// Setze die Position basierend auf der Feld-ID
node.setLocalTranslation(hotel.getPos());
// Setze die Rotation basierend auf der Feld-ID
node.setLocalRotation(hotel.getRot().toQuaternion());
return node;
}
@Override
public Spatial visit(House house) {
final Node node = new Node(HOUSE);
node.attachChild(createHouse(house));
// Setze die Position basierend auf der Feld-ID
node.setLocalTranslation(house.getPos());
// Setze die Rotation basierend auf der Feld-ID
node.setLocalRotation(house.getAlignment());
return node;
}
private Spatial createFigure(Figure figure) {
// Lade das Modell
Spatial model = app.getAssetManager().loadModel("models/" + "Spielfiguren/" + figure.getType() + "/" + figure.getType() + ".j3o");
// Skaliere und positioniere das Modell
model.scale(0.5f);
return model;
}
private Spatial createHotel(Hotel hotel) {
Spatial model = app.getAssetManager().loadModel("models/Hotel/Hotel.j3o");
model.scale(0.2f);
model.setShadowMode(ShadowMode.CastAndReceive);
return model;
}
private Spatial createHouse(House house) {
Spatial model = app.getAssetManager().loadModel("models/Haus/"+house.getStage()+"Haus.j3o");
model.scale(0.5f);
model.setShadowMode(ShadowMode.CastAndReceive);
return model;
}
/**
* Creates a simple box to represent a battleship that is not of the "King George V" type.
*
* @param ship the battleship to be represented
* @return the geometry representing the battleship as a box
*/
private Spatial createBox(Item item) {
final Box box = new Box(3,
3f,
3);
final Geometry geometry = new Geometry(FIGURE, box);
geometry.setMaterial(createColoredMaterial(ColorRGBA.Blue));
geometry.setShadowMode(ShadowMode.CastAndReceive);
geometry.setLocalTranslation(0, 2, 0);
return geometry;
}
/**
* Creates a new {@link Material} with the specified color.
* If the color includes transparency (i.e., alpha value less than 1),
* the material's render state is set to use alpha blending, allowing for
* semi-transparent rendering.
*
* @param color the {@link ColorRGBA} to be applied to the material. If the alpha value
* of the color is less than 1, the material will support transparency.
* @return a {@link Material} instance configured with the specified color and,
* if necessary, alpha blending enabled.
*/
private Material createColoredMaterial(ColorRGBA color) {
final Material material = new Material(app.getAssetManager(), UNSHADED);
if (color.getAlpha() < 1f)
material.getAdditionalRenderState().setBlendMode(BlendMode.Alpha);
material.setColor(COLOR, color);
return material;
}
@Override
public void receivedEvent(UpdatePlayerView event) {
//TODO player move animation
}
}

28
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/FigureControl.java
View File

@ -1,28 +0,0 @@
package pp.monopoly.client.gui;
import com.jme3.renderer.RenderManager;
import com.jme3.renderer.ViewPort;
import com.jme3.scene.control.AbstractControl;
import pp.monopoly.model.Figure;
public class FigureControl extends AbstractControl {
private final Figure figure;
public FigureControl(Figure figure) {
super();
this.figure = figure;
}
@Override
protected void controlUpdate(float tpf) {
//TODO: animation
}
@Override
protected void controlRender(RenderManager rm, ViewPort vp) {
// No rendering required
}
}

145
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/GameBoardSynchronizer.java
View File

@ -1,87 +1,120 @@
////////////////////////////////////////
// Programming project code
// UniBw M, 2022, 2023, 2024
// www.unibw.de/inf2
// (c) Mark Minas (mark.minas@unibw.de)
////////////////////////////////////////
package pp.monopoly.client.gui; package pp.monopoly.client.gui;
import com.jme3.material.Material;
import com.jme3.material.RenderState.BlendMode;
import com.jme3.math.ColorRGBA;
import com.jme3.renderer.queue.RenderQueue.ShadowMode;
import com.jme3.scene.Geometry;
import com.jme3.scene.Node; import com.jme3.scene.Node;
import com.jme3.scene.Spatial; import com.jme3.scene.Spatial;
import pp.monopoly.model.Item; import com.jme3.scene.shape.Box;
import pp.monopoly.model.Visitor;
import pp.monopoly.notification.DiceRollEvent; import pp.monopoly.client.MonopolyApp;
import pp.monopoly.notification.GameEventListener; import pp.monopoly.game.server.PlayerColor;
import pp.monopoly.notification.ItemAddedEvent;
import pp.monopoly.notification.ItemRemovedEvent;
import pp.monopoly.notification.UpdatePlayerView;
import pp.monopoly.model.Board; import pp.monopoly.model.Board;
import pp.monopoly.model.Figure; import pp.monopoly.model.Figure;
import pp.view.ModelViewSynchronizer; import pp.monopoly.model.Rotation;
import static pp.util.FloatMath.HALF_PI;
import static pp.util.FloatMath.PI;
/** /**
* Abstract base class for synchronizing the visual representation of a {@link Board} with its model state. * The {@code GameBoardSynchronizer} class is responsible for synchronizing the graphical
* This class handles the addition and removal of items from the board, ensuring that changes in the model * representation of the Game board and figures with the underlying data model.
* are accurately reflected in the view. * It extends the {@link BoardSynchronizer} to provide specific synchronization
* <p> * logic for the Game board.
* Subclasses are responsible for providing the specific implementation of how each item in the map
* is represented visually by implementing the {@link Visitor} interface.
* </p>
*/ */
abstract class GameBoardSynchronizer extends ModelViewSynchronizer<Item> implements Visitor<Spatial>, GameEventListener { class GameBoardSynchronizer extends BoardSynchronizer {
// The board that this synchronizer is responsible for private static final String UNSHADED = "Common/MatDefs/Misc/Unshaded.j3md"; //NON-NLS
protected final Board board; private static final String LIGHTING = "Common/MatDefs/Light/Lighting.j3md";
private static final String COLOR = "Color"; //NON-NLS
private static final String FIGURE = "figure"; //NON-NLS
private final MonopolyApp app;
/** /**
* Constructs a new GameBoardSynchronizer. * Constructs a {@code GameBoardSynchronizer} object with the specified application, root node, and ship map.
* Initializes the synchronizer with the provided board and the root node for attaching view representations.
* *
* @param map the board to be synchronized * @param app the Monopoly application
* @param root the root node to which the view representations of the board items are attached * @param root the root node to which graphical elements will be attached
* @param map the Game Board containing fields and figures
*/ */
protected GameBoardSynchronizer(Board board, Node root) { public GameBoardSynchronizer(MonopolyApp app, Node root, Board board) {
super(root); super(board, root);
this.board = board; this.app = app;
addExisting();
} }
/** /**
* Translates a model item into its corresponding visual representation. * Visits a {@link Figure} and creates a graphical representation of it.
* The specific visual representation is determined by the concrete implementation of the {@link Visitor} interface. * The representation is a 3D model.
* *
* @param item the item from the model to be translated * @param figure the figure to be represented
* @return the visual representation of the item as a {@link Spatial} * @return the node containing the graphical representation of the figure
*/ */
@Override public Spatial visit(Figure figure) {
protected Spatial translate(Item item) { final Node node = new Node(FIGURE);
return item.accept(this); node.attachChild(createBox(figure));
final float x = 1;
final float z = 1;
node.setLocalTranslation(x, 0f, z);
return node;
} }
/** /**
* Adds the existing items from the board to the view. * Creates a representation of a figure
* This method should be called during initialization to ensure that all current items in the board
* are visually represented.
*/
protected void addExisting() {
board.getItems().forEach(this::add);
}
/**
* Handles the event when an item is removed from the ship map.
* Removes the visual representation of the item from the view if it belongs to the synchronized ship map.
* *
* @param event the event indicating that an item has been removed from the ship map * @param figure the figure to be represented
* @return the geometry representing the figure
*/ */
@Override private Spatial createBox(Figure figure) {
public void receivedEvent(ItemRemovedEvent event) { final Box box = new Box(0.5f * (figure.getMaxY() - figure.getMinY()) + 0.3f,
if (board == event.board()) 0.3f,
delete(event.item()); 0.5f * (figure.getMaxX() - figure.getMinX()) + 0.3f);
final Geometry geometry = new Geometry(FIGURE, box);
geometry.setMaterial(createColoredMaterial(PlayerColor.PINK.getColor()));
geometry.setShadowMode(ShadowMode.CastAndReceive);
return geometry;
} }
/** /**
* Handles the event when an item is added to the ship map. * Creates a new {@link Material} with the specified color.
* Adds the visual representation of the new item to the view if it belongs to the synchronized ship map. * If the color includes transparency (i.e., alpha value less than 1),
* the material's render state is set to use alpha blending, allowing for
* semi-transparent rendering.
* *
* @param event the event indicating that an item has been added to the ship map * @param color the {@link ColorRGBA} to be applied to the material. If the alpha value
* of the color is less than 1, the material will support transparency.
* @return a {@link Material} instance configured with the specified color and,
* if necessary, alpha blending enabled.
*/ */
@Override private Material createColoredMaterial(ColorRGBA color) {
public void receivedEvent(ItemAddedEvent event) { final Material material = new Material(app.getAssetManager(), UNSHADED);
if (board == event.board()){ if (color.getAlpha() < 1f)
add(event.item()); material.getAdditionalRenderState().setBlendMode(BlendMode.Alpha);
} material.setColor(COLOR, color);
return material;
} }
/**
* Calculates the rotation angle for the specified rotation.
*
* @param rot the rotation of the battleship
* @return the rotation angle in radians
*/
private static float calculateRotationAngle(Rotation rot) {
return switch (rot) {
case RIGHT -> HALF_PI;
case DOWN -> 0f;
case LEFT -> -HALF_PI;
case UP -> PI;
};
}
} }

565
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/TestWorld.java Normal file
View File

@ -0,0 +1,565 @@
package pp.monopoly.client.gui;
import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
import com.jme3.light.AmbientLight;
import com.jme3.light.DirectionalLight;
import com.jme3.material.Material;
import com.jme3.math.ColorRGBA;
import com.jme3.math.FastMath;
import com.jme3.math.Vector3f;
import com.jme3.renderer.RenderManager;
import com.jme3.renderer.ViewPort;
import com.jme3.scene.control.AbstractControl;
import com.jme3.texture.Texture;
import pp.monopoly.client.MonopolyApp;
import pp.monopoly.client.gui.popups.AcceptTrade;
import pp.monopoly.client.gui.popups.BuildingPropertyCard;
import pp.monopoly.client.gui.popups.ConfirmTrade;
import pp.monopoly.client.gui.popups.EventCardPopup;
import pp.monopoly.client.gui.popups.FoodFieldCard;
import pp.monopoly.client.gui.popups.GateFieldCard;
import pp.monopoly.client.gui.popups.Gulag;
import pp.monopoly.client.gui.popups.GulagInfo;
import pp.monopoly.client.gui.popups.LooserPopUp;
import pp.monopoly.client.gui.popups.NoMoneyWarning;
import pp.monopoly.client.gui.popups.ReceivedRent;
import pp.monopoly.client.gui.popups.RejectTrade;
import pp.monopoly.client.gui.popups.Rent;
import pp.monopoly.client.gui.popups.TimeOut;
import pp.monopoly.client.gui.popups.WinnerPopUp;
import pp.monopoly.game.server.Player;
import pp.monopoly.game.server.PlayerHandler;
import pp.monopoly.message.server.NotificationMessage;
import pp.monopoly.message.server.TradeReply;
import pp.monopoly.model.fields.BuildingProperty;
import pp.monopoly.model.fields.FoodField;
import pp.monopoly.model.fields.GateField;
import pp.monopoly.notification.EventCardEvent;
import pp.monopoly.notification.GameEventListener;
import pp.monopoly.notification.PopUpEvent;
import pp.monopoly.notification.UpdatePlayerView;
/**
* TestWorld zeigt eine einfache Szene mit Spielfeld und Spielfiguren.
*/
public class TestWorld implements GameEventListener {
private final MonopolyApp app;
private PlayerHandler playerHandler;
private CameraController cameraController;
private Toolbar toolbar;
private List<String> existingHouses = new ArrayList<>();
/**
* Konstruktor für die TestWorld.
*
* @param app Die Hauptanwendung
*/
public TestWorld(MonopolyApp app) {
this.app = app;
this.playerHandler = app.getGameLogic().getPlayerHandler();
app.getGameLogic().addListener(this);
cameraController = new CameraController(app.getCamera());
}
/**
* Initialisiert die Szene mit Spielfeld und Figuren.
*/
public void initializeScene() {
// Entferne bestehende Inhalte
app.getGuiNode().detachAllChildren();
app.getRootNode().detachAllChildren();
System.out.println("Szene initialisiert.");
//Füge Inhalte ein
setSkyColor();
createBoard();
addLighting();
createPlayerFigures();
toolbar = new Toolbar(app);
toolbar.open();
}
/**
* Setzt die Hintergrundfarbe der Szene auf hellblau.
*/
private void setSkyColor() {
app.getViewPort().setBackgroundColor(new com.jme3.math.ColorRGBA(0.5f, 0.7f, 1.0f, 1.0f));
}
/**
* Erstellt das Spielfeld und fügt es zur Szene hinzu.
*/
private void createBoard() {
try {
com.jme3.scene.shape.Box box = new com.jme3.scene.shape.Box(10, 0.1f, 10);
com.jme3.scene.Geometry geom = new com.jme3.scene.Geometry("Board", box);
Material mat = new Material(app.getAssetManager(), "Common/MatDefs/Light/Lighting.j3md");
Texture texture = app.getAssetManager().loadTexture("Pictures/board2.png");
mat.setTexture("DiffuseMap", texture);
geom.setMaterial(mat);
geom.setLocalTranslation(0, -0.1f, 0);
com.jme3.math.Quaternion rotation = new com.jme3.math.Quaternion();
rotation.fromAngleAxis(FastMath.HALF_PI, com.jme3.math.Vector3f.UNIT_Y);
geom.setLocalRotation(rotation);
app.getRootNode().attachChild(geom);
} catch (Exception e) {
System.err.println("Fehler beim Erstellen des Spielfelds: " + e.getMessage());
}
}
private void addLighting() {
// Direktionales Licht
DirectionalLight sun = new DirectionalLight();
sun.setColor(ColorRGBA.White);
sun.setDirection(new Vector3f(-0.5f, -0.7f, -1.0f).normalizeLocal());
app.getRootNode().addLight(sun);
// Umgebungslicht
AmbientLight ambient = new AmbientLight();
ambient.setColor(new ColorRGBA(0.6f, 0.6f, 0.6f, 1.0f));
app.getRootNode().addLight(ambient);
}
private com.jme3.math.Quaternion calculateRotationForField(int fieldID) {
com.jme3.math.Quaternion rotation = new com.jme3.math.Quaternion();
// Berechne die Rotation basierend auf der Feld-ID
if (fieldID >= 0 && fieldID <= 9) {
// Untere Seite (0-9)
rotation.fromAngleAxis(0, Vector3f.UNIT_Y); // Richtung: nach oben
} else if (fieldID >= 10 && fieldID <= 19) {
// Rechte Seite (10-19)
rotation.fromAngleAxis(FastMath.HALF_PI, Vector3f.UNIT_Y); // Richtung: nach links
} else if (fieldID >= 20 && fieldID <= 29) {
// Obere Seite (20-29)
rotation.fromAngleAxis(FastMath.PI, Vector3f.UNIT_Y); // Richtung: nach unten
} else if (fieldID >= 30 && fieldID <= 39) {
// Linke Seite (30-39)
rotation.fromAngleAxis(3 * FastMath.HALF_PI, Vector3f.UNIT_Y); // Richtung: nach rechts
}
// Korrigiere die Richtung für die Quadranten 10–19 und 30–39 (gegenüberliegende Richtung)
if ((fieldID >= 10 && fieldID <= 19) || (fieldID >= 30 && fieldID <= 39)) {
com.jme3.math.Quaternion oppositeDirection = new com.jme3.math.Quaternion();
oppositeDirection.fromAngleAxis(FastMath.PI, Vector3f.UNIT_Y); // 180° drehen
rotation = rotation.multLocal(oppositeDirection);
}
// Füge zusätzliche 90° nach links hinzu
com.jme3.math.Quaternion leftTurn = new com.jme3.math.Quaternion();
leftTurn.fromAngleAxis(FastMath.HALF_PI, Vector3f.UNIT_Y); // 90° nach links
rotation = rotation.multLocal(leftTurn);
return rotation;
}
/**
* Erstellt die Spielfiguren basierend auf der bereits bekannten Spielerliste.
*/
private void createPlayerFigures() {
for (Player player : playerHandler.getPlayers()) {
try {
// Lade das Modell
com.jme3.scene.Spatial model = app.getAssetManager().loadModel(
"models/" + "Spielfiguren/" + player.getFigure().getType() + "/" + player.getFigure().getType() + ".j3o");
// Skaliere und positioniere das Modell
model.setLocalScale(0.5f);
Vector3f startPosition = calculateFieldPosition(player.getFieldID(), player.getId());
model.setLocalTranslation(startPosition);
// Setze die Rotation basierend auf der Feld-ID
model.setLocalRotation(calculateRotationForField(player.getFieldID()));
model.setName("PlayerFigure_" + player.getId());
// Füge das Modell zur Szene hinzu
app.getRootNode().attachChild(model);
} catch (Exception e) {
System.err.println("Fehler beim Laden des Modells für Spieler " + player.getId() + ": " + e.getMessage());
}
}
}
private Vector3f calculateFieldPosition(int fieldID, int playerIndex) {
float offset = 0.1f;
float baseX = 0.0f;
float baseZ = 0.0f;
switch (fieldID) {
case 0: baseX = -9.1f; baseZ = -9.1f; break;
case 1: baseX = -6.5f; baseZ = -9.1f; break;
case 2: baseX = -4.9f; baseZ = -9.1f; break;
case 3: baseX = -3.3f; baseZ = -9.1f; break;
case 4: baseX = -1.6f; baseZ = -9.1f; break;
case 5: baseX = 0.0f; baseZ = -9.1f; break;
case 6: baseX = 1.6f; baseZ = -9.1f; break;
case 7: baseX = 3.3f; baseZ = -9.1f; break;
case 8: baseX = 4.9f; baseZ = -9.1f; break;
case 9: baseX = 6.5f; baseZ = -9.1f; break;
case 10: baseX = 9.1f; baseZ = -9.1f; break;
case 11: baseX = 9.1f; baseZ = -6.5f; break;
case 12: baseX = 9.1f; baseZ = -4.9f; break;
case 13: baseX = 9.1f; baseZ = -3.3f; break;
case 14: baseX = 9.1f; baseZ = -1.6f; break;
case 15: baseX = 9.1f; baseZ = 0.0f; break;
case 16: baseX = 9.1f; baseZ = 1.6f; break;
case 17: baseX = 9.1f; baseZ = 3.3f; break;
case 18: baseX = 9.1f; baseZ = 4.9f; break;
case 19: baseX = 9.1f; baseZ = 6.5f; break;
case 20: baseX = 9.1f; baseZ = 9.1f; break;
case 21: baseX = 6.5f; baseZ = 9.1f; break;
case 22: baseX = 4.9f; baseZ = 9.1f; break;
case 23: baseX = 3.3f; baseZ = 9.1f; break;
case 24: baseX = 1.6f; baseZ = 9.1f; break;
case 25: baseX = 0.0f; baseZ = 9.1f; break;
case 26: baseX = -1.6f; baseZ = 9.1f; break;
case 27: baseX = -3.3f; baseZ = 9.1f; break;
case 28: baseX = -4.9f; baseZ = 9.1f; break;
case 29: baseX = -6.5f; baseZ = 9.1f; break;
case 30: baseX = -9.1f; baseZ = 9.1f; break;
case 31: baseX = -9.1f; baseZ = 6.5f; break;
case 32: baseX = -9.1f; baseZ = 4.9f; break;
case 33: baseX = -9.1f; baseZ = 3.3f; break;
case 34: baseX = -9.1f; baseZ = 1.6f; break;
case 35: baseX = -9.1f; baseZ = 0.0f; break;
case 36: baseX = -9.1f; baseZ = -1.6f; break;
case 37: baseX = -9.1f; baseZ = -3.3f; break;
case 38: baseX = -9.1f; baseZ = -4.9f; break;
case 39: baseX = -9.1f; baseZ = -6.5f; break;
default: throw new IllegalArgumentException("Ungültige Feld-ID: " + fieldID);
}
float xOffset = (playerIndex % 2) * offset;
float zOffset = (playerIndex / 2) * offset;
return new Vector3f(baseX + xOffset, 0, baseZ + zOffset);
}
private void movePlayerFigure(Player player) {
int playerIndexOnField = calculatePlayerIndexOnField(player.getFieldID(), player.getId());
String figureName = "PlayerFigure_" + player.getId();
com.jme3.scene.Spatial figure = app.getRootNode().getChild(figureName);
if (figure != null) {
// Füge einen Delay hinzu (z.B. 3 Sekunden)
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
app.enqueue(() -> {
// Setze die Position
Vector3f targetPosition = calculateFieldPosition(player.getFieldID(), player.getId());
figure.setLocalTranslation(targetPosition);
// Aktualisiere die Rotation basierend auf der Feld-ID
figure.setLocalRotation(calculateRotationForField(player.getFieldID()));
});
}
}, 3000); // 3000 Millisekunden Delay
} else {
System.err.println("Figur für Spieler " + player.getId() + " nicht gefunden.");
}
}
private int getFieldIDFromPosition(Vector3f position) {
for (int fieldID = 0; fieldID < 40; fieldID++) {
Vector3f fieldPosition = calculateFieldPosition(fieldID, 0);
if (fieldPosition.distance(position) < 0.5f) { // Toleranz für Positionserkennung
return fieldID;
}
}
throw new IllegalArgumentException("Position entspricht keinem gültigen Feld: " + position);
}
/**
* Berechnet den Eckpunkt basierend auf Start- und Zielposition.
*
* @param startPosition Die Startposition der Figur.
* @param targetPosition Die Zielposition der Figur.
* @return Die Position der Ecke, die passiert werden muss.
*/
private Vector3f calculateCornerPosition(Vector3f startPosition, Vector3f targetPosition) {
// Ziel: Immer entlang der Spielfeldkante navigieren
float deltaX = targetPosition.x - startPosition.x;
float deltaZ = targetPosition.z - startPosition.z;
// Überprüfen, ob Bewegung entlang X oder Z-Koordinate zuerst erfolgen soll
if (deltaX != 0 && deltaZ != 0) {
if (Math.abs(deltaX) > Math.abs(deltaZ)) {
// Bewegung entlang X zuerst
return new Vector3f(targetPosition.x, 0, startPosition.z);
} else {
// Bewegung entlang Z zuerst
return new Vector3f(startPosition.x, 0, targetPosition.z);
}
} else {
// Bewegung ist bereits entlang einer Achse (keine Ecke erforderlich)
return targetPosition;
}
}
private List<Vector3f> calculatePath(int startFieldID, int targetFieldID, int playerIndex) {
List<Vector3f> pathPoints = new ArrayList<>();
// Bewegung im Uhrzeigersinn
if (startFieldID < targetFieldID) {
for (int i = startFieldID; i <= targetFieldID; i++) {
// Füge Ecken hinzu, falls sie überschritten werden
if (i == 10 || i == 20 || i == 30 || i == 0) {
pathPoints.add(calculateFieldPosition(i, playerIndex));
}
}
} else {
// Bewegung über das Ende des Spielfelds hinaus (z.B. von 39 zu 5)
for (int i = startFieldID; i < 40; i++) {
if (i == 10 || i == 20 || i == 30 || i == 0) {
pathPoints.add(calculateFieldPosition(i, playerIndex));
}
}
for (int i = 0; i <= targetFieldID; i++) {
if (i == 10 || i == 20 || i == 30 || i == 0) {
pathPoints.add(calculateFieldPosition(i, playerIndex));
}
}
}
// Füge das Ziel hinzu
pathPoints.add(calculateFieldPosition(targetFieldID, playerIndex));
return pathPoints;
}
private int calculatePlayerIndexOnField(int fieldID, int playerID) {
List<Player> playersOnField = playerHandler.getPlayers().stream()
.filter(p -> p.getFieldID() == fieldID)
.toList();
for (int i = 0; i < playersOnField.size(); i++) {
if (playersOnField.get(i).getId() == playerID) {
return i;
}
}
return 0;
}
private void animateMovementAlongPath(com.jme3.scene.Spatial figure, List<Vector3f> pathPoints) {
float animationDurationPerSegment = 2.5f; // Langsamere Animation (2.5 Sekunden pro Segment)
int[] currentSegment = {0};
app.enqueue(() -> {
figure.addControl(new AbstractControl() {
private float elapsedTime = 0.0f;
@Override
protected void controlUpdate(float tpf) {
if (currentSegment[0] >= pathPoints.size() - 1) {
this.setEnabled(false); // Animation abgeschlossen
return;
}
elapsedTime += tpf;
float progress = Math.min(elapsedTime / animationDurationPerSegment, 1.0f);
Vector3f start = pathPoints.get(currentSegment[0]);
Vector3f end = pathPoints.get(currentSegment[0] + 1);
Vector3f interpolatedPosition = start.interpolateLocal(end, progress);
figure.setLocalTranslation(interpolatedPosition);
if (progress >= 1.0f) {
elapsedTime = 0.0f;
currentSegment[0]++;
}
}
@Override
protected void controlRender(RenderManager rm, ViewPort vp) {
// Nicht benötigt
}
});
});
}
@Override
public void receivedEvent(PopUpEvent event) {
if (event.msg().equals("Buy")) {
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
app.enqueue(() -> {
int field = app.getGameLogic().getPlayerHandler().getPlayerById(app.getId()).getFieldID();
Object fieldObject = app.getGameLogic().getBoardManager().getFieldAtIndex(field);
if (fieldObject instanceof BuildingProperty) {
new BuildingPropertyCard(app).open();
} else if (fieldObject instanceof GateField) {
new GateFieldCard(app).open();
} else if (fieldObject instanceof FoodField) {
new FoodFieldCard(app).open();
}
});
}
}, 2500);
} else if (event.msg().equals("Winner")) {
new WinnerPopUp(app).open();
} else if (event.msg().equals("Looser")) {
new LooserPopUp(app).open();
} else if (event.msg().equals("timeout")) {
new TimeOut(app).open();
} else if (event.msg().equals("tradeRequest")) {
new ConfirmTrade(app).open();
} else if (event.msg().equals("goingToJail")) {
new Gulag(app).open();
} else if (event.msg().equals("NoMoneyWarning")) {
new NoMoneyWarning(app).open();
} else if(event.msg().equals("rent")) {
new Rent(app, ( (NotificationMessage) event.message()).getRentOwner(), ( (NotificationMessage) event.message()).getRentAmount() ).open();
} else if (event.msg().equals("jailtryagain")) {
new GulagInfo(app, 1).open();
} else if (event.msg().equals("jailpay")) {
new GulagInfo(app, 3).open();
} else if (event.msg().equals("tradepos")) {
new AcceptTrade(app, (TradeReply) event.message()).open();
} else if (event.msg().equals("tradeneg")) {
new RejectTrade(app, (TradeReply) event.message()).open();
} else if (event.msg().equals("ReceivedRent")) {
new ReceivedRent(app, ( (NotificationMessage) event.message()).getRentOwner(), ( (NotificationMessage) event.message()).getRentAmount() ).open();
}
}
private Vector3f calculateBuildingPosition(int fieldID) {
float baseX = 0.0f;
float baseZ = 0.0f;
switch (fieldID) {
case 0: baseX = -8.4f; baseZ = -7.7f; break;
case 1: baseX = -6.3f; baseZ = -7.7f; break;
case 2: baseX = -4.7f; baseZ = -7.7f; break;
case 3: baseX = -3.1f; baseZ = -7.7f; break;
case 4: baseX = -1.4f; baseZ = -7.7f; break;
case 5: baseX = 0.2f; baseZ = -7.7f; break;
case 6: baseX = 1.8f; baseZ = -7.7f; break;
case 7: baseX = 3.5f; baseZ = -7.7f; break;
case 8: baseX = 5.1f; baseZ = -7.7f; break;
case 9: baseX = 6.7f; baseZ = -7.7f; break;
case 10: baseX = 8.2f; baseZ = -7.7f; break;
case 11: baseX = 8.2f; baseZ = -6.5f; break; //passt
case 12: baseX = 8.2f; baseZ = -4.9f; break; //passt
case 13: baseX = 8.2f; baseZ = -3.3f; break; //passt
case 14: baseX = 8.2f; baseZ = -1.6f; break; //passt
case 15: baseX = 8.2f; baseZ = 0.0f; break; //passt
case 16: baseX = 8.2f; baseZ = 1.6f; break; //passt
case 17: baseX = 8.2f; baseZ = 3.3f; break; //passt
case 18: baseX = 8.2f; baseZ = 4.9f; break; //passt
case 19: baseX = 8.2f; baseZ = 6.5f; break; //passt
case 20: baseX = 8.2f; baseZ = 7.7f; break;
case 21: baseX = 6.5f; baseZ = 7.7f; break;
case 22: baseX = 4.9f; baseZ = 7.7f; break;
case 23: baseX = 3.3f; baseZ = 7.7f; break;
case 24: baseX = 1.6f; baseZ = 7.7f; break;
case 25: baseX = 0.0f; baseZ = 7.7f; break;
case 26: baseX = -1.6f; baseZ = 7.7f; break;
case 27: baseX = -3.3f; baseZ = 7.7f; break;
case 28: baseX = -4.9f; baseZ = 7.7f; break;
case 29: baseX = -6.5f; baseZ = 7.7f; break;
case 30: baseX = -7.2f; baseZ = 7.7f; break;
case 31: baseX = -7.2f; baseZ = 6.5f; break;
case 32: baseX = -7.2f; baseZ = 4.9f; break;
case 33: baseX = -7.2f; baseZ = 3.3f; break;
case 34: baseX = -7.2f; baseZ = 1.6f; break;
case 35: baseX = -7.2f; baseZ = 0.0f; break;
case 36: baseX = -7.2f; baseZ = -1.6f; break;
case 37: baseX = -7.2f; baseZ = -3.3f; break;
case 38: baseX = -7.2f; baseZ = -4.9f; break;
case 39: baseX = -7.2f; baseZ = -6.5f; break;
default: throw new IllegalArgumentException("Ungültige Feld-ID: " + fieldID);
}
return new Vector3f(baseX, 0, baseZ);
}
private void updateHousesOnBoard() {
app.enqueue(() -> {
List<BuildingProperty> propertiesWithBuildings = app.getGameLogic().getBoardManager().getPropertiesWithBuildings();
for (BuildingProperty property : propertiesWithBuildings) {
int houseCount = property.getHouses();
int hotelCount = property.getHotel();
String uniqueIdentifier = "Building_" + property.getId() + "_" + (hotelCount > 0 ? "Hotel" : houseCount);
if (existingHouses.contains(uniqueIdentifier)) continue;
try {
String modelPath = hotelCount > 0
? "models/Hotel/Hotel.j3o"
: "models/Haus/" + houseCount + "Haus.j3o";
com.jme3.scene.Spatial buildingModel = app.getAssetManager().loadModel(modelPath);
Material mat = new Material(app.getAssetManager(), "Common/MatDefs/Light/Lighting.j3md");
buildingModel.setMaterial(mat);
buildingModel.setLocalScale(0.5f);
Vector3f position = calculateBuildingPosition(property.getId()).add(0, 0.5f, 0);
buildingModel.setLocalTranslation(position);
com.jme3.math.Quaternion rotation = new com.jme3.math.Quaternion();
if (property.getId() >= 1 && property.getId() <= 10) {
rotation.fromAngleAxis(FastMath.HALF_PI, Vector3f.UNIT_Y);
} else if (property.getId() >= 21 && property.getId() <= 30) {
rotation.fromAngleAxis(3 * FastMath.HALF_PI, Vector3f.UNIT_Y);
} else if (property.getId() >= 31 && property.getId() <= 39) {
rotation.fromAngleAxis(FastMath.PI, Vector3f.UNIT_Y);
}
buildingModel.setLocalRotation(rotation);
buildingModel.setName(uniqueIdentifier);
app.getRootNode().attachChild(buildingModel);
existingHouses.add(uniqueIdentifier);
} catch (Exception e) {
System.err.println("Fehler beim Hinzufügen eines Gebäudes: " + e.getMessage());
}
}
});
}
@Override
public void receivedEvent(EventCardEvent event) {
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
app.enqueue(() -> new EventCardPopup(app, event.description()).open());
}
}, 2500);
}
@Override
public void receivedEvent(UpdatePlayerView event) {
this.playerHandler = app.getGameLogic().getPlayerHandler();
for (Player player : playerHandler.getPlayers()) {
movePlayerFigure(player);
}
updateHousesOnBoard();
}
}

BIN
Projekte/monopoly/client/src/main/resources/Pictures/Backdrop/backdrop.jpg
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 8.0 KiB

6
Projekte/monopoly/model/src/main/java/pp/monopoly/game/client/ActiveState.java
View File

@ -1,4 +1,5 @@
package pp.monopoly.game.client; package pp.monopoly.game.client;
/** /**
* Represents the active client state in the Monopoly game. * Represents the active client state in the Monopoly game.
* Extends {@link ClientState}. * Extends {@link ClientState}.
@ -14,9 +15,4 @@ public class ActiveState extends ClientState {
ActiveState(ClientGameLogic logic) { ActiveState(ClientGameLogic logic) {
super(logic); super(logic);
} }
@Override
boolean isTurn() {
return true;
}
} }

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

@ -5,12 +5,8 @@ import java.lang.System.Logger.Level;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import com.jme3.math.Vector3f;
import pp.monopoly.game.server.Player;
import pp.monopoly.game.server.PlayerHandler; import pp.monopoly.game.server.PlayerHandler;
import pp.monopoly.message.client.ClientMessage; import pp.monopoly.message.client.ClientMessage;
import pp.monopoly.message.server.BuildInfo;
import pp.monopoly.message.server.BuyPropertyRequest; import pp.monopoly.message.server.BuyPropertyRequest;
import pp.monopoly.message.server.DiceResult; import pp.monopoly.message.server.DiceResult;
import pp.monopoly.message.server.EventDrawCard; import pp.monopoly.message.server.EventDrawCard;
@ -26,13 +22,9 @@ import pp.monopoly.message.server.TradeReply;
import pp.monopoly.message.server.TradeRequest; import pp.monopoly.message.server.TradeRequest;
import pp.monopoly.message.server.ViewAssetsResponse; import pp.monopoly.message.server.ViewAssetsResponse;
import pp.monopoly.model.Board; import pp.monopoly.model.Board;
import pp.monopoly.model.Figure; import pp.monopoly.model.IntPoint;
import pp.monopoly.model.Hotel;
import pp.monopoly.model.House;
import pp.monopoly.model.Rotation;
import pp.monopoly.model.TradeHandler; import pp.monopoly.model.TradeHandler;
import pp.monopoly.model.fields.BoardManager; import pp.monopoly.model.fields.BoardManager;
import pp.monopoly.model.fields.BuildingProperty;
import pp.monopoly.notification.ClientStateEvent; import pp.monopoly.notification.ClientStateEvent;
import pp.monopoly.notification.DiceRollEvent; import pp.monopoly.notification.DiceRollEvent;
import pp.monopoly.notification.ButtonStatusEvent; import pp.monopoly.notification.ButtonStatusEvent;
@ -41,7 +33,6 @@ import pp.monopoly.notification.GameEvent;
import pp.monopoly.notification.GameEventBroker; import pp.monopoly.notification.GameEventBroker;
import pp.monopoly.notification.GameEventListener; import pp.monopoly.notification.GameEventListener;
import pp.monopoly.notification.InfoTextEvent; import pp.monopoly.notification.InfoTextEvent;
import pp.monopoly.notification.ItemAddedEvent;
import pp.monopoly.notification.PopUpEvent; import pp.monopoly.notification.PopUpEvent;
import pp.monopoly.notification.Sound; import pp.monopoly.notification.Sound;
import pp.monopoly.notification.SoundEvent; import pp.monopoly.notification.SoundEvent;
@ -63,7 +54,7 @@ public class ClientGameLogic implements ServerInterpreter, GameEventBroker {
private final List<GameEventListener> listeners = new ArrayList<>(); private final List<GameEventListener> listeners = new ArrayList<>();
/** The game board representing the player's current state. */ /** The game board representing the player's current state. */
private Board board = new Board(10, 10, this); private Board board;
/** The current state of the client game logic. */ /** The current state of the client game logic. */
private ClientState state = new LobbyState(this); private ClientState state = new LobbyState(this);
@ -130,6 +121,15 @@ public class ClientGameLogic implements ServerInterpreter, GameEventBroker {
return tradeHandler; return tradeHandler;
} }
/**
* 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. * Sets the informational text to be displayed to the player.
* *
@ -204,21 +204,32 @@ public class ClientGameLogic implements ServerInterpreter, GameEventBroker {
state.update(delta); state.update(delta);
} }
public boolean isTurn() { /**
return state.isTurn(); * Handles the result of a dice roll.
} *
* @param msg the message containing the dice roll result
*/
@Override @Override
public void received(DiceResult msg) { public void received(DiceResult msg) {
playSound(Sound.DICE_ROLL); playSound(Sound.DICE_ROLL);
notifyListeners(new DiceRollEvent(msg.getRollResult().get(0), msg.getRollResult().get(1))); notifyListeners(new DiceRollEvent(msg.getRollResult().get(0), msg.getRollResult().get(1)));
} }
/**
* Handles drawing an event card.
*
* @param msg the message containing the drawn card details
*/
@Override @Override
public void received(EventDrawCard msg) { public void received(EventDrawCard msg) {
notifyListeners(new EventCardEvent(msg.getCardDescription())); notifyListeners(new EventCardEvent(msg.getCardDescription()));
} }
/**
* Handles the game over message.
*
* @param msg the message containing game over details
*/
@Override @Override
public void received(GameOver msg) { public void received(GameOver msg) {
if (msg.isWinner()) { if (msg.isWinner()) {
@ -230,17 +241,23 @@ public class ClientGameLogic implements ServerInterpreter, GameEventBroker {
} }
} }
/**
* Handles the start of the game.
*
* @param msg the game start message
*/
@Override @Override
public void received(GameStart msg) { public void received(GameStart msg) {
playerHandler = msg.getPlayerHandler(); playerHandler = msg.getPlayerHandler();
setState(new WaitForTurnState(this)); setState(new WaitForTurnState(this));
for (Player player : playerHandler.getPlayers()) {
board.add(new Figure(Vector3f.ZERO, Rotation.NORTH, player.getFigure()));
}
notifyListeners(new ButtonStatusEvent(false)); notifyListeners(new ButtonStatusEvent(false));
notifyListeners(new UpdatePlayerView());
} }
/**
* Handles jail-related events.
*
* @param msg the message containing jail event details
*/
@Override @Override
public void received(JailEvent msg) { public void received(JailEvent msg) {
if (msg.isGoingToJail()) { if (msg.isGoingToJail()) {
@ -249,6 +266,11 @@ public class ClientGameLogic implements ServerInterpreter, GameEventBroker {
} }
} }
/**
* Updates the status of a player.
*
* @param msg the message containing player status update details
*/
@Override @Override
public void received(PlayerStatusUpdate msg) { public void received(PlayerStatusUpdate msg) {
playerHandler = msg.getPlayerHandler(); playerHandler = msg.getPlayerHandler();
@ -256,16 +278,31 @@ public class ClientGameLogic implements ServerInterpreter, GameEventBroker {
notifyListeners(new UpdatePlayerView()); notifyListeners(new UpdatePlayerView());
} }
/**
* Handles timeout warnings.
*
* @param msg the message containing timeout warning details
*/
@Override @Override
public void received(TimeOutWarning msg) { public void received(TimeOutWarning msg) {
notifyListeners(new PopUpEvent("timeout", msg)); notifyListeners(new PopUpEvent("timeout", msg));
} }
/**
* Displays the player's assets in response to a server query.
*
* @param msg the message containing the player's assets
*/
@Override @Override
public void received(ViewAssetsResponse msg) { public void received(ViewAssetsResponse msg) {
boardManager = msg.getboard(); boardManager = msg.getboard();
} }
/**
* Handles trade replies from other players.
*
* @param msg the message containing the trade reply
*/
@Override @Override
public void received(TradeReply msg) { public void received(TradeReply msg) {
if (msg.isAccepted()) { if (msg.isAccepted()) {
@ -277,15 +314,24 @@ public class ClientGameLogic implements ServerInterpreter, GameEventBroker {
} }
} }
/**
* Handles trade requests from other players.
*
* @param msg the message containing the trade request details
*/
@Override @Override
public void received(TradeRequest msg) { public void received(TradeRequest msg) {
tradeHandler = msg.getTradeHandler(); tradeHandler = msg.getTradeHandler();
notifyListeners(new PopUpEvent("tradeRequest", msg)); notifyListeners(new PopUpEvent("tradeRequest", msg));
} }
/**
* Handles the transition to the next player's turn.
*
* @param msg the message indicating it's the next player's turn
*/
@Override @Override
public void received(NextPlayerTurn msg) { public void received(NextPlayerTurn msg) {
setState(new ActiveState(this));
notifyListeners(new ButtonStatusEvent(true)); notifyListeners(new ButtonStatusEvent(true));
} }
@ -311,18 +357,4 @@ public class ClientGameLogic implements ServerInterpreter, GameEventBroker {
notifyListeners(new PopUpEvent("ReceivedRent", msg)); notifyListeners(new PopUpEvent("ReceivedRent", msg));
} }
} }
@Override
public void received(BuildInfo msg) {
System.out.println("TRIGGER BUILD INFO");
if (msg.isAdded()) {
BuildingProperty property = ((BuildingProperty)boardManager.getFieldAtIndex(msg.getId()));
if (property.getHotel() == 1 ) {
board.add(new Hotel(property.getId()));
} else {
board.add(new House( property.getHouses(), property.getId()));
}
}
}
} }

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

@ -11,11 +11,7 @@ import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.lang.System.Logger.Level; import java.lang.System.Logger.Level;
import pp.monopoly.message.server.GameStart; import pp.monopoly.model.IntPoint;
import pp.monopoly.message.server.NextPlayerTurn;
import pp.monopoly.message.server.NotificationMessage;
import pp.monopoly.message.server.PlayerStatusUpdate;
import pp.monopoly.message.server.ViewAssetsResponse;
/** /**
* Defines the behavior and state transitions for the client-side game logic in Monopoly. * Defines the behavior and state transitions for the client-side game logic in Monopoly.
@ -58,39 +54,17 @@ abstract class ClientState {
* *
* @return true if the player's turn should be shown, false otherwise * @return true if the player's turn should be shown, false otherwise
*/ */
boolean isTurn() { boolean showTurn() {
return false; return false;
} }
/** /**
* Starts the battle based on the server message. * Moves the preview figure to the specified position on the game board.
* *
* @param msg the message indicating whose turn it is to shoot * @param pos the new position for the preview figure
*/ */
void receivedGameStart(GameStart msg) { void movePreview(IntPoint pos) {
ClientGameLogic.LOGGER.log(Level.ERROR, "receivedGameStart not allowed in {0}", getName()); //NON-NLS ClientGameLogic.LOGGER.log(Level.DEBUG, "movePreview has no effect in {0}", getName()); //NON-NLS
}
/**
* Updateds the view based on the new player status.
*
* @param msg the message containing the new player status
*/
void recivedPlayerStatusUpdate(PlayerStatusUpdate msg) {
ClientGameLogic.LOGGER.log(Level.ERROR, "recivedPlayerStatusUpdate not allowed in {0}", getName()); //NON-NLS
}
void recivedNextPlayerTurn(NextPlayerTurn msg) {
ClientGameLogic.LOGGER.log(Level.ERROR, "recivedNextPlayerTurn not allowed in {0}", getName()); //NON-NLS
}
void recivedNotificationMessage(NotificationMessage msg) {
ClientGameLogic.LOGGER.log(Level.ERROR, "recivedNotificationMessage not allowed in {0}", getName()); //NON-NLS
}
void recivedViewAssetsResponse(ViewAssetsResponse msg) {
ClientGameLogic.LOGGER.log(Level.ERROR, "recivedViewAssetsResponse not allowed in {0}", getName()); //NON-NLS
} }
/** /**

7
Projekte/monopoly/model/src/main/java/pp/monopoly/game/client/LobbyState.java
View File

@ -1,7 +1,5 @@
package pp.monopoly.game.client; package pp.monopoly.game.client;
import pp.monopoly.message.server.GameStart;
/** /**
* Represents the lobby state of the client in the Monopoly game. * Represents the lobby state of the client in the Monopoly game.
* Extends {@link ClientState}. * Extends {@link ClientState}.
@ -16,9 +14,4 @@ public class LobbyState extends ClientState {
LobbyState(ClientGameLogic logic) { LobbyState(ClientGameLogic logic) {
super(logic); super(logic);
} }
@Override
void receivedGameStart(GameStart msg) {
logic.setState(new WaitForTurnState(logic));
}
} }

12
Projekte/monopoly/model/src/main/java/pp/monopoly/game/client/WaitForTurnState.java
View File

@ -1,7 +1,5 @@
package pp.monopoly.game.client; package pp.monopoly.game.client;
import pp.monopoly.message.server.NextPlayerTurn;
/** /**
* Represents the state where the client is waiting for their turn in the Monopoly game. * Represents the state where the client is waiting for their turn in the Monopoly game.
* Extends {@link ClientState}. * Extends {@link ClientState}.
@ -16,14 +14,4 @@ public class WaitForTurnState extends ClientState {
WaitForTurnState(ClientGameLogic logic) { WaitForTurnState(ClientGameLogic logic) {
super(logic); super(logic);
} }
@Override
boolean isTurn() {
return true;
}
@Override
void recivedNextPlayerTurn(NextPlayerTurn msg) {
logic.setState(new ActiveState(logic));
}
} }

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

@ -23,6 +23,7 @@ import pp.monopoly.message.server.NextPlayerTurn;
import pp.monopoly.message.server.NotificationMessage; import pp.monopoly.message.server.NotificationMessage;
import pp.monopoly.message.server.PlayerStatusUpdate; import pp.monopoly.message.server.PlayerStatusUpdate;
import pp.monopoly.model.FieldVisitor; import pp.monopoly.model.FieldVisitor;
import pp.monopoly.model.Figure;
import pp.monopoly.model.card.Card; import pp.monopoly.model.card.Card;
import pp.monopoly.model.fields.BuildingProperty; import pp.monopoly.model.fields.BuildingProperty;
import pp.monopoly.model.fields.EventField; import pp.monopoly.model.fields.EventField;
@ -43,7 +44,7 @@ public class Player implements FieldVisitor<Void>{
private final int id; private final int id;
private String name; private String name;
private int accountBalance = 15000; private int accountBalance = 15000;
private String figure; private Figure figure;
private Set<Integer> properties = new HashSet<>(); private Set<Integer> properties = new HashSet<>();
private int getOutOfJailCard; private int getOutOfJailCard;
private int fieldID; private int fieldID;
@ -81,19 +82,11 @@ public class Player implements FieldVisitor<Void>{
this.handler = handler; this.handler = handler;
} }
/** public void setFigure(Figure figure) {
* Set the figure of the player
* @param figure the figure to be set
*/
public void setFigure(String figure) {
this.figure = figure; this.figure = figure;
} }
/** public Figure getFigure(){
* Returns the figure of the player
* @return the figure of the player
*/
public String getFigure() {
return figure; return figure;
} }
@ -187,6 +180,7 @@ public class Player implements FieldVisitor<Void>{
earnMoney(2000); // Passing GO gives money earnMoney(2000); // Passing GO gives money
} }
fieldID = (fieldID + steps) % 40; fieldID = (fieldID + steps) % 40;
figure.moveTo(fieldID);
handler.getLogic().send(this, new PlayerStatusUpdate(handler)); handler.getLogic().send(this, new PlayerStatusUpdate(handler));
handler.getLogic().getBoardManager().getFieldAtIndex(fieldID).accept(this); handler.getLogic().getBoardManager().getFieldAtIndex(fieldID).accept(this);
return fieldID; return fieldID;
@ -200,6 +194,7 @@ public class Player implements FieldVisitor<Void>{
public int setPosition(int position){ public int setPosition(int position){
if(position < 40 && position >= 0) { if(position < 40 && position >= 0) {
fieldID = position; fieldID = position;
figure.moveTo(fieldID);
handler.getLogic().send(this, new PlayerStatusUpdate(handler)); handler.getLogic().send(this, new PlayerStatusUpdate(handler));
handler.getLogic().getBoardManager().getFieldAtIndex(fieldID).accept(this); handler.getLogic().getBoardManager().getFieldAtIndex(fieldID).accept(this);
} }
@ -217,6 +212,7 @@ public class Player implements FieldVisitor<Void>{
earnMoney(2000); earnMoney(2000);
} }
fieldID = position; fieldID = position;
figure.moveTo(fieldID);
handler.getLogic().send(this, new PlayerStatusUpdate(handler)); handler.getLogic().send(this, new PlayerStatusUpdate(handler));
handler.getLogic().getBoardManager().getFieldAtIndex(fieldID).accept(this); handler.getLogic().getBoardManager().getFieldAtIndex(fieldID).accept(this);
} }

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

@ -3,10 +3,10 @@ package pp.monopoly.game.server;
import java.lang.System.Logger; import java.lang.System.Logger;
import java.lang.System.Logger.Level; import java.lang.System.Logger.Level;
import java.util.HashSet; import java.util.HashSet;
import java.util.List;
import java.util.Set; import java.util.Set;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import pp.monopoly.MonopolyConfig; import pp.monopoly.MonopolyConfig;
import pp.monopoly.message.client.AlterProperty; import pp.monopoly.message.client.AlterProperty;
import pp.monopoly.message.client.BuyPropertyResponse; import pp.monopoly.message.client.BuyPropertyResponse;
@ -18,7 +18,6 @@ import pp.monopoly.message.client.RollDice;
import pp.monopoly.message.client.TradeOffer; import pp.monopoly.message.client.TradeOffer;
import pp.monopoly.message.client.TradeResponse; import pp.monopoly.message.client.TradeResponse;
import pp.monopoly.message.client.ViewAssetsRequest; import pp.monopoly.message.client.ViewAssetsRequest;
import pp.monopoly.message.server.BuildInfo;
import pp.monopoly.message.server.GameOver; import pp.monopoly.message.server.GameOver;
import pp.monopoly.message.server.GameStart; import pp.monopoly.message.server.GameStart;
import pp.monopoly.message.server.NextPlayerTurn; import pp.monopoly.message.server.NextPlayerTurn;
@ -27,6 +26,8 @@ import pp.monopoly.message.server.ServerMessage;
import pp.monopoly.message.server.TradeReply; import pp.monopoly.message.server.TradeReply;
import pp.monopoly.message.server.TradeRequest; import pp.monopoly.message.server.TradeRequest;
import pp.monopoly.message.server.ViewAssetsResponse; import pp.monopoly.message.server.ViewAssetsResponse;
import pp.monopoly.model.Figure;
import pp.monopoly.model.Rotation;
import pp.monopoly.model.TradeHandler; import pp.monopoly.model.TradeHandler;
import pp.monopoly.model.card.DeckHelper; import pp.monopoly.model.card.DeckHelper;
import pp.monopoly.model.fields.BoardManager; import pp.monopoly.model.fields.BoardManager;
@ -94,17 +95,6 @@ public class ServerGameLogic implements ClientInterpreter {
} }
} }
/**
* Sends a message to all players in the game.
*
* @param msg the ServerMessage to send
*/
void sendAll(ServerMessage msg) {
for (Player player : playerHandler.getPlayers()) {
send(player, msg);
}
}
/** /**
* Adds a new player to the game if the game is in the LOBBY state and the maximum * Adds a new player to the game if the game is in the LOBBY state and the maximum
* player limit has not been reached. * player limit has not been reached.
@ -219,8 +209,7 @@ public class ServerGameLogic implements ClientInterpreter {
String name = msg.getName(); String name = msg.getName();
String truc = name.length() > 10 ? name.substring(0, 15) : name; String truc = name.length() > 10 ? name.substring(0, 15) : name;
player.setName(truc); player.setName(truc);
player.setFigure(msg.getFigure()); player.setFigure(new Figure(1, -10, -10, Rotation.LEFT, msg.getFigure()));
// board.addFigure(figure);
playerHandler.setPlayerReady(player, true); playerHandler.setPlayerReady(player, true);
LOGGER.log(Level.DEBUG, "Player {0} is ready", player.getName()); LOGGER.log(Level.DEBUG, "Player {0} is ready", player.getName());
} }
@ -418,8 +407,6 @@ public class ServerGameLogic implements ClientInterpreter {
for (BuildingProperty field : properties.stream().map(p -> (BuildingProperty) p).collect(Collectors.toList())) { for (BuildingProperty field : properties.stream().map(p -> (BuildingProperty) p).collect(Collectors.toList())) {
if (boardManager.canBuild(field) && sender.getAccountBalance() >= field.getHousePrice()) { if (boardManager.canBuild(field) && sender.getAccountBalance() >= field.getHousePrice()) {
field.build(); field.build();
updateAllPlayers();
sendAll( new BuildInfo(field.getId(), true));
sender.pay(field.getHousePrice()); sender.pay(field.getHousePrice());
} }
} }
@ -427,12 +414,11 @@ public class ServerGameLogic implements ClientInterpreter {
for (BuildingProperty field : properties.stream().map(p -> (BuildingProperty) p).collect(Collectors.toList())) { for (BuildingProperty field : properties.stream().map(p -> (BuildingProperty) p).collect(Collectors.toList())) {
if (boardManager.canSell(field)) { if (boardManager.canSell(field)) {
field.sell(); field.sell();
updateAllPlayers();
sendAll( new BuildInfo(field.getId(), false));
sender.earnMoney(field.getHousePrice() / 2); sender.earnMoney(field.getHousePrice() / 2);
} }
} }
} }
updateAllPlayers(); updateAllPlayers();
} }
@ -443,9 +429,9 @@ public class ServerGameLogic implements ClientInterpreter {
} else if (msg.getKeyword().equals("PayJail")) { } else if (msg.getKeyword().equals("PayJail")) {
playerHandler.getPlayerById(from).payBail(); playerHandler.getPlayerById(from).payBail();
} else if(msg.getKeyword().equals("hack")) { } else if(msg.getKeyword().equals("hack")) {
// for (BuildingProperty bp : boardManager.getPropertyFields( List.of(1,3)).stream().filter(p -> p instanceof BuildingProperty).map(p -> (BuildingProperty) p).collect(Collectors.toList())) { for (BuildingProperty bp : boardManager.getPropertyFields( List.of(1,3)).stream().filter(p -> p instanceof BuildingProperty).map(p -> (BuildingProperty) p).collect(Collectors.toList())) {
// bp.build(); bp.build();
// } }
for(PropertyField field : boardManager.getBoard().stream().filter(p -> p instanceof PropertyField).map(p -> (PropertyField) p).collect(Collectors.toList())) { for(PropertyField field : boardManager.getBoard().stream().filter(p -> p instanceof PropertyField).map(p -> (PropertyField) p).collect(Collectors.toList())) {
field.setOwner(playerHandler.getPlayerById(0)); field.setOwner(playerHandler.getPlayerById(0));
playerHandler.getPlayerById(0).addProperty(field.getId()); playerHandler.getPlayerById(0).addProperty(field.getId());

34
Projekte/monopoly/model/src/main/java/pp/monopoly/message/server/BuildInfo.java
View File

@ -1,34 +0,0 @@
package pp.monopoly.message.server;
import com.jme3.network.serializing.Serializable;
@Serializable
public class BuildInfo extends ServerMessage {
private final int id;
private final boolean added;
private BuildInfo() {
this(0, false);
}
public BuildInfo(int id, boolean added) {
this.id = id;
this.added = added;
}
public int getId() {
return id;
}
public boolean isAdded() {
return added;
}
@Override
public void accept(ServerInterpreter interpreter) {
interpreter.received(this);
}
}

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

@ -91,23 +91,16 @@ public interface ServerInterpreter {
void received(NextPlayerTurn msg); void received(NextPlayerTurn msg);
/** /**
* Handles a BuyPropertyRequest message received from the server. * Handles a NextPlayerTurn message received from the server.
* *
* @param msg the BuyPropertyRequest message received * @param msg the NextPlayerTurn message received
*/ */
void received(BuyPropertyRequest msg); void received(BuyPropertyRequest msg);
/** /**
* Handles a NotificationMessage message received from the server. * Handles a NextPlayerTurn message received from the server.
* *
* @param msg the NotificationMessage message received * @param msg the NextPlayerTurn message received
*/ */
void received(NotificationMessage msg); void received(NotificationMessage msg);
/**
* Handles a BuildInfo message received from the server.
*
* @param msg the BuildInfo message received
*/
void received(BuildInfo msg);
} }

91
Projekte/monopoly/model/src/main/java/pp/monopoly/model/Board.java
View File

@ -1,3 +1,10 @@
////////////////////////////////////////
// Programming project code
// UniBw M, 2022, 2023, 2024
// www.unibw.de/inf2
// (c) Mark Minas (mark.minas@unibw.de)
////////////////////////////////////////
package pp.monopoly.model; package pp.monopoly.model;
import java.util.ArrayList; import java.util.ArrayList;
@ -59,34 +66,7 @@ public class Board {
*/ */
private void addItem(Item item) { private void addItem(Item item) {
items.add(item); items.add(item);
notifyListeners(new ItemAddedEvent(this, item)); notifyListeners((GameEvent) new ItemAddedEvent(item, null));
}
/**
* Adds a figure to the map and triggers an item addition event.
*
* @param figure the figure to be added to the map
*/
public void add(Figure figure) {
addItem(figure);
}
/**
* Adds a house to the map and triggers an item addition event.
*
* @param house the house to be added to the map
*/
public void add(House house) {
addItem(house);
}
/**
* Adds a hotel to the map and triggers an item addition event.
*
* @param hotel the hotel to be added to the map
*/
public void add(Hotel hotel) {
addItem(hotel);
} }
/** /**
@ -96,11 +76,7 @@ public class Board {
*/ */
public void remove(Item item) { public void remove(Item item) {
items.remove(item); items.remove(item);
notifyListeners((GameEvent) new ItemRemovedEvent(this, item)); notifyListeners((GameEvent) new ItemRemovedEvent(item, null)); // Falls es ein entsprechendes ItemRemovedEvent gibt
}
public void removePlayers() {
items.removeIf(item -> item instanceof Figure);
} }
/** /**
@ -120,33 +96,6 @@ public class Board {
private <T extends Item> Stream<T> getItems(Class<T> clazz) { private <T extends Item> Stream<T> getItems(Class<T> clazz) {
return items.stream().filter(clazz::isInstance).map(clazz::cast); return items.stream().filter(clazz::isInstance).map(clazz::cast);
} }
/**
* Returns a stream of all figures currently on the map.
*
* @return a stream of all figures on the map
*/
public Stream<Figure> getFigures() {
return getItems(Figure.class);
}
/**
* Returns a stream of all houses currently on the map.
*
* @return a stream of all houses on the map
*/
public Stream<House> getHouses() {
return getItems(House.class);
}
/**
* Returns a stream of all hotels currently on the map.
*
* @return a stream of all hotels on the map
*/
public Stream<Hotel> getHotels() {
return getItems(Hotel.class);
}
/** /**
* Returns an unmodifiable list of all items currently on the map. * Returns an unmodifiable list of all items currently on the map.
@ -175,6 +124,28 @@ public class Board {
return height; 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. * Returns a string representation of the map.
* *

275
Projekte/monopoly/model/src/main/java/pp/monopoly/model/Figure.java
View File

@ -1,22 +1,28 @@
package pp.monopoly.model; package pp.monopoly.model;
import java.util.Random; import static java.lang.Math.max;
import static java.lang.Math.min;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import com.jme3.math.Vector3f;
import com.jme3.network.serializing.Serializable; import com.jme3.network.serializing.Serializable;
@Serializable @Serializable
public class Figure implements Item{ public class Figure implements Item{
private final String type; private final String type;
private Vector3f position; 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 Rotation rot; // The rotation 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, * Default constructor for serialization. Initializes a Figure with length 0,
* at position (0, 0), with a default rotation of NORTH. * at position (0, 0), with a default rotation of RIGHT.
*/ */
private Figure() { private Figure() {
this(null, Rotation.NORTH, ""); this(0, 0, 0, Rotation.RIGHT, "cube");
} }
/** /**
@ -24,12 +30,14 @@ public class Figure implements Item{
* *
* @param length the length of the Figure * @param length the length of the Figure
* @param x the x-coordinate of the Figure's initial position * @param x the x-coordinate of the Figure's initial position
* @param z the z-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 * @param rot the rotation of the Figure
*/ */
public Figure(Vector3f position, Rotation rot, String type) { public Figure(int length, int x, int y, Rotation rot, String type) {
this.position = calculateFieldPosition(0); this.x = x;
this.y = y;
this.rot = rot; this.rot = rot;
this.length = length;
this.type = type; this.type = type;
} }
@ -38,17 +46,8 @@ public class Figure implements Item{
* *
* @return the x-coordinate of the Figure * @return the x-coordinate of the Figure
*/ */
public float getX() { public int getX() {
return position.getX(); return x;
}
/**
* Returns the current z-coordinate of the Figure's position.
*
* @return the z-coordinate of the Figure
*/
public float getZ() {
return position.getZ();
} }
/** /**
@ -56,17 +55,19 @@ public class Figure implements Item{
* *
* @return the y-coordinate of the Figure * @return the y-coordinate of the Figure
*/ */
public float getY() { public int getY() {
return position.getY(); return y;
} }
/** /**
* Returns the current position of the Figure. * Moves the Figure to the specified coordinates.
* *
* @return the position of the Figure * @param x the new x-coordinate of the Figure's position
* @param y the new y-coordinate of the Figure's position
*/ */
public Vector3f getPos() { public void moveTo(int x, int y) {
return position; this.x = x;
this.y = y;
} }
/** /**
@ -74,8 +75,8 @@ public class Figure implements Item{
* *
* @param pos the new position of the Figure * @param pos the new position of the Figure
*/ */
public void moveTo(Vector3f pos) { public void moveTo(IntPosition pos) {
position = pos; moveTo(pos.getX(), pos.getY());
} }
/** /**
@ -84,62 +85,85 @@ public class Figure implements Item{
* @param fieldId the position to move to * @param fieldId the position to move to
*/ */
public void moveTo(int fieldId) { public void moveTo(int fieldId) {
moveTo(calculateFieldPosition(fieldId)); moveTo(fieldIdToPosition(fieldId));
} }
private Vector3f calculateFieldPosition(int fieldID) { private IntPoint fieldIdToPosition(int fieldId) {
float baseX = 0.0f; if (fieldId < 0 || fieldId > 39) {
float baseZ = 0.0f; throw new IllegalArgumentException("Invalid fieldId: " + fieldId);
switch (fieldID) {
case 0: baseX = -9.1f; baseZ = -9.1f; break;
case 1: baseX = -6.5f; baseZ = -9.1f; break;
case 2: baseX = -4.9f; baseZ = -9.1f; break;
case 3: baseX = -3.3f; baseZ = -9.1f; break;
case 4: baseX = -1.6f; baseZ = -9.1f; break;
case 5: baseX = 0.0f; baseZ = -9.1f; break;
case 6: baseX = 1.6f; baseZ = -9.1f; break;
case 7: baseX = 3.3f; baseZ = -9.1f; break;
case 8: baseX = 4.9f; baseZ = -9.1f; break;
case 9: baseX = 6.5f; baseZ = -9.1f; break;
case 10: baseX = 9.1f; baseZ = -9.1f; break;
case 11: baseX = 9.1f; baseZ = -6.5f; break;
case 12: baseX = 9.1f; baseZ = -4.9f; break;
case 13: baseX = 9.1f; baseZ = -3.3f; break;
case 14: baseX = 9.1f; baseZ = -1.6f; break;
case 15: baseX = 9.1f; baseZ = 0.0f; break;
case 16: baseX = 9.1f; baseZ = 1.6f; break;
case 17: baseX = 9.1f; baseZ = 3.3f; break;
case 18: baseX = 9.1f; baseZ = 4.9f; break;
case 19: baseX = 9.1f; baseZ = 6.5f; break;
case 20: baseX = 9.1f; baseZ = 9.1f; break;
case 21: baseX = 6.5f; baseZ = 9.1f; break;
case 22: baseX = 4.9f; baseZ = 9.1f; break;
case 23: baseX = 3.3f; baseZ = 9.1f; break;
case 24: baseX = 1.6f; baseZ = 9.1f; break;
case 25: baseX = 0.0f; baseZ = 9.1f; break;
case 26: baseX = -1.6f; baseZ = 9.1f; break;
case 27: baseX = -3.3f; baseZ = 9.1f; break;
case 28: baseX = -4.9f; baseZ = 9.1f; break;
case 29: baseX = -6.5f; baseZ = 9.1f; break;
case 30: baseX = -9.1f; baseZ = 9.1f; break;
case 31: baseX = -9.1f; baseZ = 6.5f; break;
case 32: baseX = -9.1f; baseZ = 4.9f; break;
case 33: baseX = -9.1f; baseZ = 3.3f; break;
case 34: baseX = -9.1f; baseZ = 1.6f; break;
case 35: baseX = -9.1f; baseZ = 0.0f; break;
case 36: baseX = -9.1f; baseZ = -1.6f; break;
case 37: baseX = -9.1f; baseZ = -3.3f; break;
case 38: baseX = -9.1f; baseZ = -4.9f; break;
case 39: baseX = -9.1f; baseZ = -6.5f; break;
default: throw new IllegalArgumentException("Ungültige Feld-ID: " + fieldID);
} }
float xOffset = new Random().nextFloat(); // Determine which edge and position along the edge
float zOffset = new Random().nextFloat(); if (fieldId <= 9) {
// Bottom edge: From (-10, -10) to (10, -10)
int x = -10 + fieldId * 2;
return new IntPoint(x, -10);
} else if (fieldId <= 19) {
// Right edge: From (10, -10) to (10, 10)
int y = -10 + (fieldId - 10) * 2;
return new IntPoint(10, y);
} else if (fieldId <= 29) {
// Top edge: From (10, 10) to (-10, 10)
int x = 10 - (fieldId - 20) * 2;
return new IntPoint(x, 10);
} else {
// Left edge: From (-10, 10) to (-10, -10)
int y = 10 - (fieldId - 30) * 2;
return new IntPoint(-10, y);
}
}
//TODO adjust y pos private Rotation fieldIdToRotation(int fieldId) {
return new Vector3f(baseX + xOffset, 1, baseZ + zOffset); if (fieldId >= 0 && fieldId <= 10) return Rotation.DOWN;
else if (fieldId <= 20) return Rotation.LEFT;
else if (fieldId <= 30) return Rotation.UP;
else if (fieldId <= 39) return Rotation.RIGHT;
else throw new IllegalArgumentException();
}
/**
* 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());
} }
/** /**
@ -160,6 +184,99 @@ public class Figure implements Item{
this.rot = 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, * Returns a string representation of the Figure, including its length, position,
* and rotation. * and rotation.
@ -168,7 +285,7 @@ public class Figure implements Item{
*/ */
@Override @Override
public String toString() { public String toString() {
return "Figur{ x=" + position.getX() + ", z=" + position.getZ() + ", rot=" + rot + '}'; //NON-NLS return "Ship{length=" + length + ", x=" + x + ", y=" + y + ", rot=" + rot + '}'; //NON-NLS
} }
/** /**

99
Projekte/monopoly/model/src/main/java/pp/monopoly/model/Hotel.java
View File

@ -1,99 +0,0 @@
package pp.monopoly.model;
import com.jme3.math.Vector3f;
public class Hotel implements Item{
/**
* The ID of the field the hotel is on.
*/
private final int fieldID;
/**
* Creates a new hotel with fieldID 0.
*/
private Hotel() {
this.fieldID = 0;
}
/**
* Creates a new hotel on the given field.
*
* @param fieldID the ID of the field the hotel is on
*/
public Hotel(int fieldID) {
this.fieldID = fieldID;
}
@Override
public <T> T accept(Visitor<T> visitor) {
return visitor.visit(this);
}
@Override
public void accept(VoidVisitor visitor) {
visitor.visit(this);
}
/**
* Returns the position of the building on the field.
*
* @return the position of the building on the field
*/
public Vector3f getPos() {
float baseX = 0.0f;
float baseZ = 0.0f;
switch (fieldID) {
case 0: baseX = -8.4f; baseZ = -7.7f; break;
case 1: baseX = -6.3f; baseZ = -7.7f; break;
case 2: baseX = -4.7f; baseZ = -7.7f; break;
case 3: baseX = -3.1f; baseZ = -7.7f; break;
case 4: baseX = -1.4f; baseZ = -7.7f; break;
case 5: baseX = 0.2f; baseZ = -7.7f; break;
case 6: baseX = 1.8f; baseZ = -7.7f; break;
case 7: baseX = 3.5f; baseZ = -7.7f; break;
case 8: baseX = 5.1f; baseZ = -7.7f; break;
case 9: baseX = 6.7f; baseZ = -7.7f; break;
case 10: baseX = 8.2f; baseZ = -7.7f; break;
case 11: baseX = 8.2f; baseZ = -6.5f; break; //passt
case 12: baseX = 8.2f; baseZ = -4.9f; break; //passt
case 13: baseX = 8.2f; baseZ = -3.3f; break; //passt
case 14: baseX = 8.2f; baseZ = -1.6f; break; //passt
case 15: baseX = 8.2f; baseZ = 0.0f; break; //passt
case 16: baseX = 8.2f; baseZ = 1.6f; break; //passt
case 17: baseX = 8.2f; baseZ = 3.3f; break; //passt
case 18: baseX = 8.2f; baseZ = 4.9f; break; //passt
case 19: baseX = 8.2f; baseZ = 6.5f; break; //passt
case 20: baseX = 8.2f; baseZ = 7.7f; break;
case 21: baseX = 6.5f; baseZ = 7.7f; break;
case 22: baseX = 4.9f; baseZ = 7.7f; break;
case 23: baseX = 3.3f; baseZ = 7.7f; break;
case 24: baseX = 1.6f; baseZ = 7.7f; break;
case 25: baseX = 0.0f; baseZ = 7.7f; break;
case 26: baseX = -1.6f; baseZ = 7.7f; break;
case 27: baseX = -3.3f; baseZ = 7.7f; break;
case 28: baseX = -4.9f; baseZ = 7.7f; break;
case 29: baseX = -6.5f; baseZ = 7.7f; break;
case 30: baseX = -7.2f; baseZ = 7.7f; break;
case 31: baseX = -7.2f; baseZ = 6.5f; break;
case 32: baseX = -7.2f; baseZ = 4.9f; break;
case 33: baseX = -7.2f; baseZ = 3.3f; break;
case 34: baseX = -7.2f; baseZ = 1.6f; break;
case 35: baseX = -7.2f; baseZ = 0.0f; break;
case 36: baseX = -7.2f; baseZ = -1.6f; break;
case 37: baseX = -7.2f; baseZ = -3.3f; break;
case 38: baseX = -7.2f; baseZ = -4.9f; break;
case 39: baseX = -7.2f; baseZ = -6.5f; break;
default: throw new IllegalArgumentException("Ungültige Feld-ID: " + fieldID);
}
return new Vector3f(baseX, 0, baseZ);
}
@Override
public Rotation getRot() {
// TODO
return Rotation.NORTH;
}
}

130
Projekte/monopoly/model/src/main/java/pp/monopoly/model/House.java
View File

@ -1,130 +0,0 @@
package pp.monopoly.model;
import com.jme3.math.FastMath;
import com.jme3.math.Quaternion;
import com.jme3.math.Vector3f;
import com.jme3.network.serializing.Serializable;
/**
* A class representing a house in the Monopoly game.
*/
@Serializable
public class House implements Item{
/**
* The stage of the house.
*/
private final int stage;
private final int fieldID;
/**
* Creates a new house with stage 0.
*/
private House() {
this.stage = 0;
this.fieldID = 0;
}
/**
* Creates a new house with the given stage.
*
* @param stage the stage of the house
*/
public House(int stage, int fieldID) {
this.stage = stage;
this.fieldID = fieldID;
}
/**
* Returns the stage of the house.
*
* @return the stage of the house
*/
public int getStage() {
return stage;
}
@Override
public <T> T accept(Visitor<T> visitor) {
return visitor.visit(this);
}
@Override
public void accept(VoidVisitor visitor) {
visitor.visit(this);
}
/**
* Returns the position of the building on the field.
*
* @return the position of the building on the field
*/
public Vector3f getPos() {
float baseX = 0.0f;
float baseZ = 0.0f;
switch (fieldID) {
case 0: baseX = -8.4f; baseZ = -7.7f; break;
case 1: baseX = -6.3f; baseZ = -7.7f; break;
case 2: baseX = -4.7f; baseZ = -7.7f; break;
case 3: baseX = -3.1f; baseZ = -7.7f; break;
case 4: baseX = -1.4f; baseZ = -7.7f; break;
case 5: baseX = 0.2f; baseZ = -7.7f; break;
case 6: baseX = 1.8f; baseZ = -7.7f; break;
case 7: baseX = 3.5f; baseZ = -7.7f; break;
case 8: baseX = 5.1f; baseZ = -7.7f; break;
case 9: baseX = 6.7f; baseZ = -7.7f; break;
case 10: baseX = 8.2f; baseZ = -7.7f; break;
case 11: baseX = 8.2f; baseZ = -6.5f; break; //passt
case 12: baseX = 8.2f; baseZ = -4.9f; break; //passt
case 13: baseX = 8.2f; baseZ = -3.3f; break; //passt
case 14: baseX = 8.2f; baseZ = -1.6f; break; //passt
case 15: baseX = 8.2f; baseZ = 0.0f; break; //passt
case 16: baseX = 8.2f; baseZ = 1.6f; break; //passt
case 17: baseX = 8.2f; baseZ = 3.3f; break; //passt
case 18: baseX = 8.2f; baseZ = 4.9f; break; //passt
case 19: baseX = 8.2f; baseZ = 6.5f; break; //passt
case 20: baseX = 8.2f; baseZ = 7.7f; break;
case 21: baseX = 6.5f; baseZ = 7.7f; break;
case 22: baseX = 4.9f; baseZ = 7.7f; break;
case 23: baseX = 3.3f; baseZ = 7.7f; break;
case 24: baseX = 1.6f; baseZ = 7.7f; break;
case 25: baseX = 0.0f; baseZ = 7.7f; break;
case 26: baseX = -1.6f; baseZ = 7.7f; break;
case 27: baseX = -3.3f; baseZ = 7.7f; break;
case 28: baseX = -4.9f; baseZ = 7.7f; break;
case 29: baseX = -6.5f; baseZ = 7.7f; break;
case 30: baseX = -7.2f; baseZ = 7.7f; break;
case 31: baseX = -7.2f; baseZ = 6.5f; break;
case 32: baseX = -7.2f; baseZ = 4.9f; break;
case 33: baseX = -7.2f; baseZ = 3.3f; break;
case 34: baseX = -7.2f; baseZ = 1.6f; break;
case 35: baseX = -7.2f; baseZ = 0.0f; break;
case 36: baseX = -7.2f; baseZ = -1.6f; break;
case 37: baseX = -7.2f; baseZ = -3.3f; break;
case 38: baseX = -7.2f; baseZ = -4.9f; break;
case 39: baseX = -7.2f; baseZ = -6.5f; break;
default: throw new IllegalArgumentException("Ungültige Feld-ID: " + fieldID);
}
return new Vector3f(baseX, 0, baseZ);
}
@Override
public Rotation getRot() {
//TODO
return Rotation.NORTH;
}
public Quaternion getAlignment() {
Quaternion rotation = new Quaternion();
if (fieldID >= 1 && fieldID <= 10) {
rotation.fromAngleAxis(FastMath.HALF_PI, Vector3f.UNIT_Y);
} else if (fieldID >= 21 && fieldID <= 30) {
rotation.fromAngleAxis(3 * FastMath.HALF_PI, Vector3f.UNIT_Y);
} else if (fieldID >= 31 && fieldID <= 39) {
rotation.fromAngleAxis(FastMath.PI, Vector3f.UNIT_Y);
}
return rotation;
}
}

17
Projekte/monopoly/model/src/main/java/pp/monopoly/model/Item.java
View File

@ -7,8 +7,6 @@
package pp.monopoly.model; package pp.monopoly.model;
import com.jme3.math.Vector3f;
/** /**
* An interface representing any item on a board * An interface representing any item on a board
* It extends the IntPosition interface to provide position information. * It extends the IntPosition interface to provide position information.
@ -30,19 +28,4 @@ public interface Item {
* @param visitor the visitor performing operations on the item * @param visitor the visitor performing operations on the item
*/ */
void accept(VoidVisitor visitor); void accept(VoidVisitor visitor);
/**
* Returns the rotation of the item on the board.
*
* @return the rotation of the item on the board
*/
Rotation getRot();
/**
* Returns the position of the item on the board.
*
* @return the position of the item on the board
*/
Vector3f getPos();
} }

121
Projekte/monopoly/model/src/main/java/pp/monopoly/model/Rotation.java
View File

@ -1,108 +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; package pp.monopoly.model;
import com.jme3.math.Quaternion; /**
import com.jme3.math.Vector3f; * Represents the rotation of a Item and provides functionality related to rotation.
*/
import java.io.Serializable; import java.io.Serializable;
import static pp.util.FloatMath.PI;
import static pp.util.FloatMath.TWO_PI;
/**
* Represents the rotation of an item in cardinal directions and provides corresponding 3D rotation quaternions.
*/
public enum Rotation implements Serializable { public enum Rotation implements Serializable {
/** /**
* Represents the item facing north (positive Z-axis). * Represents the item facing upwards.
*/ */
NORTH(0, new Quaternion().fromAngleAxis(0, Vector3f.UNIT_Y)), UP,
/** /**
* Represents the item facing south (negative Z-axis). * Represents the item facing rightwards.
*/ */
SOUTH(PI, new Quaternion().fromAngleAxis(PI, Vector3f.UNIT_Y)), RIGHT,
/** /**
* Represents the item facing west (negative X-axis). * Represents the item facing downwards.
*/ */
WEST(3 * PI / 2, new Quaternion().fromAngleAxis(3 * PI / 2, Vector3f.UNIT_Y)), DOWN,
/** /**
* Represents the item facing east (positive X-axis). * Represents the item facing leftwards.
*/ */
EAST(PI / 2, new Quaternion().fromAngleAxis(PI / 2, Vector3f.UNIT_Y)); LEFT;
private final float radians; /**
private final Quaternion rotation; * Gets the change in x-coordinate corresponding to this rotation.
*
Rotation(float radians, Quaternion rotation) { * @return the change in x-coordinate
this.radians = radians; */
this.rotation = rotation; public int dx() {
return switch (this) {
case UP, DOWN -> 0;
case RIGHT -> 1;
case LEFT -> -1;
};
} }
/** /**
* Gets the 3D rotation quaternion corresponding to this rotation. * Gets the change in y-coordinate corresponding to this rotation.
* *
* @return the rotation as a {@link Quaternion}. * @return the change in y-coordinate
*/ */
public Quaternion toQuaternion() { public int dy() {
return rotation; return switch (this) {
case UP -> 1;
case LEFT, RIGHT -> 0;
case DOWN -> -1;
};
} }
/** /**
* Gets the rotation in radians. * Rotates the orientation clockwise and returns the next rotation.
* *
* @return the rotation in radians. * @return the next rotation after rotating clockwise
*/ */
public float radians() { public Rotation rotate() {
return radians;
}
/**
* Rotates clockwise (90 degrees or PI/2 radians) and returns the next rotation.
*
* @return the next rotation after rotating clockwise.
*/
public Rotation rotateClockwise() {
return values()[(ordinal() + 1) % values().length]; return values()[(ordinal() + 1) % values().length];
} }
/**
* Rotates counterclockwise (270 degrees or 3 * PI / 2 radians) and returns the next rotation.
*
* @return the next rotation after rotating counterclockwise.
*/
public Rotation rotateCounterclockwise() {
return values()[(ordinal() - 1 + values().length) % values().length];
}
/**
* Rotates by the specified radians and returns the corresponding rotation.
* Valid radians are multiples of PI/2.
*
* @param radians the radians to rotate. Must be a multiple of PI/2.
* @return the resulting rotation.
* @throws IllegalArgumentException if the radians are not a multiple of PI/2.
*/
public Rotation rotateByRadians(float radians) {
if ((radians % (PI / 2)) != 0) {
throw new IllegalArgumentException("Radians must be a multiple of PI/2.");
}
int steps = (int) ((radians / (PI / 2)) % values().length);
if (steps < 0) {
steps += values().length; // Normalize negative steps.
}
return values()[(ordinal() + steps) % values().length];
}
/**
* Finds the rotation closest to the specified radians value.
*
* @param radians the radians value.
* @return the nearest rotation.
*/
public static Rotation closestToRadians(float radians) {
float normalized = (radians % TWO_PI + TWO_PI) % TWO_PI; // Normalize to 0-TWO_PI.
if (normalized < PI / 4 || normalized >= 7 * PI / 4) return NORTH;
if (normalized < 3 * PI / 4) return EAST;
if (normalized < 5 * PI / 4) return SOUTH;
return WEST;
}
} }

23
Projekte/monopoly/model/src/main/java/pp/monopoly/model/Visitor.java
View File

@ -1,3 +1,10 @@
////////////////////////////////////////
// Programming project code
// UniBw M, 2022, 2023, 2024
// www.unibw.de/inf2
// (c) Mark Minas (mark.minas@unibw.de)
////////////////////////////////////////
package pp.monopoly.model; package pp.monopoly.model;
/** /**
@ -15,20 +22,4 @@ public interface Visitor<T> {
*/ */
T visit(Figure figure); T visit(Figure figure);
/**
* Visits a Hotel element.
*
* @param hotel the Hotel element to visit
* @return the result of visiting the hotel element
*/
T visit(Hotel hotel);
/**
* Visits a house element.
*
* @param house the House element to visit
* @return the result of visiting the house element
*/
T visit(House figure);
} }

21
Projekte/monopoly/model/src/main/java/pp/monopoly/model/VoidVisitor.java
View File

@ -1,3 +1,10 @@
////////////////////////////////////////
// Programming project code
// UniBw M, 2022, 2023, 2024
// www.unibw.de/inf2
// (c) Mark Minas (mark.minas@unibw.de)
////////////////////////////////////////
package pp.monopoly.model; package pp.monopoly.model;
/** /**
@ -12,18 +19,4 @@ public interface VoidVisitor {
*/ */
void visit(Figure figure); void visit(Figure figure);
/**
* Visits a Hotel element.
*
* @param hotel the Hotel element to visit
*/
void visit(Hotel hotel);
/**
* Visits a House element.
*
* @param house the House element to visit
*/
void visit(House house);
} }

34
Projekte/monopoly/model/src/main/java/pp/monopoly/notification/ItemAddedEvent.java
View File

@ -6,10 +6,36 @@ import pp.monopoly.model.Item;
/** /**
* Event that is triggered when an item is added to a board. * Event that is triggered when an item is added to a board.
*/ */
public record ItemAddedEvent(Board board, Item item) implements GameEvent { public class ItemAddedEvent {
private final Item item;
private final Board board;
@Override /**
public void notifyListener(GameEventListener listener) { * Constructs a new ItemAddedEvent.
listener.receivedEvent(this); *
* @param item the item that was added
* @param board the board to which the item was added
*/
public ItemAddedEvent(Item item, Board board) {
this.item = item;
this.board = board;
}
/**
* Gets the item that was added.
*
* @return the added item
*/
public Item getItem() {
return item;
}
/**
* Gets the board to which the item was added.
*
* @return the board
*/
public Board getBoard() {
return board;
} }
} }

30
Projekte/monopoly/model/src/main/java/pp/monopoly/notification/ItemRemovedEvent.java
View File

@ -1,15 +1,35 @@
////////////////////////////////////////
// Programming project code
// UniBw M, 2022, 2023, 2024
// www.unibw.de/inf2
// (c) Mark Minas (mark.minas@unibw.de)
////////////////////////////////////////
package pp.monopoly.notification; package pp.monopoly.notification;
import pp.monopoly.model.Board; import pp.monopoly.model.Board;
import pp.monopoly.model.Item; import pp.monopoly.model.Item;
/** /**
* Event that is triggered when an item is removed from a board. * Event when an item gets removed.
*
*/ */
public record ItemRemovedEvent(Board board, Item item) implements GameEvent { public class ItemRemovedEvent {
private final Item item;
private final Board board;
@Override public ItemRemovedEvent(Item item, Board board) {
public void notifyListener(GameEventListener listener) { this.item = item;
listener.receivedEvent(this); this.board = board;
}
public Item getItem() {
return item;
}
public Board getBoard() {
return board;
} }
} }

2
Projekte/monopoly/server/src/main/java/pp/monopoly/server/MonopolyServer.java
View File

@ -39,7 +39,6 @@ import pp.monopoly.message.client.RollDice;
import pp.monopoly.message.client.TradeOffer; import pp.monopoly.message.client.TradeOffer;
import pp.monopoly.message.client.TradeResponse; import pp.monopoly.message.client.TradeResponse;
import pp.monopoly.message.client.ViewAssetsRequest; import pp.monopoly.message.client.ViewAssetsRequest;
import pp.monopoly.message.server.BuildInfo;
import pp.monopoly.message.server.BuyPropertyRequest; import pp.monopoly.message.server.BuyPropertyRequest;
import pp.monopoly.message.server.DiceResult; import pp.monopoly.message.server.DiceResult;
import pp.monopoly.message.server.EventDrawCard; import pp.monopoly.message.server.EventDrawCard;
@ -193,7 +192,6 @@ public class MonopolyServer implements MessageListener<HostedConnection>, Connec
Serializer.registerClass(JailEvent.class); Serializer.registerClass(JailEvent.class);
Serializer.registerClass(AlterProperty.class); Serializer.registerClass(AlterProperty.class);
Serializer.registerClass(GameOver.class); Serializer.registerClass(GameOver.class);
Serializer.registerClass(BuildInfo.class);
} }
/** /**