mirror of
https://bitbucket.org/seefoe/dsrc.git
synced 2026-07-31 01:15:55 -04:00
1156 lines
37 KiB
Plaintext
1156 lines
37 KiB
Plaintext
include library.locations;
|
|
include library.prose;
|
|
include library.space_transition;
|
|
include library.space_utils;
|
|
include library.utils;
|
|
|
|
const string INSTANCE_DATATABLE = "datatables/instance/instance_datatable.iff";
|
|
|
|
const string REQUEST_TYPE = "instance.request_name";
|
|
const string REQUEST_TEAM = "instance.request_team";
|
|
const string REQUEST_TRIGGER = "instance.request_trigger";
|
|
|
|
const string INSTANCE_OWNER = "instance_data.instance_owner";
|
|
const string INSTANCE_START_TIME = "instance_data.start_time";
|
|
const string PLAYER_LIST = "instance_data.player_list";
|
|
const string PLAYER_ID_LIST = "instance_data.player_obj_id_list";
|
|
const string INSTANCE_TEAM = "instance_data.team";
|
|
const string MIN_PLAYERS = "instance_data.min_players";
|
|
|
|
const string PLAYER_INSTANCE = "instance_player_data";
|
|
const string PLAYER_INSTANCE_PROTECTED = "instance_player_protected_data";
|
|
|
|
const string REQUEST_BUFF = "instance_request_pending";
|
|
|
|
const string INSTANCE_DEBUG_LOG = "instance-debug";
|
|
|
|
const int REQUEST_INVALID = -1;
|
|
const int REQUEST_MOVETO = 0;
|
|
const int REQUEST_CLOSE = 1;
|
|
|
|
const int RESET_NONE = 0;
|
|
const int RESET_DAILY = 1;
|
|
|
|
const int FAIL_INSTANCE_FULL = 0;
|
|
const int FAIL_NOT_MEMBER = 1;
|
|
const int INSTANCE_TIMEOUT = 2;
|
|
const int FAIL_INVALID_LOCKOUT = 3;
|
|
const int FAIL_INSTANCE_CLOSED = 4;
|
|
const int FAIL_INSTANCE_FEW_PLAYERS = 5;
|
|
const int FAIL_WARN_TOO_FEW = 6;
|
|
|
|
const string_id SID_UNDER_FIVE_MINUTE_WARNING = new string_id("instance", "five_minute_warning");
|
|
|
|
|
|
void registerInstance(obj_id instance_id)
|
|
{
|
|
registerInstance(instance_id, getInstanceName(instance_id));
|
|
}
|
|
|
|
void registerInstance(obj_id instance_id, string instanceName)
|
|
{
|
|
getClusterWideData("instance_manager-"+instanceName, instanceName+"_"+instance_id, true, instance_id);
|
|
}
|
|
|
|
boolean isInstanceActive(obj_id instance_id)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
boolean isInInstanceArea(obj_id subject)
|
|
{
|
|
string area_name = locations.getBuildoutAreaName(subject);
|
|
int area_row = locations.getBuildoutAreaRow(subject);
|
|
|
|
obj_id planet = getPlanetByName(getLocation(subject).area);
|
|
string instance_controller = ""+area_name+"_"+area_row;
|
|
|
|
obj_id areaInstanceController = utils.hasScriptVar(planet, instance_controller) ? utils.getObjIdScriptVar(planet, instance_controller) : null;
|
|
|
|
if (!isIdValid(areaInstanceController))
|
|
{
|
|
validateInstanceScriptsOnPlayer(subject);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
string getInstanceName(obj_id instance_id)
|
|
{
|
|
return getStringObjVar(instance_id, "instance_name");
|
|
}
|
|
|
|
int getInstancePlayerCap(obj_id instance_id)
|
|
{
|
|
return getInstancePlayerCap(getInstanceName(instance_id));
|
|
}
|
|
|
|
int getInstancePlayerCap(string instance_name)
|
|
{
|
|
return dataTableGetInt(INSTANCE_DATATABLE, instance_name, "max_players");
|
|
}
|
|
|
|
int getMinPlayers(obj_id instance_id)
|
|
{
|
|
return getMinPlayers(getInstanceName(instance_id));
|
|
}
|
|
|
|
int getMinPlayers(string instance_name)
|
|
{
|
|
return dataTableGetInt(INSTANCE_DATATABLE, instance_name, "min_players");
|
|
}
|
|
|
|
obj_id getInstanceOwner(obj_id instance_id)
|
|
{
|
|
return utils.hasScriptVar(instance_id, INSTANCE_OWNER) ? utils.getObjIdScriptVar(instance_id, INSTANCE_OWNER) : instance_id;
|
|
}
|
|
|
|
string getPlayerList(obj_id instance_id)
|
|
{
|
|
return getPlayerList(instance_id, 1);
|
|
}
|
|
|
|
string getPlayerList(obj_id instance_id, int groupNumber)
|
|
{
|
|
return utils.hasScriptVar(instance_id, PLAYER_LIST+"_"+groupNumber) ? utils.getStringScriptVar(instance_id, PLAYER_LIST+"_"+groupNumber) : "none";
|
|
}
|
|
|
|
int getInstanceCloseTime(obj_id instance_id)
|
|
{
|
|
return getInstanceStartTime(instance_id) + getInstanceDuration(instance_id);
|
|
}
|
|
|
|
int getInstanceStartTime(obj_id instance_id)
|
|
{
|
|
return utils.hasScriptVar(instance_id, INSTANCE_START_TIME) ? utils.getIntScriptVar(instance_id, INSTANCE_START_TIME) : -1;
|
|
}
|
|
|
|
int getInstanceTeam(obj_id instance_id)
|
|
{
|
|
return utils.hasScriptVar(instance_id, INSTANCE_TEAM) ? utils.getIntScriptVar(instance_id, INSTANCE_TEAM) : -1;
|
|
}
|
|
|
|
int getCurrentPopulation(obj_id instance_id)
|
|
{
|
|
obj_id[] players = utils.getPlayersInBuildoutRow(getLocation(instance_id).area, locations.getBuildoutAreaRow(instance_id));
|
|
|
|
if (players == null || players.length == 0)
|
|
return 0;
|
|
|
|
return players.length;
|
|
}
|
|
|
|
obj_id[] getPlayersInInstanceArea(obj_id instance_id)
|
|
{
|
|
string instance_area = getLocation(instance_id).area;
|
|
|
|
if(utils.hasScriptVar(instance_id, "buildoutCoordinates"))
|
|
{
|
|
dictionary coords = utils.getDictionaryScriptVar(instance_id, "buildoutCoordinates");
|
|
|
|
if(coords == null)
|
|
{
|
|
utils.removeScriptVar(instance_id, "buildoutCoordinates");
|
|
}
|
|
else
|
|
{
|
|
return utils.getPlayersInBuildoutDimensions(instance_area, coords.getFloat("x1"), coords.getFloat("x2"), coords.getFloat("z1"), coords.getFloat("z2"));
|
|
}
|
|
}
|
|
|
|
int row = locations.getBuildoutAreaRow(instance_id);
|
|
dictionary coords = utils.getCoordinatesInBuildoutRow(instance_area, row);
|
|
|
|
if(coords != null)
|
|
{
|
|
utils.setScriptVar(instance_id, "buildoutCoordinates", coords);
|
|
}
|
|
|
|
return utils.getPlayersInBuildoutDimensions(instance_area, coords.getFloat("x1"), coords.getFloat("x2"), coords.getFloat("z1"), coords.getFloat("z2"));
|
|
}
|
|
|
|
obj_id[] getPlayersInInstanceArea(string area, int row)
|
|
{
|
|
return utils.getPlayersInBuildoutRow(area, row);
|
|
}
|
|
|
|
obj_id[] getPlayersByTeamList(obj_id[] allPlayers, string groupList)
|
|
{
|
|
obj_id[] listPlayers = getPlayersInPlayerList(groupList);
|
|
|
|
resizeable obj_id[] validPlayers = new obj_id[0];
|
|
|
|
for (int i=0;i<allPlayers.length;i++)
|
|
{
|
|
for (int k=0;k<listPlayers.length;k++)
|
|
{
|
|
if (allPlayers[i] == listPlayers[k])
|
|
utils.addElement(validPlayers, allPlayers[i]);
|
|
}
|
|
|
|
}
|
|
|
|
if (validPlayers == null || validPlayers.length == 0)
|
|
return null;
|
|
|
|
return validPlayers;
|
|
}
|
|
|
|
boolean testNextPlayerInstanceCap(obj_id instance_id)
|
|
{
|
|
return testNextPlayerInstanceCap(instance_id, 1);
|
|
}
|
|
|
|
boolean testNextPlayerInstanceCap(obj_id instance_id, int team)
|
|
{
|
|
string groupList = getPlayerList(instance_id, team);
|
|
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "testNextPlayerInstanceCap-groupList for instance_id ("+instance_id+") was "+ groupList);
|
|
|
|
obj_id[] allPlayers = getPlayersInInstanceArea(instance_id);
|
|
|
|
|
|
if (allPlayers == null || allPlayers.length == 0)
|
|
{
|
|
doLogging("No players currently in instance");
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "testNextPlayerInstanceCap-array allPlayers returned null or length of 0 for instance_id ("+instance_id+") this should mean we have no players in the instance. Returning false");
|
|
return false;
|
|
}
|
|
|
|
int playerLimit = getInstancePlayerCap(instance_id);
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "testNextPlayerInstanceCap-playerLimit for instance for instance_id ("+instance_id+") was " + playerLimit);
|
|
|
|
int projectedPop = allPlayers.length +1;
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "testNextPlayerInstanceCap-projectedPop for instance for instance_id ("+instance_id+") was " + projectedPop);
|
|
|
|
if (projectedPop <= playerLimit)
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "testNextPlayerInstanceCap-projectedPop was less than or equal to playerLimit for instance_id ("+instance_id+"), returning false");
|
|
return false;
|
|
}
|
|
|
|
// obj_id[] playersOnTeam = getPlayersByTeamList(allPlayers, groupList);
|
|
|
|
// if (playersOnTeam.length + 1 <= playerLimit)
|
|
// return false;
|
|
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "testNextPlayerInstanceCap-projectedPop was GREATUER than to playerLimit for instance_id ("+instance_id+"), returning TRUE. Which means the player will not get in.");
|
|
|
|
return true;
|
|
}
|
|
|
|
boolean isFlaggedForInstance(obj_id player, dictionary data)
|
|
{
|
|
string instance_key = data.getString("key_required");
|
|
if (instance_key == "none")
|
|
return true;
|
|
|
|
return hasObjVar(player, PLAYER_INSTANCE_PROTECTED+"."+instance_key);
|
|
}
|
|
|
|
boolean isFlaggedForInstance(obj_id player, string instance_key)
|
|
{
|
|
dictionary dict = dataTableGetRow("datatables/instance/instance_datatable.iff", instance_key);
|
|
|
|
//validate the dictionary
|
|
if(dict == null || dict.isEmpty())
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isFlaggedForInstance-player "+getFirstName(player)+"("+player+") passed in an invalid instance key ("+instance_key+"). Leaving a null dictionary. Returning false");
|
|
return false;
|
|
}
|
|
string key = dict.getString("key_required");
|
|
if(key == null || key.length() <= 0)
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isFlaggedForInstance-player "+getFirstName(player)+"("+player+") got a null key_required from the datatable");
|
|
return false;
|
|
}
|
|
if (key.equals("none"))
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isFlaggedForInstance-player "+getFirstName(player)+"("+player+") got a 'none' key_required from the datatable");
|
|
return true;
|
|
}
|
|
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isFlaggedForInstance-player "+getFirstName(player)+"("+player+") passed all checks returning " +(hasObjVar(player, PLAYER_INSTANCE_PROTECTED+"."+instance_key)));
|
|
|
|
return hasObjVar(player, PLAYER_INSTANCE_PROTECTED+"."+instance_key);
|
|
}
|
|
|
|
void flagPlayerForInstance(obj_id player, string instance_key)
|
|
{
|
|
setObjVar(player, PLAYER_INSTANCE_PROTECTED+"."+instance_key, 1);
|
|
}
|
|
|
|
void removePlayerFlagForInstance(obj_id player, string instance_key)
|
|
{
|
|
utils.removeObjVar(player, PLAYER_INSTANCE_PROTECTED+"."+instance_key);
|
|
}
|
|
|
|
boolean requestInstanceMovement(obj_id player, string instanceName)
|
|
{
|
|
return requestInstanceMovement(player, instanceName, 1, "default");
|
|
}
|
|
|
|
boolean requestInstanceMovement(obj_id player, string instanceName, string defaultTrigger)
|
|
{
|
|
return requestInstanceMovement(player, instanceName, 1, defaultTrigger);
|
|
}
|
|
|
|
boolean requestInstanceMovement(obj_id player, string instanceName, int team, string defaultTrigger)
|
|
{
|
|
if (!instance.isFlaggedForInstance(player, instanceName))
|
|
{
|
|
string instance = "@"+new string_id("instance", instanceName);
|
|
prose_package pp = new prose_package();
|
|
pp.other.set(instance);
|
|
pp.stringId = new string_id("instance", "no_key");
|
|
sendSystemMessageProse(player, pp);
|
|
return false;
|
|
}
|
|
|
|
if (isSpaceScene())
|
|
{
|
|
obj_id ship = trial.getTop(player);
|
|
obj_id pilot = space_utils.getPilotId(ship);
|
|
|
|
if (pilot == player)
|
|
{
|
|
obj_id[] crew = space_utils.getAllPlayersInShip(ship);
|
|
|
|
if (crew.length > 1)
|
|
{
|
|
sendSystemMessage(player, new string_id("instance", "nomove_ship_full"));
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isRequestPending(player))
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "requestInstanceMovement-player "+getFirstName(player)+"("+player+") has a request pending already");
|
|
sendSystemMessage(player, new string_id("instance", "instance_request_pending"));
|
|
return false;
|
|
}
|
|
dictionary lockoutData = getLockoutData(player, instanceName);
|
|
|
|
if (lockoutData != null && !lockoutData.isEmpty())
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "requestInstanceMovement-LockoutData was NOT empty for player "+getFirstName(player)+"("+player+")");
|
|
int endTime = lockoutData.getInt("time");
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "requestInstanceMovement-endTime for player "+getFirstName(player)+"("+player+") is " + endTime);
|
|
obj_id instance_id = lockoutData.getObjId("instance_id");
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "requestInstanceMovement-instance_id for player "+getFirstName(player)+"("+player+") is " + instance_id);
|
|
obj_id owner = lockoutData.getObjId("owner");
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "requestInstanceMovement-owner for player "+getFirstName(player)+"("+player+") is " + owner);
|
|
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "requestInstanceMovement-Trying to bypass entry for "+getName(player)+" to "+instanceName+". Owner/Team: "+owner+"/"+team);
|
|
|
|
movePlayerToInstance(player, instance_id, instanceName, owner, false, team);
|
|
LOG("doLogging", "Trying to bypass entry for "+getName(player)+" to "+instanceName+". Owner/Team: "+owner+"/"+team);
|
|
return true;
|
|
}
|
|
|
|
utils.setScriptVar(player, REQUEST_TYPE, REQUEST_MOVETO);
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "requestInstanceMovement-setting script var '"+REQUEST_TYPE+"' for player "+getFirstName(player)+"("+player+") to " + REQUEST_MOVETO);
|
|
utils.setScriptVar(player, REQUEST_TEAM, team);
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "requestInstanceMovement-setting script var '"+REQUEST_TEAM+"' for player "+getFirstName(player)+"("+player+") to " + team);
|
|
utils.setScriptVar(player, REQUEST_TRIGGER, defaultTrigger);
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "requestInstanceMovement-setting script var '"+REQUEST_TRIGGER+"' for player "+getFirstName(player)+"("+player+") to " + defaultTrigger);
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "requestInstanceMovement-LockoutData WAS empty for player "+getFirstName(player)+"("+player+"). After setting appropriate scriptvars we are now requesting clusterWide Data");
|
|
getClusterWideData("instance_manager-"+instanceName, "*", true, player);
|
|
setRequestPending(player);
|
|
return true;
|
|
}
|
|
|
|
int getInstanceRequestType(obj_id player)
|
|
{
|
|
return utils.hasScriptVar(player, REQUEST_TYPE) ? utils.getIntScriptVar(player, REQUEST_TYPE) : REQUEST_INVALID;
|
|
}
|
|
|
|
int getInstanceRequestTeam(obj_id player)
|
|
{
|
|
return utils.hasScriptVar(player, REQUEST_TEAM) ? utils.getIntScriptVar(player, REQUEST_TEAM) : REQUEST_INVALID;
|
|
}
|
|
|
|
|
|
boolean isPlayerOwnerGroupList(obj_id player, obj_id owner, obj_id instance_id, string groupList, int team, int instance_team)
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isPlayerOwnerGroupList-Start for player "+getFirstName(player)+"("+player+").");
|
|
if (team != instance_team)
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isPlayerOwnerGroupList- (team != instance_team) for player "+getFirstName(player)+"("+player+"). Returning False");
|
|
return false;
|
|
}
|
|
|
|
if (!isIdValid(owner) || owner == instance_id)
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isPlayerOwnerGroupList- (!isIdValid(owner) || owner == instance_id) for player "+getFirstName(player)+"("+player+"). Returning false");
|
|
return false;
|
|
}
|
|
|
|
if (player == owner)
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isPlayerOwnerGroupList- (player == owner) for player "+getFirstName(player)+"("+player+"). Returning false");
|
|
return true;
|
|
}
|
|
|
|
obj_id groupId = getGroupObject(player);
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isPlayerOwnerGroupList- groupId for player "+getFirstName(player)+"("+player+") is "+groupId+".");
|
|
|
|
if (isIdValid(groupId))
|
|
{
|
|
obj_id[] members = getGroupMemberIds(groupId);
|
|
|
|
for (int i=0;i<members.length;i++)
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isPlayerOwnerGroupList-members["+i+"] for player "+getFirstName(player)+"("+player+")'s group is "+getFirstName(members[i])+"("+members[i]+").");
|
|
if(isIdValid(members[i]) && (members[i] == owner || isPlayerInPlayerList(members[i], groupList)))
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isPlayerOwnerGroupList-members["+i+"] for player "+getFirstName(player)+"("+player+")'s group is valid and is either owner("+(members[i] == owner)+") or isPlayerInPlayerList("+(isPlayerInPlayerList(members[i], groupList))+"). Returning TRUE.");
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return false;
|
|
}
|
|
|
|
void movePlayerToInstance(obj_id player, obj_id dungeon, string instance_name, obj_id owner, boolean startInstance)
|
|
{
|
|
movePlayerToInstance(player, dungeon, instance_name, owner, startInstance, 1);
|
|
}
|
|
|
|
void movePlayerToInstance(obj_id player, obj_id instance_id, string instance_name, obj_id owner, boolean startInstance, int team)
|
|
{
|
|
dictionary dict = new dictionary();
|
|
dict.put("player", player);
|
|
dict.put("team", team);
|
|
string defaultTrigger = utils.hasScriptVar(player, REQUEST_TRIGGER) ? utils.getStringScriptVar(player, REQUEST_TRIGGER) : "default";
|
|
dict.put("defaultTrigger", defaultTrigger);
|
|
dict.put("owner", owner);
|
|
|
|
if (!isValidatedByLockoutData(player, instance_id, owner, instance_name))
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "movePlayerToInstance-isValidatedByLockoutData returned false for player "+getFirstName(player)+"("+player+"). Sending messageTo 'instanceFailureMessage'");
|
|
dict.put("fail_reason", instance.FAIL_INVALID_LOCKOUT);
|
|
|
|
messageTo(player, "instanceFailureMessage", dict, 0.0f, false);
|
|
return;
|
|
}
|
|
|
|
|
|
if (startInstance)
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "movePlayerToInstance-isValidatedByLockoutData passed for player "+getFirstName(player)+"("+player+"). Sending messageTo 'startNewInstance' to instance_id " + instance_id);
|
|
messageTo(instance_id, "startNewInstance", dict, 0.0f, false);
|
|
}
|
|
else
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "movePlayerToInstance-isValidatedByLockoutData passed for player "+getFirstName(player)+"("+player+"). Sending messageTo 'requestEnterPlayer' to instance_id " + instance_id);
|
|
messageTo(instance_id, "requestEnterPlayer", dict, 0.0f, false);
|
|
}
|
|
}
|
|
|
|
void addToPlayerList(obj_id instance, obj_id player)
|
|
{
|
|
addToPlayerList(instance, player, 1);
|
|
}
|
|
|
|
void addToPlayerList(obj_id instance, obj_id player, int group)
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "addToPlayerList-Start for player "+getFirstName(player)+"("+player+").");
|
|
string playerList = getPlayerList(instance, group);
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "addToPlayerList-playerList for player "+getFirstName(player)+"("+player+") " + playerList);
|
|
if (playerList.equals("none"))
|
|
{
|
|
utils.setScriptVar(instance, PLAYER_LIST+"_"+group, ""+player);
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "addToPlayerList-playerList was 'none' for player "+getFirstName(player)+"("+player+"). setting scriptvar and bailing.");
|
|
return;
|
|
}
|
|
|
|
if (!isPlayerInPlayerList(player, playerList))
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "addToPlayerList-Player "+getFirstName(player)+"("+player+") was not in the player list. Adding them to scriptvar.");
|
|
utils.setScriptVar(instance, PLAYER_LIST+"_"+group, playerList.concat("_"+player));
|
|
}
|
|
}
|
|
|
|
void removeFromPlayerList(obj_id instance_id, obj_id player)
|
|
{
|
|
removeFromPlayerList(instance_id, player, 1);
|
|
}
|
|
|
|
void removeFromPlayerList(obj_id instance_id, obj_id player, int group)
|
|
{
|
|
string playerList = getPlayerList(instance_id, group);
|
|
if (playerList.equals("none"))
|
|
return;
|
|
|
|
string[] groupSplit = split(playerList, '_');
|
|
|
|
string newList = "";
|
|
|
|
for (int i=0;i<groupSplit.length;i++)
|
|
{
|
|
if (groupSplit.equals(""+player))
|
|
continue;
|
|
|
|
newList.concat("_"+groupSplit);
|
|
}
|
|
|
|
if (newList == "")
|
|
{
|
|
utils.setScriptVar(instance_id, PLAYER_LIST+"_"+group, "none");
|
|
return;
|
|
}
|
|
|
|
if (newList.startsWith("_"))
|
|
newList.substring(1);
|
|
|
|
utils.setScriptVar(instance_id, PLAYER_LIST+"_"+group, newList);
|
|
}
|
|
|
|
boolean isPlayerInPlayerList(obj_id player, string groupList)
|
|
{
|
|
if (groupList == "none")
|
|
return false;
|
|
|
|
string[] groupSplit = split(groupList, '_');
|
|
|
|
for (int i=0;i<groupSplit.length;i++)
|
|
{
|
|
if (utils.stringToObjId(groupSplit[i]) == player)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
obj_id[] getPlayersInPlayerList(string groupList)
|
|
{
|
|
if (groupList == null || groupList == "none")
|
|
{
|
|
doLogging("groupList was invalid or none: "+groupList);
|
|
return null;
|
|
}
|
|
string[] parse = split(groupList, '_');
|
|
|
|
obj_id[] playerList = new obj_id[parse.length];
|
|
|
|
for (int i=0;i<parse.length;i++)
|
|
{
|
|
playerList[i] = utils.stringToObjId(parse[i]);
|
|
}
|
|
|
|
return playerList;
|
|
}
|
|
|
|
void sendToEnterOne(obj_id player, obj_id instanceId, location instanceLoc, dictionary data)
|
|
{
|
|
playerEnterInstance(player, instanceId, instanceLoc, data, "enter_one");
|
|
}
|
|
|
|
void sendToEnterTwo(obj_id player, obj_id instanceId, location instanceLoc, dictionary data)
|
|
{
|
|
playerEnterInstance(player, instanceId, instanceLoc, data, "enter_two");
|
|
}
|
|
|
|
void playerEnterInstance(obj_id player, obj_id instanceId, location instanceLoc, dictionary data, string enterString)
|
|
{
|
|
if(data == null || data.isEmpty())
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "playerEnterInstance-data was null for player "+getFirstName(player)+"("+player+"), we are returning here");
|
|
return;
|
|
}
|
|
|
|
if(instanceLoc == null)
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "playerEnterInstance-instanceLoc was null for player "+getFirstName(player)+"("+player+"), we are returning here");
|
|
return;
|
|
}
|
|
|
|
if(enterString == null || enterString.length() <= 0)
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "playerEnterInstance-enterString was null for player "+getFirstName(player)+"("+player+"), we are returning here");
|
|
return;
|
|
}
|
|
|
|
string teleportToString = data.getString(enterString);
|
|
|
|
string[] parse = split(teleportToString, ',');
|
|
|
|
if(parse == null || parse.length < 4)
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "playerEnterInstance-parsed enterString was null or length ("+parse.length+") was less than 4 for player "+getFirstName(player)+"("+player+"), we are returning here");
|
|
return;
|
|
}
|
|
|
|
float locX = utils.stringToFloat(parse[0]);
|
|
float locY = utils.stringToFloat(parse[1]);
|
|
float locZ = utils.stringToFloat(parse[2]);
|
|
string cellName = parse[3];
|
|
|
|
if (cellName.equals("none"))
|
|
{
|
|
vector post = new vector(instanceLoc.x + locX, instanceLoc.y + locY, instanceLoc.z + locZ);
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "playerEnterInstance-calling warpPlayer("+player+", "+instanceLoc.area+", "+post.x+", "+post.y+", "+post.z+", obj_id.NULL_ID, "+0.0f+" , "+0.0f+" , "+0.0f+" , 'noCallBack', true) for player "+getFirstName(player)+"("+player+")");
|
|
warpPlayer(player, instanceLoc.area, post.x, post.y, post.z, obj_id.NULL_ID, 0.0f , 0.0f , 0.0f , "noCallBack", true);
|
|
}
|
|
else
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "playerEnterInstance-calling warpPlayer("+player+", "+instanceLoc.area+", "+instanceLoc.x+", "+instanceLoc.y+", "+instanceLoc.z+", "+instanceId+", "+cellName+", "+locX+", "+locY+", "+locZ+", 'noCallBack, true) for player "+getFirstName(player)+"("+player+")");
|
|
warpPlayer(player, instanceLoc.area, instanceLoc.x, instanceLoc.y, instanceLoc.z, instanceId, cellName, locX, locY, locZ, "noCallBack", true);
|
|
}
|
|
}
|
|
|
|
void requestExitPlayer(obj_id instance, obj_id[] players, int team)
|
|
{
|
|
if (players == null || players.length == 0)
|
|
return;
|
|
|
|
for (int i=0;i<players.length;i++)
|
|
requestExitPlayer(instance, players[i], team);
|
|
|
|
}
|
|
|
|
void requestExitPlayer(obj_id instance_id, obj_id player, int team)
|
|
{
|
|
string instance_name = instance.getInstanceName(instance_id);
|
|
|
|
requestExitPlayer(instance_name, player, team);
|
|
}
|
|
|
|
void requestExitPlayer(string instance_name, obj_id player)
|
|
{
|
|
requestExitPlayer(instance_name, player, 1);
|
|
}
|
|
|
|
void requestExitPlayer(string instance_name, obj_id player, int team)
|
|
{
|
|
if (!isIdValid(player) || !exists(player) || !inSameInstanceType(instance_name, player))
|
|
return;
|
|
|
|
vehicle.checkForMountAndDismountPlayer(player);
|
|
|
|
if (!dataTableOpen(instance.INSTANCE_DATATABLE))
|
|
{
|
|
doLogging("Could not open table");
|
|
return;
|
|
}
|
|
|
|
dictionary data = dataTableGetRow(instance.INSTANCE_DATATABLE, instance_name);
|
|
if (data == null)
|
|
{
|
|
doLogging("null data in table");
|
|
return;
|
|
}
|
|
|
|
buff.applyBuff(player, "instance_exiting");
|
|
removeInstanceScriptFromPlayer(player, data);
|
|
if (team == 1)
|
|
instance.sendToExitOne(player, data);
|
|
if (team == 2)
|
|
instance.sendToExitTwo(player, data);
|
|
}
|
|
|
|
boolean inSameInstanceType(string instance_name, obj_id player)
|
|
{
|
|
string test_name = locations.getBuildoutAreaName(player);
|
|
|
|
if(test_name == null || test_name == "")
|
|
{
|
|
return false;
|
|
}
|
|
|
|
|
|
return test_name.equals(instance_name);
|
|
}
|
|
|
|
void sendToExitOne(obj_id player, dictionary data)
|
|
{
|
|
string exitLoc = data.getString("exit_one");
|
|
|
|
string[] parse = split(exitLoc, ',');
|
|
|
|
float locX = utils.stringToFloat(parse[0]);
|
|
float locY = utils.stringToFloat(parse[1]);
|
|
float locZ = utils.stringToFloat(parse[2]);
|
|
|
|
warpPlayer(player, parse[3],locX, locY, locZ, null, 0.0f , 0.0f , 0.0f , "noCallBack", true);
|
|
}
|
|
|
|
void sendToExitTwo(obj_id player, dictionary data)
|
|
{
|
|
string exitLoc = data.getString("exit_two");
|
|
|
|
string[] parse = split(exitLoc, ',');
|
|
|
|
float locX = utils.stringToFloat(parse[0]);
|
|
float locY = utils.stringToFloat(parse[1]);
|
|
float locZ = utils.stringToFloat(parse[2]);
|
|
|
|
warpPlayer(player, parse[3],locX, locY, locZ, null, 0.0f , 0.0f , 0.0f , "noCallBack", true);
|
|
}
|
|
|
|
void startInstanceTimer(obj_id instance_id)
|
|
{
|
|
messageTo(instance_id, "startClock", null, 0.0f, false);
|
|
}
|
|
|
|
void closeOwnedInstance(obj_id player, string instanceName)
|
|
{
|
|
utils.setScriptVar(player, REQUEST_TYPE, REQUEST_CLOSE);
|
|
getClusterWideData("instance_manager-"+instanceName, instanceName + "*", true, player);
|
|
}
|
|
|
|
void closeInstance(obj_id owner, dictionary data)
|
|
{
|
|
obj_id instance_id = data.getObjId("instance_id");
|
|
messageTo(instance_id, "endInstanceSession", data, 0.0f, false);
|
|
}
|
|
|
|
void closeInstance(obj_id instance_id)
|
|
{
|
|
messageTo(instance_id, "endInstanceSession", null, 0.0f, false);
|
|
}
|
|
|
|
int getInstanceDuration(obj_id instance_id)
|
|
{
|
|
string instance_name = getInstanceName(instance_id);
|
|
return getInstanceDuration(instance_name);
|
|
}
|
|
|
|
int getInstanceDuration(string instance_name)
|
|
{
|
|
dictionary data = dataTableGetRow(instance.INSTANCE_DATATABLE, instance_name);
|
|
return data.getInt("time_limit");
|
|
}
|
|
|
|
void validateDungeonParticipants(obj_id instance_id)
|
|
{
|
|
int buildout_row = locations.getBuildoutAreaRow(instance_id);
|
|
obj_id[] players = utils.getPlayersInBuildoutRow(getLocation(instance_id).area, buildout_row);
|
|
|
|
if (players == null || players.length == 0)
|
|
return;
|
|
|
|
dictionary dict = new dictionary();
|
|
|
|
for (int i=0;i<players.length;i++)
|
|
{
|
|
dict.put("player", players[i]);
|
|
messageTo(instance_id, "validatePlayer", dict, 0.0f, false);
|
|
}
|
|
}
|
|
|
|
dictionary getNextClockTic(int time)
|
|
{
|
|
dictionary dict = new dictionary();
|
|
|
|
float remainder = (float)time / 300.0f;
|
|
|
|
if (remainder < 1.0f)
|
|
{
|
|
dict.put("nextTic", time);
|
|
dict.put("timeRemaining", 0);
|
|
return dict;
|
|
}
|
|
|
|
dict.put("nextTic", 300);
|
|
dict.put("timeRemaining", time - 300);
|
|
return dict;
|
|
}
|
|
|
|
void sendSoonToCloseWarining(obj_id instance_id, int timeLeft)
|
|
{
|
|
obj_id[] players = getPlayersInInstanceArea(instance_id);//getPlayersInPlayerList(getPlayerList(instance_id));
|
|
sendSoonToCloseWarining(instance_id, timeLeft, players);
|
|
}
|
|
|
|
void sendSoonToCloseWarining(obj_id instance, int timeLeft, obj_id[] players)
|
|
{
|
|
prose_package pp = prose.getPackage(SID_UNDER_FIVE_MINUTE_WARNING, timeLeft);
|
|
utils.sendSystemMessageProse(players, pp);
|
|
}
|
|
|
|
void setClock(obj_id instance_id, int seconds)
|
|
{
|
|
trial.bumpSession(instance_id, "clock");
|
|
dictionary dict = trial.getSessionDict(instance_id, "clock");
|
|
dict.put("instance_time", seconds);
|
|
messageTo(instance_id, "handleClockTic", dict, 0.0f, false);
|
|
}
|
|
|
|
boolean isExclusiveInstance(string instance_name)
|
|
{
|
|
dictionary dict = dataTableGetRow(INSTANCE_DATATABLE, instance_name);
|
|
|
|
if(dict == null || dict.isEmpty())
|
|
{
|
|
CustomerServiceLog(instance.INSTANCE_DEBUG_LOG, "isExclusiveInstance-dictionary was null, we are returning false.");
|
|
return false;
|
|
}
|
|
|
|
return dict.getInt("lockoutTimer") != RESET_NONE;
|
|
}
|
|
|
|
void setResetDataOnPlayer(obj_id player, obj_id instance_id, obj_id owner, string instance_name, int start_time)
|
|
{
|
|
dictionary dict = dataTableGetRow(INSTANCE_DATATABLE, instance_name);
|
|
|
|
if(dict == null || dict.isEmpty())
|
|
{
|
|
CustomerServiceLog(instance.INSTANCE_DEBUG_LOG, "setResetDataOnPlayer-dictionary was null for player "+getFirstName(player)+"("+player+"), we are returning here.");
|
|
return;
|
|
}
|
|
|
|
int resetType = dict.getInt("lockoutTimer");
|
|
|
|
switch (resetType)
|
|
{
|
|
case RESET_NONE:
|
|
CustomerServiceLog(instance.INSTANCE_DEBUG_LOG, "setResetDataOnPlayer-resetType was RESET_NONE for player "+getFirstName(player)+"("+player+"), doing nothing.");
|
|
break;
|
|
|
|
case RESET_DAILY:
|
|
int resetAt = getCalendarTime() + secondsUntilNextDailyTime(6, 0, 0);
|
|
setObjVar(player, PLAYER_INSTANCE+"."+instance_name, ""+resetAt+"_"+instance_id+"_"+owner+"_"+start_time);
|
|
CustomerServiceLog(instance.INSTANCE_DEBUG_LOG, "setResetDataOnPlayer-resetType was RESET_DAILY, setting objvar "+PLAYER_INSTANCE+"."+instance_name+" to "+resetAt+"_"+instance_id+"_"+owner+"_"+start_time+" on player "+getFirstName(player)+"("+player+").");
|
|
break;
|
|
}
|
|
}
|
|
|
|
boolean isValidatedByLockoutData(obj_id player, obj_id instance_id, obj_id owner, string instance_name)
|
|
{
|
|
if (!hasObjVar(player, PLAYER_INSTANCE+"."+instance_name))
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isValidatedByLockoutData-player "+getFirstName(player)+"("+player+") Doesnt have objvar "+PLAYER_INSTANCE+"."+instance_name+". Returning TRUE");
|
|
return true;
|
|
}
|
|
|
|
dictionary lockoutData = getLockoutData(player, instance_name);
|
|
|
|
if (lockoutData == null)
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isValidatedByLockoutData-lockoutData returned null for player "+getFirstName(player)+"("+player+"). Returning TRUE");
|
|
return true;
|
|
}
|
|
|
|
int endTime = lockoutData.getInt("time");
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isValidatedByLockoutData-lockoutData.endTime for player "+getFirstName(player)+"("+player+") was " + endTime);
|
|
|
|
obj_id recInstance = lockoutData.getObjId("instance_id");
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isValidatedByLockoutData-lockoutData.recInstance for player "+getFirstName(player)+"("+player+") was " + recInstance);
|
|
|
|
obj_id recOwner = lockoutData.getObjId("owner");
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isValidatedByLockoutData-lockoutData.recOwner for player "+getFirstName(player)+"("+player+") was " + recOwner);
|
|
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isValidatedByLockoutData-player "+getFirstName(player)+"("+player+") instance_id == recInstance was " + (instance_id == recInstance));
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isValidatedByLockoutData-player "+getFirstName(player)+"("+player+") recOwner == owner was " + (recOwner == owner));
|
|
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "isValidatedByLockoutData-player "+getFirstName(player)+"("+player+") calling return (" +(instance_id == recInstance)+" && " + (recOwner == owner)+")");
|
|
return (instance_id == recInstance && recOwner == owner);
|
|
}
|
|
|
|
dictionary getLockoutData (obj_id player, string instance_name)
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "getLockoutData-started for player "+getFirstName(player)+"("+player+"). instance_name was "+instance_name+".");
|
|
|
|
if (!hasObjVar(player, PLAYER_INSTANCE+"."+instance_name))
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "getLockoutData-player "+getFirstName(player)+"("+player+") does not have the objvar '"+PLAYER_INSTANCE+"."+instance_name+"'. Returning null.");
|
|
return null;
|
|
}
|
|
|
|
string lockoutString = getStringObjVar(player, PLAYER_INSTANCE+"."+instance_name);
|
|
|
|
string[] parse = split(lockoutString, '_');
|
|
|
|
if (parse.length < 4)
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "getLockoutData-player "+getFirstName(player)+"("+player+") Parse length on objvar was less than 4. Returning null.");
|
|
return null;
|
|
}
|
|
|
|
int time = utils.stringToInt(parse[0]);
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "getLockoutData-player "+getFirstName(player)+"("+player+") parsed time was "+time+".");
|
|
obj_id instance_id = utils.stringToObjId(parse[1]);
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "getLockoutData-player "+getFirstName(player)+"("+player+") parsed instance_id was "+instance_id+".");
|
|
obj_id owner = utils.stringToObjId(parse[2]);
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "getLockoutData-player "+getFirstName(player)+"("+player+") parsed owner was "+owner+".");
|
|
int start_time = utils.stringToInt(parse[3]);
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "getLockoutData-player "+getFirstName(player)+"("+player+") parsed start_time was "+start_time+".");
|
|
|
|
if (getCalendarTime() >= time)
|
|
{
|
|
CustomerServiceLog(INSTANCE_DEBUG_LOG, "getLockoutData-player "+getFirstName(player)+"("+player+") calander time was greater than or equal to parsed time. Removing objvar and returning null.");
|
|
removeObjVar(player, PLAYER_INSTANCE+"."+instance_name);
|
|
return null;
|
|
}
|
|
|
|
dictionary dict = new dictionary();
|
|
|
|
dict.put("time", time);
|
|
dict.put("instance_id", instance_id);
|
|
dict.put("owner", owner);
|
|
dict.put("instance_name", instance_name);
|
|
dict.put("start_time", start_time);
|
|
|
|
return dict;
|
|
}
|
|
|
|
dictionary[] getAllLockoutData(obj_id player)
|
|
{
|
|
int numRows = dataTableGetNumRows(INSTANCE_DATATABLE);
|
|
|
|
resizeable dictionary[] instanceData = new dictionary[0];
|
|
|
|
for (int i=0;i<numRows;i++)
|
|
{
|
|
string instanceName = dataTableGetString(INSTANCE_DATATABLE, i, "dungeon");
|
|
|
|
if (hasObjVar(player, PLAYER_INSTANCE+"."+instanceName))
|
|
{
|
|
dictionary data = getLockoutData(player, instanceName);
|
|
if (data != null)
|
|
utils.addElement(instanceData, data);
|
|
}
|
|
}
|
|
|
|
if (instanceData == null || instanceData.length == 0)
|
|
return null;
|
|
|
|
return instanceData;
|
|
}
|
|
void attachInstanceScriptsOnPlayer(obj_id player, dictionary data)
|
|
{
|
|
|
|
if(data == null || data.isEmpty())
|
|
{
|
|
CustomerServiceLog(instance.INSTANCE_DEBUG_LOG, "attachInstanceScriptsOnPlayer-data dictionary was null or empty for player "+player+"("+getPlayerName(player)+"). We are returning here.");
|
|
return;
|
|
}
|
|
string scriptList = data.getString("player_script");
|
|
if (scriptList == "none")
|
|
{
|
|
CustomerServiceLog(instance.INSTANCE_DEBUG_LOG, "attachInstanceScriptsOnPlayer-scriptList was 'none' player "+player+"("+getPlayerName(player)+"). We are returning here.");
|
|
return;
|
|
}
|
|
|
|
string[] parse = split(scriptList, ',');
|
|
|
|
if (parse == null || parse.length == 0)
|
|
{
|
|
CustomerServiceLog(instance.INSTANCE_DEBUG_LOG, "attachInstanceScriptsOnPlayer-script parse list was null for player "+player+"("+getPlayerName(player)+"). We are returning here.");
|
|
return;
|
|
}
|
|
|
|
for (int i=0;i<parse.length;i++)
|
|
{
|
|
if (!hasScript(player, parse[i]))
|
|
{
|
|
CustomerServiceLog(instance.INSTANCE_DEBUG_LOG, "attachInstanceScriptsOnPlayer-player "+player+"("+getPlayerName(player)+") did not have the script '"+parse[i]+"'. It is being attached now.");
|
|
attachScript(player, parse[i]);
|
|
}
|
|
}
|
|
|
|
CustomerServiceLog(instance.INSTANCE_DEBUG_LOG, "attachInstanceScriptsOnPlayer-all scripts have been attached for player "+player+"("+getPlayerName(player)+") returning now.");
|
|
|
|
return;
|
|
}
|
|
|
|
void removeInstanceScriptFromPlayer(obj_id player, dictionary data)
|
|
{
|
|
string scriptList = data.getString("player_script");
|
|
if (scriptList == "none")
|
|
return;
|
|
|
|
string[] parse = split(scriptList, ',');
|
|
|
|
if (parse == null || parse.length == 0)
|
|
return;
|
|
|
|
for (int i=0;i<parse.length;i++)
|
|
{
|
|
if (hasScript(player, parse[i]))
|
|
detachScript(player, parse[i]);
|
|
}
|
|
|
|
}
|
|
|
|
void validateInstanceScriptsOnPlayer(obj_id player)
|
|
{
|
|
string[] allScripts = dataTableGetStringColumn(INSTANCE_DATATABLE, "player_script");
|
|
|
|
for(int i=0;i<allScripts.length;i++)
|
|
{
|
|
if (allScripts[i].equals("none"))
|
|
continue;
|
|
|
|
string[] parse = split(allScripts[i], ',');
|
|
|
|
for (int q=0;q<parse.length;q++)
|
|
{
|
|
if (hasScript(player, parse[q]))
|
|
detachScript(player, parse[q]);
|
|
}
|
|
}
|
|
}
|
|
|
|
obj_id getAreaInstanceController(obj_id base_object)
|
|
{
|
|
string area_name = locations.getBuildoutAreaName(base_object);
|
|
int area_row = locations.getBuildoutAreaRow(base_object);
|
|
|
|
obj_id planet = getPlanetByName(getLocation(base_object).area);
|
|
string instance_controller = ""+area_name+"_"+area_row;
|
|
|
|
obj_id areaInstanceController = utils.hasScriptVar(planet, instance_controller) ? utils.getObjIdScriptVar(planet, instance_controller) : null;
|
|
|
|
return areaInstanceController;
|
|
}
|
|
|
|
boolean[] requestInstancePobGroup(obj_id[] players, string instance_name)
|
|
{
|
|
obj_id ship = space_transition.getContainingShip(players[0]);
|
|
obj_id pilot = space_utils.getPilotForRealsies(ship);
|
|
|
|
boolean[] results = new boolean[players.length];
|
|
|
|
int idx = 0;
|
|
for (int i=0;i<players.length;i++)
|
|
{
|
|
if (players[i] != pilot)
|
|
{
|
|
results[idx] = requestInstanceMovement(players[i], instance_name);
|
|
idx++;
|
|
}
|
|
}
|
|
|
|
dictionary dict = new dictionary();
|
|
dict.put("instance_name", instance_name);
|
|
messageTo(pilot, "delayInstanceRequest", dict, 10.0f, false);
|
|
|
|
results[idx] = true;
|
|
|
|
return results;
|
|
}
|
|
|
|
void playMusicInInstance(obj_id dungeon, string sound)
|
|
{
|
|
obj_id[] players = getPlayersInInstanceArea(dungeon);
|
|
if (players == null || players.length == 0)
|
|
return;
|
|
|
|
for (int r=0;r<players.length;r++)
|
|
{
|
|
playMusic(players[r], sound);
|
|
}
|
|
}
|
|
|
|
void sendInstanceSystemMessage(obj_id dungeon, string_id message)
|
|
{
|
|
obj_id[] players = getPlayersInInstanceArea(dungeon);
|
|
if (players == null || players.length == 0)
|
|
return;
|
|
|
|
utils.sendSystemMessage(players, message);
|
|
}
|
|
|
|
boolean vehicleAllowedInInstance(obj_id instance_id)
|
|
{
|
|
return vehicleAllowedInInstance(getInstanceName(instance_id));
|
|
}
|
|
|
|
boolean vehicleAllowedInInstance(string instance_name)
|
|
{
|
|
return dataTableGetInt(INSTANCE_DATATABLE, instance_name, "vehicle_allowed") == 1;
|
|
}
|
|
|
|
obj_id[] addToPlayerIdList(obj_id instance_id, obj_id player)
|
|
{
|
|
resizeable obj_id[] playerList = new obj_id[0];
|
|
|
|
if (utils.hasScriptVar(instance_id, PLAYER_ID_LIST))
|
|
playerList = utils.getResizeableObjIdArrayScriptVar(instance_id, PLAYER_ID_LIST);
|
|
|
|
if (playerList == null || playerList.length == 0)
|
|
{
|
|
playerList.add(player);
|
|
utils.setScriptVar(instance_id, PLAYER_ID_LIST, playerList);
|
|
return playerList;
|
|
}
|
|
|
|
if (!playerList.contains(player))
|
|
playerList.add(player);
|
|
|
|
utils.setScriptVar(instance_id, PLAYER_ID_LIST, playerList);
|
|
|
|
return playerList;
|
|
}
|
|
|
|
obj_id[] removeFromPlayerIdList(obj_id instance_id, obj_id player)
|
|
{
|
|
resizeable obj_id[] playerList = new obj_id[0];
|
|
|
|
if (utils.hasScriptVar(instance_id, PLAYER_ID_LIST))
|
|
playerList = utils.getResizeableObjIdArrayScriptVar(instance_id, PLAYER_ID_LIST);
|
|
|
|
if (playerList == null || playerList.length == 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
if (playerList.contains(player))
|
|
{
|
|
playerList.remove(player);
|
|
}
|
|
|
|
utils.setScriptVar(instance_id, PLAYER_ID_LIST, playerList);
|
|
return playerList;
|
|
}
|
|
|
|
obj_id[] getPlayerIdList(obj_id instance_id)
|
|
{
|
|
resizeable obj_id[] playerList = utils.hasScriptVar(instance_id, PLAYER_ID_LIST) ? utils.getResizeableObjIdArrayScriptVar(instance_id, PLAYER_ID_LIST) : null;
|
|
obj_id[] newList = playerList;
|
|
return playerList;
|
|
}
|
|
|
|
resizeable obj_id[] getResizeablePlayerIdList(obj_id instance_id)
|
|
{
|
|
return utils.hasScriptVar(instance_id, PLAYER_ID_LIST) ? utils.getResizeableObjIdArrayScriptVar(instance_id, PLAYER_ID_LIST) : null;
|
|
}
|
|
|
|
boolean isPlayerInPlayerList(obj_id instance_id, obj_id player)
|
|
{
|
|
resizeable obj_id[] playerList = getResizeablePlayerIdList(instance_id);
|
|
return playerList.contains(player);
|
|
}
|
|
|
|
void setRequestPending(obj_id player)
|
|
{
|
|
buff.applyBuff(player, REQUEST_BUFF);
|
|
}
|
|
|
|
void setRequestResolved(obj_id player)
|
|
{
|
|
buff.removeBuff(player, REQUEST_BUFF);
|
|
}
|
|
|
|
boolean isRequestPending(obj_id player)
|
|
{
|
|
return buff.hasBuff(player, REQUEST_BUFF);
|
|
}
|
|
|
|
void doLogging(string message)
|
|
{
|
|
LOG("doLogging/library.instance", message);
|
|
}
|
|
|
|
void doLogging(string section, string message)
|
|
{
|
|
LOG("doLogging/library.instance/"+section, message);
|
|
}
|