mirror of
https://github.com/michaelrausch/Party-Parrots-At-Sea.git
synced 2026-05-09 06:18:44 +00:00
Zhi You Tan
45669c333a
# Conflicts: # src/main/resources/css/RaceView.css # src/main/resources/views/RaceView.fxml
1071 lines
39 KiB
Java
1071 lines
39 KiB
Java
package seng302.gameServer;
|
|
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Random;
|
|
import java.util.Set;
|
|
import java.util.Timer;
|
|
import java.util.TimerTask;
|
|
import javafx.beans.property.ReadOnlyDoubleWrapper;
|
|
import javafx.scene.paint.Color;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
import seng302.gameServer.messages.BoatAction;
|
|
import seng302.gameServer.messages.BoatStatus;
|
|
import seng302.gameServer.messages.ChatterMessage;
|
|
import seng302.gameServer.messages.CustomizeRequestType;
|
|
import seng302.gameServer.messages.MarkRoundingMessage;
|
|
import seng302.gameServer.messages.MarkType;
|
|
import seng302.gameServer.messages.Message;
|
|
import seng302.gameServer.messages.RoundingBoatStatus;
|
|
import seng302.model.GeoPoint;
|
|
import seng302.model.Limit;
|
|
import seng302.model.Player;
|
|
import seng302.model.PolarTable;
|
|
import seng302.model.ServerYacht;
|
|
import seng302.model.mark.CompoundMark;
|
|
import seng302.model.mark.Mark;
|
|
import seng302.model.mark.MarkOrder;
|
|
import seng302.model.stream.xml.parser.RaceXMLData;
|
|
import seng302.model.token.Token;
|
|
import seng302.model.token.TokenType;
|
|
import seng302.utilities.GeoUtility;
|
|
import seng302.utilities.RandomSpawn;
|
|
import seng302.visualiser.fxObjects.assets_3D.BoatMeshType;
|
|
|
|
/**
|
|
* A Static class to hold information about the current state of the game (model)
|
|
* Also contains logic for updating itself on regular time intervals on its own thread
|
|
* Created by wmu16 on 10/07/17.
|
|
*/
|
|
public class GameState implements Runnable {
|
|
|
|
@FunctionalInterface
|
|
interface NewMessageListener {
|
|
void notify(Message message);
|
|
}
|
|
|
|
private static Logger logger = LoggerFactory.getLogger(GameState.class);
|
|
|
|
|
|
private static final Integer STATE_UPDATES_PER_SECOND = 60;
|
|
|
|
//Scheduling constants
|
|
static final int WARNING_TIME = 10 * -1000;
|
|
static final int PREPATORY_TIME = 5 * -1000;
|
|
private static final int TIME_TILL_START = 10 * 1000;
|
|
|
|
//Wind Constants
|
|
private static final int MAX_WIND_SPEED = 12000;
|
|
private static final int MIN_WIND_SPEED = 8000;
|
|
|
|
//Rounding Constants
|
|
private static final Double ROUNDING_DISTANCE = 50d; // TODO: 14/08/17 wmu16 - Look into this value further
|
|
|
|
//Collision constants
|
|
private static final Double MARK_COLLISION_DISTANCE = 15d;
|
|
public static final Double YACHT_COLLISION_DISTANCE = 15.0;
|
|
private static final Double BOUNCE_DISTANCE_MARK = 20.0;
|
|
public static final Double BOUNCE_DISTANCE_YACHT = 30.0;
|
|
private static final Double COLLISION_VELOCITY_PENALTY = 0.3;
|
|
|
|
//Powerup Constants
|
|
public static final Double VELOCITY_BOOST_MULTIPLIER = 2d;
|
|
public static final Integer HANDLING_BOOST_MULTIPLIER = 2;
|
|
private static final Double BAD_RANDOM_SPEED_PENALTY = 0.3;
|
|
public static final Long BUMPER_DISABLE_TIME = 5_000L;
|
|
private static final Long TOKEN_SPAWN_TIME = 30_000L;
|
|
|
|
private static Long previousUpdateTime;
|
|
public static Double windDirection;
|
|
public static ReadOnlyDoubleWrapper windDirectionProperty = new ReadOnlyDoubleWrapper();
|
|
private static Double windSpeed;
|
|
private static Double serverSpeedMultiplier;
|
|
|
|
private static Boolean customizationFlag; // dirty flag to tell if a player has customized their boat.
|
|
private static Boolean playerHasLeftFlag;
|
|
|
|
private static String hostIpAddress;
|
|
private static List<Player> players;
|
|
private static Map<Integer, ServerYacht> yachts;
|
|
private static GameStages currentStage;
|
|
private static MarkOrder markOrder;
|
|
private static long startTime;
|
|
private static Set<Mark> marks = new HashSet<>();
|
|
private static List<Limit> courseLimit = new ArrayList<>();
|
|
private static Integer maxPlayers = 8;
|
|
|
|
private static List<Token> tokensInPlay;
|
|
private static RandomSpawn randomSpawn;
|
|
|
|
private static List<NewMessageListener> newMessageListeners;
|
|
|
|
private static Map<Player, String> playerStringMap = new HashMap<>();
|
|
private static boolean tokensEnabled = false;
|
|
|
|
public GameState() {
|
|
windDirection = 180d;
|
|
windDirectionProperty.set(windDirection);
|
|
windSpeed = 10000d;
|
|
yachts = new HashMap<>();
|
|
tokensInPlay = new ArrayList<>();
|
|
players = new ArrayList<>();
|
|
customizationFlag = false;
|
|
playerHasLeftFlag = false;
|
|
serverSpeedMultiplier = 1.0;
|
|
currentStage = GameStages.LOBBYING;
|
|
previousUpdateTime = System.currentTimeMillis();
|
|
newMessageListeners = new ArrayList<>();
|
|
|
|
resetStartTime();
|
|
//setCourseLimit("/server_config/race.xml");
|
|
new Thread(this, "GameState").start(); //Run the auto updates on the game state
|
|
}
|
|
|
|
public static void setRace(RaceXMLData raceXMLData) {
|
|
markOrder = new MarkOrder(raceXMLData);
|
|
for (CompoundMark compoundMark : raceXMLData.getCompoundMarks().values()){
|
|
marks.addAll(compoundMark.getMarks());
|
|
}
|
|
randomSpawn = new RandomSpawn(markOrder.getOrderedUniqueCompoundMarks());
|
|
courseLimit = raceXMLData.getCourseLimit();
|
|
}
|
|
|
|
public static List<Player> getPlayers() {
|
|
return players;
|
|
}
|
|
|
|
public static List<Token> getTokensInPlay() {
|
|
return tokensInPlay;
|
|
}
|
|
|
|
public static Set<Mark> getMarks() {
|
|
return Collections.unmodifiableSet(marks);
|
|
}
|
|
|
|
public static void addPlayer(Player player) {
|
|
players.add(player);
|
|
String playerText = player.getYacht().getSourceId() + " " + player.getYacht().getBoatName()
|
|
+ " " + player.getYacht().getCountry();
|
|
playerStringMap.put(player, playerText);
|
|
}
|
|
|
|
public static void removePlayer(Player player) {
|
|
players.remove(player);
|
|
playerStringMap.remove(player);
|
|
}
|
|
|
|
public static void addYacht(Integer sourceId, ServerYacht yacht) {
|
|
yachts.put(sourceId, yacht);
|
|
}
|
|
|
|
public static void removeYacht(Integer yachtId) {
|
|
yachts.remove(yachtId);
|
|
}
|
|
|
|
public static GameStages getCurrentStage() {
|
|
return currentStage;
|
|
}
|
|
|
|
public static void setCurrentStage(GameStages currentStage) {
|
|
GameState.currentStage = currentStage;
|
|
}
|
|
|
|
public static MarkOrder getMarkOrder() {
|
|
return markOrder;
|
|
}
|
|
|
|
public static long getStartTime() {
|
|
return startTime;
|
|
}
|
|
|
|
public static void resetStartTime(){
|
|
startTime = System.currentTimeMillis() + TIME_TILL_START;
|
|
}
|
|
|
|
public static Double getWindDirection() {
|
|
return windDirection;
|
|
}
|
|
|
|
public static void setWindDirection(Double newWindDirection) {
|
|
windDirection = newWindDirection;
|
|
windDirectionProperty.set(newWindDirection);
|
|
}
|
|
|
|
public static void setWindSpeed(Double newWindSpeed) {
|
|
windSpeed = newWindSpeed;
|
|
}
|
|
|
|
public static Double getWindSpeedMMS() {
|
|
return windSpeed;
|
|
}
|
|
|
|
public static Double getWindSpeedKnots() {
|
|
return GeoUtility.mmsToKnots(windSpeed); // TODO: 26/07/17 cir27 - remove magic numbers
|
|
}
|
|
|
|
public static Map<Integer, ServerYacht> getYachts() {
|
|
return yachts;
|
|
}
|
|
|
|
|
|
/**
|
|
* Generates a new ID based off the size of current players + 1
|
|
*
|
|
* @return a playerID to be allocated to a new connetion
|
|
*/
|
|
public static Integer getUniquePlayerID() {
|
|
// TODO: 22/07/17 wmu16 - This may not be robust enough and may have to be improved on.
|
|
return yachts.size() + 1;
|
|
}
|
|
|
|
|
|
/**
|
|
* A thread to have the game state update itself at certain intervals
|
|
*/
|
|
@Override
|
|
public void run() {
|
|
|
|
while (currentStage != GameStages.FINISHED) {
|
|
try {
|
|
Thread.sleep(1000 / STATE_UPDATES_PER_SECOND);
|
|
} catch (InterruptedException e) {
|
|
System.out.println("[GameState] interrupted exception");
|
|
}
|
|
if (currentStage == GameStages.PRE_RACE) {
|
|
update();
|
|
if (System.currentTimeMillis() > startTime) {
|
|
startSpawningTokens();
|
|
startUpdatingWind();
|
|
GameState.currentStage = GameStages.RACING;
|
|
}
|
|
}
|
|
if (currentStage == GameStages.RACING) {
|
|
update();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Start spawning coins every 60s after the first minute
|
|
*/
|
|
private void startSpawningTokens() {
|
|
Timer timer = new Timer("Token Spawning Timer");
|
|
timer.schedule(new TimerTask() {
|
|
@Override
|
|
public void run() {
|
|
if (tokensEnabled) {
|
|
spawnNewToken();
|
|
notifyMessageListeners(MessageFactory.getRaceXML());
|
|
}
|
|
}
|
|
}, 0, TOKEN_SPAWN_TIME);
|
|
}
|
|
|
|
// TODO: 29/08/17 wmu16 - This sort of update should be in game state
|
|
private static void startUpdatingWind() {
|
|
Timer timer = new Timer("Wind Updating Timer");
|
|
timer.schedule(new TimerTask() {
|
|
@Override
|
|
public void run() {
|
|
updateWind();
|
|
}
|
|
}, 0, 500);
|
|
}
|
|
|
|
|
|
private static void updateWind() {
|
|
Integer direction = GameState.getWindDirection().intValue();
|
|
Integer windSpeed = GameState.getWindSpeedMMS().intValue();
|
|
|
|
Random random = new Random();
|
|
|
|
if (Math.floorMod(random.nextInt(), 2) == 0) {
|
|
direction += random.nextInt(4);
|
|
windSpeed += random.nextInt(20) + 459;
|
|
} else {
|
|
direction -= random.nextInt(4);
|
|
windSpeed -= random.nextInt(20) + 459;
|
|
}
|
|
|
|
direction = Math.floorMod(direction, 360);
|
|
|
|
if (windSpeed > MAX_WIND_SPEED) {
|
|
windSpeed -= random.nextInt(500);
|
|
}
|
|
|
|
if (windSpeed <= MIN_WIND_SPEED) {
|
|
windSpeed += random.nextInt(500);
|
|
}
|
|
|
|
GameState.windSpeed = Double.valueOf(windSpeed);
|
|
GameState.windDirection = direction.doubleValue();
|
|
}
|
|
|
|
|
|
public static void updateBoat(Integer sourceId, BoatAction actionType) {
|
|
ServerYacht playerYacht = yachts.get(sourceId);
|
|
switch (actionType) {
|
|
case VMG:
|
|
playerYacht.turnToVMG();
|
|
break;
|
|
case SAILS_IN:
|
|
playerYacht.toggleSailIn();
|
|
break;
|
|
case SAILS_OUT:
|
|
playerYacht.toggleSailIn();
|
|
break;
|
|
case TACK_GYBE:
|
|
playerYacht.tackGybe(windDirection);
|
|
break;
|
|
case UPWIND:
|
|
playerYacht.turnUpwind();
|
|
break;
|
|
case DOWNWIND:
|
|
playerYacht.turnDownwind();
|
|
break;
|
|
case CONTINUOUSLY_TURNING:
|
|
playerYacht.setContinuouslyTurning(true);
|
|
break;
|
|
case DEFAULT_TURNING:
|
|
playerYacht.setContinuouslyTurning(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Randomly select a subset of tokensInPlay from a pre defined superset
|
|
* Broadasts a new race status message to show this update
|
|
*/
|
|
private void spawnNewToken() {
|
|
tokensInPlay.clear();
|
|
Token token = randomSpawn.getRandomToken();
|
|
// token.assignType(TokenType.WIND_WALKER);
|
|
logger.debug("Spawned token of type " + token.getTokenType());
|
|
tokensInPlay.add(token);
|
|
MessageFactory.updateTokens(tokensInPlay);
|
|
}
|
|
|
|
/**
|
|
* Called periodically in this GameState thread to update the GameState values.
|
|
* -Updates yachts velocity
|
|
* -Updates locations
|
|
* -Checks for collisions
|
|
* -Checks for progression
|
|
*
|
|
* -Also checks things like the end of the race and race start time etc
|
|
*/
|
|
public void update() {
|
|
Boolean raceFinished = true;
|
|
|
|
Double timeInterval = (System.currentTimeMillis() - previousUpdateTime) / 1000000.0;
|
|
previousUpdateTime = System.currentTimeMillis();
|
|
|
|
for (ServerYacht yacht : yachts.values()) {
|
|
updateVelocity(yacht);
|
|
yacht.runAutoPilot();
|
|
yacht.updateLocation(timeInterval);
|
|
preformTokenUpdates(yacht); //This update must be done before collision. Sorta hacky
|
|
checkCollision(yacht);
|
|
if (yacht.getBoatStatus() != BoatStatus.FINISHED) {
|
|
checkForLegProgression(yacht);
|
|
raceFinished = false;
|
|
}
|
|
}
|
|
|
|
if (raceFinished) {
|
|
currentStage = GameStages.FINISHED;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* All token functionality entry points is taken care of here. So can be disabled and enabled
|
|
* easily
|
|
*
|
|
* @param yacht The yacht to perform token checks on
|
|
*/
|
|
private void preformTokenUpdates(ServerYacht yacht) {
|
|
Token collidedToken = checkTokenPickUp(yacht);
|
|
if (collidedToken != null) {
|
|
tokensInPlay.remove(collidedToken);
|
|
powerUpYacht(yacht, collidedToken);
|
|
MessageFactory.updateTokens(tokensInPlay);
|
|
notifyMessageListeners(MessageFactory.getRaceXML());
|
|
}
|
|
|
|
checkPowerUpTimeout(yacht);
|
|
TokenType powerUp = yacht.getPowerUp();
|
|
|
|
if (powerUp != null) {
|
|
switch (powerUp) {
|
|
case WIND_WALKER:
|
|
windWalk(yacht);
|
|
break;
|
|
case BUMPER:
|
|
ServerYacht collidedYacht = checkYachtCollision(yacht, true);
|
|
if (collidedYacht != null) {
|
|
yacht.powerDown();
|
|
boatTempShutDown(collidedYacht);
|
|
notifyMessageListeners(MessageFactory.makePowerDownMessage(yacht));
|
|
notifyMessageListeners(
|
|
MessageFactory.makeStatusEffectMessage(collidedYacht, powerUp));
|
|
}
|
|
break;
|
|
case RANDOM:
|
|
yacht.setPowerUpSpeedMultiplier(BAD_RANDOM_SPEED_PENALTY);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Powers up a thisYacht with the given token type.
|
|
*
|
|
* @param thisYacht The yacht to be powered up
|
|
* @param collidedToken The token which this thisYacht collided with
|
|
*/
|
|
private void powerUpYacht(ServerYacht thisYacht, Token collidedToken) {
|
|
//The random token has a 50% chance of becoming another token else becoming a speed detriment!
|
|
if (collidedToken.getTokenType() == TokenType.RANDOM && new Random().nextBoolean()) {
|
|
collidedToken.realiseRandom();
|
|
}
|
|
|
|
//If another yacht has the wind walker token, They should be powered down. Only one allowed!
|
|
else if (collidedToken.getTokenType() == TokenType.WIND_WALKER) {
|
|
for (ServerYacht otherYacht : yachts.values()) {
|
|
if (otherYacht != thisYacht && otherYacht.getPowerUp() == TokenType.WIND_WALKER) {
|
|
powerDownYacht(otherYacht);
|
|
}
|
|
}
|
|
}
|
|
|
|
thisYacht.powerUp(collidedToken.getTokenType());
|
|
String logMessage =
|
|
thisYacht.getBoatName() + " has picked up a " + collidedToken.getTokenType().getName()
|
|
+ " token";
|
|
notifyMessageListeners(
|
|
MessageFactory.makeChatterMessage(thisYacht.getSourceId(), logMessage));
|
|
notifyMessageListeners(MessageFactory.getRaceXML());
|
|
notifyMessageListeners(MessageFactory.makePickupMessage(thisYacht, collidedToken));
|
|
logger.debug(
|
|
"Yacht: " + thisYacht.getShortName() + " got powerup " + collidedToken.getTokenType());
|
|
}
|
|
|
|
private void powerDownYacht(ServerYacht yacht) {
|
|
String logMessage =
|
|
yacht.getBoatName() + "'s " + yacht.getPowerUp().getName() + " expired";
|
|
notifyMessageListeners(
|
|
MessageFactory.makeChatterMessage(yacht.getSourceId(), logMessage));
|
|
notifyMessageListeners(MessageFactory.makePowerDownMessage(yacht));
|
|
logger.debug("Yacht: " + yacht.getShortName() + " powered down!");
|
|
|
|
yacht.powerDown();
|
|
}
|
|
|
|
// TODO: 23/09/17 wmu16 - This is a hacky way to have the boat power down. Need some sort of separation between token and status effect :/
|
|
|
|
/**
|
|
* Disables the given boat for BUMPER_DISABLE_TIME ms.
|
|
*
|
|
* @param yacht The yacht to disable
|
|
*/
|
|
private void boatTempShutDown(ServerYacht yacht) {
|
|
yacht.setPowerUpSpeedMultiplier(0d);
|
|
Timer shutDownTimer = new Timer("Shutdown Timer");
|
|
shutDownTimer.schedule(new TimerTask() {
|
|
@Override
|
|
public void run() {
|
|
yacht.powerDown(); //Note this actually resets the boat to normal.
|
|
}
|
|
}, BUMPER_DISABLE_TIME);
|
|
}
|
|
|
|
|
|
/**
|
|
* Checks how long a powerup has been active for. If it has exceeded its timeout, it powers the
|
|
* yacht down.
|
|
*
|
|
* @param yacht The yacht to check to power down
|
|
*/
|
|
private void checkPowerUpTimeout(ServerYacht yacht) {
|
|
if (yacht.getPowerUp() != null) {
|
|
if (System.currentTimeMillis() - yacht.getPowerUpStartTime() > yacht.getPowerUp()
|
|
.getTimeout()) {
|
|
powerDownYacht(yacht);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* This function changes the wind to be at an angle that causes the yacht in question to be at
|
|
* its fastest velocity
|
|
*
|
|
* @param yacht The yacht to fix the wind for
|
|
*/
|
|
private void windWalk(ServerYacht yacht) {
|
|
Double optimalAngle = PolarTable.getOptimalAngle();
|
|
Double heading = yacht.getHeading();
|
|
windDirection = (double) Math.floorMod(Math.round(heading + optimalAngle), 360L);
|
|
windDirectionProperty.set(windDirection);
|
|
}
|
|
|
|
|
|
/**
|
|
* Check if the yacht has crossed the course limit
|
|
*
|
|
* @param yacht the yacht to be tested
|
|
* @return a boolean value of if there is a boundary collision
|
|
*/
|
|
private static Boolean checkBoundaryCollision(ServerYacht yacht) {
|
|
for (int i = 0; i < courseLimit.size() - 1; i++) {
|
|
if (GeoUtility.checkCrossedLine(courseLimit.get(i), courseLimit.get(i + 1),
|
|
yacht.getLastLocation(), yacht.getLocation()) != 0) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (GeoUtility.checkCrossedLine(courseLimit.get(courseLimit.size() - 1), courseLimit.get(0),
|
|
yacht.getLastLocation(), yacht.getLocation()) != 0) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Checks all tokensInPlay to see if a yacht has picked one up. If so, the yacht is powered up
|
|
* in the appropriate way
|
|
* @param yacht The yacht to check for collision with a token
|
|
*
|
|
* @return The token collided with
|
|
*/
|
|
private Token checkTokenPickUp(ServerYacht yacht) {
|
|
for (Token token : tokensInPlay) {
|
|
Double distance = GeoUtility.getDistance(token, yacht.getLocation());
|
|
if (distance < YACHT_COLLISION_DISTANCE) {
|
|
return token;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
|
|
/**
|
|
* Checks for collision with other in game objects for the given serverYacht. To be called each
|
|
* update. If there is a collision, Notifies the server to send the appropriate messages out.
|
|
* Checks for these items in turn:
|
|
* - Other yachts
|
|
* - Marks
|
|
* - Boundary
|
|
* - Tokens
|
|
*
|
|
* @param serverYacht The server yacht to check collisions with
|
|
*/
|
|
public static void checkCollision(ServerYacht serverYacht) {
|
|
//Yacht Collision
|
|
ServerYacht collidedYacht = checkYachtCollision(serverYacht, false);
|
|
Mark collidedMark = checkMarkCollision(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(MessageFactory.makeCollisionMessage(serverYacht));
|
|
}
|
|
|
|
//Mark Collision
|
|
else if (collidedMark != null) {
|
|
serverYacht.setLocation(
|
|
calculateBounceBack(serverYacht, collidedMark, BOUNCE_DISTANCE_MARK)
|
|
);
|
|
|
|
serverYacht.setCurrentVelocity(
|
|
serverYacht.getCurrentVelocity() * COLLISION_VELOCITY_PENALTY
|
|
);
|
|
notifyMessageListeners(MessageFactory.makeCollisionMessage(serverYacht));
|
|
}
|
|
|
|
//Boundary Collision
|
|
else if (checkBoundaryCollision(serverYacht)) {
|
|
serverYacht.setLocation(
|
|
calculateBounceBack(serverYacht, serverYacht.getLocation(),
|
|
BOUNCE_DISTANCE_YACHT)
|
|
);
|
|
|
|
serverYacht.setCurrentVelocity(
|
|
serverYacht.getCurrentVelocity() * COLLISION_VELOCITY_PENALTY
|
|
);
|
|
notifyMessageListeners(MessageFactory.makeCollisionMessage(serverYacht));
|
|
}
|
|
}
|
|
|
|
|
|
private void updateVelocity(ServerYacht yacht) {
|
|
Double trueWindAngle = Math.abs(windDirection - yacht.getHeading());
|
|
Double boatSpeedInKnots = PolarTable.getBoatSpeed(getWindSpeedKnots(), trueWindAngle);
|
|
Double maxBoatSpeed =
|
|
GeoUtility.knotsToMMS(boatSpeedInKnots) * serverSpeedMultiplier * yacht
|
|
.getPowerUpSpeedMultiplier() * yacht.getBoatTypeSpeedMultiplier();
|
|
|
|
Double currentVelocity = yacht.getCurrentVelocity();
|
|
// TODO: 15/08/17 remove magic numbers from these equations.
|
|
if (yacht.getSailIn()) {
|
|
if (currentVelocity < maxBoatSpeed - 500) {
|
|
yacht.changeVelocity(
|
|
(maxBoatSpeed / 100) * yacht.getBoatTypeAccelerationMultiplier());
|
|
} else if (currentVelocity > maxBoatSpeed + 500) {
|
|
yacht.changeVelocity(
|
|
(-currentVelocity / 200) * yacht.getBoatTypeAccelerationMultiplier());
|
|
} else {
|
|
yacht
|
|
.setCurrentVelocity((maxBoatSpeed) * yacht.getBoatTypeAccelerationMultiplier());
|
|
}
|
|
} else {
|
|
if (currentVelocity > 3000) {
|
|
yacht.changeVelocity(
|
|
(-currentVelocity / 200) * yacht.getBoatTypeAccelerationMultiplier());
|
|
} else if (currentVelocity > 100) {
|
|
yacht.changeVelocity(
|
|
(-currentVelocity / 50) * yacht.getBoatTypeAccelerationMultiplier());
|
|
} else if (currentVelocity <= 100) {
|
|
yacht.setCurrentVelocity(0d);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Calculates the distance to the next mark (closest of the two if a gate mark). For purposes of
|
|
* mark rounding
|
|
*
|
|
* @return A distance in metres. Returns -1 if there is no next mark
|
|
* @throws IndexOutOfBoundsException If the next mark is null (ie the last mark in the race)
|
|
* Check first using {@link seng302.model.mark.MarkOrder#isLastMark(Integer)}
|
|
*/
|
|
private Double calcDistanceToCurrentMark(ServerYacht yacht) throws IndexOutOfBoundsException {
|
|
Integer currentMarkSeqID = yacht.getCurrentMarkSeqID();
|
|
CompoundMark currentMark = markOrder.getCurrentMark(currentMarkSeqID);
|
|
GeoPoint location = yacht.getLocation();
|
|
|
|
if (currentMark.isGate()) {
|
|
Mark sub1 = currentMark.getSubMark(1);
|
|
Mark sub2 = currentMark.getSubMark(2);
|
|
Double distance1 = GeoUtility.getDistance(location, sub1);
|
|
Double distance2 = GeoUtility.getDistance(location, sub2);
|
|
if (distance1 < distance2) {
|
|
yacht.setClosestCurrentMark(sub1);
|
|
return distance1;
|
|
} else {
|
|
yacht.setClosestCurrentMark(sub2);
|
|
return distance2;
|
|
}
|
|
} else {
|
|
yacht.setClosestCurrentMark(currentMark.getSubMark(1));
|
|
return GeoUtility.getDistance(location, currentMark.getSubMark(1));
|
|
}
|
|
}
|
|
|
|
|
|
/** lobbyController.setPlayerListSource(clientLobbyList);
|
|
* 4 Different cases of progression in the race 1 - Passing the start line 2 - Passing any
|
|
* in-race Gate 3 - Passing any in-race Mark 4 - Passing the finish line
|
|
*
|
|
* @param yacht the current yacht to check for progression
|
|
*/
|
|
private void checkForLegProgression(ServerYacht yacht) {
|
|
Integer currentMarkSeqID = yacht.getCurrentMarkSeqID();
|
|
CompoundMark currentMark = markOrder.getCurrentMark(currentMarkSeqID);
|
|
|
|
Boolean hasProgressed;
|
|
if (currentMarkSeqID == 0) {
|
|
hasProgressed = checkStartLineCrossing(yacht);
|
|
} else if (markOrder.isLastMark(currentMarkSeqID)) {
|
|
hasProgressed = checkFinishLineCrossing(yacht);
|
|
} else if (currentMark.isGate()) {
|
|
hasProgressed = checkGateRounding(yacht);
|
|
} else {
|
|
hasProgressed = checkMarkRounding(yacht);
|
|
}
|
|
|
|
if (hasProgressed) {
|
|
if (currentMarkSeqID != 0 && !markOrder.isLastMark(currentMarkSeqID)) {
|
|
|
|
String logMessage = yacht.getBoatName() + " passed leg " + yacht.getLegNumber();
|
|
notifyMessageListeners(
|
|
MessageFactory.makeChatterMessage(yacht.getSourceId(), logMessage));
|
|
}
|
|
yacht.incrementLegNumber();
|
|
sendMarkRoundingMessage(yacht);
|
|
logMarkRounding(yacht);
|
|
yacht.setHasPassedLine(false);
|
|
yacht.setHasEnteredRoundingZone(false);
|
|
yacht.setHasPassedThroughGate(false);
|
|
if (!markOrder.isLastMark(currentMarkSeqID)) {
|
|
yacht.incrementMarkSeqID();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* If we pass the start line gate in the correct direction, progress
|
|
*
|
|
* @param yacht The current yacht to check for
|
|
*/
|
|
private Boolean checkStartLineCrossing(ServerYacht yacht) {
|
|
long timeTillStart = System.currentTimeMillis() - this.getStartTime();
|
|
if (timeTillStart < 0){
|
|
return false;
|
|
}
|
|
Integer currentMarkSeqID = yacht.getCurrentMarkSeqID();
|
|
CompoundMark currentMark = markOrder.getCurrentMark(currentMarkSeqID);
|
|
GeoPoint lastLocation = yacht.getLastLocation();
|
|
GeoPoint location = yacht.getLocation();
|
|
|
|
Mark mark1 = currentMark.getSubMark(1);
|
|
Mark mark2 = currentMark.getSubMark(2);
|
|
CompoundMark nextMark = markOrder.getNextMark(currentMarkSeqID);
|
|
|
|
Integer crossedLine = GeoUtility.checkCrossedLine(mark1, mark2, lastLocation, location);
|
|
if (crossedLine > 0) {
|
|
Boolean isClockwiseCross = GeoUtility.isClockwise(mark1, mark2, nextMark.getMidPoint());
|
|
if (crossedLine == 2 && isClockwiseCross || crossedLine == 1 && !isClockwiseCross) {
|
|
yacht.setClosestCurrentMark(mark1);
|
|
yacht.setBoatStatus(BoatStatus.RACING);
|
|
String logMessage = yacht.getBoatName() + " passed start line";
|
|
notifyMessageListeners(
|
|
MessageFactory.makeChatterMessage(yacht.getSourceId(), logMessage));
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* This algorithm checks for mark rounding. And increments the currentMarSeqID number attribute
|
|
* of the yacht if so. A visual representation of this algorithm can be seen on the Wiki under
|
|
* 'mark passing algorithm'
|
|
*
|
|
* @param yacht The current yacht to check for
|
|
*/
|
|
private Boolean checkMarkRounding(ServerYacht yacht) {
|
|
Integer currentMarkSeqID = yacht.getCurrentMarkSeqID();
|
|
CompoundMark currentMark = markOrder.getCurrentMark(currentMarkSeqID);
|
|
GeoPoint lastLocation = yacht.getLastLocation();
|
|
GeoPoint location = yacht.getLocation();
|
|
GeoPoint nextPoint = markOrder.getNextMark(currentMarkSeqID).getMidPoint();
|
|
GeoPoint prevPoint = markOrder.getPreviousMark(currentMarkSeqID).getMidPoint();
|
|
GeoPoint midPoint = GeoUtility.getDirtyMidPoint(nextPoint, prevPoint);
|
|
|
|
if (calcDistanceToCurrentMark(yacht) < ROUNDING_DISTANCE) {
|
|
yacht.setHasEnteredRoundingZone(true);
|
|
}
|
|
|
|
//In case current mark is a gate, loop through all marks just in case
|
|
for (Mark thisCurrentMark : currentMark.getMarks()) {
|
|
if (GeoUtility.isPointInTriangle(lastLocation, location, midPoint, thisCurrentMark)) {
|
|
yacht.setHasPassedLine(true);
|
|
}
|
|
}
|
|
|
|
return yacht.hasPassedLine() && yacht.hasEnteredRoundingZone();
|
|
}
|
|
|
|
|
|
/**
|
|
* Checks if a gate line has been crossed and in the correct direction
|
|
*
|
|
* @param yacht The current yacht to check for
|
|
*/
|
|
private Boolean checkGateRounding(ServerYacht yacht) {
|
|
Integer currentMarkSeqID = yacht.getCurrentMarkSeqID();
|
|
CompoundMark currentMark = markOrder.getCurrentMark(currentMarkSeqID);
|
|
GeoPoint lastLocation = yacht.getLastLocation();
|
|
GeoPoint location = yacht.getLocation();
|
|
|
|
Mark mark1 = currentMark.getSubMark(1);
|
|
Mark mark2 = currentMark.getSubMark(2);
|
|
CompoundMark prevMark = markOrder.getPreviousMark(currentMarkSeqID);
|
|
CompoundMark nextMark = markOrder.getNextMark(currentMarkSeqID);
|
|
|
|
Integer crossedLine = GeoUtility.checkCrossedLine(mark1, mark2, lastLocation, location);
|
|
|
|
//We have crossed the line
|
|
if (crossedLine > 0) {
|
|
Boolean isClockwiseCross = GeoUtility.isClockwise(mark1, mark2, prevMark.getMidPoint());
|
|
|
|
//Check we cross the line in the correct direction
|
|
if (crossedLine == 1 && isClockwiseCross || crossedLine == 2 && !isClockwiseCross) {
|
|
yacht.setHasPassedThroughGate(true);
|
|
}
|
|
}
|
|
|
|
Boolean prevMarkSide = GeoUtility.isClockwise(mark1, mark2, prevMark.getMidPoint());
|
|
Boolean nextMarkSide = GeoUtility.isClockwise(mark1, mark2, nextMark.getMidPoint());
|
|
|
|
if (yacht.hasPassedThroughGate()) {
|
|
//Check if we need to round this gate after passing through
|
|
if (prevMarkSide == nextMarkSide) {
|
|
return checkMarkRounding(yacht);
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* If we pass the finish gate in the correct direction
|
|
*
|
|
* @param yacht The current yacht to check for
|
|
*/
|
|
private Boolean checkFinishLineCrossing(ServerYacht yacht) {
|
|
Integer currentMarkSeqID = yacht.getCurrentMarkSeqID();
|
|
CompoundMark currentMark = markOrder.getCurrentMark(currentMarkSeqID);
|
|
GeoPoint lastLocation = yacht.getLastLocation();
|
|
GeoPoint location = yacht.getLocation();
|
|
|
|
Mark mark1 = currentMark.getSubMark(1);
|
|
Mark mark2 = currentMark.getSubMark(2);
|
|
CompoundMark prevMark = markOrder.getPreviousMark(currentMarkSeqID);
|
|
|
|
Integer crossedLine = GeoUtility.checkCrossedLine(mark1, mark2, lastLocation, location);
|
|
if (crossedLine > 0) {
|
|
Boolean isClockwiseCross = GeoUtility.isClockwise(mark1, mark2, prevMark.getMidPoint());
|
|
if (crossedLine == 1 && isClockwiseCross || crossedLine == 2 && !isClockwiseCross) {
|
|
yacht.setClosestCurrentMark(mark1);
|
|
yacht.setBoatStatus(BoatStatus.FINISHED);
|
|
|
|
String logMessage = yacht.getBoatName() + " passed finish line";
|
|
notifyMessageListeners(
|
|
MessageFactory.makeChatterMessage(yacht.getSourceId(), logMessage));
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Handles player customization.
|
|
*
|
|
* @param playerID The ID of the player being modified.
|
|
* @param requestType the type of player customization the player wants
|
|
* @param customizeData the data related to the customization (color, name, shape)
|
|
*/
|
|
public static void customizePlayer(long playerID, CustomizeRequestType requestType,
|
|
byte[] customizeData) {
|
|
ServerYacht playerYacht = yachts.get((int) playerID);
|
|
|
|
if (requestType.equals(CustomizeRequestType.NAME)) {
|
|
String name = new String(customizeData);
|
|
playerYacht.setBoatName(name);
|
|
} else if (requestType.equals(CustomizeRequestType.COLOR)) {
|
|
//This low level stuff shouldnt be here alistair! In fact no logic LIKE THIS should! - wmu16
|
|
int red = customizeData[0] & 0xFF;
|
|
int green = customizeData[1] & 0xFF;
|
|
int blue = customizeData[2] & 0xFF;
|
|
Color yachtColor = Color.rgb(red, green, blue);
|
|
playerYacht.setBoatColor(yachtColor);
|
|
} else if (requestType.equals(CustomizeRequestType.SHAPE)) {
|
|
String type = new String(customizeData);
|
|
playerYacht.setBoatType(BoatMeshType.valueOf(type));
|
|
}
|
|
}
|
|
|
|
private static Mark checkMarkCollision(ServerYacht yacht) {
|
|
Set<Mark> marksInRace = new HashSet<>(marks);
|
|
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 static GeoPoint calculateBounceBack(ServerYacht yacht, GeoPoint collidedWith,
|
|
Double bounceDistance) {
|
|
Double heading = GeoUtility.getBearing(yacht.getLastLocation(), 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.
|
|
*
|
|
* UPDATE: HACK!!! wmu16 - forBumperCollision is (the goddamn dirtiest) dirty flag to fix a
|
|
* weird bug where the bumper collision would not be registerd but the knock back collision would.
|
|
* In other words, only set the 'forBumperCollision' flag true if used for the bumper power up.
|
|
*
|
|
* @return yacht to compare to all other yachts.
|
|
*/
|
|
private static ServerYacht checkYachtCollision(ServerYacht yacht, Boolean forBumperCollision) {
|
|
Double collisionDistance =
|
|
(forBumperCollision) ? YACHT_COLLISION_DISTANCE + 2.5 : YACHT_COLLISION_DISTANCE;
|
|
|
|
for (ServerYacht otherYacht : GameState.getYachts().values()) {
|
|
if (otherYacht != yacht) {
|
|
Double distance = GeoUtility
|
|
.getDistance(otherYacht.getLocation(), yacht.getLocation());
|
|
;
|
|
if (distance < collisionDistance) {
|
|
return otherYacht;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private void sendMarkRoundingMessage(ServerYacht yacht) {
|
|
Integer sourceID = yacht.getSourceId();
|
|
Integer currentMarkSeqID = yacht.getCurrentMarkSeqID();
|
|
CompoundMark currentMark = markOrder.getCurrentMark(currentMarkSeqID);
|
|
MarkType markType = (currentMark.isGate()) ? MarkType.GATE : MarkType.ROUNDING_MARK;
|
|
Mark roundingMark = yacht.getClosestCurrentMark();
|
|
|
|
// TODO: 13/8/17 figure out the rounding side, rounded mark source ID and boat status.
|
|
Message markRoundingMessage = new MarkRoundingMessage(0, 0,
|
|
sourceID, RoundingBoatStatus.RACING, roundingMark.getRoundingSide(), markType,
|
|
currentMarkSeqID + 1);
|
|
|
|
notifyMessageListeners(markRoundingMessage);
|
|
}
|
|
|
|
private static void notifyMessageListeners(Message message) {
|
|
for (NewMessageListener ml : newMessageListeners) {
|
|
ml.notify(message);
|
|
}
|
|
}
|
|
|
|
private void logMarkRounding(ServerYacht yacht) {
|
|
Mark roundingMark = yacht.getClosestCurrentMark();
|
|
logger.debug(
|
|
String.format("Yacht srcID(%d) passed Mark srcID(%d)", yacht.getSourceId(),
|
|
roundingMark.getSourceID()));
|
|
}
|
|
|
|
public static void processChatter(ChatterMessage chatterMessage, boolean isHost) {
|
|
String chatterText = chatterMessage.getMessage();
|
|
String[] words = chatterText.split("\\s+");
|
|
if (words.length > 2 && isHost) {
|
|
switch (words[2].trim()) {
|
|
case "/speed":
|
|
try {
|
|
serverSpeedMultiplier = Double.valueOf(words[3]);
|
|
String logMessage = "Speed modifier set to x" + words[3];
|
|
notifyMessageListeners(MessageFactory
|
|
.makeChatterMessage(chatterMessage.getMessageType(), logMessage));
|
|
} catch (Exception e) {
|
|
Logger logger = LoggerFactory.getLogger(GameState.class);
|
|
logger.error("cannot parse >speed value");
|
|
}
|
|
return;
|
|
case "/finish":
|
|
String logMessage = "Game will now finish";
|
|
notifyMessageListeners(MessageFactory
|
|
.makeChatterMessage(chatterMessage.getMessageType(), logMessage));
|
|
endRace();
|
|
return;
|
|
}
|
|
}
|
|
notifyMessageListeners(chatterMessage);
|
|
}
|
|
|
|
public static void addMessageEventListener(NewMessageListener listener) {
|
|
newMessageListeners.add(listener);
|
|
}
|
|
|
|
public static void setCustomizationFlag() {
|
|
customizationFlag = true;
|
|
}
|
|
|
|
public static Boolean getCustomizationFlag() {
|
|
return customizationFlag;
|
|
}
|
|
|
|
public static void resetCustomizationFlag() {
|
|
customizationFlag = false;
|
|
}
|
|
|
|
public static void setPlayerHasLeftFlag(Boolean flag) {
|
|
playerHasLeftFlag = flag;
|
|
}
|
|
|
|
public static Boolean getPlayerHasLeftFlag() {
|
|
return playerHasLeftFlag;
|
|
}
|
|
|
|
public static Integer getNumberOfPlayers(){
|
|
Integer numPlayers = 1;
|
|
|
|
for(Player p : getPlayers()){
|
|
if(p.getSocket().isConnected()){
|
|
numPlayers++;
|
|
}
|
|
}
|
|
|
|
return numPlayers;
|
|
}
|
|
|
|
public static Integer getCapacity(){
|
|
return maxPlayers;
|
|
}
|
|
|
|
public static void setMaxPlayers(Integer newMax){
|
|
maxPlayers = newMax;
|
|
|
|
try {
|
|
ServerAdvertiser.getInstance().setCapacity(newMax);
|
|
} catch (IOException e) {
|
|
logger.warn("Couldn't update max players");
|
|
}
|
|
}
|
|
|
|
public static void endRace () {
|
|
yachts.forEach((id, yacht) -> yacht.setBoatStatus(BoatStatus.FINISHED));
|
|
currentStage = GameStages.FINISHED;
|
|
}
|
|
|
|
public static double getServerSpeedMultiplier() {
|
|
return serverSpeedMultiplier;
|
|
}
|
|
|
|
public static void setTokensEnabled (boolean tokensEnabled) {
|
|
GameState.tokensEnabled = tokensEnabled;
|
|
}
|
|
|
|
public static ReadOnlyDoubleWrapper getWindDirectionProperty() {
|
|
return windDirectionProperty;
|
|
}
|
|
}
|