mirror of
https://bitbucket.org/seefoe/dsrc.git
synced 2026-07-31 01:15:55 -04:00
1611 lines
50 KiB
Plaintext
1611 lines
50 KiB
Plaintext
// ======================================================================
|
|
// library/space_transition.scriptlib
|
|
// ======================================================================
|
|
|
|
include library.callable;
|
|
include library.pclib;
|
|
include library.space_flags;
|
|
include library.pet_lib;
|
|
include library.ship_ai;
|
|
include library.space_combat;
|
|
include library.utils;
|
|
include library.features;
|
|
include library.space_dungeon;
|
|
include library.space_dungeon_data;
|
|
include library.township;
|
|
|
|
// ======================================================================
|
|
|
|
const boolean debugSpaceTransition = true;
|
|
const string DATATABLE_SHIP_START_LOCATIONS = "datatables/ship/ship_start_locations.iff";
|
|
const string COLUMN_TEMPLATE = "template";
|
|
const string COLUMN_SLOT = "slot";
|
|
const string COLUMN_CELL = "cell";
|
|
const string COLUMN_X = "x";
|
|
const string COLUMN_Y = "y";
|
|
const string COLUMN_Z = "z";
|
|
const int NEWBIE_CONVO_DELAY = 60;
|
|
|
|
const int SHIP_LIMIT_EXPANSION = 6;
|
|
const int SHIP_LIMIT_MAX = 3;
|
|
|
|
const float STATION_COMM_MAX_DISTANCE = 750.0f;
|
|
|
|
const string POB_SHIP_PILOT_SLOT_NAME = "ship_pilot_pob";
|
|
const string SHIP_PILOT_SLOT_NAME = "ship_pilot";
|
|
|
|
const string_id SID_PVP_NOW_OVERT = new string_id("space/space_interaction", "pvp_now_overt");
|
|
const string_id SID_PVP_NOW_NEUTRAL = new string_id("space/space_interaction", "pvp_now_neutral");
|
|
|
|
// ======================================================================
|
|
// Functions for external use
|
|
// ======================================================================
|
|
|
|
void handlePotentialSceneChange(obj_id player)
|
|
{
|
|
if (utils.hasLocalVar(player, "loggingOut"))
|
|
return;
|
|
|
|
obj_id containingShip = getContainingShip(player);
|
|
LIVE_LOG("TeleportFixup", "containingShip is "+containingShip);
|
|
if (isSpaceScene())
|
|
{
|
|
// Players in space scenes should be in ships.
|
|
if (isIdValid(containingShip))
|
|
{
|
|
// Ships should not have teleport fixups put them into interiors in space scenes
|
|
adjustShipTeleportFixupInSpaceScene(containingShip);
|
|
if (getOwner(containingShip) == player)
|
|
updateShipFaction(containingShip, player);
|
|
doAIImmunityCheck(containingShip);
|
|
return;
|
|
}
|
|
|
|
// Player is not in a ship, but is in space. This means we need to check
|
|
// their launch information, and if they should be going to a portallized
|
|
// ship interior, send them there, or if they should be unpacking their
|
|
// ship, do so.
|
|
|
|
obj_id launchedShip = getObjIdObjVar(player, "space.launch.ship");
|
|
int launchedShipStartIndex = getIntObjVar(player, "space.launch.startIndex") - 1; // 0 is pilot
|
|
|
|
if ((!isGod(player)||(!utils.checkConfigFlag("ScriptFlags", "e3Demo"))&& shouldSendToGroundOnLogout()))
|
|
{
|
|
removeObjVar(player, "space.launch.ship");
|
|
removeObjVar(player, "space.launch.startIndex");
|
|
}
|
|
|
|
if (isIdValid(launchedShip) && launchedShip.isLoaded())
|
|
{
|
|
LOG("space", "checking "+launchedShip);
|
|
// player should be going into a valid ship, which may or may not
|
|
// currently be unpacked.
|
|
obj_id shipContainer = getContainedBy(launchedShip);
|
|
LOG("space", "2 shipContainer is "+shipContainer);
|
|
if (!isIdValid(shipContainer))
|
|
{
|
|
LOG("space", "shipContainer is "+shipContainer);
|
|
// Going to a valid ship which is already unpacked, so just move them there.
|
|
resizeable location[] startLocations = getShipStartLocations(launchedShip);
|
|
if (startLocations != null && startLocations.length > 0)
|
|
{
|
|
if (launchedShipStartIndex < 0)
|
|
launchedShipStartIndex = 0;
|
|
location loc = startLocations[launchedShipStartIndex % startLocations.length];
|
|
if (loc.cell == null)
|
|
{
|
|
// going to a ship station - loc.area is the slot name on the ship
|
|
boolean success = equip(player, launchedShip, loc.area);
|
|
if (success)
|
|
{
|
|
if (debugSpaceTransition)
|
|
LOG("space_transition", "Player [" + player + "] in space, going to an already unpacked ship [" + launchedShip + "] in station [" + loc.area + "] succeeded.");
|
|
return;
|
|
}
|
|
else if (debugSpaceTransition)
|
|
LOG("space_transition", "Player [" + player + "] in space, going to an already unpacked ship [" + launchedShip + "] in station [" + loc.area + "] failed.");
|
|
}
|
|
else
|
|
{
|
|
if (debugSpaceTransition)
|
|
LOG("space_transition", "Player [" + player + "] in space, going to an already unpacked ship [" + launchedShip + "] at location [" + loc + "].");
|
|
setLocation(player, loc);
|
|
return;
|
|
}
|
|
}
|
|
else if (hasObjVar(player, space_dungeon.VAR_TICKET_DUNGEON) && space_dungeon.isSpaceDungeon(launchedShip) && space_dungeon.getDungeonIdForPlayer(player) == launchedShip)
|
|
{
|
|
string dungeon = getStringObjVar(player, space_dungeon.VAR_TICKET_DUNGEON);
|
|
string cellName = space_dungeon_data.getDungeonStartCellName(dungeon);
|
|
location start = space_dungeon_data.getDungeonStartLocation(dungeon);
|
|
obj_id cell = getCellId(launchedShip, cellName);
|
|
start.cell = cell;
|
|
|
|
LOG("space_transition", "Sending player " + player + " to dungeon " + dungeon + " " + launchedShip);
|
|
setLocation(player, start);
|
|
|
|
return;
|
|
}
|
|
else if (debugSpaceTransition)
|
|
LOG("space_transition", "Player [" + player + "] in space, going to an already unpacked ship [" + launchedShip + "] but could not find a start location.");
|
|
}
|
|
else
|
|
{
|
|
// Going to a ship which is not unpacked, so unpack it if it is ours and is in a control device in our datapad
|
|
if (getOwner(launchedShip) == player && getContainedBy(getContainedBy(launchedShip)) == utils.getDatapad(player))
|
|
{
|
|
if (debugSpaceTransition)
|
|
LOG("space_transition", "Player [" + player + "] in space, going to his own packed ship [" + launchedShip + "].");
|
|
if (unpackShipForPlayer(player, launchedShip))
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Unable to unpack the player's default ship, so send him back to his bind point.
|
|
if (debugSpaceTransition)
|
|
{
|
|
if (isIdValid(launchedShip))
|
|
LOG("space_transition", "Player " + player + " could not enter ship in space, sending to launch point. Ship("+launchedShip+") isValid("+isIdValid(launchedShip)+") isLoaded("+launchedShip.isLoaded()+")");
|
|
else
|
|
LOG("space_transition", "Player " + player + " could not enter ship in space, sending to launch point. Ship(null)");
|
|
|
|
String scripts = "";
|
|
String[] scriptArray = getScriptList(player);
|
|
for (int i = 0; i < scriptArray.length; ++i)
|
|
{
|
|
scripts += (scriptArray[i] + "|");
|
|
}
|
|
LOG("space_transition", "Detailed player info: objvars: " + getPackedObjvars(player) + " scripts: " + scripts);
|
|
}
|
|
|
|
teleportPlayerToLaunchLoc(player);
|
|
}
|
|
else
|
|
{
|
|
// Players in ground scenes should not be in ships.
|
|
removeObjVar(player, "space.launch");
|
|
if (isIdValid(containingShip))
|
|
{
|
|
if (debugSpaceTransition)
|
|
LIVE_LOG("TeleportFixup", "Player " + player + " in a ship but not in space, packing the ship.");
|
|
packShip(containingShip);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void handleLogout(obj_id player)
|
|
{
|
|
obj_id containingShip = getContainingShip(player);
|
|
|
|
if (isIdValid(containingShip))
|
|
{
|
|
if (debugSpaceTransition)
|
|
LOG("space_transition", "player " + player + " logging out in ship " + containingShip);
|
|
|
|
obj_id owner = getOwner(containingShip);
|
|
|
|
// Players that own the ship they are in pack their ship where they are.
|
|
// This will send any passengers back to their launch location.
|
|
if (owner == player)
|
|
{
|
|
utils.setLocalVar(player, "loggingOut", true);
|
|
packShip(containingShip);
|
|
utils.removeLocalVar(player, "loggingOut");
|
|
}
|
|
|
|
// Players should now always get sent home when their ship gets packed up (or when they log back in after having done so).
|
|
// In god mode, we don't do this, so that you can unpilot a ship without getting thrown back to the ground.
|
|
if (!isGod(player))
|
|
{
|
|
// If we're the pilot of the ship at this point, we need to unpilot,
|
|
// since it's someone else's ship and we're logging out. If it were
|
|
// our ship this would have been done from the packShip call above.
|
|
if (player == getPilotId(containingShip))
|
|
unpilotShip(player);
|
|
|
|
if (player != owner || shouldSendToGroundOnLogout())
|
|
teleportPlayerToLaunchLoc(player);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
boolean shouldSendToGroundOnLogout()
|
|
{
|
|
String s = getConfigSetting("ScriptFlags", "sendToGroundOnLogout");
|
|
if ( s != null
|
|
&& ( s.equals("false")
|
|
|| s.equals("0")
|
|
|| s.equals("off")))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void setLaunchInfo(obj_id player, obj_id ship, int startLocationIndex, location groundLoc)
|
|
{
|
|
setObjVar(player, "space.launch.worldLoc", groundLoc);
|
|
setObjVar(player, "space.launch.ship", ship);
|
|
setObjVar(player, "space.launch.startIndex", startLocationIndex);
|
|
}
|
|
|
|
// ======================================================================
|
|
// Functions for internal use
|
|
// ======================================================================
|
|
|
|
obj_id getContainingShip(obj_id obj)
|
|
{
|
|
obj_id containedBy = getContainedBy(obj);
|
|
while (isIdValid(containedBy))
|
|
{
|
|
if (isGameObjectTypeOf(getGameObjectType(containedBy), GOT_ship))
|
|
return containedBy;
|
|
containedBy = getContainedBy(containedBy);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
obj_id[] findShipControlDevicesForPlayer(obj_id player)
|
|
{
|
|
return findShipControlDevicesForPlayer(player, false);
|
|
}
|
|
|
|
|
|
obj_id[] findShipControlDevicesForPlayer(obj_id player, boolean checkHangar)
|
|
{
|
|
obj_id datapad = utils.getDatapad(player);
|
|
obj_id playerHangar = obj_id.NULL_ID;
|
|
|
|
if(checkHangar)
|
|
playerHangar = utils.getPlayerHangar(player);
|
|
|
|
//LOG("space", "datapad is "+datapad);
|
|
if (isIdValid(datapad))
|
|
{
|
|
obj_id[] datapadContents = getContents(datapad);
|
|
//LOG("space", "contents length is "+datapadContents);
|
|
if (datapadContents != null)
|
|
{
|
|
int count = 0;
|
|
for (int i = 0; i < datapadContents.length; ++i)
|
|
{
|
|
|
|
//LOG("space", "datapadContents["+i+"] is "+ getGameObjectType(datapadContents[i]));
|
|
//LOG("space", "Check type is "+ GOT_data_ship_control_device);
|
|
if (isIdValid(datapadContents[i]) && getGameObjectType(datapadContents[i]) == GOT_data_ship_control_device)
|
|
++count;
|
|
}
|
|
if(checkHangar && isIdValid(playerHangar))
|
|
{
|
|
obj_id[] hangarContents = getContents(playerHangar);
|
|
|
|
if(hangarContents != null && hangarContents.length > 0)
|
|
{
|
|
for (int q = 0; q < hangarContents.length; ++q)
|
|
{
|
|
//LOG("space", "hangarContents["+q+"] is "+ getGameObjectType(hangarContents[q]));
|
|
//LOG("space", "Check type is "+ GOT_data_ship_control_device);
|
|
if (isIdValid(hangarContents[q]) && getGameObjectType(hangarContents[q]) == GOT_data_ship_control_device)
|
|
++count;
|
|
}
|
|
}
|
|
}
|
|
if (count > 0)
|
|
{
|
|
obj_id[] shipControlDevices = new obj_id[count];
|
|
//LOG("space", "Count is "+count);
|
|
count = 0;
|
|
for (int j = 0; j < datapadContents.length; ++j)
|
|
{
|
|
if (isIdValid(datapadContents[j]) && getGameObjectType(datapadContents[j]) == GOT_data_ship_control_device)
|
|
{
|
|
//LOG("space", "adding "+datapadContents[j]);
|
|
shipControlDevices[count++] = datapadContents[j];
|
|
}
|
|
}
|
|
|
|
if(checkHangar && isIdValid(playerHangar))
|
|
{
|
|
obj_id[] hangarContents = getContents(playerHangar);
|
|
if(hangarContents != null && hangarContents.length > 0)
|
|
{
|
|
for (int k = 0; k < hangarContents.length; ++k)
|
|
{
|
|
if (isIdValid(hangarContents[k]) && getGameObjectType(hangarContents[k]) == GOT_data_ship_control_device)
|
|
{
|
|
//LOG("space", "adding "+hangarContents[k]);
|
|
shipControlDevices[count++] = hangarContents[k];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return shipControlDevices;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
obj_id[] findShipControlDevicesInHangarSlot(obj_id player)
|
|
{
|
|
obj_id playerHangarSlot = utils.getPlayerHangar(player);
|
|
if ( isIdValid(playerHangarSlot) )
|
|
{
|
|
obj_id[] hangarContents = getContents(playerHangarSlot);
|
|
|
|
if( hangarContents != null && hangarContents.length > 0 )
|
|
{
|
|
int count = 0;
|
|
for (int q = 0; q < hangarContents.length; ++q)
|
|
{
|
|
//LOG("space", "hangarContents["+q+"] is "+ getGameObjectType(hangarContents[q]));
|
|
//LOG("space", "Check type is "+ GOT_data_ship_control_device);
|
|
if (isIdValid(hangarContents[q]) && getGameObjectType(hangarContents[q]) == GOT_data_ship_control_device)
|
|
++count;
|
|
}
|
|
|
|
if ( count > 0 )
|
|
{
|
|
obj_id[] shipHangarSlotControlDevices = new obj_id[count];
|
|
count = 0;
|
|
for ( int k = 0; k < hangarContents.length; ++k )
|
|
{
|
|
if ( isIdValid(hangarContents[k]) && getGameObjectType(hangarContents[k]) == GOT_data_ship_control_device )
|
|
{
|
|
//LOG("vehicle", "adding "+hangarContents[k]);
|
|
shipHangarSlotControlDevices[count++] = hangarContents[k];
|
|
}
|
|
}
|
|
return shipHangarSlotControlDevices;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
obj_id findEmptyShipControlDeviceForShip(obj_id player, obj_id ship)
|
|
{
|
|
if ( hasObjVar( ship, "shipControlDevice" ) )
|
|
return getObjIdObjVar( ship, "shipControlDevice" );
|
|
else
|
|
return findEmptyShipControlDeviceForPlayer(player);//Just as a precaution...
|
|
|
|
}
|
|
|
|
//this function is the old one, and is prone to returning ship control devices
|
|
//that in fact HAVE ships in them. We only call it if we can't figure out which is the
|
|
//correct scd to use otherwise (per above!):
|
|
obj_id findEmptyShipControlDeviceForPlayer(obj_id player)
|
|
{
|
|
obj_id[] shipControlDevices = findShipControlDevicesForPlayer(player);
|
|
if (shipControlDevices != null)
|
|
{
|
|
for (int i = 0; i < shipControlDevices.length; ++i)
|
|
{
|
|
obj_id[] contents = getContents(shipControlDevices[i]);
|
|
if (contents == null || contents.length == 0)
|
|
return shipControlDevices[i];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
obj_id getShipFromShipControlDevice(obj_id shipControlDevice)
|
|
{
|
|
obj_id[] contents = getContents(shipControlDevice);
|
|
if (contents != null && contents.length > 0)
|
|
return contents[0];
|
|
return null;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
int countShipControlDevicesForPlayer(obj_id player)
|
|
{
|
|
int count = -1;
|
|
|
|
obj_id datapad = utils.getDatapad(player);
|
|
if (isIdValid(datapad))
|
|
{
|
|
obj_id[] datapadContents = getContents(datapad);
|
|
if (datapadContents != null)
|
|
{
|
|
count = 0;
|
|
for (int i = 0; i < datapadContents.length; ++i)
|
|
if (isIdValid(datapadContents[i]) && getGameObjectType(datapadContents[i]) == GOT_data_ship_control_device)
|
|
++count;
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
boolean isPlayerBelowShipLimit(obj_id player, obj_id destinationContainer)
|
|
{
|
|
if(getTemplateName(destinationContainer).equals("object/tangible/datapad/character_hangar_datapad.iff"))
|
|
return true;
|
|
else
|
|
return isPlayerBelowShipLimit(player);
|
|
}
|
|
|
|
boolean isPlayerBelowShipLimit(obj_id player)
|
|
{
|
|
int count = countShipControlDevicesForPlayer(player);
|
|
|
|
int limit = SHIP_LIMIT_MAX;
|
|
|
|
if (features.hasEpisode3Expansion( player ))
|
|
{
|
|
limit = SHIP_LIMIT_EXPANSION;
|
|
}
|
|
|
|
if (count < 0)
|
|
return false;
|
|
|
|
if (count >= limit)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
obj_id findPilotSlotObjectForShip(obj_id pilot, obj_id ship)
|
|
{
|
|
// If this is a single person craft we can just go into its pilot slot
|
|
if (canPutInSlot(pilot, ship, SHIP_PILOT_SLOT_NAME) == CEC_SUCCESS)
|
|
return ship;
|
|
// Otherwise, this may be a portallized ship, in which case we may go into
|
|
// the ship_pilot_pob slot of an immediate content of a cell.
|
|
obj_id[] cells = getContents(ship);
|
|
if (cells != null)
|
|
{
|
|
for (int i = 0; i < cells.length; ++i)
|
|
{
|
|
obj_id[] contents = getContents(cells[i]);
|
|
if (contents != null)
|
|
for (int j = 0; j < contents.length; ++j)
|
|
if (canPutInSlot(pilot, contents[j], POB_SHIP_PILOT_SLOT_NAME) == CEC_SUCCESS)
|
|
return contents[j];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
Vector getContainedPlayers(obj_id obj)
|
|
{
|
|
return getContainedPlayers(obj, null);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
Vector getContainedPlayers(obj_id obj, Vector players)
|
|
{
|
|
if (isPlayer(obj))
|
|
return utils.addElement(players, obj);
|
|
|
|
obj_id[] contents = getContents(obj);
|
|
if (contents != null)
|
|
for (int i = 0; i < contents.length; ++i)
|
|
players = getContainedPlayers(contents[i], players);
|
|
|
|
return players;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void packShip(obj_id ship)
|
|
{
|
|
// If we're packing a ship, we have to deal with players potentially still
|
|
// on the ship. If the ship is being packed in space, we put the owner
|
|
// where the ship was heading and send everyone else to their launch
|
|
// location. If not in space, we put each of those players at the location
|
|
// of the ship. In case of ships teleporting to interiors, we transfer the
|
|
// teleport fixup information from the ship to each player that was
|
|
// being moved to the location of the ship, to cause those players to arrive
|
|
// where the ship was headed.
|
|
|
|
if ( getTopMostContainer(ship) != ship )
|
|
return;//this ship is already packed.
|
|
|
|
// if the ship is a space dungeon, we don't want to destroy it
|
|
if (space_dungeon.isSpaceDungeon(ship))
|
|
return;
|
|
|
|
boolean inSpace = isSpaceScene();
|
|
boolean teleportFixup = hasObjVar(ship, "teleportFixup");
|
|
obj_id pilot = getPilotId(ship);
|
|
obj_id owner = getOwner(ship);
|
|
location shipLoc = getLocation(ship);
|
|
|
|
|
|
if (debugSpaceTransition)
|
|
LIVE_LOG("TeleportFixup", "packShip, ship=" + ship + ", template=" + getTemplateName(ship) + ", pilot=" + pilot + ", teleportFixup=" + teleportFixup + ", inSpace=" + inSpace + ", owner=" + owner);
|
|
|
|
resizeable obj_id[] players = getContainedPlayers(ship, null);
|
|
if (players != null)
|
|
{
|
|
for (int i = 0; i < players.length; ++i)
|
|
{
|
|
obj_id player = players[i];
|
|
|
|
// fix up people who were lounging about in the ship
|
|
setState(player, STATE_SITTING_ON_CHAIR, false);
|
|
int posture = getPosture(player);
|
|
if (posture == POSTURE_SITTING || posture == POSTURE_PRONE)
|
|
setPostureClientImmediate(player, POSTURE_UPRIGHT);
|
|
|
|
revokeDroidCommands(player);
|
|
if (debugSpaceTransition)
|
|
LOG("space_transition", "packShip dealing with contained player " + player);
|
|
if (player == pilot)
|
|
unpilotShip(pilot);
|
|
if (inSpace && player != owner)
|
|
{
|
|
teleportPlayerToLaunchLoc(player);
|
|
}
|
|
else
|
|
{
|
|
if (teleportFixup)
|
|
{
|
|
copyObjVar(ship, player, "teleportFixup");
|
|
LIVE_LOG("TeleportFixup", "Copying teleportFixup objVar from " + ship + " to " + player);
|
|
}
|
|
setLocation(player, shipLoc);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (teleportFixup)
|
|
{
|
|
removeObjVar(ship, "teleportFixup");
|
|
LIVE_LOG("TeleportFixup", "Removing teleportFixup objVar from " + ship);
|
|
}
|
|
|
|
// put the ship back in the owner's ship control device
|
|
if (isIdValid(owner))
|
|
{
|
|
space_combat.clearHyperspace(ship);
|
|
//obj_id shipControlDevice = findEmptyShipControlDeviceForPlayer(owner);
|
|
|
|
obj_id shipControlDevice = findEmptyShipControlDeviceForShip(owner, ship);
|
|
|
|
if (debugSpaceTransition)
|
|
LOG("space_transition", "packShip ship=" + ship + " scd=" + shipControlDevice);
|
|
|
|
obj_id droidControlDevice = getDroidControlDeviceForShip(ship);
|
|
LOG("space", "droidControlDevice is "+droidControlDevice);
|
|
|
|
if (isIdValid(droidControlDevice))
|
|
{
|
|
obj_id droid = callable.getCDCallable(droidControlDevice);
|
|
|
|
LOG("space", "droid is "+droid);
|
|
|
|
if(isIdValid(droid))
|
|
{
|
|
space_combat.removeFlightDroidFromShip(droidControlDevice, droid);
|
|
}
|
|
}
|
|
space_pilot_command.allPurposeShipComponentReset(ship);
|
|
|
|
if (isIdValid(shipControlDevice) && putIn(ship, shipControlDevice))
|
|
{
|
|
// Let any contents of a pob ship know that they are being packed so that they can react if necessary.
|
|
if ( isGameObjectTypeOf(ship, GOT_ship_fighter) && space_utils.isShipWithInterior(ship) )
|
|
{
|
|
obj_id[] shipContents = getAllObjectsInPob(ship);
|
|
if ( shipContents != null && shipContents.length > 0 )
|
|
{
|
|
for ( int i = 0; i < shipContents.length; i ++ )
|
|
{
|
|
if ( isIdValid(shipContents[i]) )
|
|
{
|
|
messageTo(shipContents[i], "OnPack", null, 1.0f, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
// something wasn't set up properly, so don't leave the ship hanging around
|
|
if (debugSpaceTransition)
|
|
LOG("space_transition", "packShip failed to clean up ship properly, destroying");
|
|
destroyObject(ship);
|
|
}
|
|
|
|
obj_id[] getAllObjectsInPob(obj_id pob)
|
|
{
|
|
obj_id[] cells = getCellIds(pob);
|
|
|
|
if (cells == null || cells.length == 0)
|
|
return null;
|
|
|
|
resizeable obj_id[] objects = new obj_id[0];
|
|
|
|
for (int i=0;i<cells.length;i++)
|
|
{
|
|
obj_id[] contents = getContents(cells[i]);
|
|
|
|
if (contents != null && contents.length > 0)
|
|
{
|
|
for (int k=0;k<contents.length;k++)
|
|
{
|
|
utils.addElement(objects, contents[k]);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (objects == null || objects.length == 0)
|
|
return null;
|
|
|
|
obj_id[] returnList = objects;
|
|
|
|
return returnList;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
/*
|
|
// **********************************************************************
|
|
// Note: this stuff is rotted, will need to be reworked
|
|
// **********************************************************************
|
|
void transitionToInterior(obj_id ship, obj_id objDestinationShip)
|
|
{
|
|
// If we're packing a ship, we have to deal with players potentially still
|
|
// on the ship. We put each of those players at the location of the ship,
|
|
// and if the ship was teleporting to an interior, we set up the teleport
|
|
// fixup information to cause those players to arrive where the ship was
|
|
// headed.
|
|
|
|
boolean teleportFixup = hasObjVar(ship, "teleportFixup");
|
|
obj_id pilot = getPilotId(ship);
|
|
|
|
if (debugSpaceTransition)
|
|
LOG("space_transition", "packShip, ship=" + ship + ", pilot=" + pilot + ", teleportFixup=" + teleportFixup);
|
|
|
|
resizeable obj_id[] players = getContainedPlayers(ship, null);
|
|
if (players != null)
|
|
{
|
|
for (int i = 0; i < players.length; ++i)
|
|
{
|
|
if (debugSpaceTransition)
|
|
LOG("space_transition", "packShip dealing with contained player " + players[i]);
|
|
if (teleportFixup)
|
|
copyObjVar(ship, players[i], "teleportFixup");
|
|
|
|
if (players[i] == pilot)
|
|
{
|
|
unpilotShip(pilot);
|
|
utils.setLocalVar(players[i], "locLastSpawnLocation", getLocation(players[i]));
|
|
utils.setLocalVar(players[i], "objPilot", pilot);
|
|
}
|
|
else
|
|
{
|
|
utils.setLocalVar(players[i], "locLastSpawnLocation", getLocation(players[i]));
|
|
location locTest = getShipBoardingDestination(objDestinationShip);
|
|
utils.setLocalVar(players[i], "objPilot", pilot);
|
|
setLocation(players[i], locTest);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (teleportFixup)
|
|
removeObjVar(ship, "teleportFixup");
|
|
|
|
// put the ship back in the owner's ship control device
|
|
obj_id owner = getOwner(ship);
|
|
if (isIdValid(owner))
|
|
{
|
|
LOG("space", "Valid owner");
|
|
obj_id shipControlDevice = findEmptyShipControlDeviceForPlayer(owner);
|
|
obj_id droidControlDevice = getDroidControlDeviceForShip(ship);
|
|
if (isIdValid(droidControlDevice))
|
|
{
|
|
obj_id objDroid = callable.getCDCallable(droidControlDevice);
|
|
if(isIdValid(objDroid))
|
|
{
|
|
pet_lib.storePet(objDroid);
|
|
}
|
|
}
|
|
LOG("space", "scd is " + shipControlDevice);
|
|
location locTest = getShipBoardingDestination(objDestinationShip);
|
|
setLocation(owner, locTest);
|
|
if (isIdValid(shipControlDevice) && putIn(ship, shipControlDevice))
|
|
{
|
|
sendSystemMessageTestingOnly(owner, "TEST TEST TEST ");
|
|
return;
|
|
}
|
|
}
|
|
// something wasn't set up properly, so don't leave the ship hanging around
|
|
if (debugSpaceTransition)
|
|
LOG("space_transition", "packShip failed to clean up ship properly, destroying");
|
|
destroyObject(ship);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
boolean transitionOutOfInterior(obj_id player)
|
|
{
|
|
obj_id ship = getObjIdObjVar(player, "space.launch.ship");
|
|
obj_id shipControlDevice = null;
|
|
if (isIdValid(ship))
|
|
shipControlDevice = getContainedBy(ship);
|
|
if (debugSpaceTransition)
|
|
LOG("space_transition", "unpackShipForPlayer: scd=" + shipControlDevice + " ship=" + ship + " player=" + player);
|
|
if (isIdValid(shipControlDevice))
|
|
{
|
|
// pull the ship out to the location of the player
|
|
obj_id objCell = getContainedBy(player);
|
|
obj_id objContainerShip = getContainedBy(objCell);
|
|
|
|
location locTest = getLocation(objContainerShip);
|
|
locTest.x = locTest.x + 100;
|
|
locTest.z = locTest.z;
|
|
|
|
setLocation(ship, locTest);
|
|
obj_id pilotSlotObject = findPilotSlotObjectForShip(player, ship);
|
|
if (debugSpaceTransition)
|
|
LOG("space_transition", "unpackShipForPlayer: ship=" + ship + " pilotSlotObject=" + pilotSlotObject + " player=" + player);
|
|
// pilot the ship
|
|
if (isIdValid(pilotSlotObject) && pilotShip(player, pilotSlotObject))
|
|
{
|
|
|
|
utils.removeLocalVar(player, "locLastSpawnLocation");
|
|
utils.removeLocalVar(player, "objPilot");
|
|
// unpack droid if necessary
|
|
resizeable obj_id[] players = getContainedPlayers(objContainerShip, null);
|
|
if (players != null)
|
|
{
|
|
for (int intI = 0; intI < players.length; intI++)
|
|
{
|
|
location locDestination = utils.getLocationLocalVar(players[intI], "locLastSpawnLocation");
|
|
utils.removeLocalVar(players[intI], "objPilot");
|
|
utils.removeLocalVar(players[intI], "locLastSpawnLocation");
|
|
if (locDestination == null)
|
|
teleportPlayerToLaunchLoc(players[intI]);
|
|
else
|
|
setLocation(players[intI], locDestination);
|
|
}
|
|
}
|
|
obj_id droidControlDevice = getDroidControlDeviceForShip(ship);
|
|
if (isIdValid(droidControlDevice))
|
|
{
|
|
if (debugSpaceTransition)
|
|
LOG("space_transition", "unpacking droid from control device " + droidControlDevice + ", ship=" + ship + ", pilotSlotObject=" + pilotSlotObject + ", pilot=" + player);
|
|
pet_lib.createPetFromData(droidControlDevice, pilotSlotObject);
|
|
if (!space_utils.isShipWithInterior(ship))
|
|
grantDroidCommands(player);
|
|
}
|
|
|
|
// make other ships not aggro on us if we are a gm
|
|
if (hasObjVar(player, "gm"))
|
|
ship_ai.unitSetAutoAggroImmuneTime(ship, 100000.f);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
*/
|
|
// ----------------------------------------------------------------------
|
|
|
|
void setShipName(obj_id ship, obj_id player, obj_id shipControlDevice)
|
|
{
|
|
string strName = getAssignedName(shipControlDevice);
|
|
LOG("space", "strName is "+strName);
|
|
|
|
if (strName == null || strName.length() == 0)
|
|
{
|
|
setName(ship, getName(player));
|
|
}
|
|
else
|
|
{
|
|
// no string id
|
|
setName(ship, getName(player)+" ("+strName+")");
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
boolean unpackShipForPlayer(obj_id player, obj_id ship)
|
|
{
|
|
obj_id shipControlDevice = getContainedBy(ship);
|
|
if (debugSpaceTransition)
|
|
LOG("space_transition", "unpackShipForPlayer: scd=" + shipControlDevice + " ship=" + ship + " player=" + player);
|
|
if (isIdValid(shipControlDevice) && isIdValid(ship))
|
|
{
|
|
// pull the ship out to the location of the player\
|
|
setShipName(ship, player, shipControlDevice);
|
|
setLocation(ship, getLocation(player));
|
|
|
|
setObjVar( shipControlDevice, "ship", ship );
|
|
setObjVar( ship, "shipControlDevice", shipControlDevice );
|
|
obj_id pilotSlotObject = findPilotSlotObjectForShip(player, ship);
|
|
if (debugSpaceTransition)
|
|
LOG("space_transition", "unpackShipForPlayer: ship=" + ship + " pilotSlotObject=" + pilotSlotObject + " player=" + player);
|
|
// pilot the ship
|
|
LOG("space", "Trying to pilot the ship for slot "+pilotSlotObject);
|
|
if (isIdValid(pilotSlotObject) && pilotShip(player, pilotSlotObject))
|
|
{
|
|
LOG("space", "I think i piloted");
|
|
updateShipFaction(ship, player);
|
|
doAIImmunityCheck(ship);
|
|
|
|
// unpack droid if necessary
|
|
obj_id droidControlDevice = getDroidControlDeviceForShip(ship);
|
|
|
|
//check to see if there's already a droid there.
|
|
if (isIdValid(droidControlDevice))
|
|
{
|
|
obj_id objDroid = callable.getCDCallable(droidControlDevice);
|
|
|
|
if(isIdValid(objDroid))
|
|
{
|
|
space_combat.removeFlightDroidFromShip(droidControlDevice, objDroid);
|
|
}
|
|
}
|
|
|
|
if (isIdValid(droidControlDevice))
|
|
{
|
|
if(debugSpaceTransition)
|
|
{
|
|
LOG("space_transition", "unpacking droid from control device " + droidControlDevice + ", ship=" + ship + ", pilotSlotObject=" + pilotSlotObject + ", pilot=" + player);
|
|
}
|
|
|
|
space_combat.createFlightDroidFromData(droidControlDevice, pilotSlotObject);
|
|
|
|
obj_id objDroid = callable.getCDCallable(droidControlDevice);
|
|
|
|
setAnimationMood(objDroid, "ship");
|
|
|
|
if(!space_utils.isShipWithInterior(ship))
|
|
{
|
|
grantDroidCommands(player);
|
|
}
|
|
|
|
utils.setLocalVar(ship, "droidPcdId", droidControlDevice);
|
|
}
|
|
if (hasScript(ship, "conversation.ship_trainer_01")||hasScript(ship, "conversation.npe_new_jtl_tutorial"))
|
|
{
|
|
space_utils.openCommChannelAfterLoad(ship, ship);
|
|
}
|
|
|
|
// update the launch waypoint to match the spacestation we launched near
|
|
if (utils.hasScriptVar(player, "strLaunchPointName"))
|
|
{
|
|
obj_id objStation = space_combat.getClosestSpaceStation(ship);
|
|
string strLaunchName = getStringObjVar(objStation, "strName");
|
|
location locTest= getLocation(objStation);
|
|
space_transition.updateLaunchWaypoint(player, locTest, strLaunchName);
|
|
// also check if it's a n00b zone and send the system message if needed.
|
|
utils.setScriptVar(player, "intNewbieZoneLaunch", 1);
|
|
}
|
|
if (isSpaceBattlefieldZone())
|
|
{
|
|
if (hasObjVar(ship, "battlefield.locEntryLocation"))
|
|
{
|
|
location locEntryLocation = getLocationObjVar(ship, "battlefield.locEntryLocation");
|
|
warpPlayer(
|
|
ship,
|
|
locEntryLocation.area,
|
|
locEntryLocation.x,
|
|
locEntryLocation.y,
|
|
locEntryLocation.z,
|
|
locEntryLocation.cell,
|
|
locEntryLocation.x,
|
|
locEntryLocation.y,
|
|
locEntryLocation.z);
|
|
}
|
|
}
|
|
|
|
obj_id[] shipContents = trial.getAllObjectsInDungeon(ship);
|
|
if ( shipContents != null && shipContents.length > 0 )
|
|
{
|
|
for(int i = 0, j = shipContents.length; i < j; i++)
|
|
{
|
|
if ( isIdValid(shipContents[i]) )
|
|
{
|
|
messageTo(shipContents[i], "OnShipUnpack", null, 1.0f, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
LOG("space", "AOK");
|
|
return true; // success
|
|
}
|
|
else
|
|
{
|
|
LOG("space", "NO piloting");
|
|
}
|
|
|
|
// we've failed, but have our ship out, so put it back
|
|
packShip(ship);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
boolean inNovaOrionBattle(obj_id player)
|
|
{
|
|
location here = getLocation(player);
|
|
if ( here.area.equals("space_nova_orion") )
|
|
{
|
|
if ( hasCompletedCollectionSlot(player, "orion_rank_01_04") || hasCompletedCollectionSlot(player, "nova_rank_01_04") )
|
|
{
|
|
if ( !hasCompletedCollectionSlot(player, "orion_rank_01_05") && !hasCompletedCollectionSlot(player, "nova_rank_01_05") )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
int getPreOverridePlayerSpaceFaction(obj_id player)
|
|
{
|
|
obj_id ship = getContainingShip(player);
|
|
if ( !isIdValid(ship) )
|
|
return 0;
|
|
|
|
if (hasObjVar(ship, "spaceFaction.FactionOverride"))
|
|
{
|
|
return getIntObjVar(ship, "spaceFaction.FactionOverride");
|
|
}
|
|
else if (hasSkill(player, "pilot_imperial_navy_novice"))
|
|
{
|
|
return ##"imperial";
|
|
}
|
|
else if (hasSkill(player, "pilot_rebel_navy_novice"))
|
|
{
|
|
return ##"rebel";
|
|
}
|
|
else
|
|
{
|
|
string strFaction = space_flags.getSpaceTrack(player);
|
|
if (strFaction != null)
|
|
{
|
|
// NEUTRAL or something else
|
|
if (strFaction.equals(space_flags.PRIVATEER_CORELLIA))
|
|
{
|
|
return ##"corsec";
|
|
}
|
|
if (strFaction.equals(space_flags.PRIVATEER_TATOOINE))
|
|
{
|
|
if (space_flags.isInTierTwo(player))
|
|
return ##"valarian";//in tier2 you are Valarian
|
|
else if (space_flags.isInTierThree(player) && (!space_quest.hasReceivedReward(player, "escort", "tatooine_privateer_tier2_4a")))
|
|
return ##"valarian";//in tier three, you're valarian 'til you finish the last mission!
|
|
else
|
|
return ##"hutt";
|
|
}
|
|
if (strFaction.equals(space_flags.PRIVATEER_NABOO))
|
|
{
|
|
return ##"rsf";
|
|
}
|
|
}
|
|
}
|
|
|
|
return ##"npe_player";
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
int getPlayerSpaceFaction(obj_id player)
|
|
{
|
|
obj_id ship = getContainingShip(player);
|
|
if ( !isIdValid(ship) )
|
|
return 0;
|
|
|
|
// Check for nova or orion alliance in the battle between those two space factions.
|
|
if ( hasObjVar(player, township.OBJVAR_NOVA_ORION_FACTION) )
|
|
{
|
|
if ( inNovaOrionBattle(player) )
|
|
{
|
|
string novaOrionFaction = getStringObjVar(player, township.OBJVAR_NOVA_ORION_FACTION);
|
|
if ( novaOrionFaction!= null )
|
|
{
|
|
if ( novaOrionFaction.equals("nova") || novaOrionFaction.equals("orion") )
|
|
{
|
|
int[] alliedFactions = new int[3];
|
|
if ( novaOrionFaction.equals("nova") )
|
|
{
|
|
alliedFactions[0] = ##"nova";
|
|
alliedFactions[1] = ##"unattackable";
|
|
alliedFactions[2] = getPreOverridePlayerSpaceFaction(player);
|
|
shipSetSpaceFactionAllies( ship, alliedFactions );
|
|
return ##"nova";
|
|
}
|
|
else
|
|
{
|
|
alliedFactions[0] = ##"orion";
|
|
alliedFactions[1] = ##"unattackable";
|
|
alliedFactions[2] = getPreOverridePlayerSpaceFaction(player);
|
|
shipSetSpaceFactionAllies( ship, alliedFactions );
|
|
return ##"orion";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (hasObjVar(ship, "spaceFaction.FactionOverride"))
|
|
{
|
|
int[] alliedFactions = new int[1];
|
|
alliedFactions[0] = ##"unattackable";
|
|
shipSetSpaceFactionAllies( ship, alliedFactions );
|
|
return getIntObjVar(ship, "spaceFaction.FactionOverride");
|
|
}
|
|
else if (hasSkill(player, "pilot_imperial_navy_novice"))
|
|
{
|
|
int[] alliedFactions = new int[2];
|
|
alliedFactions[0] = ##"rsf";
|
|
alliedFactions[1] = ##"unattackable";
|
|
shipSetSpaceFactionAllies( ship, alliedFactions );
|
|
return ##"imperial";
|
|
}
|
|
else if (hasSkill(player, "pilot_rebel_navy_novice"))
|
|
{
|
|
int[] alliedFactions = new int[2];
|
|
alliedFactions[0] = ##"nym";
|
|
alliedFactions[1] = ##"unattackable";
|
|
shipSetSpaceFactionAllies( ship, alliedFactions );
|
|
return ##"rebel";
|
|
}
|
|
else
|
|
{
|
|
string strFaction = space_flags.getSpaceTrack(player);
|
|
if (strFaction != null)
|
|
{
|
|
// NEUTRAL or something else
|
|
if (strFaction.equals(space_flags.PRIVATEER_CORELLIA))
|
|
{
|
|
int[] alliedFactions = new int[1];
|
|
alliedFactions[0] = ##"unattackable";
|
|
shipSetSpaceFactionAllies( ship, alliedFactions );
|
|
return ##"corsec";
|
|
}
|
|
if (strFaction.equals(space_flags.PRIVATEER_TATOOINE))
|
|
{
|
|
int[] alliedFactions = new int[1];
|
|
alliedFactions[0] = ##"unattackable";
|
|
shipSetSpaceFactionAllies( ship, alliedFactions );
|
|
if (space_flags.isInTierTwo(player))
|
|
return ##"valarian";//in tier2 you are Valarian
|
|
else if (space_flags.isInTierThree(player) && (!space_quest.hasReceivedReward(player, "escort", "tatooine_privateer_tier2_4a")))
|
|
return ##"valarian";//in tier three, you're valarian 'til you finish the last mission!
|
|
else
|
|
return ##"hutt";
|
|
}
|
|
if (strFaction.equals(space_flags.PRIVATEER_NABOO))
|
|
{
|
|
int[] alliedFactions = new int[2];
|
|
alliedFactions[0] = ##"imperial";
|
|
alliedFactions[1] = ##"unattackable";
|
|
shipSetSpaceFactionAllies(ship, alliedFactions);
|
|
return ##"rsf";
|
|
}
|
|
}
|
|
}
|
|
int[] alliedFactions = new int[1];
|
|
alliedFactions[0] = ##"unattackable";
|
|
shipSetSpaceFactionAllies(ship, alliedFactions);
|
|
return ##"npe_player";
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void grantDroidCommands(obj_id objPlayer)
|
|
{
|
|
string[] strDroidCommands = space_combat.getProgrammedDroidCommands(objPlayer);
|
|
if (strDroidCommands != null && strDroidCommands.length > 0)
|
|
{
|
|
for (int intI = 0; intI < strDroidCommands.length; intI++)
|
|
{
|
|
grantCommand(objPlayer, "droid+"+strDroidCommands[intI]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void revokeDroidCommands(obj_id objPlayer)
|
|
{
|
|
string[] strDroidCommands = space_combat.getProgrammedDroidCommands(objPlayer);
|
|
if (strDroidCommands != null && strDroidCommands.length > 0)
|
|
{
|
|
for (int intI = 0; intI < strDroidCommands.length; intI++)
|
|
{
|
|
revokeCommand(objPlayer, "droid+"+strDroidCommands[intI]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void teleportPlayerToLaunchLoc(obj_id player)
|
|
{
|
|
teleportPlayerToLaunchLoc(player, false);
|
|
}
|
|
|
|
void teleportPlayerToLaunchLoc(obj_id player, boolean hyperspace)
|
|
{
|
|
// Note: this may be used on a player which is incapable of changing
|
|
// scenes, in which case we move them into the world and clear their
|
|
// ship launch information so they will be sent back next time they
|
|
// are in a valid state.
|
|
//
|
|
// This will also be called if the "Go Home" button is pushed on the client
|
|
// in that case, a hyperspace effect will be played for the transition
|
|
|
|
location worldLaunchLoc = getLocationObjVar(player, "space.launch.worldLoc");
|
|
|
|
// if the player is in the npe, let the npe teleportPlayerToLaunchLoc take care of this
|
|
if (hasObjVar(player, "npe.phase_number"))
|
|
{
|
|
// if the npe teleportPlayerToLaunchLoc fails, we continue here
|
|
if (npe.teleportPlayerToLaunchLoc(player, hyperspace))
|
|
return;
|
|
}
|
|
|
|
if (worldLaunchLoc == null)
|
|
{
|
|
// They didn't use a space terminal, so send them near the tatooine origin as punishment.
|
|
sendSystemMessageTestingOnly(player, "You do not have a launch location. This usually means that you didn't use the launch terminal. Please do so.");
|
|
worldLaunchLoc = new location(5.f, 195.f, 5.f, "tatooine");
|
|
}
|
|
|
|
float theta = rand()*(2.f*(float)Math.PI);
|
|
float radius = 2.f + rand()*3.f;
|
|
worldLaunchLoc.x += radius * Math.cos(theta);
|
|
worldLaunchLoc.z += radius * Math.sin(theta);
|
|
|
|
if (hyperspace)
|
|
hyperspacePlayerToLocation(player, worldLaunchLoc.area, worldLaunchLoc.x, worldLaunchLoc.y, worldLaunchLoc.z, null, worldLaunchLoc.x, worldLaunchLoc.y, worldLaunchLoc.z, null, false);
|
|
else
|
|
warpPlayer(player, worldLaunchLoc.area, worldLaunchLoc.x, worldLaunchLoc.y, worldLaunchLoc.z, null, worldLaunchLoc.x, worldLaunchLoc.y, worldLaunchLoc.z, null, false);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
location getShipBoardingDestination(obj_id objShip)
|
|
{
|
|
transform[] trEntrances= utils.getTransformArrayScriptVar(objShip, "locEntrance");
|
|
if (trEntrances == null)
|
|
{
|
|
obj_id[] objCells = getContents(objShip);
|
|
if (objCells == null || objCells.length == 0)
|
|
{
|
|
return null;
|
|
}
|
|
obj_id objCell = objCells[0];
|
|
location locTest = new location();
|
|
locTest.cell = objCell;
|
|
LOG("space", "HORRIBLY BAD SHIP OF OBJECT ID "+objShip);
|
|
return locTest;
|
|
}
|
|
obj_id[] objCells = utils.getObjIdArrayScriptVar(objShip, "locEntranceCells");
|
|
int intTest = rand(0, trEntrances.length-1);
|
|
transform tr = trEntrances[intTest];
|
|
location locDestination = space_utils.getLocationFromTransform(tr);
|
|
locDestination.cell = objCells[intTest];
|
|
return locDestination;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
boolean isShipBoardable(obj_id objPlayer, obj_id objShip)
|
|
{
|
|
obj_id objPlayerShip = getPilotedShip(objPlayer);
|
|
|
|
if (!isIdValid(objPlayerShip))
|
|
{
|
|
string_id strSpam = new string_id("space/space_advanced","no_board_without_ship");
|
|
sendSystemMessage(objPlayer, strSpam);
|
|
return false;
|
|
}
|
|
|
|
if (!isIdValid(objShip))
|
|
{
|
|
string_id strSpam = new string_id("space/space_advanced","no_ship_targeted");
|
|
sendSystemMessage(objPlayer, strSpam);
|
|
return false;
|
|
}
|
|
|
|
obj_id[] objCells = getContents(objShip);
|
|
|
|
if (objCells == null || objCells.length==0)
|
|
{
|
|
string_id strSpam = new string_id("space/space_advanced","not_boardable");
|
|
sendSystemMessage(objPlayer, strSpam);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
Vector getShipStartLocations(obj_id ship)
|
|
{
|
|
Vector startLocations = null;
|
|
String shipTemplateName = getTemplateName(ship);
|
|
|
|
String[] templateNames = dataTableGetStringColumn(DATATABLE_SHIP_START_LOCATIONS, COLUMN_TEMPLATE);
|
|
|
|
if(templateNames != null)
|
|
{
|
|
int rowIndex = 0;
|
|
for(; rowIndex < templateNames.length; ++rowIndex)
|
|
if(templateNames[rowIndex].equals(shipTemplateName))
|
|
break;
|
|
|
|
if(rowIndex < templateNames.length)
|
|
{
|
|
do
|
|
{
|
|
string slotName = dataTableGetString(DATATABLE_SHIP_START_LOCATIONS, rowIndex, COLUMN_SLOT);
|
|
|
|
if(slotName != null && slotName.length() > 0)
|
|
{
|
|
int slot = utils.stringToInt(slotName.substring(11));
|
|
|
|
if(slot > 0 && isShipSlotInstalled(ship, slot + ship_chassis_slot_type.SCST_weapon_0))
|
|
{
|
|
startLocations = utils.addElement(startLocations, new location(0.f, 0.f, 0.f, slotName, null));
|
|
}
|
|
else
|
|
{
|
|
LOG("space", "Launching into space. Turret not installed. slotName: " + slotName + " slot: " + slot);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string cellName = dataTableGetString(DATATABLE_SHIP_START_LOCATIONS, rowIndex, COLUMN_CELL);
|
|
obj_id cell = getCellId(ship, cellName);
|
|
|
|
if(isIdValid(cell))
|
|
{
|
|
float x = dataTableGetFloat(DATATABLE_SHIP_START_LOCATIONS, rowIndex, COLUMN_X);
|
|
float y = dataTableGetFloat(DATATABLE_SHIP_START_LOCATIONS, rowIndex, COLUMN_Y);
|
|
float z = dataTableGetFloat(DATATABLE_SHIP_START_LOCATIONS, rowIndex, COLUMN_Z);
|
|
startLocations = utils.addElement(startLocations, new location(x, y, z, getCurrentSceneName(), cell));
|
|
}
|
|
}
|
|
|
|
++rowIndex;
|
|
|
|
}
|
|
while(rowIndex < templateNames.length && templateNames[rowIndex].length() == 0);
|
|
}
|
|
}
|
|
return startLocations;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void updateLaunchWaypoint(obj_id objPlayer, location locTest, string strName)
|
|
{
|
|
// so the location is actually wrong.. we'll update this once we get the correct location
|
|
obj_id objLaunchWaypoint = null;
|
|
|
|
if (!hasObjVar(objPlayer, "space.objLaunchWaypoint"))
|
|
{
|
|
LOG("space", "HASOBJVAR");
|
|
objLaunchWaypoint = createWaypointInDatapad(objPlayer, locTest);
|
|
}
|
|
else
|
|
{
|
|
objLaunchWaypoint = getObjIdObjVar(objPlayer, "space.objLaunchWaypoint");
|
|
LOG("space", "objLaunchWaypoint of "+objLaunchWaypoint+" does not exist");
|
|
if (!space_utils.hasWaypointInDatapad(objPlayer, objLaunchWaypoint))
|
|
{
|
|
objLaunchWaypoint = createWaypointInDatapad(objPlayer, locTest);
|
|
}
|
|
else
|
|
{
|
|
setWaypointLocation(objLaunchWaypoint, locTest);
|
|
}
|
|
}
|
|
if (isIdValid(objLaunchWaypoint))
|
|
{
|
|
setObjVar(objPlayer, "space.objLaunchWaypoint", objLaunchWaypoint);
|
|
setWaypointActive(objLaunchWaypoint, true);
|
|
string_id strSpam = new string_id("launch_names", strName);
|
|
setWaypointName(objLaunchWaypoint, utils.packStringId(strSpam));
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void updateShipFaction(obj_id ship, obj_id player)
|
|
{
|
|
int spaceFaction = 0;
|
|
if (isSpaceBattlefieldZone() && hasObjVar(ship, "intBattlefieldTeam"))
|
|
{
|
|
spaceFaction = getIntObjVar(ship, "intBattlefieldTeam");
|
|
shipSetSpaceFaction(ship, spaceFaction);
|
|
}
|
|
else
|
|
{
|
|
spaceFaction = getPlayerSpaceFaction(player);
|
|
shipSetSpaceFaction(ship, spaceFaction);
|
|
updatePVPStatus(ship);
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
/***********************************************************
|
|
* This is called by the Imperial and Rebel space stations
|
|
* to make players overt / pvp-able
|
|
*
|
|
* It can only ever be "rebel" or "imperial"
|
|
**/
|
|
|
|
// this version is called from C++
|
|
void setPlayerOvert(long player)
|
|
{
|
|
const obj_id playerObjId = obj_id.getObjId(player);
|
|
if (isIdValid(playerObjId) && exists(playerObjId) && playerObjId.isAuthoritative())
|
|
setPlayerOvert(playerObjId);
|
|
}
|
|
|
|
void setPlayerOvert(obj_id player)
|
|
{
|
|
//Dan's magical code to set the bitches Overt goes here.
|
|
obj_id objShip = getContainingShip(player);
|
|
if (isIdValid(objShip))
|
|
{
|
|
setObjVar(objShip, "spaceFaction.overt", 1);
|
|
messageTo(objShip, "checkSpacePVPStatus", null, 30, false);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void setPlayerOvert(obj_id player, int overrideFaction)
|
|
{
|
|
obj_id ship = getContainingShip(player);
|
|
setObjVar(ship, "spaceFaction.FactionOverride", overrideFaction);
|
|
shipSetSpaceFaction(ship, overrideFaction);
|
|
setPlayerOvert(player);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
// this version is called from C++
|
|
void clearOvertStatus(long objShip)
|
|
{
|
|
const obj_id objShipObjId = obj_id.getObjId(objShip);
|
|
if (isIdValid(objShipObjId) && exists(objShipObjId) && objShipObjId.isAuthoritative())
|
|
clearOvertStatus(objShipObjId);
|
|
}
|
|
|
|
void clearOvertStatus(obj_id objShip)
|
|
{
|
|
if (isIdValid(objShip))
|
|
{
|
|
if(hasObjVar(objShip, "intBattlefieldTeam"))
|
|
{
|
|
removeObjVar(objShip, "intBattlefieldTeam");
|
|
}
|
|
removeObjVar(objShip, "spaceFaction.FactionOverride");
|
|
removeObjVar(objShip, "spaceFaction.overt");
|
|
space_utils.notifyObject(objShip, "checkSpacePVPStatus", null);
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void updatePVPStatus(obj_id objShip)
|
|
{
|
|
if (hasObjVar(objShip, "spaceFaction.FactionOverride"))
|
|
shipSetSpaceFaction(objShip, getIntObjVar(objShip, "spaceFaction.FactionOverride"));
|
|
|
|
if (hasObjVar(objShip, "spaceFaction.overt"))
|
|
{
|
|
// HACK HACK
|
|
obj_id objPlayer = getPilotId(objShip);
|
|
// check if overt
|
|
int intType = pvpGetType(objShip);
|
|
if (intType != PVPTYPE_DECLARED)
|
|
{
|
|
if (isIdValid(objPlayer))
|
|
{
|
|
space_utils.sendSystemMessage(objPlayer, SID_PVP_NOW_OVERT);
|
|
}
|
|
}
|
|
pvpMakeDeclared(objShip);
|
|
}
|
|
else
|
|
{
|
|
int intType = pvpGetType(objShip);
|
|
if (intType == PVPTYPE_DECLARED)
|
|
{
|
|
obj_id objPlayer = getPilotId(objShip);
|
|
if (isIdValid(objPlayer))
|
|
{
|
|
space_utils.sendSystemMessage(objPlayer, SID_PVP_NOW_NEUTRAL);
|
|
}
|
|
}
|
|
pvpSetAlignedFaction(objShip, 0);
|
|
pvpMakeNeutral(objShip);
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void doAIImmunityCheck(obj_id objShip)
|
|
{
|
|
string strChassisType = getShipChassisType(objShip);
|
|
|
|
// Clear me from any AI attack target lists
|
|
|
|
ship_ai.unitRemoveFromAllAttackTargetLists(objShip);
|
|
|
|
if (strChassisType.equals("player_sorosuub_space_yacht"))
|
|
{
|
|
LOG("space", "Setting sorosuub to be immune");
|
|
ship_ai.unitSetAutoAggroImmune(objShip, true); // auto-aggro immune for infinity
|
|
}
|
|
else
|
|
{
|
|
ship_ai.unitSetAutoAggroImmuneTime(objShip, 60); // 60 seconds of auto-aggro immunity
|
|
}
|
|
|
|
if (hasObjVar(getOwner(objShip), "gm"))
|
|
{
|
|
ship_ai.unitRemoveFromAllAttackTargetLists(objShip);
|
|
ship_ai.unitSetAutoAggroImmune(objShip, true);
|
|
ship_ai.unitSetDamageAggroImmune(objShip, true);
|
|
sendSystemMessageTestingOnly(getOwner(objShip), "aiIgnore[ON]: AI will no longer aggro you or fight back.");
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void adjustShipTeleportFixupInSpaceScene(obj_id ship)
|
|
{
|
|
if (hasObjVar(ship, "teleportFixup"))
|
|
{
|
|
// The only portion of a teleport fixup which would be valid for a ship in a space scene is the callback.
|
|
string fixupCallback = getStringObjVar(ship, "teleportFixup.callback");
|
|
LIVE_LOG("TeleportFixup", "Removing teleport fixup from " + ship);
|
|
removeObjVar(ship, "teleportFixup");
|
|
if (fixupCallback != null && fixupCallback.length() > 0)
|
|
setObjVar(ship, "teleportFixup.callback", fixupCallback);
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
int getNextStartIndex(resizeable location[] shipStartLocations, int lastStartIndex)
|
|
{
|
|
int startIndex = lastStartIndex+1;
|
|
|
|
// If we have more players than start locations, see if we have any start
|
|
// locations in cells and reuse those. We assume that all start locations
|
|
// not in cells come at the beginning of the list.
|
|
|
|
if (startIndex > shipStartLocations.length)
|
|
{
|
|
for (startIndex = 1; startIndex <= shipStartLocations.length; ++startIndex)
|
|
if (shipStartLocations[startIndex-1].cell != null)
|
|
break;
|
|
}
|
|
|
|
return startIndex;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
void launch(obj_id player, obj_id ship, obj_id[] passengers, location warpLocation, location groundLoc)
|
|
{
|
|
resizeable obj_id[] passengersToWarp = utils.addElement(null, player);
|
|
resizeable int[] passengerStartIndexes = utils.addElement(null, 0);
|
|
// utils.setScriptVar(player, "strLaunchPointName", "launching");
|
|
resizeable location[] shipStartLocations = space_transition.getShipStartLocations(ship);
|
|
|
|
if (null != passengers)
|
|
{
|
|
if (shipStartLocations != null && shipStartLocations.length > 0)
|
|
{
|
|
int startIndex = 0;
|
|
location playerLoc = getLocation(player);
|
|
|
|
for (int i = 0; i < passengers.length; ++i)
|
|
{
|
|
obj_id passenger = passengers[i];
|
|
if (passenger != player)
|
|
{
|
|
if (features.isSpaceEdition(passenger))
|
|
{
|
|
startIndex = space_transition.getNextStartIndex(shipStartLocations, startIndex);
|
|
if (startIndex <= shipStartLocations.length)
|
|
{
|
|
passengersToWarp = utils.addElement(passengersToWarp, passenger);
|
|
passengerStartIndexes = utils.addElement(passengerStartIndexes, startIndex);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string_id strSpam = new string_id("space/space_interaction", "no_space_expansion");
|
|
sendSystemMessage(passenger, strSpam);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < passengersToWarp.length; ++i)
|
|
{
|
|
obj_id passenger = passengersToWarp[i];
|
|
int passengerStartIndex = passengerStartIndexes[i];
|
|
|
|
space_transition.setLaunchInfo(passenger, ship, passengerStartIndex, groundLoc);
|
|
warpPlayer(
|
|
passenger,
|
|
warpLocation.area,
|
|
warpLocation.x, warpLocation.y, warpLocation.z,
|
|
null,
|
|
warpLocation.x, warpLocation.y, warpLocation.z);
|
|
}
|
|
//sendSystemMessageTestingOnly(player, "(unlocalized) Finishing launch sequence...");
|
|
}
|
|
// ======================================================================
|
|
|
|
void exitCapitalShip(obj_id objPlayer, transform trTest)
|
|
{
|
|
|
|
obj_id objContainingShip = space_transition.getContainingShip(objPlayer);
|
|
location locTest = getLocationObjVar(objContainingShip, "locLaunchLocation");
|
|
|
|
obj_id[] objControlDevices = space_transition.findShipControlDevicesForPlayer(objPlayer);
|
|
LOG("space", "control device is "+objControlDevices[0]);
|
|
obj_id ship = space_transition.getShipFromShipControlDevice(objControlDevices[0]);
|
|
|
|
setObjVar(objPlayer, "space.launch.worldLoc", locTest);
|
|
setObjVar(objPlayer, "space.launch.ship", ship);
|
|
setObjVar(objPlayer, "space.launch.startIndex", 0);
|
|
setLocation(ship, locTest);
|
|
LOG("space", "Putting ship at "+locTest);
|
|
dictionary dctParams = new dictionary();
|
|
dctParams.put("objShip", ship);
|
|
dctParams.put("locTest", locTest);
|
|
dctParams.put("trTest", trTest);
|
|
|
|
messageTo(objPlayer, "doDelayedPilot", dctParams, 1.0f, false);
|
|
}
|
|
|
|
void enterCapitalShip(obj_id objPlayer, transform trTest, obj_id objCell)
|
|
{
|
|
|
|
space_transition.packShip(space_transition.getContainingShip(objPlayer));
|
|
location locTest = new location();
|
|
locTest.cell = objCell;
|
|
setLocation(objPlayer, locTest);
|
|
LOG("space", "sending player to "+locTest);
|
|
setTransform_o2p(objPlayer, trTest);
|
|
|
|
}
|