From 16c425c5077af41bc8d1b4ae583b4e1b875f2a1e Mon Sep 17 00:00:00 2001 From: Yannik Bretschneider Date: Mon, 7 Jun 2021 01:58:25 +0200 Subject: [PATCH] refactor: formatted Lobby files properly --- .../marvelous/server/lobby/Lobby.java | 59 ++++++++++--------- .../marvelous/server/lobby/TurnTimer.java | 6 +- .../lobby/pipelining/DisconnectSegment.java | 9 ++- .../lobby/pipelining/GameStateSegment.java | 6 +- .../server/lobby/pipelining/Packet.java | 12 ++-- .../server/lobby/pipelining/PauseSegment.java | 18 +++--- .../server/lobby/pipelining/Pipeline.java | 35 +++++------ .../pipelining/RequestGameStateSegment.java | 4 +- .../server/lobby/pipelining/Segment.java | 24 ++++---- 9 files changed, 90 insertions(+), 83 deletions(-) diff --git a/Server/src/main/java/uulm/teamname/marvelous/server/lobby/Lobby.java b/Server/src/main/java/uulm/teamname/marvelous/server/lobby/Lobby.java index 40de790..b15d1d2 100644 --- a/Server/src/main/java/uulm/teamname/marvelous/server/lobby/Lobby.java +++ b/Server/src/main/java/uulm/teamname/marvelous/server/lobby/Lobby.java @@ -30,14 +30,14 @@ public class Lobby { private final TurnTimer turnTimer; /** - * The {@link Lobby} is where the magic happens. - * In this class is a whole {@link GameInstance game} is processed. - * To initialize the game it gets the following parameters - * @param gameID a String to identify the game - * @param connection the Connection to the {@link uulm.teamname.marvelous.server.lobbymanager.LobbyManager} - * @param partyConfig declared in Editor + * The {@link Lobby} is where the magic happens. In this class is a whole {@link GameInstance game} is processed. To + * initialize the game it gets the following parameters + * + * @param gameID a String to identify the game + * @param connection the Connection to the {@link uulm.teamname.marvelous.server.lobbymanager.LobbyManager} + * @param partyConfig declared in Editor * @param characterConfig declared in Editor - * @param scenarioConfig declared in Editor + * @param scenarioConfig declared in Editor */ public Lobby( String gameID, @@ -84,15 +84,16 @@ public class Lobby { /** * Called by {@link LobbyConnection} to handle requests + * * @param requests to be processed - * @param source the player executing the requests + * @param source the player executing the requests */ public synchronized void receiveRequests(Request[] requests, Participant source) { Logger.trace("Received {} requests from participant '{}' of type {}", requests.length, source.name, source.type); - if(activePlayer != source && source.type != ParticipantType.Spectator) { + if (activePlayer != source && source.type != ParticipantType.Spectator) { Logger.trace("Resetting bad requests as new participant sent data"); activePlayer = source; badRequests = 0; @@ -118,8 +119,8 @@ public class Lobby { } /** - * This method is called at the end of receiveRequests, to start a timer. - * The active player has now a specific amount of time to do his moves. + * This method is called at the end of receiveRequests, to start a timer. The active player has now a specific + * amount of time to do his moves. */ void updateTimer() { var currentActiveCharacterType = game.state.getActiveCharacter().type; @@ -151,28 +152,29 @@ public class Lobby { /** * If the player executed a false request the request gets rejected. + * * @param source the executing player */ private void reject(Participant source) { connection.sendEvents(source, new EventBuilder(EventType.Nack).buildGameEvent(), game.getGameStateEvent()); - badRequests ++; + badRequests++; //if the player sends 2 bad messages after one another, the player gets kicked out of the lobby. - if(badRequests >= 5){ + if (badRequests >= 5) { connection.removeParticipant(source); - if(connection.hasPlayer1()){ - generateWin(connection.getPlayer1()); - } - else if(connection.hasPlayer2()) { - generateWin(connection.getPlayer2()); + if (connection.hasPlayer1()) { + generateWin(connection.getPlayer1()); + } else if (connection.hasPlayer2()) { + generateWin(connection.getPlayer2()); } } } /** * Warns the player he get timeouted soon. + * * @param source soon to be timeouted player */ - public synchronized void soonTimeout (Participant source){ + public synchronized void soonTimeout(Participant source) { connection.sendEvents( source, new EventBuilder(EventType.TimeoutWarningEvent).buildGameStateEvent()); @@ -180,27 +182,26 @@ public class Lobby { /** * If a player times out the other player automatically wins. + * * @param source is the timeouted player */ - public synchronized void timeout(Participant source){ + public synchronized void timeout(Participant source) { connection.sendEvents( source, new EventBuilder(EventType.TimeoutEvent).buildGameStateEvent()); connection.removeParticipant(source); - if(connection.hasPlayer1() && !connection.hasPlayer2()){ + if (connection.hasPlayer1() && !connection.hasPlayer2()) { generateWin(connection.getPlayer1()); - } - else if(!connection.hasPlayer1() && connection.hasPlayer2()) { + } else if (!connection.hasPlayer1() && connection.hasPlayer2()) { generateWin(connection.getPlayer2()); - } - else { + } else { throw new IllegalStateException("Spectator was time-outed which is impossible"); } } /** Skips the current turn, and starts a new one. Exclusively called in the {@link TurnTimer}. */ - private synchronized void turnTimeout(Participant source){ + private synchronized void turnTimeout(Participant source) { var nextTurnEvents = game.endTurn(); nextTurnEvents.add(game.getGameStateEvent()); connection.broadcastEvents(); @@ -208,12 +209,12 @@ public class Lobby { } /** - * The method generates a Win event for a {@link Participant}. - * Afterwards it sends a Disconnect to everyone, and terminates the connection. + * The method generates a Win event for a {@link Participant}. Afterwards it sends a Disconnect to everyone, and + * terminates the connection. * * @param winner is the {@link Participant} that won */ - public synchronized void generateWin(Participant winner){ + public synchronized void generateWin(Participant winner) { connection.broadcastEvents( new EventBuilder(EventType.WinEvent) .withPlayerWon(winner.type.equals(ParticipantType.PlayerOne) ? 1 : 2) diff --git a/Server/src/main/java/uulm/teamname/marvelous/server/lobby/TurnTimer.java b/Server/src/main/java/uulm/teamname/marvelous/server/lobby/TurnTimer.java index 7e610d7..8ca2847 100644 --- a/Server/src/main/java/uulm/teamname/marvelous/server/lobby/TurnTimer.java +++ b/Server/src/main/java/uulm/teamname/marvelous/server/lobby/TurnTimer.java @@ -34,6 +34,7 @@ public class TurnTimer { /** * This method checks if the participant is not a spectator. Otherwise it won't start a timer. + * * @param participant the timer is for */ public void startTurnTimer(Participant participant) { @@ -44,7 +45,10 @@ public class TurnTimer { clear(); Logger.debug("Starting turn timer for participant '{}' with role {}", participant.name, participant.type); - current = timer.schedule(() -> {callback.accept(participant); return participant;}, + current = timer.schedule(() -> { + callback.accept(participant); + return participant; + }, maxRoundTime, TimeUnit.SECONDS); } diff --git a/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/DisconnectSegment.java b/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/DisconnectSegment.java index accac3a..1aeeb32 100644 --- a/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/DisconnectSegment.java +++ b/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/DisconnectSegment.java @@ -10,8 +10,8 @@ import java.util.List; import java.util.concurrent.atomic.AtomicBoolean; /** - * The {@link DisconnectSegment} handles requests of {@link RequestType} DisconnectRequest. - * Therefore it removes the disconnecting player-connection from the {@link Lobby}. + * The {@link DisconnectSegment} handles requests of {@link RequestType} DisconnectRequest. Therefore it removes the + * disconnecting player-connection from the {@link Lobby}. */ public class DisconnectSegment implements Segment { @@ -29,10 +29,9 @@ public class DisconnectSegment implements Segment { parent.getConnection().removeParticipant(packet.getOrigin()); if (packet.getOrigin().type != ParticipantType.Spectator) { - if(parent.getConnection().hasPlayer1()){ + if (parent.getConnection().hasPlayer1()) { parent.generateWin(parent.getConnection().getPlayer1()); - } - else if(parent.getConnection().hasPlayer2()) { + } else if (parent.getConnection().hasPlayer2()) { parent.generateWin(parent.getConnection().getPlayer2()); } } diff --git a/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/GameStateSegment.java b/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/GameStateSegment.java index 4ada08b..da3a5b7 100644 --- a/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/GameStateSegment.java +++ b/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/GameStateSegment.java @@ -12,14 +12,14 @@ import java.util.List; import java.util.concurrent.atomic.AtomicBoolean; /** - * The {@link GameStateSegment} handles all {@link GameInstance game} relevant {@link Request Requests}. - * Therefore it updates the game with the matching request. + * The {@link GameStateSegment} handles all {@link GameInstance game} relevant {@link Request Requests}. Therefore it + * updates the game with the matching request. */ public class GameStateSegment implements Segment { private GameInstance game; - public GameStateSegment(GameInstance game){ + public GameStateSegment(GameInstance game) { this.game = game; } diff --git a/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/Packet.java b/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/Packet.java index 1c9c9ff..948eb00 100644 --- a/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/Packet.java +++ b/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/Packet.java @@ -7,20 +7,21 @@ import uulm.teamname.marvelous.server.lobbymanager.Participant; import java.util.*; /** - * The {@link Packet} contains all {@link Request Requests} and the belonging {@link Participant}. - * You can add and remove {@link Request Requests} at will. + * The {@link Packet} contains all {@link Request Requests} and the belonging {@link Participant}. You can add and + * remove {@link Request Requests} at will. */ public class Packet extends ArrayList { private final Participant origin; - public Packet (Request[] requests, Participant origin) { + public Packet(Request[] requests, Participant origin) { this.origin = origin; addAll(Arrays.asList(requests)); } /** * This method checks if a {@link RequestType} is part of the {@link Packet} or not + * * @param requiredType RequestType to check. * @return boolean */ @@ -35,6 +36,7 @@ public class Packet extends ArrayList { /** * This method removes all {@link Request Requests} of given {@link RequestType types} from the {@link Packet}. + * * @param types RequestType(s) to remove */ public void removeRequestsOfTypes(RequestType... types) { @@ -43,7 +45,9 @@ public class Packet extends ArrayList { } /** - * This method removes all {@link Request Requests} except of given {@link RequestType types} from the {@link Packet}. + * This method removes all {@link Request Requests} except of given {@link RequestType types} from the {@link + * Packet}. + * * @param types RequestType(s) to not remove */ public void removeRequestsNotOfTypes(RequestType... types) { diff --git a/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/PauseSegment.java b/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/PauseSegment.java index 067ccd4..d6241c4 100644 --- a/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/PauseSegment.java +++ b/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/PauseSegment.java @@ -18,15 +18,13 @@ public class PauseSegment implements Segment { private boolean paused; - public PauseSegment(){ + public PauseSegment() { paused = false; } - /** - * This method pauses the game if it is not already paused. - */ - public void pauseGame(){ - if(!paused) { + /** This method pauses the game if it is not already paused.*/ + public void pauseGame() { + if (!paused) { paused = true; Logger.debug("Game paused."); } @@ -35,8 +33,8 @@ public class PauseSegment implements Segment { /** * This method ends a paused game. */ - public void pauseEnd(){ - if(paused) { + public void pauseEnd() { + if (paused) { paused = false; Logger.debug("Game unpaused."); } @@ -48,8 +46,8 @@ public class PauseSegment implements Segment { /** - * Pipelining method to process a set of requests. - * The list of requests will be processed according to the following rules: + * Pipelining method to process a set of requests. The list of requests will be processed according to the following + * rules: *
    *
  • If there is a PauseStartRequest, the paused value will be set to true
    • *
  • Any CharacterRequests will be removed from the requests if the game is paused. These include: diff --git a/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/Pipeline.java b/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/Pipeline.java index 7226ffc..6578d96 100644 --- a/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/Pipeline.java +++ b/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/Pipeline.java @@ -9,8 +9,8 @@ import java.util.*; import java.util.concurrent.atomic.AtomicBoolean; /** - * The {@link Pipeline} class pipelines {@link Request Requests} through {@link Segment Segments} to - * create {@link Event Events}. To add functionality without dabbling in the game library, create a new {@link Segment}. + * The {@link Pipeline} class pipelines {@link Request Requests} through {@link Segment Segments} to create {@link Event + * Events}. To add functionality without dabbling in the game library, create a new {@link Segment}. */ public class Pipeline { @@ -25,17 +25,17 @@ public class Pipeline { } /** - * Pipeline the {@link Request Requests} through all {@link Segment Segments} that are in the pipeline. - * The {@link Request Requests} are declared as the Packet. The {@link Request Requests} are filtered - * by each {@link Segment segment}, whereby each {@link Segment segment} takes (and thereby removes) all - * {@link Event events} relevant to the {@link Segment segment}. The {@link Event Events} are returned at the - * end of the pipeline. + * Pipeline the {@link Request Requests} through all {@link Segment Segments} that are in the pipeline. The {@link + * Request Requests} are declared as the Packet. The {@link Request Requests} are filtered by each {@link + * Segment segment}, whereby each {@link Segment segment} takes (and thereby removes) all {@link Event events} + * relevant to the {@link Segment segment}. The {@link Event Events} are returned at the end of the pipeline. + * * @param requests are the requests that are being pipelined through the pipeline * @return a {@link Optional}<{@link Event}[]>, whereby the state of the {@link Optional} declares whether the - * execution of the {@link Pipeline} was successful. If the optional is empty, the input requests were - * invalid, and an error message can be sent to the client. To get the {@link Event Events} - * out of the {@link Optional}, first check whether the {@link Optional} is empty by doing - * {@link Optional#isEmpty()} or {@link Optional#isPresent()}, and act accordingly. + * execution of the {@link Pipeline} was successful. If the optional is empty, the input requests were invalid, + * and an error message can be sent to the client. To get the {@link Event Events} out of the {@link Optional}, + * first check whether the {@link Optional} is empty by doing {@link Optional#isEmpty()} or {@link + * Optional#isPresent()}, and act accordingly. */ public Optional> processRequests(Request[] requests, Participant origin) { Logger.trace("Pipeline started RequestProcessing"); @@ -48,7 +48,7 @@ public class Pipeline { Logger.trace("Iterating through segments"); // Loop through all segments - for (Segment segment: segments) { + for (Segment segment : segments) { // Give the segment the packet, carrier and abort, and let it process requests segment.processRequests(packet, carrier, abort); if (packet.size() == 0 || abort.get()) { // if packet is empty (all requests processed) or abort initiated @@ -65,10 +65,11 @@ public class Pipeline { } /** - * Adds a segment to the pipeline. Note that ORDER MATTERS! The first segment added will be the - * first segment to process events. Also note that segments cannot be removed once added. This is by - * design, as removing segments would give the pipeline runtime customizability, which it is not supposed to - * possess in the first place. + * Adds a segment to the pipeline. Note that ORDER MATTERS! The first segment added will be the first segment + * to process events. Also note that segments cannot be removed once added. This is by design, as removing + * segments would give the pipeline runtime customizability, which it is not supposed to possess in the first + * place. + * * @param toAdd is the segment that will be added to the pipeline * @return the pipeline itself for chaining */ @@ -77,7 +78,7 @@ public class Pipeline { return this; } - public boolean contains(Segment segment){ + public boolean contains(Segment segment) { return segments.contains(segment); } } diff --git a/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/RequestGameStateSegment.java b/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/RequestGameStateSegment.java index f94ece3..c7cdcb8 100644 --- a/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/RequestGameStateSegment.java +++ b/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/RequestGameStateSegment.java @@ -11,8 +11,8 @@ import java.util.List; import java.util.concurrent.atomic.AtomicBoolean; /** - * The {@link RequestGameStateSegment} handles requests of {@link RequestType} Req. - * Therefore it sends the active gamestate and clears the {@link Packet} afterwards. + * The {@link RequestGameStateSegment} handles requests of {@link RequestType} Req. Therefore it sends the active + * gamestate and clears the {@link Packet} afterwards. */ public class RequestGameStateSegment implements Segment { diff --git a/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/Segment.java b/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/Segment.java index 9fb2df2..fc42dce 100644 --- a/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/Segment.java +++ b/Server/src/main/java/uulm/teamname/marvelous/server/lobby/pipelining/Segment.java @@ -8,18 +8,18 @@ import java.util.concurrent.atomic.AtomicBoolean; public interface Segment { /** - * Pipelining method to process a set of requests. - * The list of requests will be processed according to some set of rules. Hereby, - * the {@link Request Requests} in the packet will be filtered out as appropriate, - * whereby the resulting {@link Event Events} are appended to the carrier. - * @param packet is a {@link List} of {@link Request Requests} that is filtered - * by the {@link Segment} as appropriate - * @param carrier is a {@link List} of {@link Event Events} that is appended to - * if new requests are generated from the execution of the {@link Segment} - * @param abort is an {@link AtomicBoolean} describing whether an error has occurred during the execution of - * the {@link Segment} Note that error here does not describe an execution error - * of the segment, but instead an error in the events passed to it, like for example moving into a Rock. - * The conventional way of setting this boolean is to write {@code abort.set(true); return;} + * Pipelining method to process a set of requests. The list of requests will be processed according to some set of + * rules. Hereby, the {@link Request Requests} in the packet will be filtered out as appropriate, whereby the + * resulting {@link Event Events} are appended to the carrier. + * + * @param packet is a {@link List} of {@link Request Requests} that is filtered by the {@link Segment} as + * appropriate + * @param carrier is a {@link List} of {@link Event Events} that is appended to if new requests are generated from + * the execution of the {@link Segment} + * @param abort is an {@link AtomicBoolean} describing whether an error has occurred during the execution of the + * {@link Segment} Note that error here does not describe an execution error of the + * segment, but instead an error in the events passed to it, like for example moving into a Rock. The + * conventional way of setting this boolean is to write {@code abort.set(true); return;} */ public void processRequests(Packet packet, List carrier, AtomicBoolean abort); }