fix: Refactored to Gradle-based project, and added dependencies

src/main/java/uulm/teamname/marvelous/gamelibrary/gamelogic/GameLogic.java

@@ -0,0 +1,85 @@
+package uulm.teamname.marvelous.gamelibrary.gamelogic;
+
+import uulm.teamname.marvelous.gamelibrary.Tuple;
+import uulm.teamname.marvelous.gamelibrary.events.Event;
+import uulm.teamname.marvelous.gamelibrary.requests.Request;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+/** Contains game logic handling.
+ */
+class GameLogic {
+    /** Produces resulting {@link Event}s from a given {@link Request} independently of any {@link GameState}.
+     * @return The list of resulting events.
+     */
+    public static ArrayList<Event> executeRequest(Request request) {
+        ArrayList<Event> result = new ArrayList<Event>();
+
+        //TODO: implement GameLogic.executeRequest
+
+        /* Example Code:
+        switch (event.type) {
+            case EventType.MeleeAttack:
+                result.add(Event.Construct(EventType.APReduced, event.sourceEntity, event.ap));
+                result.add(Event.Construct(EventType.DamageTaken, event.targetEntity, event.value));
+                break;
+        }
+        */
+
+        return result;
+    }
+
+    /** Checks a {@link Request} for validity for a {@link GameState}.
+     * @param state The game state to check on.
+     * @param request The request to validate.
+     * @return Whether or not the request is valid
+     */
+    public static boolean checkRequest(GameState state, Request request) {
+        //TODO: implement GameLogic.checkRequest
+        return false;
+    }
+
+    /** Applies an {@link Event} to a {@link GameState}.
+     * @param state The game state to apply to.
+     * @param event The event to apply.
+     */
+    public static void applyEvent(GameState state, Event event) {
+        //TODO: implement GameLogic.applyEvent
+    }
+
+    /** Checks a {@link GameState} for the current overtime win condition.
+     * @param state The game state to check.
+     * @return The {@link ParticipantType} that is currently winning the game according to overtime ruling.
+     */
+    public static ParticipantType checkWinConditions(GameState state) {
+        //TODO: GameLogic.checkWinConditions is kind of ugly
+
+        Tuple<ParticipantType, WinCondition> player1;
+        Tuple<ParticipantType, WinCondition> player2;
+        int value1;
+        int value2;
+        for(WinCondition condition: WinCondition.values()) {
+            player1 = new Tuple<ParticipantType, WinCondition>(ParticipantType.Player1, condition);
+            player2 = new Tuple<ParticipantType, WinCondition>(ParticipantType.Player2, condition);
+            value1 = 0;
+            value2 = 0;
+
+            if(state.winConditions.containsKey(player1)) {
+                value1 = state.winConditions.get(player1);
+            }
+            if(state.winConditions.containsKey(player2)) {
+                value2 = state.winConditions.get(player2);
+            }
+
+            if(value1 > value2) {
+                return ParticipantType.Player1;
+            }
+            if(value2 > value1) {
+                return ParticipantType.Player2;
+            }
+        }
+
+        return ParticipantType.None;
+    }
+}