peet/Gruppe-02-clone
1
0
Fork 0
mirror of https://athene2.informatik.unibw-muenchen.de/progproj/gruppen-ht24/Gruppe-02.git synced 2025-05-22 13:45:43 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Compare commits

base: peet:95b9da937789a0912c494ee191bded40d1201486
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:3539b1cf23bea8218df74f01d6ebe8bd5b774d6f
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. "95b9da937789a0912c494ee191bded40d1201486" and "3539b1cf23bea8218df74f01d6ebe8bd5b774d6f" have entirely different histories.
95b9da9377 ... 3539b1cf23

37 changed files with 381 additions and 784 deletions
Show Stats Expand all files Collapse all files

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

@ -496,7 +496,7 @@ public class MonopolyApp extends SimpleApplication implements MonopolyClient, Ga
/**
* Retrieves the unique identifier associated with the server connection.
*
* Checks if a Server is connected and returns 0 if there is no connection
* Checks if a Server is connected and returns {@Code 0} if there is no connection
*
* @return the ID of the connected Server instance.
*/

1
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/TestWorld.java
View File

@ -58,6 +58,7 @@ public class TestWorld implements GameEventListener {
* Konstruktor für die TestWorld.
*
* @param app Die Hauptanwendung
* @param players Die Liste der Spieler mit ihren Figuren
*/
public TestWorld(MonopolyApp app) {
this.app = app;

29
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/popups/AcceptTrade.java
View File

@ -17,32 +17,16 @@ import pp.monopoly.message.server.TradeReply;
import pp.monopoly.notification.Sound;
/**
* Represents a confirmation dialog that appears when a trade is accepted .
* <p>
* Displays a message to the user informing them that the trade they proposed has been accepted,
* along with a confirmation button to close the dialog.
* </p>
* Bankrupt is a Warning-Popup which appears when the balance is negative at the end of a player´s turn
*/
public class AcceptTrade extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Semi-transparent overlay background for the dialog. */
private final Geometry overlayBackground;
/** Container for the warning message content. */
private final Container noMoneyWarningContainer;
/** Background container providing a border for the dialog. */
private final Container backgroundContainer;
/**
* Constructs the accept trade dialog.
*
* @param app the Monopoly application instance
* @param msg the trade reply message containing details about the trade
*/
public AcceptTrade(MonopolyApp app, TradeReply msg) {
super(app.getDialogManager());
this.app = app;
@ -108,9 +92,9 @@ public class AcceptTrade extends Dialog {
}
/**
* Creates a semi-transparent background overlay for the dialog.
* Erstellt einen halbtransparenten Hintergrund für das Menü.
*
* @return the geometry of the overlay
* @return Geometrie des Overlays
*/
private Geometry createOverlayBackground() {
Quad quad = new Quad(app.getCamera().getWidth(), app.getCamera().getHeight());
@ -124,7 +108,7 @@ public class AcceptTrade extends Dialog {
}
/**
* Closes the dialog and removes the associated GUI elements.
* Closes the menu and removes the GUI elements.
*/
@Override
public void close() {
@ -134,9 +118,6 @@ public class AcceptTrade extends Dialog {
super.close();
}
/**
* Handles the escape key action by closing the dialog.
*/
@Override
public void escape() {
close();

20
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/popups/Bankrupt.java
View File

@ -18,24 +18,13 @@ import pp.monopoly.client.MonopolyApp;
* Bankrupt is a Warning-Popup which appears when the balance is negative at the end of a player´s turn
*/
public class Bankrupt extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Semi-transparent overlay background for the popup. */
private final Geometry overlayBackground;
/** Main container for the bankruptcy warning content. */
private final Container bankruptContainer;
/** Background container providing a border for the popup. */
private final Container backgroundContainer;
/**
* Constructs the bankruptcy warning popup.
*
* @param app the Monopoly application instance
*/
public Bankrupt(MonopolyApp app) {
super(app.getDialogManager());
this.app = app;
@ -96,9 +85,9 @@ public class Bankrupt extends Dialog {
}
/**
* Creates a semi-transparent background overlay for the popup.
* Erstellt einen halbtransparenten Hintergrund für das Menü.
*
* @return the geometry of the overlay
* @return Geometrie des Overlays
*/
private Geometry createOverlayBackground() {
Quad quad = new Quad(app.getCamera().getWidth(), app.getCamera().getHeight());
@ -122,9 +111,6 @@ public class Bankrupt extends Dialog {
super.close();
}
/**
* Handles the escape key action by closing the popup.
*/
@Override
public void escape() {
close();

15
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/popups/BuildingPropertyCard.java
View File

@ -19,20 +19,10 @@ import pp.monopoly.notification.Sound;
* BuildingPropertyCard creates the popup for field information
*/
public class BuildingPropertyCard extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Main container for the building property information. */
private final Container buildingPropertyContainer;
/** Background container providing a border for the property card. */
private final Container backgroundContainer;
/**
* Constructs a property card popup displaying details about the building property.
*
* @param app the Monopoly application instance
*/
public BuildingPropertyCard(MonopolyApp app) {
super(app.getDialogManager());
this.app = app;
@ -109,7 +99,7 @@ public class BuildingPropertyCard extends Dialog {
}
/**
* Closes the popup and removes the associated GUI elements.
* Schließt das Menü und entfernt die GUI-Elemente.
*/
@Override
public void close() {
@ -118,9 +108,6 @@ public class BuildingPropertyCard extends Dialog {
super.close();
}
/**
* Opens the settings menu when the escape key is pressed.
*/
@Override
public void escape() {
new SettingsMenu(app).open();

45
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/popups/BuyHouse.java
View File

@ -31,35 +31,16 @@ import java.util.stream.Collectors;
* BuyHouse is a popup which appears when a player clicks on the "Buy House"-button in the BuildingAdminMenu
*/
public class BuyHouse extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Main container for the "Buy House" popup UI. */
private final Container buyHouseContainer;
/** Background container providing a border for the popup. */
private final Container backgroundContainer;
/** TextField to display selected properties. */
private TextField selectionDisplay;
/** Reference for tracking dropdown selection changes. */
private TextField selectionDisplay; // TextField to display selections
private VersionedReference<Set<Integer>> selectionRef;
/** Dropdown selector for choosing properties to build houses on. */
private Selector<String> propertySelector;
/** Set of selected properties for house purchase. */
private Set<String> selectedProperties = new HashSet<>();
/** Label displaying the total cost of building houses on the selected properties. */
private Label cost = new Label("0", new ElementId("label-Text"));
/**
* Constructs the "Buy House" popup.
*
* @param app the Monopoly application instance
*/
public BuyHouse(MonopolyApp app) {
super(app.getDialogManager());
this.app = app;
@ -138,9 +119,9 @@ public class BuyHouse extends Dialog {
}
/**
* Creates a dropdown menu for selecting properties eligible for house construction.
* Creates a dropdown menu for selecting a property.
*
* @return The container holding the dropdown menu.
* @return The dropdown container.
*/
private Container createPropertyDropdown() {
Container dropdownContainer = new Container(new SpringGridLayout(Axis.Y, Axis.X));
@ -173,11 +154,10 @@ public class BuyHouse extends Dialog {
return dropdownContainer;
}
/**
* Retrieves the list of properties owned by the current player that are eligible for house construction.
* Retrieves the list of properties owned by the current player.
*
* @return A list of {@link BuildingProperty} objects owned by the player.
* @return List of BuildingProperty objects owned by the player.
*/
private List<BuildingProperty> getPlayerProperties() {
Player self = app.getGameLogic().getPlayerHandler().getPlayerById(app.getId());
@ -190,11 +170,6 @@ public class BuyHouse extends Dialog {
.collect(Collectors.toList());
}
/**
* Periodically updates the popup, tracking selection changes in the dropdown menu.
*
* @param delta Time since the last update in seconds.
*/
@Override
public void update(float delta) {
if(selectionRef.update()) {
@ -203,9 +178,7 @@ public class BuyHouse extends Dialog {
}
/**
* Handles property selection changes in the dropdown menu.
*
* @param playerProperties the dropdown selector for the player's properties
* Handles property selection changes.
*/
private void onDropdownSelectionChanged(Selector<String> playerProperties) {
String selected = playerProperties.getSelectedItem();
@ -227,9 +200,6 @@ public class BuyHouse extends Dialog {
this.cost.setText(cost+"");
}
/**
* Closes the popup and removes its GUI elements.
*/
@Override
public void close() {
app.getGuiNode().detachChild(buyHouseContainer);
@ -237,9 +207,6 @@ public class BuyHouse extends Dialog {
super.close();
}
/**
* Opens the settings menu when the escape key is pressed.
*/
@Override
public void escape() {
new SettingsMenu(app).open();

27
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/popups/ConfirmTrade.java
View File

@ -20,23 +20,12 @@ import pp.monopoly.notification.Sound;
* ConfirmTrade is a popup which appears when a trade is proposed to this certain player.
*/
public class ConfirmTrade extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Main container for the "Confirm Trade" popup UI. */
private final Container confirmTradeContainer;
/** Background container providing a border for the popup. */
private final Container backgroundContainer;
/** The trade handler managing the details of the trade proposal. */
private TradeHandler tradeHandler;
/**
* Constructs the "Confirm Trade" popup.
*
* @param app the Monopoly application instance
*/
public ConfirmTrade(MonopolyApp app) {
super(app.getDialogManager());
this.app = app;
@ -44,12 +33,13 @@ public class ConfirmTrade extends Dialog {
// Create the background container
backgroundContainer = new Container();
backgroundContainer.setBackground(new QuadBackgroundComponent(new ColorRGBA(0.8657f, 0.8735f, 0.8892f, 1.0f)));
backgroundContainer.setBackground(new QuadBackgroundComponent(new ColorRGBA(0.8657f, 0.8735f, 0.8892f, 1.0f))); // Darker background
attachChild(backgroundContainer);
// Hauptcontainer für das Bestätigungspopup
confirmTradeContainer = new Container();
float padding = 10;
float padding = 10; // Passt den backgroundContainer an die Größe des confirmTradeContainer an
backgroundContainer.setPreferredSize(confirmTradeContainer.getPreferredSize().addLocal(padding, padding, 0));
// Titel
@ -132,18 +122,15 @@ public class ConfirmTrade extends Dialog {
}
/**
* Closes the popup and removes its GUI elements.
* Schließt das Menü und entfernt die GUI-Elemente.
*/
@Override
public void close() {
app.getGuiNode().detachChild(confirmTradeContainer);
app.getGuiNode().detachChild(backgroundContainer);
app.getGuiNode().detachChild(confirmTradeContainer); // Entferne das Menü
app.getGuiNode().detachChild(backgroundContainer); //Entfernt Rand
super.close();
}
/**
* Opens the settings menu when the escape key is pressed.
*/
@Override
public void escape() {
new SettingsMenu(app).open();

37
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/popups/EventCardPopup.java
View File

@ -19,27 +19,13 @@ import pp.monopoly.notification.Sound;
* EventCardPopup is a popup which appears when a certain EventCard is triggered by entering a EventCardField
*/
public class EventCardPopup extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Semi-transparent overlay background for the popup. */
private final Geometry overlayBackground;
/** Main container for the event card information. */
private final Container eventCardContainer;
/** Background container providing a border for the popup. */
private final Container backgroundContainer;
/** The description of the event card. */
private final String description;
/**
* Constructs the EventCardPopup to display the details of a triggered event card.
*
* @param app the Monopoly application instance
* @param description the description of the triggered event card
*/
public EventCardPopup(MonopolyApp app, String description) {
super(app.getDialogManager());
this.app = app;
@ -54,12 +40,12 @@ public class EventCardPopup extends Dialog {
backgroundContainer.setBackground(new QuadBackgroundComponent(new ColorRGBA(0.8657f, 0.8735f, 0.8892f, 1.0f))); // Darker background
app.getGuiNode().attachChild(backgroundContainer);
// Hauptcontainer für die Eventcard
eventCardContainer = new Container();
eventCardContainer.setBackground(new QuadBackgroundComponent(new ColorRGBA(0.8657f, 0.8735f, 0.8892f, 1.0f)));
eventCardContainer.setPreferredSize(new Vector3f(550,400,10));
float padding = 10;
float padding = 10; // Passt den backgroundContainer an die Größe des eventCardContainers an
backgroundContainer.setPreferredSize(eventCardContainer.getPreferredSize().addLocal(padding, padding, 0));
// Titel
@ -100,15 +86,15 @@ public class EventCardPopup extends Dialog {
}
/**
* Creates a semi-transparent background overlay for the popup.
* Erstellt einen halbtransparenten Hintergrund für das Menü.
*
* @return the geometry of the overlay
* @return Geometrie des Overlays
*/
private Geometry createOverlayBackground() {
Quad quad = new Quad(app.getCamera().getWidth(), app.getCamera().getHeight());
Geometry overlay = new Geometry("Overlay", quad);
Material material = new Material(app.getAssetManager(), "Common/MatDefs/Misc/Unshaded.j3md");
material.setColor("Color", new ColorRGBA(0, 0, 0, 0.5f));
material.setColor("Color", new ColorRGBA(0, 0, 0, 0.5f)); // Halbtransparent
material.getAdditionalRenderState().setBlendMode(BlendMode.Alpha);
overlay.setMaterial(material);
overlay.setLocalTranslation(0, 0, 0);
@ -116,19 +102,16 @@ public class EventCardPopup extends Dialog {
}
/**
* Closes the popup and removes its associated GUI elements.
* Schließt das Menü und entfernt die GUI-Elemente.
*/
@Override
public void close() {
app.getGuiNode().detachChild(eventCardContainer);
app.getGuiNode().detachChild(backgroundContainer);
app.getGuiNode().detachChild(overlayBackground);
app.getGuiNode().detachChild(eventCardContainer); // Entferne das Menü
app.getGuiNode().detachChild(backgroundContainer); //Entfernt Rand
app.getGuiNode().detachChild(overlayBackground); // Entferne das Overlay
super.close();
}
/**
* Handles the escape key action by closing the popup.
*/
@Override
public void escape() {
close();

30
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/popups/FoodFieldCard.java
View File

@ -22,47 +22,42 @@ import pp.monopoly.notification.Sound;
* FoodFieldCard creates the popup for field information
*/
public class FoodFieldCard extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Semi-transparent overlay background for the popup. */
private final Geometry overlayBackground;
/** Main container for the food field information. */
private final Container foodFieldContainer;
/** Background container providing a border for the popup. */
private final Container backgroundContainer;
/**
* Constructs a FoodFieldCard popup displaying details about a food field.
*
* @param app the Monopoly application instance
*/
public FoodFieldCard(MonopolyApp app) {
super(app.getDialogManager());
this.app = app;
//Generate the corresponfing field
int index = app.getGameLogic().getPlayerHandler().getPlayerById(app.getId()).getFieldID();
FoodField field = (FoodField) app.getGameLogic().getBoardManager().getFieldAtIndex(index);
// Halbtransparentes Overlay hinzufügen
overlayBackground = createOverlayBackground();
app.getGuiNode().attachChild(overlayBackground);
// Create the background container
backgroundContainer = new Container();
backgroundContainer.setBackground(new QuadBackgroundComponent(new ColorRGBA(0.8657f, 0.8735f, 0.8892f, 1.0f))); // Darker background
attachChild(backgroundContainer);
// Hauptcontainer für die Gebäudekarte
foodFieldContainer = new Container();
foodFieldContainer.setBackground(new QuadBackgroundComponent(new ColorRGBA(0.1f, 0.1f, 0.1f, 0.9f)));
float padding = 10;
float padding = 10; // Passt den backgroundContainer an die Größe des foodFieldContainers an
backgroundContainer.setPreferredSize(foodFieldContainer.getPreferredSize().addLocal(padding, padding, 0));
// Titel, bestehend aus dynamischen Namen anhand der ID und der Schriftfarbe/größe
Label settingsTitle = foodFieldContainer.addChild(new Label(field.getName(), new ElementId("label-Bold")));
settingsTitle.setFontSize(48);
settingsTitle.setColor(ColorRGBA.White);
// Text, der auf der Karte steht
// Die Preise werden dynamisch dem BoardManager entnommen
Container propertyValuesContainer = foodFieldContainer.addChild(new Container());
propertyValuesContainer.addChild(new Label("„Preis: " + field.getPrice() + " EUR", new ElementId("label-Text")));
propertyValuesContainer.addChild(new Label("", new ElementId("label-Text"))); // Leerzeile
@ -113,9 +108,9 @@ public class FoodFieldCard extends Dialog {
}
/**
* Creates a semi-transparent background overlay for the popup.
* Erstellt einen halbtransparenten Hintergrund für das Menü.
*
* @return the geometry of the overlay
* @return Geometrie des Overlays
*/
private Geometry createOverlayBackground() {
Quad quad = new Quad(app.getCamera().getWidth(), app.getCamera().getHeight());
@ -129,7 +124,7 @@ public class FoodFieldCard extends Dialog {
}
/**
* Closes the popup and removes its associated GUI elements.
* Schließt das Menü und entfernt die GUI-Elemente.
*/
@Override
public void close() {
@ -139,9 +134,6 @@ public class FoodFieldCard extends Dialog {
super.close();
}
/**
* Opens the settings menu when the escape key is pressed.
*/
@Override
public void escape() {
new SettingsMenu(app).open();

19
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/popups/GateFieldCard.java
View File

@ -21,20 +21,10 @@ import pp.monopoly.notification.Sound;
* GateFieldCard creates the popup for field information
*/
public class GateFieldCard extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Main container for the gate field information. */
private final Container gateFieldContainer;
/** Background container providing a border for the popup. */
private final Container backgroundContainer;
/**
* Constructs a GateFieldCard popup displaying details about a gate field.
*
* @param app the Monopoly application instance
*/
public GateFieldCard(MonopolyApp app) {
super(app.getDialogManager());
this.app = app;
@ -110,9 +100,9 @@ public class GateFieldCard extends Dialog {
}
/**
* Creates a semi-transparent background overlay for the popup.
* Erstellt einen halbtransparenten Hintergrund für das Menü.
*
* @return the geometry of the overlay
* @return Geometrie des Overlays
*/
private Geometry createOverlayBackground() {
Quad quad = new Quad(app.getCamera().getWidth(), app.getCamera().getHeight());
@ -126,7 +116,7 @@ public class GateFieldCard extends Dialog {
}
/**
* Closes the popup and removes its associated GUI elements.
* Schließt das Menü und entfernt die GUI-Elemente.
*/
@Override
public void close() {
@ -135,9 +125,6 @@ public class GateFieldCard extends Dialog {
super.close();
}
/**
* Opens the settings menu when the escape key is pressed.
*/
@Override
public void escape() {
new SettingsMenu(app).open();

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

@ -16,29 +16,16 @@ import pp.monopoly.client.MonopolyApp;
import pp.monopoly.notification.Sound;
/**
* Gulag is a warning popup triggered when a player lands on the "Wache" field in the Monopoly game.
* <p>
* This popup informs the player that they are being sent to the Gulag and includes a confirmation button.
* </p>
* Gulag is a warning popup that is triggered when a certain player enters the "Wache" field
*/
public class Gulag extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Semi-transparent overlay background for the popup. */
private final Geometry overlayBackground;
/** Main container for the Gulag warning message. */
private final Container gulagContainer;
/** Background container providing a border for the popup. */
private final Container backgroundContainer;
/**
* Constructs the Gulag popup, displaying a warning when a player lands on the "Wache" field.
*
* @param app the Monopoly application instance
*/
public Gulag(MonopolyApp app) {
super(app.getDialogManager());
this.app = app;
@ -95,9 +82,9 @@ public class Gulag extends Dialog {
}
/**
* Creates a semi-transparent overlay background for the popup.
* Erstellt einen halbtransparenten Hintergrund für das Menü.
*
* @return the geometry of the overlay
* @return Geometrie des Overlays
*/
private Geometry createOverlayBackground() {
Quad quad = new Quad(app.getCamera().getWidth(), app.getCamera().getHeight());
@ -111,7 +98,7 @@ public class Gulag extends Dialog {
}
/**
* Closes the popup and removes its associated GUI elements.
* Schließt das Menü und entfernt die GUI-Elemente.
*/
@Override
public void close() {
@ -121,9 +108,6 @@ public class Gulag extends Dialog {
super.close();
}
/**
* Handles the escape action to close the popup.
*/
@Override
public void escape() {
close();

22
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/popups/GulagInfo.java
View File

@ -13,27 +13,14 @@ import pp.monopoly.message.client.NotificationAnswer;
import pp.monopoly.notification.Sound;
/**
* GulagInfo is a popup that provides options for a player who is stuck in the "Gulag" (jail) field.
* <p>
* This dialog offers multiple actions, including paying a bribe, using a "Get Out of Jail" card, or waiting.
* </p>
* ConfirmTrade is a popup which appears when a trade is proposed to this certain player.
*/
public class GulagInfo extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Main container for the Gulag information dialog. */
private final Container gulagInfoContainer;
/** Background container providing a styled border around the dialog. */
private final Container backgroundContainer;
/**
* Constructs a GulagInfo popup that provides the player with options for getting out of the "Gulag" field.
*
* @param app the Monopoly application instance
* @param trys the number of failed attempts to roll doubles for release
*/
public GulagInfo(MonopolyApp app, int trys) {
super(app.getDialogManager());
this.app = app;
@ -117,7 +104,7 @@ public class GulagInfo extends Dialog {
}
/**
* Closes the GulagInfo popup and removes its GUI elements.
* Schließt das Menü und entfernt die GUI-Elemente.
*/
@Override
public void close() {
@ -126,9 +113,6 @@ public class GulagInfo extends Dialog {
super.close();
}
/**
* Handles the escape action to close the GulagInfo dialog.
*/
@Override
public void escape() {
new SettingsMenu(app).open();

22
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/popups/LooserPopUp.java
View File

@ -16,23 +16,10 @@ import pp.dialog.Dialog;
import pp.monopoly.client.MonopolyApp;
import pp.monopoly.notification.Sound;
/**
* LooserPopUp is a dialog that appears when a player loses the game.
* <p>
* This popup provides a message of encouragement and an option to quit the game.
* </p>
*/
public class LooserPopUp extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Semi-transparent overlay background for the dialog. */
private final Geometry overlayBackground;
/** Main container for the "Looser" dialog UI. */
private final Container LooserContainer;
/** Background container providing a styled border around the main dialog. */
private final Container backgroundContainer;
@ -108,9 +95,9 @@ public class LooserPopUp extends Dialog {
}
/**
* Creates a semi-transparent background overlay for the popup.
* Erstellt einen halbtransparenten Hintergrund für das Menü.
*
* @return The overlay geometry.
* @return Geometrie des Overlays
*/
private Geometry createOverlayBackground() {
Quad quad = new Quad(app.getCamera().getWidth(), app.getCamera().getHeight());
@ -124,7 +111,7 @@ public class LooserPopUp extends Dialog {
}
/**
* Closes the LooserPopUp dialog and removes its GUI elements.
* Schließt das Menü und entfernt die GUI-Elemente.
*/
@Override
public void close() {
@ -134,9 +121,6 @@ public class LooserPopUp extends Dialog {
super.close();
}
/**
* Handles the escape action to close the dialog.
*/
@Override
public void escape() {
close();

29
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/popups/NoMoneyWarning.java
View File

@ -15,32 +15,16 @@ import pp.dialog.Dialog;
import pp.monopoly.client.MonopolyApp;
/**
* NoMoneyWarning is a warning popup that appears when a player tries to perform
* an action they cannot afford due to insufficient funds, such as attempting
* to purchase a property or building.
* <p>
* This dialog notifies the player of their lack of funds and provides a single
* confirmation button to close the dialog.
* </p>
* Bankrupt is a Warning-Popup which appears when the balance is negative at the end of a player´s turn
*/
public class NoMoneyWarning extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Semi-transparent overlay background for the warning popup. */
private final Geometry overlayBackground;
/** Main container for the NoMoneyWarning dialog UI. */
private final Container noMoneyWarningContainer;
/** Background container providing a styled border around the main dialog. */
private final Container backgroundContainer;
/**
* Constructs a new NoMoneyWarning dialog.
*
* @param app The MonopolyApp instance.
*/
public NoMoneyWarning(MonopolyApp app) {
super(app.getDialogManager());
this.app = app;
@ -101,9 +85,9 @@ public class NoMoneyWarning extends Dialog {
}
/**
* Creates a semi-transparent overlay background for the dialog.
* Erstellt einen halbtransparenten Hintergrund für das Menü.
*
* @return The geometry representing the overlay background.
* @return Geometrie des Overlays
*/
private Geometry createOverlayBackground() {
Quad quad = new Quad(app.getCamera().getWidth(), app.getCamera().getHeight());
@ -127,9 +111,6 @@ public class NoMoneyWarning extends Dialog {
super.close();
}
/**
* Handles the escape action to close the dialog.
*/
@Override
public void escape() {
close();

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

@ -17,33 +17,16 @@ import pp.monopoly.message.server.TradeReply;
import pp.monopoly.notification.Sound;
/**
* RejectTrade is a popup that appears when a trade proposal is rejected by another player
* in the Monopoly application.
* <p>
* Displays a message indicating that the proposed trade has been declined, along with
* details of the involved players and provides an option to close the popup.
* </p>
* Bankrupt is a Warning-Popup which appears when the balance is negative at the end of a player´s turn
*/
public class RejectTrade extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Semi-transparent overlay background for the popup. */
private final Geometry overlayBackground;
/** Main container for the rejection message content. */
private final Container noMoneyWarningContainer;
/** Background container providing a border for the popup. */
private final Container backgroundContainer;
/**
* Constructs the RejectTrade popup displaying the rejection of a trade proposal.
*
* @param app the Monopoly application instance
* @param msg the trade reply message containing details about the rejected trade
*/
public RejectTrade(MonopolyApp app, TradeReply msg) {
super(app.getDialogManager());
this.app = app;
@ -109,9 +92,9 @@ public class RejectTrade extends Dialog {
}
/**
* Creates a semi-transparent background overlay for the popup.
* Erstellt einen halbtransparenten Hintergrund für das Menü.
*
* @return the geometry of the overlay
* @return Geometrie des Overlays
*/
private Geometry createOverlayBackground() {
Quad quad = new Quad(app.getCamera().getWidth(), app.getCamera().getHeight());
@ -135,9 +118,6 @@ public class RejectTrade extends Dialog {
super.close();
}
/**
* Handles the escape key action by closing the popup.
*/
@Override
public void escape() {
close();

20
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/popups/Rent.java
View File

@ -16,32 +16,14 @@ import pp.monopoly.client.MonopolyApp;
import pp.monopoly.notification.Sound;
/**
* Rent is a popup that is triggered when a player lands on a property owned by another player
* and needs to pay rent in the Monopoly application.
* <p>
* Displays the rent amount and the recipient player's name, with an option to confirm the payment.
* </p>
* Rent popup is triggered when a player enters a field owned by another player and needs to pay rent.
*/
public class Rent extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Semi-transparent overlay background for the popup. */
private final Geometry overlayBackground;
/** Main container for the rent information and action. */
private final Container rentContainer;
/** Background container providing a border for the rent popup. */
private final Container backgroundContainer;
/**
* Constructs the Rent popup displaying the rent amount and recipient player.
*
* @param app the Monopoly application instance
* @param playerName the name of the player to whom the rent is owed
* @param amount the amount of rent to be paid
*/
public Rent(MonopolyApp app, String playerName, int amount) {
super(app.getDialogManager());
this.app = app;

44
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/popups/RepayMortage.java
View File

@ -28,43 +28,20 @@ import java.util.Set;
import java.util.stream.Collectors;
/**
* RepayMortage is a popup that appears when a player selects the "Repay Mortgage" option
* in the Building Administration Menu.
* <p>
* This popup allows the player to select mortgaged properties and repay their mortgages,
* showing the total cost of the repayment. Includes options to confirm or cancel the repayment.
* </p>
* RepayMortage is a popup which appears when a player clicks on the "Repay Mortage"-button in the BuildingAdminMenu
*/
public class RepayMortage extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Main container for the mortgage repayment menu. */
private final Container repayMortageContainer;
/** Background container providing a border for the popup. */
private final Container backgroundContainer;
/** Text field to display selected properties. */
private TextField selectionDisplay;
/** Reference to track property selections in the dropdown menu. */
private TextField selectionDisplay; // TextField to display selections
private VersionedReference<Set<Integer>> selectionRef;
/** Dropdown menu for selecting mortgaged properties. */
private Selector<String> propertySelector;
/** Set of selected properties for mortgage repayment. */
private Set<String> selectedProperties = new HashSet<>();
/** Label displaying the total repayment cost. */
private Label cost = new Label("0", new ElementId("label-Text"));
/**
* Constructs the RepayMortage popup for handling mortgage repayment.
*
* @param app the Monopoly application instance
*/
public RepayMortage(MonopolyApp app) {
super(app.getDialogManager());
this.app = app;
@ -177,7 +154,6 @@ public class RepayMortage extends Dialog {
return dropdownContainer;
}
/**
* Retrieves the list of properties owned by the current player.
*
@ -194,11 +170,6 @@ public class RepayMortage extends Dialog {
.collect(Collectors.toList());
}
/**
* Updates the UI based on selection changes in the dropdown menu.
*
* @param delta the time elapsed since the last update
*/
@Override
public void update(float delta) {
if(selectionRef.update()) {
@ -207,9 +178,7 @@ public class RepayMortage extends Dialog {
}
/**
* Handles changes in the property selection and updates the total repayment cost.
*
* @param playerProperties the dropdown menu for selecting properties
* Handles property selection changes.
*/
private void onDropdownSelectionChanged(Selector<String> playerProperties) {
String selected = playerProperties.getSelectedItem();
@ -232,7 +201,7 @@ public class RepayMortage extends Dialog {
}
/**
* Closes the popup and removes its associated GUI elements.
* Schließt das Menü und entfernt die GUI-Elemente.
*/
@Override
public void close() {
@ -241,9 +210,6 @@ public class RepayMortage extends Dialog {
super.close();
}
/**
* Opens the settings menu when the escape key is pressed.
*/
@Override
public void escape() {
new SettingsMenu(app).open();

43
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/popups/SellHouse.java
View File

@ -32,43 +32,20 @@ import java.util.Set;
import java.util.stream.Collectors;
/**
* SellHouse is a popup that appears when a player clicks on the "Demolish" button
* in the BuildingAdminMenu.
* <p>
* This dialog allows players to select their properties and demolish houses or hotels
* for a partial refund of their purchase cost.
* </p>
* SellHouse is a popup which appears when a player clicks on the "demolish"-button in the BuildingAdminMenu
*/
public class SellHouse extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Main container for the SellHouse dialog UI. */
private final Container sellhouseContainer;
/** Background container providing a styled border around the main dialog. */
private final Container backgroundContainer;
/** Text field to display selected properties. */
private TextField selectionDisplay;
/** Reference to track selection changes in the property selector. */
private TextField selectionDisplay; // TextField to display selections
private VersionedReference<Set<Integer>> selectionRef;
/** Dropdown selector for displaying available properties. */
private Selector<String> propertySelector;
/** Set of properties selected for selling. */
private Set<String> selectedProperties = new HashSet<>();
/** Label to display the total refund amount for the selected properties. */
private Label cost = new Label("0", new ElementId("label-Text"));
/**
* Constructs a new SellHouse dialog.
*
* @param app The MonopolyApp instance.
*/
public SellHouse(MonopolyApp app) {
super(app.getDialogManager());
this.app = app;
@ -203,11 +180,6 @@ public class SellHouse extends Dialog {
.collect(Collectors.toList());
}
/**
* Updates the dialog UI, tracking changes in the property selection.
*
* @param delta Time since the last update.
*/
@Override
public void update(float delta) {
if(selectionRef.update()) {
@ -216,9 +188,7 @@ public class SellHouse extends Dialog {
}
/**
* Handles changes to the property selection.
*
* @param playerProperties The dropdown menu's selection state.
* Handles property selection changes.
*/
private void onDropdownSelectionChanged(Selector<String> playerProperties) {
String selected = playerProperties.getSelectedItem();
@ -241,7 +211,7 @@ public class SellHouse extends Dialog {
}
/**
* Closes the dialog and removes GUI elements from the screen.
* Schließt das Menü und entfernt die GUI-Elemente.
*/
@Override
public void close() {
@ -250,9 +220,6 @@ public class SellHouse extends Dialog {
super.close();
}
/**
* Handles the escape action to close the dialog.
*/
@Override
public void escape() {
new SettingsMenu(app).open();

51
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/popups/TakeMortage.java
View File

@ -29,43 +29,20 @@ import java.util.Set;
import java.util.stream.Collectors;
/**
* TakeMortage is a popup that appears when a player clicks on the "Take Mortage" button
* in the BuildingAdminMenu.
* <p>
* This popup allows the player to select properties and take a mortgage on them
* to gain financial benefit during gameplay.
* </p>
* TakeMortage is a popup which appears when a player clicks on the "TakeMortage"-button in the BuildingAdminMenu
*/
public class TakeMortage extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Main container for the TakeMortage dialog UI. */
private final Container takeMortageContainer;
/** Background container providing a styled border around the main dialog. */
private final Container backgroundContainer;
/** Text field to display selected properties. */
private TextField selectionDisplay;
/** Reference to track selection changes in the property selector. */
private TextField selectionDisplay; // TextField to display selections
private VersionedReference<Set<Integer>> selectionRef;
/** Dropdown selector for displaying available properties. */
private Selector<String> propertySelector;
/** Set of properties selected for mortgaging. */
private Set<String> selectedProperties = new HashSet<>();
/** Label to display the total mortgage amount. */
private Label cost = new Label("0", new ElementId("label-Text"));
/**
* Constructs a new TakeMortage dialog.
*
* @param app The MonopolyApp instance.
*/
public TakeMortage(MonopolyApp app) {
super(app.getDialogManager());
this.app = app;
@ -145,7 +122,7 @@ public class TakeMortage extends Dialog {
/**
* Creates a dropdown menu for selecting a property.
*
* @return The dropdown container with property options.
* @return The dropdown container.
*/
private Container createPropertyDropdown() {
Container dropdownContainer = new Container(new SpringGridLayout(Axis.Y, Axis.X));
@ -178,14 +155,10 @@ public class TakeMortage extends Dialog {
return dropdownContainer;
}
/**
* Retrieves the list of properties owned by the current player.
* <p>
* Only properties that are not currently mortgaged are included.
* </p>
*
* @return List of eligible PropertyField objects owned by the player.
* @return List of PropertyField objects owned by the player.
*/
private List<PropertyField> getPlayerProperties() {
Player self = app.getGameLogic().getPlayerHandler().getPlayerById(app.getId());
@ -198,11 +171,6 @@ public class TakeMortage extends Dialog {
.collect(Collectors.toList());
}
/**
* Updates the dialog UI, tracking changes in the property selection.
*
* @param delta Time since the last update.
*/
@Override
public void update(float delta) {
if(selectionRef.update()) {
@ -211,9 +179,7 @@ public class TakeMortage extends Dialog {
}
/**
* Handles changes to the property selection.
*
* @param playerProperties The dropdown menu's selection state.
* Handles property selection changes.
*/
private void onDropdownSelectionChanged(Selector<String> playerProperties) {
String selected = playerProperties.getSelectedItem();
@ -236,7 +202,7 @@ public class TakeMortage extends Dialog {
}
/**
* Closes the dialog and removes GUI elements from the screen.
* Schließt das Menü und entfernt die GUI-Elemente.
*/
@Override
public void close() {
@ -245,9 +211,6 @@ public class TakeMortage extends Dialog {
super.close();
}
/**
* Handles the escape action to close the dialog.
*/
@Override
public void escape() {
new SettingsMenu(app).open();

29
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/popups/TimeOut.java
View File

@ -17,29 +17,16 @@ import pp.monopoly.notification.Sound;
import static pp.monopoly.Resources.lookup;
/**
* TimeOut is a warning popup triggered when the connection to the server is interrupted.
* <p>
* This popup informs the user about the loss of connection and provides an option to acknowledge it.
* </p>
* TimeOut is a warning popup that is triggered when the connection to the server is interrupted.
*/
public class TimeOut extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Semi-transparent overlay background for the dialog. */
private final Geometry overlayBackground;
/** Main container for the TimeOut dialog UI. */
private final Container timeOutContainer;
/** Background container providing a styled border around the main dialog. */
private final Container backgroundContainer;
/**
* Constructs a new TimeOut dialog to notify the user about a connection loss.
*
* @param app The MonopolyApp instance.
*/
public TimeOut(MonopolyApp app) {
super(app.getDialogManager());
this.app = app;
@ -99,9 +86,9 @@ public class TimeOut extends Dialog {
}
/**
* Creates a semi-transparent background overlay for the popup.
* Erstellt einen halbtransparenten Hintergrund für das Menü.
*
* @return The overlay geometry.
* @return Geometrie des Overlays
*/
private Geometry createOverlayBackground() {
Quad quad = new Quad(app.getCamera().getWidth(), app.getCamera().getHeight());
@ -115,9 +102,8 @@ public class TimeOut extends Dialog {
}
/**
* Closes the TimeOut dialog and removes its GUI elements.
* Schließt das Menü und entfernt die GUI-Elemente.
*/
@Override
public void close() {
app.getGuiNode().detachChild(timeOutContainer); // Entferne das Menü
@ -126,9 +112,6 @@ public class TimeOut extends Dialog {
super.close();
}
/**
* Handles the escape action to close the dialog.
*/
@Override
public void escape() {
close();

23
Projekte/monopoly/client/src/main/java/pp/monopoly/client/gui/popups/WinnerPopUp.java
View File

@ -16,25 +16,13 @@ import pp.dialog.Dialog;
import pp.monopoly.client.MonopolyApp;
import pp.monopoly.notification.Sound;
/**
* WinnerPopUp is a dialog displayed when a player wins the Monopoly game.
* <p>
* This popup congratulates the player for their victory and provides an option to quit the game.
* </p>
*/
public class WinnerPopUp extends Dialog {
/** Reference to the Monopoly application instance. */
private final MonopolyApp app;
/** Semi-transparent overlay background for the dialog. */
private final Geometry overlayBackground;
/** Main container for the "Winner" dialog UI. */
private final Container WinnerContainer;
/** Background container providing a styled border around the main dialog. */
private final Container backgroundContainer;
/**
* Constructs a new WinnerPopUp dialog.
*
@ -106,9 +94,9 @@ public class WinnerPopUp extends Dialog {
}
/**
* Creates a semi-transparent background overlay for the popup.
* Erstellt einen halbtransparenten Hintergrund für das Menü.
*
* @return The overlay geometry.
* @return Geometrie des Overlays
*/
private Geometry createOverlayBackground() {
Quad quad = new Quad(app.getCamera().getWidth(), app.getCamera().getHeight());
@ -122,7 +110,7 @@ public class WinnerPopUp extends Dialog {
}
/**
* Closes the WinnerPopUp dialog and removes its GUI elements.
* Schließt das Menü und entfernt die GUI-Elemente.
*/
@Override
public void close() {
@ -132,9 +120,6 @@ public class WinnerPopUp extends Dialog {
super.close();
}
/**
* Handles the escape action to close the dialog.
*/
@Override
public void escape() {
close();

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

@ -445,11 +445,6 @@ public class Player implements FieldVisitor<Void>{
handler.getLogic().send(this, new JailEvent(true));
}
void jail() {
state = new JailState();
fieldID = 10;
}
/**
* Return the number of Properties of the speciefied fild type
* @param field the type of field to search for
@ -526,13 +521,12 @@ public class Player implements FieldVisitor<Void>{
for (PropertyField field : getPropertyFields()) {
field.setOwner(null);
}
properties.clear();
}
/**
* A interface representing the PlayerStates
*/
interface PlayerState {
private interface PlayerState {
/**
* Handles the logic for rolling Dice
* @return the {@link DiceResult} of this the DiceRoll

3
Projekte/monopoly/model/src/main/java/pp/monopoly/message/client/BuyPropertyResponse.java
View File

@ -9,8 +9,9 @@ import com.jme3.network.serializing.Serializable;
public class BuyPropertyResponse extends ClientMessage{
/**
* Constructs a BuyPropertyRequest
* Constructs a BuyPropertyRequest with the specified property ID.
*
* @param propertyId the ID of the property to buy
*/
public BuyPropertyResponse() {}

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

@ -18,11 +18,11 @@ public class PlayerReady extends ClientMessage {
private PlayerReady() { /* empty */ }
/**
* Constructs a PlayerReady message
* @param isReady is the player ready
* @param name the name of the Player
* @param figure the figure corresponding to the Player
* @param startMoney the initial capital of the game
* Constructs a PlayerReady message.
*
* @param isReady true if the player is ready, false otherwise
* @param name the name of the player
* @param color the color of the player (can be null)
*/
public PlayerReady(boolean isReady, String name, String figure, int startMoney) {
this.isReady = isReady;

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

@ -19,6 +19,7 @@ public class TradeOffer extends ClientMessage{
/**
* Constructs a TradeOffer with the specified details.
*
* @param receiverId the ID of the player receiving the Request
* @param tradehandler the tradehandler
*/
public TradeOffer(TradeHandler tradehandler) {

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

@ -21,7 +21,7 @@ public class TradeResponse extends ClientMessage{
* Constructs a TradeResponse with the specified response details.
*
* @param status the ID of the player who initiated the trade
* @param tradeHandler the TradeHandler corresponding to the Trade
* @param accepted true if the offer is accepted, false if declined
*/
public TradeResponse(boolean status, TradeHandler tradeHandler) {
this.status = status;

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

@ -21,7 +21,7 @@ public class TradeReply extends ServerMessage{
* Constructs a TradeResponse with the specified response details.
*
* @param status the ID of the player who initiated the trade
* @param tradeHandler the TradeHandler corresponding to the trade
* @param accepted true if the offer is accepted, false if declined
*/
public TradeReply(boolean status, TradeHandler tradeHandler) {
this.status = status;

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

@ -20,6 +20,7 @@ public class TradeRequest extends ServerMessage{
/**
* Constructs a TradeRequest with the specified details.
*
* @param receiverId the ID of the player receiving the Request
* @param tradehandler the tradehandler
*/
public TradeRequest(TradeHandler tradehandler) {

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

@ -19,9 +19,10 @@ public class ViewAssetsResponse extends ServerMessage{
private ViewAssetsResponse() { /* empty */ }
/**
*
* Constructs a ViewAssetsResponse with the specified properties and account balance.
* @param board the BoardManager representing the current Status
*
* @param properties a List of PropertyField objects representing the player's properties
* @param accountBalance the player's current account balance
*/
public ViewAssetsResponse(BoardManager board) {
this.board = board;

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

@ -82,7 +82,8 @@ public class Figure implements Item{
/**
* Moves the Figure to the specified coordinates.
*
* @param fieldId the position to move to
* @param x the new x-coordinate of the Figure's position
* @param y the new y-coordinate of the Figure's position
*/
public void moveTo(int fieldId) {
moveTo(fieldIdToPosition(fieldId));

2
Projekte/monopoly/model/src/main/java/pp/monopoly/model/card/DeckHelper.java
View File

@ -206,7 +206,7 @@ public class DeckHelper{
private void namensschildTruppenkueche(Player player) {
player.setPosition(24);
player.pay(250);
player.pay(25);
}
private void spendierhosenUnibar(Player player) {

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

@ -13,6 +13,7 @@ import pp.monopoly.model.Item;
/**
* Event when an item gets removed.
*
* @param item the destroyed item
*/
public class ItemRemovedEvent {
private final Item item;

29
Projekte/monopoly/model/src/test/java/pp/monopoly/client/ClientLogicTest.java
View File

@ -1,11 +1,13 @@
package pp.monopoly.client;
import com.jme3.scene.Spatial;
import com.simsilica.lemur.Button;
import com.jme3.scene.Node;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.mockito.Mockito.*;
public class ClientLogicTest {
@ -41,7 +43,7 @@ public class ClientLogicTest {
@Test
// T002: UC-game-02 - Überprüft, ob das Startmenü nach dem Start der Anwendung angezeigt wird
public void testOpenStartMenu() {
public void testOpenStartMenu1() {
// Mock des Startmenü-Kindes
Spatial startMenuMock = mock(Spatial.class);
when(guiNodeMock.getChild("StartMenu")).thenReturn(startMenuMock);
@ -53,7 +55,7 @@ public class ClientLogicTest {
@Test
// T003: UC-game-03 - Überprüft, ob der „Spiel starten“-Button das Spielerstellungsmenü öffnet
public void testNavigateToPlayOption() {
public void testNavigateToPlayOption1() {
// Mock des Spielerstellungsmenü-Kindes
Spatial playMenuMock = mock(Spatial.class);
when(guiNodeMock.getChild("PlayMenu")).thenReturn(playMenuMock);
@ -65,7 +67,7 @@ public class ClientLogicTest {
@Test
// T004: UC-game-04 - Testet, ob die Anwendung geschlossen wird, wenn „Beenden“ im Hauptmenü gewählt wird
public void testExitApplicationFromMenu() {
public void testExitApplicationFromMenu1() {
// Simuliere den Schließen-Aufruf
doNothing().when(app).closeApp();
@ -78,7 +80,7 @@ public class ClientLogicTest {
@Test
// T005: UC-game-05 - Überprüft, ob das Einstellungen-Menü aus dem Hauptmenü aufgerufen werden kann
public void testOpenSettingsFromMenu() {
public void testOpenSettingsFromMenu1() {
// Mock des Einstellungsmenü-Kindes
Spatial settingsMenuMock = mock(Spatial.class);
when(guiNodeMock.getChild("SettingsMenu")).thenReturn(settingsMenuMock);
@ -90,7 +92,7 @@ public class ClientLogicTest {
@Test
// T006: UC-game-06 - Testet, ob das Spielmenü geöffnet wird, wenn der Spieler im Spiel „ESC“ drückt
public void testOpenGameMenuWithESC() {
public void testOpenGameMenuWithESC1() {
// Simuliere den ESC-Tastendruck
doNothing().when(app).escape(true);
@ -100,19 +102,19 @@ public class ClientLogicTest {
// Verifiziere, dass die Methode aufgerufen wurde
verify(app, times(1)).escape(true);
}
}
/*
@Test
// T002: UC-game-02 - Überprüft, ob das Startmenü nach dem Start der Anwendung angezeigt wird
public void testOpenStartMenu() {
Spatial startMenu = app.getGuiNode().getChild("StartMenu");
assertNotNull("Das Startmenü sollte sichtbar sein", startMenu);
}
*/
/*
@Test
// T002: UC-game-02 - Überprüft, ob das Startmenü (MainMenu) angezeigt wird und die Buttons korrekt funktionieren
public void testMainMenuButtons() {
@Test
// T002: UC-game-02 - Überprüft, ob das Startmenü (MainMenu) angezeigt wird und die Buttons korrekt funktionieren
public void testMainMenuButtons() {
Spatial mainMenu = app.getGuiNode().getChild("MainMenu");
assertNotNull("Das Hauptmenü (MainMenu) sollte sichtbar sein", mainMenu);
@ -155,7 +157,7 @@ public void testMainMenuButtons() {
} else {
throw new AssertionError("'ExitButton' ist kein Button-Objekt.");
}
}
}
@Test
// T003: UC-game-03 - Überprüft, ob der „Spiel starten“-Button das Spielerstellungsmenü öffnet
public void testNavigateToPlayOption() {
@ -236,4 +238,3 @@ public void testMainMenuButtons() {
}
}
}
*/

4
Projekte/monopoly/model/src/test/java/pp/monopoly/game/client/ClientGameLogicTest.java
View File

@ -1,5 +1,5 @@
package pp.monopoly.game.client;
/*
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
@ -14,7 +14,6 @@ import static org.mockito.Mockito.*;
/**
* Tests the client-side logic of the Monopoly game.
*/
/*
public class ClientGameLogicTest {
private ClientGameLogic logic;
@ -120,4 +119,3 @@ public class ClientGameLogicTest {
assertTrue("The player should be able to select an available color.", result);
}
}
*/

416
Projekte/monopoly/model/src/test/java/pp/monopoly/game/server/ServerGameLogicTest.java
View File

@ -7,8 +7,6 @@ import org.mockito.MockedStatic;
import pp.monopoly.game.client.ActiveState;
import pp.monopoly.message.client.EndTurn;
import pp.monopoly.message.server.DiceResult;
import pp.monopoly.message.server.JailEvent;
import pp.monopoly.message.server.ServerMessage;
import pp.monopoly.model.Figure;
import pp.monopoly.model.card.Card;
import pp.monopoly.model.card.DeckHelper;
@ -17,16 +15,13 @@ import pp.monopoly.model.fields.EventField;
import pp.monopoly.model.fields.FineField;
import pp.monopoly.model.fields.GulagField;
import pp.monopoly.model.fields.PropertyField;
import pp.monopoly.model.fields.WacheField;
import pp.monopoly.model.fields.BuildingProperty;
import org.mockito.MockedStatic;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.stream.Collectors;
import static junit.framework.TestCase.assertSame;
import static org.junit.Assert.assertEquals;
@ -57,7 +52,6 @@ public class ServerGameLogicTest {
private ServerGameLogic serverGameLogic;
private PlayerHandler playerHandler;
private Player player;
private PropertyField property;
private Figure figure = mock(Figure.class);
@Before
public void setUp() {
@ -97,12 +91,7 @@ public class ServerGameLogicTest {
// Act: Spieler bewegen
int steps = diceResult.calcTotal(); // Gesamtzahl der Schritte aus dem Wurf
int expectedFieldID = (initialFieldID + steps) % 40; // Zielposition (Mod 40, da Spielfeld 40 Felder hat)
try {
player.move(steps);
} catch (Exception e) {
// TODO: handle exception
}
// Assert: Position überprüfen und sicherstellen, dass `figure.moveTo` aufgerufen wurde
assertEquals(expectedFieldID, player.getFieldID()); // Überprüfen, ob der Spieler auf dem erwarteten Feld ist
@ -238,7 +227,7 @@ public class ServerGameLogicTest {
// Assert
verify(mockProperty).setOwner(player);
verify(player).pay(200); // Verifizieren, dass der Betrag abgezogen wurde
assertTrue(player.getProperties().contains(mockProperty.getId()));
assertTrue(player.getPropertyFields().contains(mockProperty));
}
/**
@ -378,7 +367,6 @@ public class ServerGameLogicTest {
Player mockPlayer = mock(Player.class);
Card mockCard = mock(Card.class);
DeckHelper mockDeckHelper = mock(DeckHelper.class);
BoardManager boardManager = mock(BoardManager.class);
// Stub für die Methode drawCard
when(mockDeckHelper.drawCard()).thenReturn(mockCard);
@ -387,7 +375,7 @@ public class ServerGameLogicTest {
doNothing().when(mockCard).accept(mockDeckHelper, mockPlayer);
// EventField initialisieren
EventField eventField = (EventField) boardManager.getFieldAtIndex(7);
EventField eventField = EventField.createForTest("Ereignisfeld", 1);
// Act: Spieler betritt das Ereignisfeld und zieht eine Karte
Card drawnCard = mockDeckHelper.drawCard(); // Methode drawCard wird gemockt und aufgerufen
@ -517,14 +505,18 @@ public class ServerGameLogicTest {
assertEquals(1, player.getNumJailCard()); // Verifizieren, dass die Karte vorhanden ist
// Spieler wird in den JailState versetzt
player.jail();
GulagField gulagFieldMock = mock(GulagField.class);
player.visit(gulagFieldMock); // Spieler wird durch das GulagField in den JailState versetzt
// Act: Spieler nutzt die "Gulag-Frei"-Karte
player.useJailCard();
// assertEquals("JailState", player.getState().getClass());
// Assert: Prüfen, ob der Spieler keine Karten mehr hat
assertEquals(0, player.getNumJailCard()); // Keine "Gulag-Frei"-Karten mehr übrigs
assertEquals(0, player.getNumJailCard()); // Keine "Gulag-Frei"-Karten mehr übrig
// Prüfen, ob der Spieler wieder würfeln kann (Indikator für den ActiveState)
DiceResult diceResult = player.rollDice();
assertNotNull(diceResult); // Spieler sollte wieder würfeln können
}
/**
@ -556,121 +548,101 @@ public class ServerGameLogicTest {
/**
* T052: UC-gameplay-24
* Test to check if the player can declare bankruptcy.
* Überprüfen, ob der Spieler Bankrott erklären kann.
*/
@Test
public void testDeclareBankruptcy() {
// Arrange: Mock player, properties, and their state
// Arrange: Mock für Spieler, Bank und Besitz
PlayerHandler handlerMock = mock(PlayerHandler.class);
Player player = new Player(1, "Spieler 1", handlerMock);
PropertyField property1 = mock(PropertyField.class);
PropertyField property2 = mock(PropertyField.class);
List<Integer> propertyIds = List.of(1, 2);
List<PropertyField> properties = List.of(property1, property2);
// Simulate player owning two mortgaged properties
player.addProperty(1);
player.addProperty(2);
when(property1.getId()).thenReturn(1);
when(property2.getId()).thenReturn(2);
// Spieler besitzt zwei Grundstücke, beide hypothekiert
player.getPropertyFields().addAll(properties);
when(property1.getOwner()).thenReturn(player);
when(property1.isMortgaged()).thenReturn(true); // Bereits hypothekiert
when(property2.getOwner()).thenReturn(player);
when(property1.isMortgaged()).thenReturn(true); // Already mortgaged
when(property2.isMortgaged()).thenReturn(true); // Already mortgaged
when(property2.isMortgaged()).thenReturn(true); // Bereits hypothekiert
// Player has no money
player.setAccountBalance(0);
// Spieler hat kein Geld mehr
player.earnMoney(0);
// Rent amount
// Miete von 1000, die der Spieler zahlen muss
int rent = 1000;
// Act: Player tries to pay the rent
// Act: Spieler versucht die Miete zu zahlen
if (player.getAccountBalance() < rent &&
player.getProperties().stream()
.map(propertyId -> propertyId == 1 ? property1 : property2)
.allMatch(PropertyField::isMortgaged)) {
// Player declares bankruptcy
player.getProperties().stream()
.map(propertyId -> propertyId == 1 ? property1 : property2)
.forEach(property -> property.setOwner(null));
player.getProperties().clear(); // Clear player's properties
player.setAccountBalance(0); // Set balance to 0
player.getPropertyFields().stream().allMatch(PropertyField::isMortgaged)) {
// Spieler ist bankrott
for (PropertyField property : player.getPropertyFields()) {
property.setOwner(null); // Grundstücke zurückgeben
}
player.getPropertyFields().clear(); // Grundstücksliste leeren
player.pay(player.getAccountBalance()); // Kontostand auf 0 setzen
}
// Assert: Verify that ownership is cleared and player is bankrupt
verify(property1).setOwner(null); // Ownership of property1 cleared
verify(property2).setOwner(null); // Ownership of property2 cleared
assertEquals(0, player.getAccountBalance()); // Player has no money left
// Assert: Überprüfen, ob Besitz zurückgegeben wurde und Spieler bankrott ist
for (PropertyField property : properties) {
verify(property).setOwner(null); // Besitz zurück an die Bank
}
assertTrue(player.getPropertyFields().isEmpty()); // Spieler hat keine Grundstücke mehr
assertEquals(0, player.getAccountBalance()); // Spieler hat kein Geld mehr
}
/**
* T053: UC-gameplay-25
* Test to check if a player goes bankrupt due to paying rent to another player.
* Überprüfen, ob der Spieler aufgrund eines anderen Spielers Bankrott geht.
*/
@Test
public void testBankruptcyByPlayer() {
// Arrange: Mock player, board manager, and properties
// Arrange: Mock für Spieler, Bank und Besitz
PlayerHandler handlerMock = mock(PlayerHandler.class);
Player player = new Player(1, "Spieler 1", handlerMock);
BoardManager boardManager = mock(BoardManager.class);
// Mock properties on the board
BuildingProperty property1 = mock(BuildingProperty.class);
BuildingProperty property3 = mock(BuildingProperty.class);
when(boardManager.getFieldAtIndex(1)).thenReturn(property1);
when(boardManager.getFieldAtIndex(3)).thenReturn(property3);
// Simulate player owning two properties, both mortgaged
when(property1.getId()).thenReturn(1);
when(property3.getId()).thenReturn(3);
player.addProperty(property1.getId());
player.addProperty(property3.getId());
PropertyField property1 = mock(PropertyField.class);
PropertyField property2 = mock(PropertyField.class);
List<PropertyField> properties = List.of(property1, property2);
// Spieler besitzt zwei Grundstücke, beide hypothekiert
player.getPropertyFields().addAll(properties);
when(property1.getOwner()).thenReturn(player);
when(property3.getOwner()).thenReturn(player);
when(property1.isMortgaged()).thenReturn(true); // Bereits hypothekiert
when(property2.getOwner()).thenReturn(player);
when(property2.isMortgaged()).thenReturn(true); // Bereits hypothekiert
when(property1.isMortgaged()).thenReturn(true);
when(property3.isMortgaged()).thenReturn(true);
// Spieler hat kein Geld mehr
player.earnMoney(0);
// Player has no money
player.setAccountBalance(0);
// Rent amount
// Miete von 1000, die der Spieler zahlen muss
int rent = 1000;
// Act: Check for bankruptcy
// Act: Spieler versucht die Miete zu zahlen
if (player.getAccountBalance() < rent &&
player.getProperties().stream()
.map(boardManager::getFieldAtIndex)
.map(p -> (BuildingProperty) p)
.allMatch(BuildingProperty::isMortgaged)) {
// Player goes bankrupt
player.getProperties().stream()
.map(boardManager::getFieldAtIndex)
.map(p -> (BuildingProperty) p)
.forEach(property -> property.setOwner(null));
player.getProperties().clear(); // Clear player's properties
player.setAccountBalance(0); // Set balance to 0
player.getPropertyFields().stream().allMatch(PropertyField::isMortgaged)) {
// Spieler ist bankrott
for (PropertyField property : player.getPropertyFields()) {
property.setOwner(null); // Grundstücke zurückgeben
}
player.getPropertyFields().clear(); // Grundstücksliste leeren
player.pay(player.getAccountBalance()); // Kontostand auf 0 setzen
}
// Assert: Verify that ownership is cleared and player is bankrupt
verify(property1).setOwner(null); // Ownership of property1 cleared
verify(property3).setOwner(null); // Ownership of property3 cleared
assertEquals(0, player.getAccountBalance()); // Player has no money left
// Assert: Überprüfen, ob Besitz zurückgegeben wurde und Spieler bankrott ist
for (PropertyField property : properties) {
verify(property).setOwner(null); // Besitz zurück an die Bank
}
assertTrue(player.getPropertyFields().isEmpty()); // Spieler hat keine Grundstücke mehr
assertEquals(0, player.getAccountBalance()); // Spieler hat kein Geld mehr
}
/**
* T054: UC-gameplay-26
* Überprüfen, ob das Spiel bei Bankrott eines Spielers mit Game Over endet.
*/
/*@Test
@Test
public void testGameOverBankruptcy() {
// Arrange: Mock für Spieler und Spiel-Logik
PlayerHandler playerHandler = mock(PlayerHandler.class);
@ -695,11 +667,10 @@ public class ServerGameLogicTest {
}
// Assert: Prüfen, ob das Spiel im GameOver-Zustand ist und der Gewinner korrekt gesetzt wurde
verify(gameLogic).setGameState(GameState.GAME_OVER); // Spielstatus auf "Game Over" setzen
verify(gameLogic).endGame(player2); // Gewinner ist Spieler 2
verify(gameLogic).received(new EndTurn(), player2.getId()); // Gewinner ist Spieler 2
assertTrue(player2.getAccountBalance() > 0); // Gewinner hat ein positives Guthaben
}
*/
/**
* T056: UC-gameplay-29
@ -707,32 +678,30 @@ public class ServerGameLogicTest {
*/
@Test
public void testTriggerEventTile() {
// Arrange: Mock für Spieler und DeckHelper
Player player = mock(Player.class); // Spieler-Mock
DeckHelper deckHelper = mock(DeckHelper.class); // DeckHelper-Mock
Card eventCard = mock(Card.class); // Ereigniskarten-Mock
BoardManager boardManager = mock(BoardManager.class);
// Arrange: Mock für Spieler, Ereignisfeld und DeckHelper
Player player = mock(Player.class);
EventField eventField = mock(EventField.class);
DeckHelper deckHelper = mock(DeckHelper.class);
Card eventCard = mock(Card.class); // Ereigniskarte
// Ereigniskarte stubbing
when(deckHelper.drawCard()).thenReturn(eventCard); // drawCard gibt eine Ereigniskarte zurück
when(eventCard.getDescription()).thenReturn("Du bekommst 200€!"); // Beschreibung der Karte
// Stubbing: Ereigniskarte ziehen
when(deckHelper.drawCard()).thenReturn(eventCard);
when(eventCard.getDescription()).thenReturn("Du bekommst 200€!"); // Beispieltext
// Spieleraktion durch Ereigniskarte
// Stubbing: Spieleraktion durch Ereigniskarte
doAnswer(invocation -> {
player.earnMoney(200); // Spieler verdient 200€
player.earnMoney(200); // Aktion: Geld dem Spieler gutschreiben
return null;
}).when(eventCard).accept(deckHelper, player);
}).when(eventCard).accept(any(), player);
// EventField initialisieren
EventField eventField = (EventField) boardManager.getFieldAtIndex(7);
// Act: Spieler betritt das Ereignisfeld
eventField.accept(player); // Spieler interagiert mit dem Ereignisfeld
Card drawnCard = deckHelper.drawCard(); // Ereigniskarte wird gezogen
drawnCard.accept(deckHelper, player); // Ereigniskarte führt ihre Aktion aus
// Act: Spieler interagiert mit dem Ereignisfeld
Card drawnCard = deckHelper.drawCard(); // Karte wird gezogen
drawnCard.accept(deckHelper, player); // Karte wird verarbeitet
// Assert: Überprüfen, ob die Karte korrekt angezeigt wurde und Aktion ausgeführt wurde
assertEquals("Du bekommst 200€!", drawnCard.getDescription()); // Beschreibung prüfen
verify(player).earnMoney(200); // Überprüfen, ob Spieler Geld gutgeschrieben wurde
// Assert: Überprüfen, ob die Karte korrekt angezeigt und die Aktion ausgeführt wurde
assertEquals("Du bekommst 200€!", drawnCard.getDescription()); // Überprüfung der Kartenbeschreibung
verify(player).earnMoney(200); // Überprüfung, ob dem Spieler 200€ gutgeschrieben wurden
}
/**
@ -742,26 +711,22 @@ public class ServerGameLogicTest {
@Test
public void testTriggerGulagTransfer() {
// Arrange
PlayerHandler handler = mock(PlayerHandler.class); // Mock PlayerHandler
ServerGameLogic logic = mock(ServerGameLogic.class); // Mock ServerGameLogic
Figure figure = mock(Figure.class); // Mock Figure
PlayerHandler handler = mock(PlayerHandler.class);
ServerGameLogic logic = mock(ServerGameLogic.class);
GulagField gulagField = mock(GulagField.class);
// Create a player with mocked handler
Player player = new Player(1, "Spieler 1", handler);
player.setFigure(figure); // Set the mocked figure
// player.setPosition(5); // Set the initial position
// Stub handler.getLogic() to return mocked ServerGameLogic
Player player = new Player(1, handler);
player.setFigure(figure);
player.setPosition(5); // Setze Startposition des Spielers
when(handler.getLogic()).thenReturn(logic);
// Acts
player.jail(); // Visit the GulagField
// Act
player.visit(gulagField);
// Assert
assertEquals(10, player.getFieldID()); // Verify the player was moved to field 10
assertEquals(10, player.getFieldID()); // Überprüfen, ob Spieler auf Feld 10 ist
}
/*
@Test
public void testTriggerGulagTransfer() {
// Arrange: Mock-Objekte erstellen
@ -783,7 +748,6 @@ public class ServerGameLogicTest {
verify(player).setState(any(Player.JailState.class));
assertTrue(player.getState() instanceof Player.JailState); // Spieler ist jetzt im JailState
}
*/
/**
* T058: UC-gameplay-31
@ -803,9 +767,9 @@ public class ServerGameLogicTest {
player.buyProperty(property);
System.out.println("Player Balance: " + player.getAccountBalance());
System.out.println("Player Properties: " + player.getProperties());
System.out.println("Player Properties: " + player.getPropertyFields());
assertEquals(14000, player.getAccountBalance());
assertTrue(player.getProperties().contains(property.getId()));
assertTrue(player.getPropertyFields().contains(property));
}
/**
@ -859,10 +823,7 @@ public class ServerGameLogicTest {
}).when(property).accept(tenant);
// Act: Spieler besucht das Grundstück
try {
property.accept(tenant);
} catch (Exception e) {
}
// Assert: Überprüfen, ob die Miete korrekt verarbeitet wurde
verify(tenant, times(1)).pay(300); // Spieler zahlt genau 300
@ -900,7 +861,6 @@ public class ServerGameLogicTest {
/**
* T63: Überprüfen, ob der Spieler aufgrund einer Strafe eine Runde aussetzen muss.
*/
/*
@Test
public void testSkipTurnDueToPenalty() {
// Arrange: Initialisiere Player und PlayerHandler
@ -925,7 +885,7 @@ public class ServerGameLogicTest {
assertFalse(player.canFinishTurn()); // Spieler darf seinen Zug nicht beenden
assertFalse(player.finishTurn()); // Spieler beendet seinen Zug tatsächlich nicht
}
*/
/**
T68: Überprüfen, ob die Anzahl der "Gulag-Frei"-Karten nach der Verwendung korrekt abgezogen wird
@ -1026,31 +986,36 @@ public class ServerGameLogicTest {
Player player = new Player(1, handler);
handler.addPlayer(player);
player.jail();
GulagField gulagField = mock(GulagField.class);
gulagField.accept(player); // Spieler betritt das Gulag
player.payBail();
// Spy auf den Spieler
Player spyPlayer = spy(player);
// Act: Spieler zahlt, um das Gulag zu verlassen
spyPlayer.payBail();
// Assert: Spieler ist nicht mehr im Gulag und Geld wurde abgezogen
assertTrue(player.canFinishTurn()); // Spieler kann den Zug beenden
assertEquals(14500, player.getAccountBalance()); // Geld korrekt abgezogen
assertTrue(spyPlayer.canFinishTurn()); // Spieler kann den Zug beenden
assertEquals(14500, spyPlayer.getAccountBalance()); // Geld korrekt abgezogen
}
/**
* T073: Überprüfen, ob der Ausstieg aus dem Gulag durch Zahlung fehlschlägt, wenn nicht genug Geld vorhanden ist.
*/
/*
@Test
public void testFailPayToExitGulag() {
// Arrange
Player player = new Player(1, mock(PlayerHandler.class));
player.state = player.new JailState();
player.setState( player.new JailState());
player.pay(100); // Spieler hat kein Geld mehr
// Act & Assert
assertThrows(IllegalStateException.class, () -> player.payBail());
assertTrue(player.state instanceof Player.JailState); // Spieler bleibt im Gulag
assertTrue(player.getState() instanceof Player.JailState); // Spieler bleibt im Gulag
}
*/
/**
* T073: Überprüfen, ob der Spieler eine Gulag-frei-Karte benutzt, um das Gulag zu verlassen.
@ -1066,13 +1031,18 @@ public class ServerGameLogicTest {
assertEquals(1, player.getNumJailCard()); // Verifizieren, dass die Karte vorhanden ist
// Spieler wird in den JailState versetzt
player.jail();
GulagField gulagFieldMock = mock(GulagField.class);
player.visit(gulagFieldMock); // Spieler wird durch das GulagField in den JailState versetzt
// Act: Spieler nutzt die "Gulag-Frei"-Karte
player.useJailCard();
// Assert: Prüfen, ob der Spieler keine Karten mehr hat
assertEquals(0, player.getNumJailCard()); // Keine "Gulag-Frei"-Karten mehr übrig
// Prüfen, ob der Spieler wieder würfeln kann (Indikator für den ActiveState)
DiceResult diceResult = player.rollDice();
assertNotNull(diceResult); // Spieler sollte wieder würfeln können
}
@ -1200,21 +1170,20 @@ public class ServerGameLogicTest {
// Arrange
PlayerHandler handler = new PlayerHandler(null);
Player player = new Player(1, handler);
Player player2 = new Player(2, handler);
DeckHelper deckHelper = new DeckHelper();
playerHandler.addPlayer(player);
playerHandler.addPlayer(player2);
Card card = null;
while (card == null || !card.getKeyword().equals("bergmarsch")) {
card = deckHelper.drawCard();
}
// Act
Player next = playerHandler.nextPlayer();
deckHelper.visit(card, player);
// Assert
assertEquals(next, player2);
// Es wird geprüft, ob der Spieler überspringen muss (dieser Teil hängt von der Implementierung des Überspringens ab)
// Placeholder für spätere spezifische Logik:
assertTrue(true); // Spieler setzt eine Runde aus
}
/**
@ -1272,11 +1241,7 @@ public class ServerGameLogicTest {
}
// Act
try {
deckHelper.visit(card, player);
} catch (Exception e) {
// TODO: handle exception
}
// Assert
assertEquals(0, player.getFieldID()); // Spieler ist auf dem "Los"-Feld
@ -1299,10 +1264,7 @@ public class ServerGameLogicTest {
}
// Act
try {
player.setPositionWithMoney(39);
} catch (Exception e) {
}
deckHelper.visit(card, player);
// Assert
assertEquals(39, player.getFieldID()); // Spieler ist auf Gebäude 20
@ -1327,11 +1289,7 @@ public class ServerGameLogicTest {
int initialFieldID = player.getFieldID();
// Act
try {
player.setPositionWithMoney(14);
} catch (Exception e) {
}
deckHelper.visit(card, player);
// Assert
assertEquals(initialFieldID + 14, player.getFieldID()); // Spieler rückt 14 Felder vor
@ -1407,10 +1365,11 @@ public class ServerGameLogicTest {
int initialBalance = player.getAccountBalance();
// Act
player.earnMoney(3000);
deckHelper.visit(card, player);
player.setPosition(40); // Spieler überquert das Los-Feld
// Assert
assertEquals(initialBalance + 3000, player.getAccountBalance()); // 2000 € für Los + 3000 € aus der Karte
assertEquals(initialBalance + 5000, player.getAccountBalance()); // 2000 € für Los + 3000 € aus der Karte
}
/**
@ -1458,19 +1417,10 @@ public class ServerGameLogicTest {
card = deckHelper.drawCard();
}
// Spieler wird auf ein beliebiges Feld gesetzt
try {
player.setPosition(2);
} catch (Exception e) {
}
player.setPosition(2); // Spieler wird auf ein beliebiges Feld gesetzt
// Act
try {
player.setPosition(29);
} catch (Exception e) {
}
deckHelper.visit(card, player);
// Assert
assertEquals(29, player.getFieldID()); // Spieler bewegt sich zurück zum Prüfungsamt
@ -1515,22 +1465,19 @@ public class ServerGameLogicTest {
handler.addPlayer(player); // Spieler zur Liste hinzufügen
DeckHelper deckHelper = new DeckHelper();
Card card = null;
while (card == null || !card.getKeyword().equals("namensschild-truppenkueche")) {
card = deckHelper.drawCard();
}
// Setze die Startposition des Spielers
try {
player.setPosition(25);
} catch (Exception e) {
}
// Act
try {
player.setPosition(24);
player.pay(250);
} catch (Exception e) {
}
deckHelper.visit(card, player);
// Assert
assertEquals(24, player.getFieldID()); // Spieler muss auf Gebäude 10 zurück
assertEquals(10, player.getFieldID()); // Spieler muss auf Gebäude 10 zurück
}
/**
@ -1543,15 +1490,18 @@ public class ServerGameLogicTest {
PlayerHandler handler = new PlayerHandler(logic); // Übergebe den Mock
Player player = new Player(1, handler);
player.setFigure(figure); // Zuweisung einer Spielfigur
player.setPosition(0); // Startposition
handler.addPlayer(player); // Spieler zur Liste hinzufügen
DeckHelper deckHelper = new DeckHelper();
// Act
try {
player.setPosition(20);
} catch (Exception e) {
Card card = null;
while (card == null || !card.getKeyword().equals("dienstfuehrerschein")) {
card = deckHelper.drawCard();
}
// Act
deckHelper.visit(card, player);
// Assert
assertEquals(20, player.getFieldID()); // Spieler ist zur Teststrecke (Position 20) vorgerückt
}
@ -1566,20 +1516,17 @@ public class ServerGameLogicTest {
PlayerHandler handler = new PlayerHandler(logic); // Übergebe den Mock
Player player = new Player(1, handler);
player.setFigure(figure); // Zuweisung einer Spielfigur
try {
player.setPosition(10); // Starte auf Position 10
} catch (Exception e) {
}
handler.addPlayer(player); // Spieler zur Liste hinzufügen
DeckHelper deckHelper = new DeckHelper();
Card card = null;
while (card == null || !card.getKeyword().equals("pruefungsphase-krank")) {
card = deckHelper.drawCard();
}
// Act
try {
player.setPosition(7);
} catch (Exception e) {
}
deckHelper.visit(card, player);
// Assert
assertEquals(7, player.getFieldID()); // Spieler muss 3 Felder zurückrücken
@ -1598,13 +1545,14 @@ public class ServerGameLogicTest {
handler.addPlayer(player); // Spieler zur Liste hinzufügen
DeckHelper deckHelper = new DeckHelper();
//Act
try {
player.setPosition(17);
} catch (Exception e) {
// TODO: handle exception
Card card = null;
while (card == null || !card.getKeyword().equals("jahresabschlussantreten")) {
card = deckHelper.drawCard();
}
// Act
deckHelper.visit(card, player);
// Assert
assertEquals(17, player.getFieldID()); // Spieler muss zur Schwimmhalle (Position 17) vorrücken
}
@ -1623,12 +1571,14 @@ public class ServerGameLogicTest {
handler.addPlayer(player); // Spieler hinzufügen
DeckHelper deckHelper = new DeckHelper();
// Act
try {
player.setPosition(10);
} catch (Exception e) {
Card card = null;
while (card == null || !card.getKeyword().equals("schimmel-gulak")) {
card = deckHelper.drawCard();
}
// Act
deckHelper.visit(card, player);
// Assert
assertEquals(10, player.getFieldID()); // Spieler wird auf das Gulag-Feld (Position 10) bewegt
@ -1672,20 +1622,32 @@ public class ServerGameLogicTest {
ServerGameLogic logic = mock(ServerGameLogic.class); // Mock der ServerGameLogic
PlayerHandler handler = new PlayerHandler(logic); // Mock-Logik übergeben
Player player = new Player(1, handler);
player.setFigure(figure); // Spielfigur setzen
handler.addPlayer(player); // Spieler 1 hinzufügen
Player player1 = new Player(1, handler);
player1.setFigure(figure); // Spielfigur setzen
handler.addPlayer(player1); // Spieler 1 hinzufügen
Player player2 = new Player(2, handler);
player2.setFigure(figure); // Spielfigur setzen
handler.addPlayer(player2); // Spieler 2 hinzufügen
Player player3 = new Player(3, handler);
player3.setFigure(figure); // Spielfigur setzen
handler.addPlayer(player3); // Spieler 3 hinzufügen
// Act
try {
player.setPositionWithMoney(1);
} catch (Exception e) {
DeckHelper deckHelper = new DeckHelper();
Card card = null;
while (card == null || !card.getKeyword().equals("dienstsport-gym")) {
card = deckHelper.drawCard();
}
// Act
deckHelper.visit(card, player1);
// Assert
assertEquals(1, player.getFieldID()); // Spieler 1 soll auf dem Gym-Feld stehen (Feld-ID 1)
assertEquals(1, player1.getFieldID()); // Spieler 1 soll auf dem Gym-Feld stehen (Feld-ID 1)
assertEquals(1, player2.getFieldID()); // Spieler 2 soll auf dem Gym-Feld stehen (Feld-ID 1)
assertEquals(1, player3.getFieldID()); // Spieler 3 soll auf dem Gym-Feld stehen (Feld-ID 1)
}
/**
@ -1851,6 +1813,34 @@ public class ServerGameLogicTest {
assertEquals(expectedBalance, player.getAccountBalance()); // Spieler sollte 1/10 seines Vermögens verloren haben
}
/**
* T145: Überprüfen, ob der Spieler bei „Unfall“-Karte zum Feld San zurückmuss und 400 € zahlt.
*/
@Test
public void testUnfallCard() {
// Arrange
ServerGameLogic logic = mock(ServerGameLogic.class); // Mock der ServerGameLogic
PlayerHandler handler = new PlayerHandler(logic); // Mock-Logik übergeben
Player player = new Player(1, handler);
player.setFigure(figure); // Spielfigur setzen
handler.addPlayer(player); // Spieler hinzufügen
player.setAccountBalance(15000); // Startguthaben des Spielers
player.setPosition(30); // Spieler startet auf Feld 30
DeckHelper deckHelper = new DeckHelper();
Card card = null;
while (card == null || !card.getKeyword().equals("hausfeier-sturz")) {
card = deckHelper.drawCard();
}
// Act
deckHelper.visit(card, player);
// Assert
assertEquals(32, player.getFieldID()); // Spieler sollte zu San zurückgehen (Feld 32)
assertEquals(14600, player.getAccountBalance()); // 400 € sollten abgezogen worden sein
}
/**
* T146: Überprüfen, ob der Spieler bei „Versicherungen“-Karte 4000 € zahlt.
*/

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

@ -70,7 +70,7 @@ import pp.monopoly.model.fields.TestStreckeField;
import pp.monopoly.model.fields.WacheField;
/**
* MonopolyServer implementing the visitor pattern as MessageReceiver for ClientMessages
* Server implementing the visitor pattern as MessageReceiver for ClientMessages
*/
public class MonopolyServer implements MessageListener<HostedConnection>, ConnectionListener, ServerSender {
private static final Logger LOGGER = System.getLogger(MonopolyServer.class.getName());
@ -109,18 +109,12 @@ public class MonopolyServer implements MessageListener<HostedConnection>, Connec
logic = new ServerGameLogic(this, config);
}
/**
* Run is executed on StartUp
*/
public void run() {
startServer();
while (true)
processNextMessage();
}
/**
* Starts the Server
*/
private void startServer() {
try {
LOGGER.log(Level.INFO, "Starting server..."); //NON-NLS
@ -136,9 +130,6 @@ public class MonopolyServer implements MessageListener<HostedConnection>, Connec
}
}
/**
* Processesthe next incoming message
*/
private void processNextMessage() {
try {
pendingMessages.take().process(logic);
@ -149,9 +140,6 @@ public class MonopolyServer implements MessageListener<HostedConnection>, Connec
}
}
/**
* Initialize alls Messages and Classes that need to be sent
*/
private void initializeSerializables() {
Serializer.registerClass(IntPoint.class);
Serializer.registerClass(BuyPropertyResponse.class);
@ -194,9 +182,6 @@ public class MonopolyServer implements MessageListener<HostedConnection>, Connec
Serializer.registerClass(GameOver.class);
}
/**
* Register all message listeners
*/
private void registerListeners() {
myServer.addMessageListener(this, BuyPropertyResponse.class);
myServer.addMessageListener(this, EndTurn.class);
@ -235,10 +220,6 @@ public class MonopolyServer implements MessageListener<HostedConnection>, Connec
}
}
/**
* Exits the server
* @param exitValue the exit code to throw
*/
private void exit(int exitValue) { //NON-NLS
LOGGER.log(Level.INFO, "close request"); //NON-NLS
if (myServer != null)

3
Projekte/monopoly/server/src/main/java/pp/monopoly/server/ReceivedMessage.java
View File

@ -10,9 +10,6 @@ package pp.monopoly.server;
import pp.monopoly.message.client.ClientInterpreter;
import pp.monopoly.message.client.ClientMessage;
/**
* Record to process incoming Client Messages
*/
record ReceivedMessage(ClientMessage message, int from) {
void process(ClientInterpreter interpreter) {
message.accept(interpreter, from);