mirror of
https://github.com/ProjectSWGCore/Holocore.git
synced 2026-10-05 20:13:20 -04:00
582 lines
21 KiB
Java
582 lines
21 KiB
Java
package services.galaxy;
|
|
|
|
import java.sql.ResultSet;
|
|
import java.sql.SQLException;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.concurrent.ExecutorService;
|
|
import java.util.concurrent.Executors;
|
|
|
|
import network.packets.Packet;
|
|
import network.packets.swg.zone.EnterTicketPurchaseModeMessage;
|
|
import network.packets.swg.zone.PlanetTravelPointListRequest;
|
|
import network.packets.swg.zone.PlanetTravelPointListResponse;
|
|
import intents.chat.ChatBroadcastIntent;
|
|
import intents.network.GalacticPacketIntent;
|
|
import intents.object.ObjectCreatedIntent;
|
|
import intents.object.ObjectTeleportIntent;
|
|
import intents.travel.*;
|
|
import resources.Location;
|
|
import resources.Posture;
|
|
import resources.Terrain;
|
|
import resources.TravelPoint;
|
|
import resources.client_info.ClientFactory;
|
|
import resources.client_info.visitors.DatatableData;
|
|
import resources.config.ConfigFile;
|
|
import resources.control.Intent;
|
|
import resources.control.Service;
|
|
import resources.encodables.ProsePackage;
|
|
import resources.encodables.StringId;
|
|
import resources.objects.SWGObject;
|
|
import resources.objects.creature.CreatureObject;
|
|
import resources.player.Player;
|
|
import resources.server_info.Log;
|
|
import resources.server_info.RelationalServerData;
|
|
import resources.sui.ISuiCallback;
|
|
import resources.sui.SuiButtons;
|
|
import resources.sui.SuiEvent;
|
|
import resources.sui.SuiListBox;
|
|
import resources.sui.SuiListBox.SuiListBoxItem;
|
|
import resources.sui.SuiMessageBox;
|
|
import services.objects.ObjectManager;
|
|
|
|
public final class TravelService extends Service {
|
|
|
|
private static final String DB_TABLE_NAME = "travel";
|
|
private static final String TRAVEL_POINTS_FOR_PLANET = "SELECT * FROM " + DB_TABLE_NAME + " WHERE planet=";
|
|
private static final byte PLANET_NAMES_COLUMN_INDEX = 0;
|
|
private static final short TICKET_USE_RADIUS = 25; // The distance a player needs to be within in order to use their ticket
|
|
|
|
private final ObjectManager objectManager;
|
|
private final RelationalServerData travelPointDatabase;
|
|
private Terrain[] travelPlanets;
|
|
private final Map<Terrain, Map<Terrain, Integer>> allowedRoutes; // Describes which planets are linked and base prices.
|
|
private final DatatableData travelFeeTable;
|
|
|
|
/**
|
|
* This variable stores all the loaded TravelPoints for a given planet.
|
|
* All TravelPoints on tatooine are mapped to {@code Terrain.TATOOINE}
|
|
*/
|
|
private final Map<Terrain, Collection<TravelPoint>> pointsOnPlanet;
|
|
|
|
// Fields relating to shuttle take-off and landing
|
|
private Posture currentShuttlePosture;
|
|
private final ExecutorService executor;
|
|
private final int timeUntilLand;
|
|
private int timeRemaining;
|
|
private final long landDelay;
|
|
private boolean shuttleLanded;
|
|
private final long timeGrounded;
|
|
|
|
public TravelService(ObjectManager objectManager) {
|
|
this.objectManager = objectManager;
|
|
|
|
travelPointDatabase = new RelationalServerData("serverdata/static/travel.db");
|
|
|
|
if(!travelPointDatabase.linkTableWithSdb(DB_TABLE_NAME, "serverdata/static/travel.sdb")) {
|
|
throw new main.ProjectSWG.CoreException("Unable to load sdb files for TravelService");
|
|
}
|
|
|
|
allowedRoutes = new HashMap<>();
|
|
travelFeeTable = (DatatableData) ClientFactory.getInfoFromFile("datatables/travel/travel.iff");
|
|
pointsOnPlanet = new HashMap<>();
|
|
|
|
executor = Executors.newSingleThreadExecutor();
|
|
timeUntilLand = getConfig(ConfigFile.FEATURES).getInt("SHUTTLE-AWAY-TIME", 60);
|
|
timeRemaining = timeUntilLand;
|
|
shuttleLanded = true; // Shuttles start off being grounded
|
|
currentShuttlePosture = Posture.UPRIGHT;
|
|
landDelay = 10000; // debugging
|
|
timeGrounded = 120000;
|
|
|
|
loadTravelPlanetNames();
|
|
loadAllowedRoutesAndPrices();
|
|
loadTravelPoints();
|
|
|
|
registerForIntent(TravelPointSelectionIntent.TYPE);
|
|
registerForIntent(GalacticPacketIntent.TYPE);
|
|
registerForIntent(TicketPurchaseIntent.TYPE);
|
|
registerForIntent(TicketUseIntent.TYPE);
|
|
registerForIntent(ObjectCreatedIntent.TYPE);
|
|
}
|
|
|
|
@Override
|
|
public boolean start() {
|
|
executor.execute(new ShuttleBehaviour());
|
|
|
|
return super.start();
|
|
}
|
|
|
|
@Override
|
|
public boolean stop() {
|
|
executor.shutdown();
|
|
|
|
return super.stop();
|
|
}
|
|
|
|
@Override
|
|
public boolean terminate() {
|
|
travelPointDatabase.close();
|
|
|
|
return super.terminate();
|
|
}
|
|
|
|
@Override
|
|
public void onIntentReceived(Intent i) {
|
|
switch(i.getType()) {
|
|
case TravelPointSelectionIntent.TYPE: handlePointSelection((TravelPointSelectionIntent) i); break;
|
|
case GalacticPacketIntent.TYPE: handleTravelPointRequest((GalacticPacketIntent) i); break;
|
|
case TicketPurchaseIntent.TYPE: handleTicketPurchase((TicketPurchaseIntent) i); break;
|
|
case TicketUseIntent.TYPE: handleTicketUse((TicketUseIntent) i); break;
|
|
case ObjectCreatedIntent.TYPE: handleObjectCreation((ObjectCreatedIntent) i); break;
|
|
}
|
|
}
|
|
|
|
private void loadTravelPlanetNames() {
|
|
travelPlanets = new Terrain[travelFeeTable.getRowCount()];
|
|
|
|
travelFeeTable.handleRows(currentRow -> travelPlanets[currentRow] = Terrain.getTerrainFromName((String) travelFeeTable.getCell(currentRow, PLANET_NAMES_COLUMN_INDEX)));
|
|
}
|
|
|
|
private void loadAllowedRoutesAndPrices() {
|
|
for(Terrain travelPlanet : travelPlanets) {
|
|
int rowIndex = travelFeeTable.getColumnFromName(travelPlanet.getName()) - 1;
|
|
Map<Terrain, Integer> prices = new HashMap<>();
|
|
|
|
for(int columnIndex = 1; columnIndex < travelPlanets.length; columnIndex++) {
|
|
int price = (int) travelFeeTable.getCell(rowIndex, columnIndex);
|
|
|
|
if(price > 0) { // If price is above 0, the planets are linked
|
|
Terrain arrivalPlanet = travelPlanets[columnIndex - 1];
|
|
Map<Terrain, Integer> reverseRoute = allowedRoutes.get(arrivalPlanet);
|
|
|
|
if(reverseRoute != null) {
|
|
Integer reverseRoutePriceObj = reverseRoute.get(travelPlanet);
|
|
|
|
if(reverseRoutePriceObj != null) {
|
|
int reverseRoutePrice = reverseRoutePriceObj.intValue();
|
|
|
|
if(reverseRoutePrice > price) {
|
|
price = reverseRoutePrice;
|
|
}
|
|
}
|
|
}
|
|
|
|
prices.put(arrivalPlanet, price);
|
|
}
|
|
}
|
|
|
|
allowedRoutes.put(travelPlanet, prices);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Travel points are loaded from /serverdata/static/travel.sdb
|
|
* A travel point represents a travel destination.
|
|
* @author Mads
|
|
* @return true if all points were loaded succesfully and false if not.
|
|
*/
|
|
private boolean loadTravelPoints() {
|
|
boolean success = true;
|
|
|
|
for(Terrain travelPlanet : allowedRoutes.keySet()) {
|
|
String planetName = travelPlanet.getName();
|
|
|
|
try(ResultSet set = travelPointDatabase.prepareStatement(TRAVEL_POINTS_FOR_PLANET + "'" + planetName + "'").executeQuery()) {
|
|
while(set.next()) {
|
|
String pointName = set.getString("name");
|
|
double x = set.getDouble("x");
|
|
double y = set.getDouble("y");
|
|
double z = set.getDouble("z");
|
|
String type = set.getString("type");
|
|
|
|
TravelPoint point = new TravelPoint(pointName, new Location(x, y, z, travelPlanet), 0, type.equals("starport"), true);
|
|
|
|
Collection<TravelPoint> pointsOnCurrentPlanet = pointsOnPlanet.get(travelPlanet);
|
|
|
|
if(pointsOnCurrentPlanet == null) {
|
|
pointsOnCurrentPlanet = new ArrayList<>();
|
|
pointsOnPlanet.put(travelPlanet, pointsOnCurrentPlanet);
|
|
}
|
|
|
|
pointsOnCurrentPlanet.add(point);
|
|
}
|
|
} catch (SQLException e) {
|
|
Log.e("TravelService", String.format("Failed to load a travel point for %s. %s", planetName, e.getLocalizedMessage()));
|
|
e.printStackTrace();
|
|
success = false;
|
|
}
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
private Collection<TravelPoint> pointsForPlanet(Location location, String planetName) {
|
|
Collection<TravelPoint> points = new ArrayList<>();
|
|
Terrain objectTerrain = location.getTerrain();
|
|
Terrain destinationTerrain = Terrain.getTerrainFromName(planetName);
|
|
|
|
Collection<TravelPoint> candidatePoints = pointsOnPlanet.get(destinationTerrain);
|
|
|
|
for(TravelPoint candidatePoint : candidatePoints) {
|
|
if(objectTerrain == destinationTerrain) {
|
|
// If the destination planet is the same as our current
|
|
points.addAll(candidatePoints);
|
|
break; // Then return all the points on this planet
|
|
} else {
|
|
if(candidatePoint.isStarport()) { // If the terrains aren't the same, we only want to add the starports.
|
|
points.add(candidatePoint);
|
|
}
|
|
}
|
|
}
|
|
|
|
return points;
|
|
}
|
|
|
|
private void handlePointSelection(TravelPointSelectionIntent tpsi) {
|
|
CreatureObject traveler = tpsi.getCreature();
|
|
|
|
traveler.sendSelf(new EnterTicketPurchaseModeMessage(traveler.getTerrain().getName(), nearestTravelPoint(traveler.getWorldLocation()).getName(), tpsi.isInstant()));
|
|
}
|
|
|
|
private void handleTravelPointRequest(GalacticPacketIntent i) {
|
|
Packet p = i.getPacket();
|
|
|
|
if(p instanceof PlanetTravelPointListRequest ) {
|
|
PlanetTravelPointListRequest req = (PlanetTravelPointListRequest) p;
|
|
String planetName = req.getPlanetName();
|
|
Player player = i.getPlayerManager().getPlayerFromNetworkId(i.getNetworkId());
|
|
|
|
player.sendPacket(new PlanetTravelPointListResponse(planetName, pointsForPlanet(player.getCreatureObject().getWorldLocation(), planetName)));
|
|
}
|
|
}
|
|
|
|
private int getTotalTicketPrice(TravelPoint departurePoint, Terrain arrivalPlanet) {
|
|
int totalPrice = 0;
|
|
Terrain departurePlanet = departurePoint.getLocation().getTerrain();
|
|
|
|
totalPrice += allowedRoutes.get(departurePlanet).get(arrivalPlanet);
|
|
totalPrice += departurePoint.getAdditionalCost();
|
|
|
|
return totalPrice;
|
|
}
|
|
|
|
private void handleTicketPurchase(TicketPurchaseIntent i) {
|
|
CreatureObject purchaser = i.getPurchaser();
|
|
Location purchaserWorldLocation = purchaser.getWorldLocation();
|
|
TravelPoint nearestPoint = nearestTravelPoint(purchaserWorldLocation);
|
|
TravelPoint destinationPoint = destinationPoint(Terrain.getTerrainFromName(i.getDestinationPlanet()), i.getDestinationName());
|
|
Player purchaserOwner = purchaser.getOwner();
|
|
boolean roundTrip = i.isRoundTrip();
|
|
|
|
if(nearestPoint == null || destinationPoint == null)
|
|
return;
|
|
|
|
int ticketPrice = getTotalTicketPrice(nearestPoint, destinationPoint.getLocation().getTerrain());
|
|
int newBankBalance = purchaser.getBankBalance();
|
|
int newCashBalance = purchaser.getCashBalance();
|
|
|
|
if(roundTrip)
|
|
ticketPrice *= 2;
|
|
|
|
int difference = newBankBalance - ticketPrice;
|
|
|
|
if(difference < 0) { // If they don't have enough credits in their bank
|
|
newBankBalance = 0; // They now have no more credits in their bank
|
|
newCashBalance += difference; // We subtract the remaining credits from their cash balance.
|
|
|
|
if(newCashBalance < 0) { // If they don't have enough bank and cash funds combined, they receive no ticket!
|
|
// Make the message in the SUI window reflect the fail
|
|
showMessageBox(purchaserOwner, "short_funds");
|
|
return;
|
|
}
|
|
} else {
|
|
newBankBalance = difference;
|
|
}
|
|
|
|
// Make the message in the SUI window reflect the success
|
|
showMessageBox(purchaserOwner, "ticket_purchase_complete");
|
|
|
|
// Also send the purchaser a system message
|
|
// There's no StringId for this message.
|
|
new ChatBroadcastIntent(purchaserOwner, String.format("You succesfully make a payment of %d credits to the Galactic Travel Commission.", ticketPrice)).broadcast();
|
|
|
|
purchaser.setCashBalance(newCashBalance);
|
|
purchaser.setBankBalance(newBankBalance);
|
|
|
|
// Put the ticket in their inventory
|
|
grantTicket(nearestPoint, destinationPoint, purchaser);
|
|
|
|
if(roundTrip) {
|
|
// Put the ticket in their inventory
|
|
grantTicket(destinationPoint, nearestPoint, purchaser);
|
|
}
|
|
|
|
}
|
|
|
|
private void showMessageBox(Player receiver, String message) {
|
|
// Create the SUI window
|
|
SuiMessageBox messageBox = new SuiMessageBox(SuiButtons.OK, "STAR WARS GALAXIES", "@travel:" + message);
|
|
|
|
// Display the window to the purchaser
|
|
messageBox.display(receiver);
|
|
}
|
|
|
|
private void grantTicket(TravelPoint departure, TravelPoint destination, SWGObject receiver) {
|
|
// Create the ticket object
|
|
SWGObject ticket = objectManager.createObject("object/tangible/travel/travel_ticket/base/shared_base_travel_ticket.iff", false);
|
|
|
|
// Departure attributes
|
|
ticket.addAttribute("@obj_attr_n:travel_departure_planet", "@planet_n:" + departure.getLocation().getTerrain().getName());
|
|
ticket.addAttribute("@obj_attr_n:travel_departure_point", departure.getName());
|
|
|
|
// Arrival attributes
|
|
ticket.addAttribute("@obj_attr_n:travel_arrival_planet", "@planet_n:" + destination.getLocation().getTerrain().getName());
|
|
ticket.addAttribute("@obj_attr_n:travel_arrival_point", destination.getName());
|
|
|
|
receiver.getSlottedObject("inventory").addObject(ticket);
|
|
}
|
|
|
|
private void handleTicketUse(TicketUseIntent i) {
|
|
if(isShuttleAvailable()) {
|
|
// The shuttle is available at this time
|
|
if(i.getTicket() == null)
|
|
handleTicketUseSui(i);
|
|
else
|
|
handleTicketUseClick(i);
|
|
} else { // The shuttle isn't available
|
|
if(isShuttleBoarding()) { // Unavailable but about to board
|
|
new ChatBroadcastIntent(i.getPlayer(), "@travel/travel:shuttle_begin_boarding").broadcast();
|
|
} else { // Unavailable but not about to board, because...
|
|
if(isShuttleDeparting()) // ... it's departing
|
|
new ChatBroadcastIntent(i.getPlayer(), "@travel:shuttle_not_available").broadcast();
|
|
else // ... or it's done departing and is completely away
|
|
new ChatBroadcastIntent(i.getPlayer(), new ProsePackage(new StringId("travel/travel", "shuttle_board_delay"), "DI", timeRemaining)).broadcast();
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private void handleTicketUseSui(TicketUseIntent i) {
|
|
Player player = i.getPlayer();
|
|
CreatureObject creature = player.getCreatureObject();
|
|
Collection<SWGObject> tickets = creature.getItemsByTemplate("inventory", "object/tangible/travel/travel_ticket/base/shared_base_travel_ticket.iff");
|
|
SuiListBox destinationSelection;
|
|
List<SWGObject> usableTickets = new ArrayList<>();
|
|
|
|
for(SWGObject ticket : tickets)
|
|
if(isTicket(ticket))
|
|
if(ticketCanBeUsedAtNearestPoint(ticket))
|
|
usableTickets.add(ticket);
|
|
|
|
if(usableTickets.isEmpty()) // They don't have a valid ticket.
|
|
new ChatBroadcastIntent(player, "@travel:no_ticket_for_shuttle").broadcast();
|
|
else {
|
|
destinationSelection = new SuiListBox(SuiButtons.OK_CANCEL, "@travel:select_destination", "@travel:select_destination");
|
|
|
|
for(SWGObject usableTicket : usableTickets) {
|
|
TravelPoint destinationPoint = destinationPoint(usableTicket);
|
|
|
|
destinationSelection.addListItem(destinationPoint.getSuiFormat(), destinationPoint);
|
|
}
|
|
|
|
destinationSelection.addOkButtonCallback("handleSelectedItem", new DestinationSelectionSuiCallback(destinationSelection, usableTickets));
|
|
destinationSelection.display(player);
|
|
}
|
|
}
|
|
|
|
private void handleTicketUseClick(TicketUseIntent i) {
|
|
CreatureObject traveler = i.getPlayer().getCreatureObject();
|
|
Location worldLoc = traveler.getWorldLocation();
|
|
TravelPoint nearestPoint = nearestTravelPoint(worldLoc);
|
|
double distanceToNearestPoint = worldLoc.distanceTo(nearestPoint.getShuttle().getLocation());
|
|
SWGObject ticket = i.getTicket();
|
|
Player player = i.getPlayer();
|
|
|
|
if(isTicket(ticket)) {
|
|
if(ticketCanBeUsedAtNearestPoint(ticket)) {
|
|
if(distanceToNearestPoint <= TICKET_USE_RADIUS) {
|
|
// They can use their ticket if they're within range.
|
|
teleportAndDestroyTicket(destinationPoint(ticket), ticket, traveler);
|
|
} else {
|
|
// They're out of range - let them know.
|
|
new ChatBroadcastIntent(player, "@travel:boarding_too_far").broadcast();
|
|
}
|
|
} else {
|
|
// This ticket isn't valid for this point
|
|
new ChatBroadcastIntent(player, "@travel:wrong_shuttle").broadcast();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void handleObjectCreation(ObjectCreatedIntent i) {
|
|
SWGObject object = i.getObject();
|
|
String template = object.getTemplate();
|
|
|
|
if(template.contains("shared_player_shuttle") || template.contains("shared_player_transport")) {
|
|
CreatureObject shuttle = (CreatureObject) object;
|
|
Location shuttleLocation = shuttle.getLocation();
|
|
TravelPoint pointForShuttle = nearestTravelPoint(shuttleLocation);
|
|
|
|
// Assign the shuttle to the nearest travel point
|
|
pointForShuttle.setShuttle(shuttle);
|
|
}
|
|
}
|
|
|
|
private void teleportAndDestroyTicket(TravelPoint destination, SWGObject ticket, CreatureObject traveler) {
|
|
objectManager.destroyObject(ticket);
|
|
|
|
new ObjectTeleportIntent(traveler, destination.getLocation()).broadcast();
|
|
}
|
|
|
|
private boolean isTicket(SWGObject object) {
|
|
String departurePlanet = object.getAttribute("@obj_attr_n:travel_departure_planet");
|
|
String departureDestination = object.getAttribute("@obj_attr_n:travel_departure_point");
|
|
String arrivalPlanet = object.getAttribute("@obj_attr_n:travel_arrival_planet");
|
|
String arrivalPoint = object.getAttribute("@obj_attr_n:travel_arrival_point");
|
|
|
|
return departurePlanet != null && departureDestination != null && arrivalPlanet != null && arrivalPoint != null;
|
|
}
|
|
|
|
private boolean ticketCanBeUsedAtNearestPoint(SWGObject ticket) {
|
|
CreatureObject ticketOwner = ticket.getOwner().getCreatureObject();
|
|
Location worldLoc = ticketOwner.getWorldLocation();
|
|
TravelPoint nearest = nearestTravelPoint(worldLoc);
|
|
String departurePoint = ticket.getAttribute("@obj_attr_n:travel_departure_point");
|
|
String departurePlanet = ticket.getAttribute("@obj_attr_n:travel_departure_planet");
|
|
Terrain departureTerrain = Terrain.getTerrainFromName(departurePlanet.split(":")[1]);
|
|
Terrain currentTerrain = worldLoc.getTerrain();
|
|
|
|
return departureTerrain == currentTerrain && departurePoint.equals(nearest.getName());
|
|
}
|
|
|
|
private TravelPoint destinationPoint(SWGObject ticket) {
|
|
return destinationPoint(Terrain.getTerrainFromName(ticket.getAttribute("@obj_attr_n:travel_arrival_planet").split(":")[1]), ticket.getAttribute("@obj_attr_n:travel_arrival_point"));
|
|
}
|
|
|
|
private TravelPoint destinationPoint(Terrain terrain, String pointName) {
|
|
TravelPoint currentResult = null;
|
|
Iterator<TravelPoint> pointIterator = pointsOnPlanet.get(terrain).iterator();
|
|
|
|
while(pointIterator.hasNext()) {
|
|
TravelPoint candidate = pointIterator.next();
|
|
|
|
if(candidate.getName().equals(pointName)) {
|
|
currentResult = candidate;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return currentResult;
|
|
}
|
|
|
|
private TravelPoint nearestTravelPoint(Location objectLocation) {
|
|
TravelPoint currentResult = null;
|
|
double currentResultDistance = Double.MAX_VALUE;
|
|
double candidateDistance;
|
|
Collection<TravelPoint> pointsForPlanet = pointsOnPlanet.get(objectLocation.getTerrain());
|
|
|
|
for(TravelPoint candidate : pointsForPlanet) {
|
|
if(currentResult == null) { // Will occur upon the first iteration.
|
|
currentResult = candidate; // The first candidate will always be the first possible result.
|
|
currentResultDistance = distanceFromPoint(currentResult, objectLocation);
|
|
} else {
|
|
candidateDistance = distanceFromPoint(candidate, objectLocation);
|
|
|
|
if(candidateDistance < currentResultDistance) {
|
|
currentResult = candidate;
|
|
currentResultDistance = candidateDistance;
|
|
}
|
|
}
|
|
}
|
|
|
|
return currentResult;
|
|
}
|
|
|
|
private double distanceFromPoint(TravelPoint point, Location objectLocation) {
|
|
return point.getLocation().distanceTo(objectLocation);
|
|
}
|
|
|
|
private void updateShuttlePostures(Posture posture) {
|
|
for(Collection<TravelPoint> travelPoints : pointsOnPlanet.values()) {
|
|
for(TravelPoint tp : travelPoints) {
|
|
CreatureObject shuttle = tp.getShuttle();
|
|
|
|
if(shuttle == null) // This TravelPoint has no associated shuttle
|
|
continue; // Continue with the next TravelPoint
|
|
|
|
shuttle.setPosture(posture);
|
|
}
|
|
}
|
|
|
|
currentShuttlePosture = posture;
|
|
}
|
|
|
|
private boolean isShuttleAvailable() {
|
|
return currentShuttlePosture == Posture.UPRIGHT && shuttleLanded;
|
|
}
|
|
|
|
private boolean isShuttleBoarding() {
|
|
return currentShuttlePosture == Posture.UPRIGHT && !shuttleLanded;
|
|
}
|
|
|
|
private boolean isShuttleDeparting() {
|
|
return currentShuttlePosture == Posture.PRONE && !shuttleLanded && timeRemaining == timeUntilLand;
|
|
}
|
|
|
|
private class DestinationSelectionSuiCallback implements ISuiCallback {
|
|
|
|
private final SuiListBox destinationSelection;
|
|
private final List<SWGObject> usableTickets;
|
|
|
|
private DestinationSelectionSuiCallback(SuiListBox destinationSelection, List<SWGObject> usableTickets) {
|
|
this.destinationSelection = destinationSelection;
|
|
this.usableTickets = usableTickets;
|
|
}
|
|
|
|
@Override
|
|
public void handleEvent(Player player, SWGObject actor, SuiEvent event, Map<String, String> parameters) {
|
|
int selection = SuiListBox.getSelectedRow(parameters);
|
|
SuiListBoxItem selectedItem = destinationSelection.getListItem(selection);
|
|
TravelPoint selectedDestination = (TravelPoint) selectedItem.getObject();
|
|
|
|
teleportAndDestroyTicket(selectedDestination, usableTickets.get(selection), player.getCreatureObject());
|
|
}
|
|
}
|
|
|
|
private class ShuttleBehaviour implements Runnable {
|
|
@Override
|
|
public void run() {
|
|
while(true) {
|
|
try {
|
|
// GROUNDED
|
|
Thread.sleep(timeGrounded);
|
|
|
|
// LEAVE
|
|
updateShuttlePostures(Posture.PRONE);
|
|
shuttleLanded = false;
|
|
Thread.sleep(landDelay);
|
|
|
|
// Make the shuttle stay away for some time.
|
|
for(long timeElapsed = 0; timeUntilLand > timeElapsed; timeRemaining--, timeElapsed++) {
|
|
Thread.sleep(1000); // Sleep for a second
|
|
}
|
|
|
|
timeRemaining = timeUntilLand; // Reset the timer
|
|
|
|
// LANDING
|
|
updateShuttlePostures(Posture.UPRIGHT);
|
|
Thread.sleep(landDelay);
|
|
shuttleLanded = true;
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|