swg-source/dsrc
1
0
Fork 0
mirror of https://github.com/SWG-Source/dsrc.git synced 2026-01-17 00:05:07 -05:00
Code Issues Projects Releases Wiki Activity
Files
6f9305efe0377da58e992fa59b0dc209d949760e
dsrc/sku.0/sys.server/compiled/game/script/library/travel.java
Tekaoh 5c2e112349 Java 11.0.2 migration (#32) 
* Code compiles - execution NOT tested

* updating gitignore

* Removed intellij settings files

* Removed more intellij files

* Added exclusion for JDK classes.

* Fixed purchasing script for vendors that have listed coin types.

* Updated script to not kick off until the entire preload is complete.

* adds static name entry for Solo movie poster and tcg9 vendor entry

* clean up empty and orphaned object templates

* adds placeholder black market (static) spawns

* corrects entries for the video game table to correctly set it in tcg series 2 and remove series 1 console errors

* Updated gitignore and removed intellij project files

* Fixed appearance reference for thranta payroll and kashyyyk door, added skipLosCheck objvar due to cannit see issue. Requires updated src

* Fixed appearance and template for terminal (#2)

* Fixed appearance and template for terminal (#3)

* Fixed appearance and template for terminal (#4)

* Deleted another faulty/orphaned object template

* Fixed gcw ranks option on frog. Only issue is that it doesn't award the officer commands or badges.

* Fixed some unneeded java 11 changes
2019-04-18 18:31:52 -05:00

1397 lines
53 KiB
Java
Executable File
Raw Blame History

package script.library;
import script.dictionary;
import script.location;
import script.obj_id;
import script.string_id;
import java.util.Vector;
public class travel extends script.base_script
{
public travel()
{
}
public static final String STARPORT_DATATABLE = "datatables/structure/municipal/starport.iff";
public static final String DATATABLE_COL_STRUCTURE = "STRUCTURE";
public static final String DATATABLE_COL_ARRIVAL_X = "ARRIVAL_X";
public static final String DATATABLE_COL_ARRIVAL_Y = "ARRIVAL_Y";
public static final String DATATABLE_COL_ARRIVAL_Z = "ARRIVAL_Z";
public static final String DATATABLE_COL_ARRIVAL_CELL = "ARRIVAL_CELL";
public static final String DATATABLE_COL_GROUND_TIME = "GROUND_TIME";
public static final String DATATABLE_COL_AIR_TIME = "AIR_TIME";
public static final String DATATABLE_COL_IS_SHUTTLEPORT = "IS_SHUTTLEPORT";
public static final String DATATABLE_COL_VERSION = "VERSION";
public static final String DATATABLE_COL_OBJECT = "OBJECT";
public static final String DATATABLE_COL_X = "X";
public static final String DATATABLE_COL_Y = "Y";
public static final String DATATABLE_COL_Z = "Z";
public static final String DATATABLE_COL_CELL = "CELL";
public static final String DATATABLE_COL_HEADING = "HEADING";
public static final String DATATABLE_COL_IS_TERMINAL = "IS_TERMINAL";
public static final String DATATABLE_COL_IS_TRANSPORT = "IS_TRANSPORT";
public static final String DATATABLE_COL_IS_PILOT = "IS_PILOT";
public static final String SCRIPT_STARPORT = "structure.municipal.starport";
public static final String SCRIPT_TERMINAL = "terminal.terminal_travel";
public static final String SCRIPT_SHUTTLE = "item.travel_ticket.travel_shuttle";
public static final String SCRIPT_SHUTTLE_PILOT = "item.travel_ticket.travel_shuttle_pilot";
public static final String BASE_TRAVEL_TICKET = "object/tangible/travel/travel_ticket/base/base_travel_ticket.iff";
public static final String TRAVEL_COUPON_TEMPLATE = "object/tangible/item/new_player/new_player_travel_coupon.iff";
public static final float MAXIMUM_SHUTTLE_DISTANCE = 25.0f;
public static final float MAXIMUM_TERMINAL_DISTANCE = 15.0f;
public static final float MIN_RANDOM_DISTANCE = 2.0f;
public static final float MAX_RANDOM_DISTANCE = 5.0f;
public static final int CURRENT_VERSION = 3;
public static final String VAR_TRAVEL = "travel";
public static final String VAR_TRAVEL_POINT_NAME = "travel.point_name";
public static final String VAR_ARRIVAL_LOCATION = "travel.arrival_location";
public static final String VAR_TRAVEL_COST = "travel.cost";
public static final String VAR_BASE_OBJECT = "travel.base_object";
public static final String VAR_GROUND_TIME = "travel.ground_time";
public static final String VAR_AIR_TIME = "travel.air_time";
public static final String VAR_IS_SHUTTLEPORT = "travel.is_shuttleport";
public static final String VAR_SHUTTLE_AVAILABLE = "travel.shuttle_available";
public static final String SCRIPTVAR_SHUTTLE_AVAILABLE_COUNT = "travel.shuttle_available_count";
public static final String VAR_SHUTTLE_TIMESTAMP = "travel.shuttle_timestamp";
public static final String VAR_VERSION = "travel.version";
public static final String VAR_STARPORT = "travel.starport";
public static final String VAR_DEPARTURE_PLANET = "travel.ticket.departure_planet";
public static final String VAR_ARRIVAL_PLANET = "travel.ticket.arrival_planet";
public static final String VAR_DEPARTURE_POINT = "travel.ticket.departure_point";
public static final String VAR_ARRIVAL_POINT = "travel.ticket.arrival_point";
public static final String VAR_STARPORT_ORIGIN = "travel.ticket.starport_origin";
public static final String VAR_VALID_TICKETS = "travel.valid_tickets";
public static final String VAR_BOARDING_SHUTTLE = "travel.boarding_shuttle";
public static final String VAR_PURCHASING_TICKET = "travel.purchasing_ticket";
public static final String SCRIPT_VAR_TERMINAL = "travel.ticket_terminal";
public static final string_id SID_MUSTAFAR_UNAUTHORIZED = new string_id("travel", "mustafar_unauthorized");
public static final string_id SID_KASHYYYK_UNAUTHORIZED = new string_id("travel", "kashyyyk_unauthorized");
public static final int TRAVEL_BLOCK_ALLOW_LAUNCH = 1;
public static boolean initializeStarport(obj_id structure, String travel_point, int travel_cost, boolean civic) throws InterruptedException
{
LOG("LOG_CHANNEL", "structure ->" + structure + " travel ->" + travel_point + " cost ->" + travel_cost);
if (structure == null || structure == obj_id.NULL_ID)
{
return false;
}
int num_items = dataTableGetNumRows(STARPORT_DATATABLE);
String template = getTemplateName(structure);
int idx = getStarportTableIndex(template);
LOG("LOG_CHANNEL", "idx ->" + idx);
if (idx == -1)
{
return false;
}
String planet = getCurrentSceneName();
dictionary row = dataTableGetRow(STARPORT_DATATABLE, idx);
float arrival_x = row.getFloat(DATATABLE_COL_ARRIVAL_X);
float arrival_y = row.getFloat(DATATABLE_COL_ARRIVAL_Y);
float arrival_z = row.getFloat(DATATABLE_COL_ARRIVAL_Z);
String arrival_cell = row.getString(DATATABLE_COL_ARRIVAL_CELL);
int ground_time = row.getInt(DATATABLE_COL_GROUND_TIME);
int air_time = row.getInt(DATATABLE_COL_AIR_TIME);
int is_shuttleport = row.getInt(DATATABLE_COL_IS_SHUTTLEPORT);
location arrival_loc;
if (arrival_cell.equals("WORLD_DELTA"))
{
location s_loc = getLocation(structure);
float s_yaw = getYaw(structure);
if (s_yaw < 0.0f)
{
s_yaw = s_yaw + 360.0f;
}
float[] transform = transformDeltaWorldYaw(structure, arrival_x, arrival_z);
arrival_x = transform[0];
arrival_z = transform[1];
arrival_loc = new location(s_loc.x - arrival_x, s_loc.y - arrival_y, s_loc.z - arrival_z, planet, obj_id.NULL_ID);
}
else
{
obj_id cell_id = getCellId(structure, arrival_cell);
if (cell_id == null || cell_id == obj_id.NULL_ID)
{
return false;
}
arrival_loc = new location(arrival_x, arrival_y, arrival_z, planet, cell_id);
}
setObjVar(structure, VAR_GROUND_TIME, ground_time);
setObjVar(structure, VAR_AIR_TIME, air_time);
setObjVar(structure, VAR_SHUTTLE_AVAILABLE, 1);
setObjVar(structure, VAR_SHUTTLE_TIMESTAMP, getGameTime());
setObjVar(structure, VAR_VERSION, CURRENT_VERSION);
if (is_shuttleport > 0)
{
setObjVar(structure, VAR_IS_SHUTTLEPORT, is_shuttleport);
}
else if (hasObjVar(structure, VAR_IS_SHUTTLEPORT))
{
removeObjVar(structure, VAR_IS_SHUTTLEPORT);
}
setStarportTravelPoint(structure, travel_point, arrival_loc, travel_cost, civic);
if (hasObjVar(structure, VAR_BASE_OBJECT))
{
destroyBaseObjects(structure);
}
if (num_items > idx + 1)
{
float s_yaw = getYaw(structure);
if (s_yaw < 0.0f)
{
s_yaw = s_yaw + 360.0f;
}
Vector object_list = new Vector();
object_list.setSize(0);
for (int i = idx + 1; i < num_items; i++)
{
String struct_temp = dataTableGetString(STARPORT_DATATABLE, i, DATATABLE_COL_STRUCTURE);
if (struct_temp.length() > 0)
{
break;
}
dictionary object_row = dataTableGetRow(STARPORT_DATATABLE, i);
String obj_template = object_row.getString(DATATABLE_COL_OBJECT);
float x = object_row.getFloat(DATATABLE_COL_X);
float y = object_row.getFloat(DATATABLE_COL_Y);
float z = object_row.getFloat(DATATABLE_COL_Z);
String cell = object_row.getString(DATATABLE_COL_CELL);
float heading = object_row.getFloat(DATATABLE_COL_HEADING);
int is_terminal = object_row.getInt(DATATABLE_COL_IS_TERMINAL);
int is_transport = object_row.getInt(DATATABLE_COL_IS_TRANSPORT);
int is_pilot = object_row.getInt(DATATABLE_COL_IS_PILOT);
location obj_loc;
obj_id object;
if (cell.equals("WORLD_DELTA"))
{
float[] delta_trans = transformDeltaWorldYaw(structure, x, z);
x = delta_trans[0];
z = delta_trans[1];
heading = heading + s_yaw;
if (heading > 360)
{
heading = heading - 360;
}
location s_loc = getLocation(structure);
obj_loc = new location(s_loc.x - x, s_loc.y - y, s_loc.z - z, planet, obj_id.NULL_ID);
object = createObject(obj_template, obj_loc);
}
else
{
obj_id cell_id = getCellId(structure, cell);
if (cell_id == null || cell_id == obj_id.NULL_ID)
{
continue;
}
obj_loc = new location(x, y, z, planet, cell_id);
object = createObjectInCell(obj_template, structure, cell, obj_loc);
}
if (heading != 0.0f)
{
}
{
setYaw(object, heading);
object_list = utils.addElement(object_list, object);
}
if (is_terminal == 1)
{
setObjVar(object, VAR_STARPORT, structure);
}
if (is_transport == 1)
{
setObjVar(object, VAR_STARPORT, structure);
attachScript(object, SCRIPT_SHUTTLE);
}
if (is_pilot == 1)
{
setObjVar(object, VAR_STARPORT, structure);
attachScript(object, SCRIPT_SHUTTLE_PILOT);
}
if (object_list.size() > 0)
{
setObjVar(structure, VAR_BASE_OBJECT, object_list);
}
}
}
return true;
}
public static String getTravelPointName(obj_id structure) throws InterruptedException
{
if (structure == null || structure == obj_id.NULL_ID)
{
return null;
}
if (player_structure.isCivic(structure))
{
int cityId = getCityAtLocation(getLocation(structure), 0);
if (cityId != 0 && cityGetTravelCost(cityId) > 0)
{
return cityGetName(cityId);
}
return null;
}
if (hasObjVar(structure, VAR_TRAVEL_POINT_NAME))
{
return getStringObjVar(structure, VAR_TRAVEL_POINT_NAME);
}
else
{
return null;
}
}
public static location getArrivalLocation(obj_id structure) throws InterruptedException
{
if (structure == null || structure == obj_id.NULL_ID)
{
return null;
}
if (hasObjVar(structure, VAR_ARRIVAL_LOCATION))
{
return getLocationObjVar(structure, VAR_ARRIVAL_LOCATION);
}
else
{
return null;
}
}
public static int getTravelCost(obj_id structure) throws InterruptedException
{
if (structure == null || structure == obj_id.NULL_ID)
{
return -1;
}
if (hasObjVar(structure, VAR_TRAVEL_COST))
{
return getIntObjVar(structure, VAR_TRAVEL_COST);
}
else
{
return -1;
}
}
public static int getGroundTime(obj_id structure) throws InterruptedException
{
if (structure == null || structure == obj_id.NULL_ID)
{
return -1;
}
if (hasObjVar(structure, VAR_GROUND_TIME))
{
return getIntObjVar(structure, VAR_GROUND_TIME);
}
else
{
return -1;
}
}
public static int getAirTime(obj_id structure) throws InterruptedException
{
if (structure == null || structure == obj_id.NULL_ID)
{
return -1;
}
if (hasObjVar(structure, VAR_AIR_TIME))
{
return getIntObjVar(structure, VAR_AIR_TIME);
}
else
{
return -1;
}
}
public static int getShuttleTimestamp(obj_id structure) throws InterruptedException
{
if (structure == null || structure == obj_id.NULL_ID)
{
return -1;
}
if (hasObjVar(structure, VAR_SHUTTLE_TIMESTAMP))
{
return getIntObjVar(structure, VAR_SHUTTLE_TIMESTAMP);
}
else
{
return -1;
}
}
public static obj_id[] getBaseObjects(obj_id structure) throws InterruptedException
{
if (structure == null || structure == obj_id.NULL_ID)
{
return null;
}
if (hasObjVar(structure, VAR_BASE_OBJECT))
{
return getObjIdArrayObjVar(structure, VAR_BASE_OBJECT);
}
else
{
return null;
}
}
public static String getTicketDeparturePlanet(obj_id ticket) throws InterruptedException
{
if (ticket == null || ticket == obj_id.NULL_ID)
{
return null;
}
if (hasObjVar(ticket, VAR_DEPARTURE_PLANET))
{
return getStringObjVar(ticket, VAR_DEPARTURE_PLANET);
}
else
{
return null;
}
}
public static String getTicketDeparturePoint(obj_id ticket) throws InterruptedException
{
if (ticket == null || ticket == obj_id.NULL_ID)
{
return null;
}
if (hasObjVar(ticket, VAR_DEPARTURE_POINT))
{
return getStringObjVar(ticket, VAR_DEPARTURE_POINT);
}
else
{
return null;
}
}
public static String getTicketArrivalPlanet(obj_id ticket) throws InterruptedException
{
if (ticket == null || ticket == obj_id.NULL_ID)
{
return null;
}
if (hasObjVar(ticket, VAR_ARRIVAL_PLANET))
{
return getStringObjVar(ticket, VAR_ARRIVAL_PLANET);
}
else
{
return null;
}
}
public static String getTicketArrivalPoint(obj_id ticket) throws InterruptedException
{
if (ticket == null || ticket == obj_id.NULL_ID)
{
return null;
}
if (hasObjVar(ticket, VAR_ARRIVAL_POINT))
{
return getStringObjVar(ticket, VAR_ARRIVAL_POINT);
}
else
{
return null;
}
}
public static int getStarportVersion(obj_id starport) throws InterruptedException
{
if (starport == null || starport == obj_id.NULL_ID)
{
return -1;
}
if (hasObjVar(starport, VAR_VERSION))
{
return getIntObjVar(starport, VAR_VERSION);
}
else
{
return 0;
}
}
public static int getStarportTableIndex(String template) throws InterruptedException
{
int idx = -1;
int numItems = dataTableGetNumRows(STARPORT_DATATABLE);
for (int i = 0; i < numItems; i++)
{
String starportTemplate = dataTableGetString(STARPORT_DATATABLE, i, DATATABLE_COL_STRUCTURE);
if (starportTemplate.equals(template))
{
idx = i;
break;
}
}
return idx;
}
public static boolean isTravelTicketValid(obj_id object, String depart_planet, String depart_point) throws InterruptedException
{
if (object == null || object == obj_id.NULL_ID)
{
return false;
}
if (hasObjVar(object, VAR_DEPARTURE_PLANET)) {
String ticket_planet = getTicketDeparturePlanet(object);
String ticket_point = getTicketDeparturePoint(object);
return ticket_planet.equals(depart_planet) && ticket_point.equals(depart_point);
}
else
{
return false;
}
}
public static boolean isShuttlePort(obj_id structure) throws InterruptedException
{
if (structure == null || structure == obj_id.NULL_ID)
{
return false;
}
return hasObjVar(structure, VAR_IS_SHUTTLEPORT);
}
public static boolean isTravelShuttle(obj_id object) throws InterruptedException
{
if (object == null || object == obj_id.NULL_ID)
{
return false;
}
return hasScript(object, SCRIPT_SHUTTLE);
}
public static boolean isTravelShuttlePilot(obj_id object) throws InterruptedException
{
if (object == null || object == obj_id.NULL_ID)
{
return false;
}
return hasScript(object, SCRIPT_SHUTTLE_PILOT);
}
public static boolean isShuttleAvailable(obj_id starport) throws InterruptedException
{
if (starport == null || starport == obj_id.NULL_ID)
{
return false;
}
int available = getIntObjVar(starport, VAR_SHUTTLE_AVAILABLE);
return available == 1;
}
public static boolean qualifiesForGcwTravelPerks(obj_id player) throws InterruptedException
{
if (!isIdValid(player))
{
return false;
}
final int faction = pvpGetAlignedFaction(player);
if (faction == 0)
{
return false;
}
if (pvpGetCurrentGcwRank(player) < 7)
{
return false;
}
final int imperialScore = getGcwGroupImperialScorePercentile(getCurrentSceneName());
if ((-615855020) == faction)
{
return (imperialScore >= 70);
}
else if ((370444368) == faction)
{
return (imperialScore <= 30);
}
return false;
}
public static boolean restrictedByGcwTravelRestrictions(obj_id player) throws InterruptedException
{
if (!isIdValid(player))
{
return false;
}
final int faction = pvpGetAlignedFaction(player);
if (faction == 0)
{
return false;
}
if (pvpGetCurrentGcwRank(player) < 7)
{
return false;
}
final int imperialScore = getGcwGroupImperialScorePercentile(getCurrentSceneName());
if ((-615855020) == faction)
{
return (imperialScore <= 30);
}
else if ((370444368) == faction)
{
return (imperialScore >= 70);
}
return false;
}
public static int getGcwTravelRestrictionsSurcharge(obj_id player, String departPlanet, String arrivePlanet) throws InterruptedException
{
if (!isIdValid(player))
{
return 0;
}
final int faction = pvpGetAlignedFaction(player);
if (faction == 0)
{
return 0;
}
if (pvpGetCurrentGcwRank(player) < 7)
{
return 0;
}
final int imperialScoreDepartPlanet = getGcwGroupImperialScorePercentile(departPlanet);
final int imperialScoreArrivePlanet = getGcwGroupImperialScorePercentile(arrivePlanet);
if ((-615855020) == faction)
{
final int largerRebelScore = Math.max(100 - imperialScoreDepartPlanet, 100 - imperialScoreArrivePlanet);
if (largerRebelScore > 70)
{
return (largerRebelScore - 70) * 500;
}
}
else if ((370444368) == faction)
{
final int largerImperialScore = Math.max(imperialScoreDepartPlanet, imperialScoreArrivePlanet);
if (largerImperialScore > 70)
{
return (largerImperialScore - 70) * 500;
}
}
return 0;
}
public static String getGcwTravelRestrictionsAvailableStarport(obj_id player, String planet) throws InterruptedException
{
if (!isIdValid(player))
{
return null;
}
if ((planet == null) || (planet.length() <= 0))
{
return null;
}
final int faction = pvpGetAlignedFaction(player);
if (faction == 0)
{
return null;
}
if (pvpGetCurrentGcwRank(player) < 7)
{
return null;
}
final int imperialScore = getGcwGroupImperialScorePercentile(planet);
if ((((-615855020) == faction) && (imperialScore <= 30)) || (((370444368) == faction) && (imperialScore >= 70)))
{
String availableStarport = null;
int highestScore = -1;
String[] planetTravelPoints = getPlanetTravelPoints(planet);
if ((planetTravelPoints != null) && (planetTravelPoints.length > 0))
{
int numStarport = 0;
String gcwContestedRegion;
for (String planetTravelPoint : planetTravelPoints) {
if (getPlanetTravelPointInterplanetary(planet, planetTravelPoint)) {
++numStarport;
int score = 50;
gcwContestedRegion = getPlanetTravelPointGcwContestedRegion(planet, planetTravelPoint);
if ((gcwContestedRegion != null) && (gcwContestedRegion.length() > 0)) {
score = getGcwImperialScorePercentile(gcwContestedRegion);
if ((370444368) == faction) {
score = 100 - score;
}
}
if (score > highestScore) {
availableStarport = planetTravelPoint;
highestScore = score;
}
}
}
if (numStarport <= 1)
{
return null;
}
}
return availableStarport;
}
return null;
}
public static obj_id getTravelShuttle(obj_id player) throws InterruptedException
{
if (player == null || player == obj_id.NULL_ID)
{
return null;
}
location loc = getLocation(player);
obj_id[] items = getObjectsInRange(loc, MAXIMUM_SHUTTLE_DISTANCE);
for (obj_id item : items) {
if (isTravelShuttle(item)) {
return item;
}
}
return null;
}
public static boolean isInShuttleBoardingRange(obj_id player, obj_id shuttle) throws InterruptedException
{
if (player == null || player == obj_id.NULL_ID)
{
return false;
}
if (shuttle == null || shuttle == obj_id.NULL_ID)
{
return false;
}
location loc_player = getLocation(player);
location loc_shuttle = getLocation(shuttle);
float distance = loc_player.distance(loc_shuttle);
if (distance < 0)
{
return false;
}
return distance <= MAXIMUM_SHUTTLE_DISTANCE;
}
public static boolean isValidRoute(String planet1, String point1, String planet2, String point2) throws InterruptedException
{
int planet_cost = getPlanetTravelCost(planet1, planet2);
if (planet_cost == 0)
{
return false;
}
int point_cost1 = getPlanetTravelPointCost(planet1, point1);
if (point_cost1 == 0)
{
return false;
}
int point_cost2 = getPlanetTravelPointCost(planet2, point2);
if (point_cost2 == 0)
{
return false;
}
if (!planet1.equals(planet2))
{
boolean starport1 = getPlanetTravelPointInterplanetary(planet1, point1);
boolean starport2 = getPlanetTravelPointInterplanetary(planet2, point2);
LOG("LOG_CHANNEL", "starport1 ->" + starport1 + " starport2 ->" + starport2);
if (!starport1 || !starport2)
{
return false;
}
}
return true;
}
public static obj_id getStarportFromTerminal(obj_id terminal) throws InterruptedException
{
if (terminal == null || terminal == obj_id.NULL_ID || !isIdValid(terminal))
{
return null;
}
if (hasObjVar(terminal, VAR_STARPORT))
{
return getObjIdObjVar(terminal, VAR_STARPORT);
}
else
{
return null;
}
}
public static obj_id getShuttleFromStarport(obj_id starport) throws InterruptedException
{
obj_id[] starport_objects = travel.getBaseObjects(starport);
obj_id shuttle = obj_id.NULL_ID;
if (starport_objects != null)
{
for (obj_id starport_object : starport_objects) {
if (travel.isTravelShuttle(starport_object)) {
shuttle = starport_object;
break;
}
}
}
if (shuttle == obj_id.NULL_ID)
{
return null;
}
else
{
return shuttle;
}
}
public static boolean setShuttleAvailability(obj_id starport) throws InterruptedException
{
if (starport == null || starport == obj_id.NULL_ID)
{
return false;
}
if (hasObjVar(starport, VAR_SHUTTLE_AVAILABLE))
{
int available = getIntObjVar(starport, VAR_SHUTTLE_AVAILABLE);
if (available == 1)
{
setObjVar(starport, VAR_SHUTTLE_AVAILABLE, 0);
int shuttleAvailableCount = 0;
if (utils.hasScriptVar(starport, SCRIPTVAR_SHUTTLE_AVAILABLE_COUNT))
{
shuttleAvailableCount = utils.getIntScriptVar(starport, SCRIPTVAR_SHUTTLE_AVAILABLE_COUNT);
}
++shuttleAvailableCount;
utils.setScriptVar(starport, SCRIPTVAR_SHUTTLE_AVAILABLE_COUNT, shuttleAvailableCount);
}
else
{
setObjVar(starport, VAR_SHUTTLE_AVAILABLE, 1);
}
setObjVar(starport, VAR_SHUTTLE_TIMESTAMP, getGameTime());
return true;
}
else
{
return false;
}
}
public static boolean setStarportTravelPoint(obj_id structure, String travel_point, location arrival_loc, int travel_cost, boolean civic) throws InterruptedException
{
String planet = getCurrentSceneName();
if (structure == null || structure == obj_id.NULL_ID)
{
return false;
}
if (travel_point == null || travel_point.length() < 1)
{
return false;
}
if (arrival_loc == null)
{
return false;
}
if (travel_cost < 0)
{
return false;
}
boolean interplanetary;
interplanetary = !isShuttlePort(structure);
boolean setup;
if (civic)
{
setup = city.addStarport(structure, arrival_loc, travel_cost, interplanetary);
}
else
{
int type = TPT_NPC_Shuttleport;
if (interplanetary)
{
type = TPT_NPC_Starport;
}
else
{
String template = getTemplateName(structure);
if ((template != null) && (template.equals("object/tangible/camp/camp_shuttle_beacon.iff")))
{
type = TPT_PC_CampShuttleBeacon;
}
else if ((template != null) && (template.equals("object/tangible/gcw/static_base/invisible_beacon.iff")))
{
type = TPT_NPC_StaticBaseBeacon;
}
}
setup = addPlanetTravelPoint(planet, travel_point, arrival_loc, travel_cost, interplanetary, type);
}
if (setup)
{
if (!hasObjVar(structure, VAR_TRAVEL_POINT_NAME))
{
setObjVar(structure, VAR_TRAVEL_POINT_NAME, travel_point);
}
if (!hasObjVar(structure, VAR_ARRIVAL_LOCATION))
{
setObjVar(structure, VAR_ARRIVAL_LOCATION, arrival_loc);
}
if (!hasObjVar(structure, VAR_TRAVEL_COST))
{
setObjVar(structure, VAR_TRAVEL_COST, travel_cost);
}
return true;
}
else
{
return false;
}
}
public static boolean removeTravelPoint(obj_id structure) throws InterruptedException
{
if (structure == null || structure == obj_id.NULL_ID)
{
return false;
}
String planet = getCurrentSceneName();
String travel_point = "";
if (hasObjVar(structure, VAR_TRAVEL_POINT_NAME))
{
travel_point = getStringObjVar(structure, VAR_TRAVEL_POINT_NAME);
}
else
{
return false;
}
if (removePlanetTravelPoint(planet, travel_point))
{
removeObjVar(structure, VAR_TRAVEL);
return true;
}
else
{
return false;
}
}
public static boolean destroyBaseObjects(obj_id structure) throws InterruptedException
{
if (structure == null || structure == obj_id.NULL_ID)
{
return false;
}
obj_id[] base_objects = getBaseObjects(structure);
if (base_objects != null)
{
for (obj_id base_object : base_objects) {
if (isIdValid(base_object)) {
destroyObject(base_object);
}
}
}
return true;
}
public static boolean purchaseTicket(obj_id player, String planet1, String point1, String planet2, String point2, boolean roundtrip, obj_id starport) throws InterruptedException
{
LOG("LOG_CHANNEL", "travel::purchaseTicket");
if (player == null || player == obj_id.NULL_ID)
{
return false;
}
if (utils.hasScriptVar(player, VAR_PURCHASING_TICKET))
{
LOG("LOG_CHANNEL", player + " ->You already have an outstanding ticket purchase request. Please wait for it to complete.");
sui.msgbox(player, new string_id("travel", "purchase_pending"));
return false;
}
if (planet2.equals("mustafar"))
{
if (!features.hasMustafarExpansionRetail(player))
{
sendSystemMessage(player, SID_MUSTAFAR_UNAUTHORIZED);
return false;
}
}
else if (planet2.equals("kashyyyk_main"))
{
if (!features.hasEpisode3Expansion(player))
{
sendSystemMessage(player, SID_KASHYYYK_UNAUTHORIZED);
return false;
}
}
else if (planet1.equals(planet2))
{
if (point1.equals(point2))
{
LOG("LOG_CHANNEL", player + " ->Your destination cannot be the same as your current location.");
sui.msgbox(player, new string_id("travel", "same_spot"));
return false;
}
}
else
{
if (!getPlanetTravelPointInterplanetary(planet1, point1))
{
LOG("LOG_CHANNEL", player + " ->Shuttleports do not offer interplanetary transportation.");
sui.msgbox(player, new string_id("travel", "shuttle_interplanet_fail"));
return false;
}
}
int city_id = findCityByName(point2);
if (city.isCityBanned(player, city_id))
{
sendSystemMessage(player, new string_id("city/city", "banned_buy_ticket"));
return false;
}
int planet_cost = getPlanetTravelCost(planet1, planet2);
if (planet_cost == 0)
{
LOG("LOG_CHANNEL", player + " ->Your planetary route is not valid.");
sui.msgbox(player, new string_id("travel", "route_invalid"));
return false;
}
int point_cost1 = getPlanetTravelPointCost(planet1, point1);
if (point_cost1 == 0)
{
LOG("LOG_CHANNEL", player + " ->Your departure location is not valid.");
sui.msgbox(player, new string_id("travel", "departure_invalid"));
return false;
}
int point_cost2 = getPlanetTravelPointCost(planet2, point2);
if (point_cost2 == 0)
{
LOG("LOG_CHANNEL", player + " ->Your destination is not valid.");
sui.msgbox(player, new string_id("travel", "destination_invalid"));
return false;
}
int total_cost = planet_cost + point_cost1 + point_cost2;
if (roundtrip)
{
total_cost = total_cost * 2;
}
LOG("LOG_CHANNEL", "total_cost ->" + total_cost + " " + planet_cost + "/" + point_cost1 + "/" + point_cost2);
boolean hasTravelVoucher = false;
boolean hasEnoughMoney = true;
if (utils.playerHasItemByTemplate(player, TRAVEL_COUPON_TEMPLATE))
{
hasTravelVoucher = true;
}
int total_money = getTotalMoney(player);
if (total_money < total_cost)
{
hasEnoughMoney = false;
if (!hasTravelVoucher)
{
LOG("LOG_CHANNEL", player + " ->You do not have sufficient funds for that.");
sui.msgbox(player, new string_id("travel", "no_cash"));
return false;
}
}
obj_id inv = getObjectInSlot(player, "inventory");
if (inv == null || inv == obj_id.NULL_ID)
{
LOG("LOG_CHANNEL", "player_dispenser::msgMedicinePurchaseSelected -- can't find inventory for " + player);
return false;
}
int free_space = getVolumeFree(inv);
if (free_space < 1)
{
sui.msgbox(player, new string_id("travel", "inv_full"));
return false;
}
if (roundtrip)
{
if (free_space < 2)
{
sui.msgbox(player, new string_id("travel", "inv_full"));
return false;
}
}
int city_fee = 0;
if (player_structure.isCivic(starport))
{
city_id = getCityAtLocation(getLocation(starport), 0);
city_fee = cityGetTravelCost(city_id);
total_cost -= city_fee;
}
dictionary params = new dictionary();
params.put("player_id", player);
params.put("account_name", money.ACCT_TRAVEL);
params.put("amount", total_cost);
params.put("planet1", planet1);
params.put("point1", point1);
params.put("planet2", planet2);
params.put("point2", point2);
params.put("roundtrip", roundtrip);
if (hasTravelVoucher)
{
obj_id travel_coupon = utils.getItemPlayerHasByTemplate(player, TRAVEL_COUPON_TEMPLATE);
if (isIdValid(travel_coupon))
{
if (hasObjVar(travel_coupon, "owner"))
{
obj_id owner = getObjIdObjVar(travel_coupon, "owner");
if (isIdValid(owner))
{
if (player == owner)
{
if (utils.hasScriptVar(player, "travel_voucher.travelVoucherSui"))
{
int oldSui = utils.getIntScriptVar(player, "travel_voucher.travelVoucherSui");
utils.removeScriptVar(player, "travel_voucher.travelVoucherSui");
if (oldSui > -1)
{
forceCloseSUIPage(oldSui);
}
}
params.put("city_fee", city_fee);
params.put("starport", starport);
params.put("travel_coupon", travel_coupon);
params.put("hasEnoughMoney", hasEnoughMoney);
utils.setScriptVar(player, "travelTicketDict", params);
string_id titleMsg = new string_id("new_player", "travel_coupon");
string_id textMsgPurchaseOption = new string_id("new_player", "travel_coupon_use_text_option");
string_id textMsgNoMoney = new string_id("new_player", "travel_coupon_use_text_no_money");
string_id okButton = new string_id("new_player", "travel_coupon_use_coupon_button");
string_id cancelButtonPay = new string_id("new_player", "travel_coupon_pay_credits_button");
string_id cancelButtonCancel = new string_id("new_player", "travel_coupon_cancel_button");
String TITLE_MSG = utils.packStringId(titleMsg);
String TEXT_MSG = utils.packStringId(textMsgPurchaseOption) + " " + total_cost;
String OK_BUTTON = utils.packStringId(okButton);
String CANCEL_BUTTON = utils.packStringId(cancelButtonPay);
if (!hasEnoughMoney)
{
TEXT_MSG = utils.packStringId(textMsgNoMoney);
CANCEL_BUTTON = utils.packStringId(cancelButtonCancel);
}
int pid = sui.createSUIPage(sui.SUI_MSGBOX, player, player, "msgUseTravelCouponSui");
setSUIProperty(pid, "", "Size", "500,200");
setSUIProperty(pid, sui.MSGBOX_TITLE, sui.PROP_TEXT, TITLE_MSG);
setSUIProperty(pid, sui.MSGBOX_PROMPT, sui.PROP_TEXT, TEXT_MSG);
sui.msgboxButtonSetup(pid, sui.YES_NO);
setSUIProperty(pid, sui.MSGBOX_BTN_OK, sui.PROP_TEXT, OK_BUTTON);
setSUIProperty(pid, sui.MSGBOX_BTN_CANCEL, sui.PROP_TEXT, CANCEL_BUTTON);
utils.setScriptVar(player, "travel_voucher.travelVoucherSui", pid);
sui.showSUIPage(pid);
return false;
}
else
{
String custLogMsg = "New Player Rewards: %TU tried to use a travel voucher but isn't the owner. Rightful owner is %TT";
CustomerServiceLog("NEW_PLAYER_QUESTS", custLogMsg, player, owner);
if (isGod(player))
{
sendSystemMessage(player, new string_id("travel", "not_voucher_owner"));
if (!hasEnoughMoney)
{
return false;
}
}
}
}
}
else
{
String custLogMsg = "New Player Rewards: %TU tried to use a travel voucher but the voucher is invalid - does not have an owner.";
CustomerServiceLog("NEW_PLAYER_QUESTS", custLogMsg, player);
if (isGod(player))
{
sendSystemMessage(player, new string_id("travel", "not_voucher_valid"));
if (!hasEnoughMoney)
{
return false;
}
}
}
}
}
if (money.pay(player, money.ACCT_TRAVEL, total_cost, "msgTicketPaymentComplete", params, true))
{
params.put("amount", city_fee);
if ((city_fee > 0) && !money.pay(player, city.getCityHall(starport), city_fee, "msgCityTicketPaymentComplete", params, true))
{
return false;
}
LOG("LOG_CHANNEL", "Deducting " + total_cost);
utils.setScriptVar(player, VAR_PURCHASING_TICKET, 1);
return true;
}
else
{
return false;
}
}
public static void showTravelVoucherSui() throws InterruptedException
{
}
public static obj_id[] createTicket(obj_id player, String planet1, String point1, String planet2, String point2, boolean roundtrip) throws InterruptedException
{
if (player == null || player == obj_id.NULL_ID)
{
return null;
}
obj_id ticket;
obj_id inv = getObjectInSlot(player, "inventory");
if (inv == null)
{
LOG("LOG_CHANNEL", "player_travel::createTicket -- Unable to get an inventory slot!");
sendSystemMessage(player, new string_id("travel", "no_room_for_ticket"));
ticket = createObject(BASE_TRAVEL_TICKET, getLocation(player));
}
else
{
ticket = createObject(BASE_TRAVEL_TICKET, inv, "");
}
if (ticket == null)
{
LOG("LOG_CHANNEL", "player_travel::createTicket -- Unable to create ticket.");
return null;
}
setObjVar(ticket, VAR_DEPARTURE_PLANET, planet1);
setObjVar(ticket, VAR_DEPARTURE_POINT, point1);
setObjVar(ticket, VAR_ARRIVAL_PLANET, planet2);
setObjVar(ticket, VAR_ARRIVAL_POINT, point2);
obj_id[] tickets = null;
if (roundtrip)
{
tickets = new obj_id[2];
}
else
{
tickets = new obj_id[1];
}
tickets[0] = ticket;
if (roundtrip)
{
obj_id return_ticket = createObjectOverloaded(BASE_TRAVEL_TICKET, inv);
setObjVar(return_ticket, VAR_DEPARTURE_PLANET, planet2);
setObjVar(return_ticket, VAR_DEPARTURE_POINT, point2);
setObjVar(return_ticket, VAR_ARRIVAL_PLANET, planet1);
setObjVar(return_ticket, VAR_ARRIVAL_POINT, point1);
tickets[1] = return_ticket;
}
return tickets;
}
public static boolean movePlayerToDestination(obj_id player, String planet, String point) throws InterruptedException
{
return movePlayerToDestination(player, planet, point, false);
}
public static boolean movePlayerToDestination(obj_id player, String planet, String point, boolean groupPickupPointTravel) throws InterruptedException
{
if (!isIdValid(player))
{
LOG("LOG_CHANNEL", "travel::movePlayerToDestination -- player is not valid");
return false;
}
if (planet == null)
{
LOG("LOG_CHANNEL", "travel::movePlayerToDestination -- planet is null");
return false;
}
if (point == null)
{
LOG("LOG_CHANNEL", "travel::movePlayerToDestination -- point is null");
return false;
}
if (!groupPickupPointTravel)
{
if (isTravelBlocked(player, false))
{
return false;
}
if (planet.equals("mustafar"))
{
if (!features.hasMustafarExpansionRetail(player))
{
sendSystemMessage(player, SID_MUSTAFAR_UNAUTHORIZED);
return false;
}
}
else if (planet.equals("kashyyyk_main"))
{
if (!features.hasEpisode3Expansion(player))
{
sendSystemMessage(player, SID_KASHYYYK_UNAUTHORIZED);
return false;
}
}
}
location loc = getPlanetTravelPointLocation(planet, point);
LOG("LOG_CHANNEL", "travel::movePlayerToDestination -- location ->" + loc);
if (loc == null)
{
LOG("LOG_CHANNEL", "travel::movePlayerToDestination -- location is null");
return false;
}
location arrival = utils.getRandomAwayLocation(loc, MIN_RANDOM_DISTANCE, MAX_RANDOM_DISTANCE);
if (arrival.cell == null || arrival.cell == obj_id.NULL_ID)
{
setLookAtTarget(player, null);
int numbuff = buff.getBuffOnTargetFromGroup(player, "vr_familiar");
if (buff.hasBuff(player, numbuff))
{
buff.removeBuff(player, numbuff);
}
if (utils.hasScriptVar(player, "currentHolo"))
{
performance.holographicCleanup(player);
}
if (groupPickupPointTravel)
{
warpPlayer(player, planet, arrival.x, arrival.y, arrival.z, null, 0.0f, 0.0f, 0.0f);
}
else
{
warpPlayer(player, planet, arrival.x, arrival.y, arrival.z, null, 0.0f, 0.0f, 0.0f, "msgTravelComplete");
}
}
else
{
LOG("LOG_CHANNEL", "travel::movePlayerToDestination -- travel point: " + planet + ", " + point + " has a cell arrival location. This is not supported.");
}
return true;
}
public static float[] transformDeltaWorldCoord(float X, float Z, int rotation) throws InterruptedException
{
float x = X;
float z = Z;
switch (rotation)
{
case 0:
break;
case 1:
X = z;
Z = -x;
break;
case 2:
Z = -z;
X = -x;
break;
case 3:
X = -z;
Z = x;
break;
}
return new float[]{
X,
Z
};
}
public static float[] transformDeltaWorldYaw(obj_id object, float x, float z) throws InterruptedException
{
if (!isIdValid(object))
{
return null;
}
float yaw = getYaw(object);
float yaw_radians = (float)Math.toRadians(yaw);
float X = (x * (float) StrictMath.cos(yaw_radians)) + (z * (float) StrictMath.sin(yaw_radians));
float Z = (z * (float) StrictMath.cos(yaw_radians)) - (x * (float) StrictMath.sin(yaw_radians));
return new float[]{
X,
Z
};
}
public static boolean testBoardShuttle(obj_id player, obj_id shuttle) throws InterruptedException
{
String planet = getCurrentSceneName();
obj_id starport = getStarportFromTerminal(shuttle);
if (starport == null)
{
LOG("LOG_CHANNEL", "player.player_travel::OnBoardShuttle -- Unable to find the starport for " + shuttle);
}
String depart_point = getTravelPointName(starport);
Vector dsrc = new Vector();
dsrc.setSize(0);
obj_id inventory = getObjectInSlot(player, "inventory");
obj_id[] inv_contents = utils.getContents(inventory, false);
String ticket_planet;
for (obj_id inv_content : inv_contents) {
if (isTravelTicketValid(inv_content, planet, depart_point)) {
ticket_planet = getTicketArrivalPlanet(inv_content);
ticket_planet = (ticket_planet.substring(0, 1)).toUpperCase() + (ticket_planet.substring(1)).toLowerCase();
dsrc = utils.addElement(dsrc, ticket_planet + " -- " + getTicketArrivalPoint(inv_content));
}
}
if (dsrc.size() < 1)
{
LOG("LOG_CHANNEL", player + " ->You do not have a ticket to board this shuttle.");
sendSystemMessage(player, new string_id("travel", "no_ticket_for_shuttle"));
return false;
}
else
{
string_id sd = new string_id("travel", "select_destination");
String txt = utils.packStringId(sd);
sui.listbox(player, player, txt, sui.OK_CANCEL, txt, dsrc, "msgBoardShuttle");
return true;
}
}
public static Vector getFilteredPortLocationsForPlanet(String planet, boolean isStarport) throws InterruptedException
{
if (planet == null || planet.equals(""))
{
return null;
}
String[] allPts = getPlanetTravelPoints(planet);
if (allPts == null || allPts.length == 0)
{
return null;
}
Vector ret = new Vector();
ret.setSize(0);
for (String allPt : allPts) {
if (getPlanetTravelPointInterplanetary(planet, allPt) == isStarport) {
ret = utils.addElement(ret, allPt);
}
}
return ret;
}
public static String[] getStarportsForPlanet(String planet) throws InterruptedException
{
return utils.toStaticStringArray(getFilteredPortLocationsForPlanet(planet, true));
}
public static String[] getStarportsForPlanet() throws InterruptedException
{
return getStarportsForPlanet(getCurrentSceneName());
}
public static String[] getShuttleportsForPlanet(String planet) throws InterruptedException
{
return utils.toStaticStringArray(getFilteredPortLocationsForPlanet(planet, false));
}
public static String[] getShuttleportsForPlanet() throws InterruptedException
{
return getShuttleportsForPlanet(getCurrentSceneName());
}
public static boolean instantTravel(obj_id player, String planet1, String point1, String planet2, String point2, boolean roundtrip, obj_id starport) throws InterruptedException
{
LOG("LOG_CHANNEL", "travel::instantTravel");
if (player == null || player == obj_id.NULL_ID)
{
return false;
}
if (utils.hasScriptVar(player, VAR_PURCHASING_TICKET))
{
LOG("LOG_CHANNEL", player + " ->You already have an outstanding ticket purchase request. Please wait for it to complete.");
sui.msgbox(player, new string_id("travel", "travel_pending"));
return false;
}
if (!planet1.equals(planet2))
{
LOG("LOG_CHANNEL", player + " ->Shuttleports do not offer interplanetary transportation.");
sui.msgbox(player, new string_id("travel", "instant_interplanet_fail"));
return false;
}
int city_id = findCityByName(point2);
if (city.isCityBanned(player, city_id))
{
sendSystemMessage(player, new string_id("travel", "banned_travel"));
return false;
}
if (callable.hasAnyCallable(player))
{
sendSystemMessage(player, new string_id("beast", "beast_cant_travel"));
return false;
}
return movePlayerToDestination(player, planet2, point2);
}
public static boolean isTravelBlocked(obj_id player, boolean isLaunch) throws InterruptedException
{
boolean blocked = false;
if (utils.hasScriptVar(player, "travelBlock"))
{
blocked = true;
}
if (isLaunch && utils.getIntScriptVar(player, "travelBlock") == TRAVEL_BLOCK_ALLOW_LAUNCH)
{
blocked = false;
}
if (instance.isInInstanceArea(player) && trial.getTop(player) == player)
{
blocked = true;
}
if (blocked)
{
sendSystemMessage(player, new string_id("travel", "blocked_by_authorities"));
}
return blocked;
}
public static void setTravelBlock(obj_id player, boolean allowLaunch) throws InterruptedException
{
int travelBlockValue = allowLaunch ? TRAVEL_BLOCK_ALLOW_LAUNCH : 0;
utils.setScriptVar(player, "travelBlock", travelBlockValue);
}
public static void clearTravelBlock(obj_id player) throws InterruptedException
{
if (utils.hasScriptVar(player, "travelBlock"))
{
utils.removeScriptVar(player, "travelBlock");
}
}
}
Reference in New Issue View Git Blame Copy Permalink