Merged with develop. Moved all collision logic into game state.

#refactor

src/main/java/seng302/gameServer/GameState.java

@@ -1,11 +1,11 @@
 package seng302.gameServer;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-
-import seng302.gameServer.server.messages.BoatAction;
+import java.util.Set;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import seng302.gameServer.server.messages.BoatAction;
@@ -14,6 +14,7 @@ import seng302.gameServer.server.messages.MarkRoundingMessage;
 import seng302.gameServer.server.messages.MarkType;
 import seng302.gameServer.server.messages.Message;
 import seng302.gameServer.server.messages.RoundingBoatStatus;
+import seng302.gameServer.server.messages.YachtEventCodeMessage;
 import seng302.model.GeoPoint;
 import seng302.model.Player;
 import seng302.model.PolarTable;
@@ -22,13 +23,6 @@ import seng302.model.mark.CompoundMark;
 import seng302.model.mark.Mark;
 import seng302.model.mark.MarkOrder;
 import seng302.utilities.GeoUtility;
-import javafx.application.Platform;
-import javafx.collections.FXCollections;
-import javafx.collections.ObservableList;
-import seng302.model.GeoPoint;
-import seng302.model.mark.CompoundMark;
-import seng302.model.mark.Mark;
-import seng302.utilities.GeoUtility;
 
 /**
  * A Static class to hold information about the current state of the game (model)
@@ -38,8 +32,8 @@ import seng302.utilities.GeoUtility;
 public class GameState implements Runnable {
 
     @FunctionalInterface
-    interface MarkPassingListener {
-        void markPassing(Message message);
+    interface NewMessageListener {
+        void notify(Message message);
     }
 
     private Logger logger = LoggerFactory.getLogger(GameState.class);
@@ -47,6 +41,12 @@ public class GameState implements Runnable {
     private static final Integer STATE_UPDATES_PER_SECOND = 60;
     public static Integer MAX_PLAYERS = 8;
     public static Double ROUNDING_DISTANCE = 50d; // TODO: 14/08/17 wmu16 - Look into this value further
+    public static final Double MARK_COLLISION_DISTANCE = 15d;
+    public static final Double YACHT_COLLISION_DISTANCE = 25.0;
+    private static final Double BOUNCE_DISTANCE_MARK = 20.0;
+    private static final Double BOUNCE_DISTANCE_YACHT = 30.0;
+    private static final Integer COLLISION_UPDATE_INTERVAL = 100;
+    private static final Double COLLISION_VELOCITY_PENALTY = 0.3;
 
     private static Long previousUpdateTime;
     public static Double windDirection;
@@ -61,7 +61,7 @@ public class GameState implements Runnable {
     private static long startTime;
     private static Set<Mark> marks;
 
-    private static List<MarkPassingListener> markListeners;
+    private static List<NewMessageListener> markListeners;
 
     private static Map<Player, String> playerStringMap = new HashMap<>();
     /*
@@ -237,12 +237,49 @@ public class GameState implements Runnable {
             yacht.runAutoPilot();
             yacht.updateLocation(timeInterval);
             if (!yacht.getFinishedRace()) {
+                checkForCollision(yacht);
                 checkForLegProgression(yacht);
             }
         }
     }
 
 
+    private void checkForCollision(ServerYacht serverYacht) {
+        ServerYacht collidedYacht = checkCollision(serverYacht);
+        if (collidedYacht != null) {
+            GeoPoint originalLocation = serverYacht.getLocation();
+            serverYacht.setLocation(
+                calculateBounceBack(serverYacht, originalLocation, BOUNCE_DISTANCE_YACHT)
+            );
+            serverYacht.setCurrentVelocity(
+                serverYacht.getCurrentVelocity() * COLLISION_VELOCITY_PENALTY
+            );
+            collidedYacht.setLocation(
+                calculateBounceBack(collidedYacht, originalLocation, BOUNCE_DISTANCE_YACHT)
+            );
+            collidedYacht.setCurrentVelocity(
+                collidedYacht.getCurrentVelocity() * COLLISION_VELOCITY_PENALTY
+            );;
+            notifyMessageListeners(
+                new YachtEventCodeMessage(serverYacht.getSourceId())
+            );
+        } else {
+            Mark collidedMark = markCollidedWith(serverYacht);
+            if (collidedMark != null) {
+                serverYacht.setLocation(
+                    calculateBounceBack(serverYacht, collidedMark, BOUNCE_DISTANCE_MARK)
+                );
+                serverYacht.setCurrentVelocity(
+                    serverYacht.getCurrentVelocity() * COLLISION_VELOCITY_PENALTY
+                );
+                notifyMessageListeners(
+                    new YachtEventCodeMessage(serverYacht.getSourceId())
+                );
+            }
+        }
+    }
+
+
     private void updateVelocity(ServerYacht yacht) {
         Double velocity = yacht.getCurrentVelocity();
         Double trueWindAngle = Math.abs(windDirection - yacht.getHeading());
@@ -333,6 +370,7 @@ public class GameState implements Runnable {
         }
     }
 
+
     /**
      * If we pass the start line gate in the correct direction, progress
      *
@@ -465,6 +503,50 @@ public class GameState implements Runnable {
         return false;
     }
 
+
+    private Mark markCollidedWith(ServerYacht yacht) {
+        Set<Mark> marksInRace = GameState.getMarks();
+        for (Mark mark : marksInRace) {
+            if (GeoUtility.getDistance(yacht.getLocation(), mark)
+                <= MARK_COLLISION_DISTANCE) {
+                return mark;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Calculate the new position of the boat after it has had a collision
+     *
+     * @return The boats new position
+     */
+    private GeoPoint calculateBounceBack(ServerYacht yacht, GeoPoint collidedWith, Double bounceDistance) {
+        Double heading = GeoUtility.getBearing(yacht.getLocation(), collidedWith);
+        // Invert heading
+        heading -= 180;
+        Integer newHeading = Math.floorMod(heading.intValue(), 360);
+        return GeoUtility.getGeoCoordinate(yacht.getLocation(), newHeading.doubleValue(), bounceDistance);
+    }
+
+    /**
+     * Collision detection which iterates through all the yachts and check if any yacht collided
+     * with this yacht. Return collided yacht or null if no collision.
+     *
+     * @return yacht to compare to all other yachts.
+     */
+    private ServerYacht checkCollision(ServerYacht yacht) {
+
+        for (ServerYacht otherYacht : GameState.getYachts().values()) {
+            if (otherYacht != yacht) {
+                Double distance = GeoUtility.getDistance(otherYacht.getLocation(), yacht.getLocation());
+                if (distance < YACHT_COLLISION_DISTANCE) {
+                    return otherYacht;
+                }
+            }
+        }
+        return null;
+    }
+
     private void sendMarkRoundingMessage(ServerYacht yacht) {
         Integer sourceID = yacht.getSourceId();
         Integer currentMarkSeqID = yacht.getCurrentMarkSeqID();
@@ -477,11 +559,14 @@ public class GameState implements Runnable {
             sourceID, RoundingBoatStatus.RACING, roundingMark.getRoundingSide(), markType,
             roundingMark.getSourceID());
 
-        for (MarkPassingListener mpl : markListeners) {
-            mpl.markPassing(markRoundingMessage);
-        }
+        notifyMessageListeners(markRoundingMessage);
     }
 
+    private void notifyMessageListeners(Message message) {
+        for (NewMessageListener mpl : markListeners) {
+            mpl.notify(message);
+        }
+    }
 
     private void logMarkRounding(ServerYacht yacht) {
         Mark roundingMark = yacht.getClosestCurrentMark();
@@ -491,7 +576,7 @@ public class GameState implements Runnable {
     }
 
 
-    public static void addMarkPassListener(MarkPassingListener listener) {
+    public static void addMarkPassListener(NewMessageListener listener) {
         markListeners.add(listener);
     }
 }