mirror of
https://github.com/SWG-Source/dsrc.git
synced 2026-07-31 00:15:54 -04:00
2212 lines
66 KiB
Plaintext
2212 lines
66 KiB
Plaintext
include library.ai_lib;
|
|
include library.city;
|
|
include library.beast_lib;
|
|
include library.instance;
|
|
include library.pet_lib;
|
|
include library.player_structure;
|
|
include library.space_utils;
|
|
include library.utils;
|
|
|
|
const string STORYTELLER_DATATABLE = "datatables/item/master_item/storyteller_item.iff";
|
|
const string STATIC_ITEM_DATATABLE = "datatables/item/master_item/master_item.iff";
|
|
|
|
const string THEATER_MODE = "theater_mode";
|
|
|
|
const string EFFECT_TOKEN_NAME = "storytellerEffectName";
|
|
const string EFFECT_ACTIVE_OBJVAR = "storytellerPersistedEffectActive";
|
|
|
|
const string STORYTELLER_THEATER_CONTROL_SCRIPT = "systems.storyteller.theater_controller";
|
|
const string STORYTELLER_PROP_CONTROL_SCRIPT = "systems.storyteller.prop_controller";
|
|
const string STORYTELLER_NPC_CONTROL_SCRIPT = "systems.storyteller.npc_controller";
|
|
|
|
const string STORYTELLER_DAILY_COUNT_OBJVAR = "storytellerToken.dailyCount";
|
|
const string STORYTELLER_DAILY_COUNT_RESET = "storytellerToken.dailyResetTime";
|
|
|
|
const string STORYTELLER_OBJECT_OBJVAR = "storytellerid";
|
|
|
|
const int BLUEPRINT_MAX_NUM_OBJECTS = 200;
|
|
const float BLUEPRINT_DEFAULT_RADIUS = 100.0f;
|
|
const string BLUEPRINT_OBJECTS_OBJVAR = "blueprintObjects";
|
|
const string BLUEPRINT_AUTHOR_OBJVAR = "blueprintAuthor";
|
|
const string BLUEPRINT_AUTHOR_NAME_OBJVAR = "blueprintAuthorName";
|
|
const string BLUEPRINT_DECRIPTION_OBJVAR = "blueprintDescription";
|
|
|
|
const int BLUEPRINT_CREATE_CYCLE_MAX = 30;
|
|
const int BLUEPRINT_CREATE_CYCLE_LOOP = 25;
|
|
|
|
const int BLUEPRINT_VERSION_NUM = 1;
|
|
const string BLUEPRINT_VERSION_OBJVAR = "blueprintVersion";
|
|
|
|
const int BLUEPRINT_TOKEN_LOADED = 1;
|
|
const int BLUEPRINT_TOKEN_NEEDED = 0;
|
|
|
|
const int PROP = 0;
|
|
const int STATIC_EFFECT = 1;
|
|
const int IMMEDIATE_EFFECT = 2;
|
|
const int COMBAT_NPC = 3;
|
|
const int FLAVOR_NPC = 4;
|
|
const int OTHER = 5;
|
|
const int COSTUME = 6;
|
|
const int THEATER = 7;
|
|
|
|
const int DEFAULT_PROP_CLEANUP_TIME = 16*60*60;//16 hours
|
|
const int DEFAULT_NPC_CLEANUP_TIME = 16*60*60;//16 hours
|
|
|
|
const string VAR_AUTODECLINE_STORY_INVITES = "decline_story_invites";
|
|
|
|
|
|
int getTokenType (obj_id token)
|
|
{
|
|
return dataTableGetInt(STORYTELLER_DATATABLE, getStaticItemName(token), "type");
|
|
}
|
|
|
|
int getTokenType (string tokenName)
|
|
{
|
|
return dataTableGetInt(STORYTELLER_DATATABLE, tokenName, "type");
|
|
}
|
|
|
|
boolean isProp(obj_id token)
|
|
{
|
|
return (dataTableGetInt(STORYTELLER_DATATABLE, getStaticItemName(token), "type") == PROP);
|
|
}
|
|
|
|
boolean isAnyNpc(obj_id token)
|
|
{
|
|
return (isFlavorNpc(token) || isCombatNpc(token));
|
|
}
|
|
|
|
boolean isFlavorNpc(obj_id token)
|
|
{
|
|
return (dataTableGetInt(STORYTELLER_DATATABLE, getStaticItemName(token), "type") == FLAVOR_NPC);
|
|
}
|
|
|
|
boolean isFlavorNpc(string tokenName)
|
|
{
|
|
return (dataTableGetInt(STORYTELLER_DATATABLE, tokenName, "type") == FLAVOR_NPC);
|
|
}
|
|
|
|
boolean isCombatNpc(obj_id token)
|
|
{
|
|
return (dataTableGetInt(STORYTELLER_DATATABLE, getStaticItemName(token), "type") == COMBAT_NPC);
|
|
}
|
|
|
|
boolean isAnyEffect(string st_effect_token)
|
|
{
|
|
return (isStaticEffect(st_effect_token) || isImmediateEffect(st_effect_token));
|
|
}
|
|
boolean isAnyEffect(obj_id token)
|
|
{
|
|
return (isStaticEffect(token) || isImmediateEffect(token));
|
|
}
|
|
|
|
boolean isStaticEffect(string st_effect_token)
|
|
{
|
|
return (dataTableGetInt(STORYTELLER_DATATABLE, st_effect_token, "type") == STATIC_EFFECT);
|
|
}
|
|
|
|
boolean isStaticEffect(obj_id token)
|
|
{
|
|
return (dataTableGetInt(STORYTELLER_DATATABLE, getStaticItemName(token), "type") == STATIC_EFFECT);
|
|
}
|
|
|
|
boolean isImmediateEffect(string st_effect_token)
|
|
{
|
|
return (dataTableGetInt(STORYTELLER_DATATABLE, st_effect_token, "type") == IMMEDIATE_EFFECT);
|
|
}
|
|
|
|
boolean isImmediateEffect(obj_id token)
|
|
{
|
|
return (dataTableGetInt(STORYTELLER_DATATABLE, getStaticItemName(token), "type") == IMMEDIATE_EFFECT);
|
|
}
|
|
|
|
boolean isTheater(obj_id token)
|
|
{
|
|
return (dataTableGetInt(STORYTELLER_DATATABLE, getStaticItemName(token), "type") == THEATER);
|
|
}
|
|
|
|
boolean isOther(obj_id token)
|
|
{
|
|
return (dataTableGetInt(STORYTELLER_DATATABLE, getStaticItemName(token), "type") == OTHER);
|
|
}
|
|
|
|
boolean isAnyStorytellerItem(obj_id token)
|
|
{
|
|
return (dataTableGetInt(STORYTELLER_DATATABLE, getStaticItemName(token), "type") != -1);
|
|
}
|
|
|
|
string getEffectName(string st_effect_name)
|
|
{
|
|
return dataTableGetString(STORYTELLER_DATATABLE, st_effect_name, "template_name");
|
|
}
|
|
|
|
string getNpcTemplate(obj_id token)
|
|
{
|
|
return dataTableGetString(STORYTELLER_DATATABLE, getStaticItemName(token), "template_name");
|
|
}
|
|
|
|
string getNpcTemplate(string tokenName)
|
|
{
|
|
return dataTableGetString(STORYTELLER_DATATABLE, tokenName, "template_name");
|
|
}
|
|
|
|
float getTheaterBuildoutRadius(obj_id theater)
|
|
{
|
|
return dataTableGetFloat(STORYTELLER_DATATABLE, getStaticItemName(theater), "buildout_radius");
|
|
}
|
|
|
|
obj_id createTheaterObject(obj_id token, boolean inBuildout)
|
|
{
|
|
obj_id player = getTopMostContainer(token);
|
|
if (!isPlayer(player))
|
|
return null;
|
|
|
|
float yaw = getYaw(player);
|
|
return createTheaterObject(token, inBuildout, getLocation(player), yaw);
|
|
|
|
}
|
|
|
|
obj_id createTheaterObject(obj_id token, boolean inBuildout, location createLoc, float yaw)
|
|
{
|
|
string itemName = getStaticItemName(token);
|
|
dictionary dict = new dictionary();
|
|
|
|
int row = dataTableSearchColumnForString( itemName , "name", storyteller.STORYTELLER_DATATABLE);
|
|
if (row == -1)
|
|
return null;
|
|
|
|
dict = dataTableGetRow(storyteller.STORYTELLER_DATATABLE, itemName);
|
|
string template = dict.getString("template_name");
|
|
string objVarString = dict.getString("objvar");
|
|
string scriptString = dict.getString("scripts");
|
|
|
|
|
|
|
|
obj_id theater = create.object(template, createLoc);
|
|
setYaw(theater, yaw);
|
|
|
|
if (!isIdValid(theater))
|
|
return null;
|
|
|
|
static_item.setObjVarString(theater, objVarString);
|
|
static_item.setScriptString(theater, scriptString);
|
|
setStaticItemName(theater, getStaticItemName(token));
|
|
setObjVar(theater, storyteller.THEATER_MODE, inBuildout);
|
|
attachScript(theater, STORYTELLER_THEATER_CONTROL_SCRIPT);
|
|
destroyObject(token);
|
|
return theater;
|
|
|
|
}
|
|
|
|
obj_id createPropObject(obj_id token, boolean inBuildout)
|
|
{
|
|
obj_id player = utils.getContainingPlayer(token);
|
|
if (!isIdValid(player))
|
|
return null;
|
|
|
|
float yaw = getYaw(player);
|
|
return createPropObject(token, player, inBuildout, getLocation(player), yaw);
|
|
}
|
|
|
|
obj_id createPropObject(obj_id token, obj_id player, boolean inBuildout, location createLoc, float yaw)
|
|
{
|
|
obj_id prop = null;
|
|
|
|
if ( canDeployStorytellerToken(player, createLoc, token) )
|
|
{
|
|
string itemName = getStaticItemName(token);
|
|
dictionary dict = new dictionary();
|
|
dictionary dict_m = new dictionary();
|
|
int row = dataTableSearchColumnForString( itemName , "name", STORYTELLER_DATATABLE);
|
|
if (row == -1)
|
|
return null;
|
|
|
|
dict = dataTableGetRow(STORYTELLER_DATATABLE, itemName);
|
|
string template = dict.getString("template_name");
|
|
string objVarString = dict.getString("objvar");
|
|
string scriptString = dict.getString("scripts");
|
|
dict_m = dataTableGetRow(STATIC_ITEM_DATATABLE, itemName);
|
|
string finalName = dict_m.getString("string_name");
|
|
|
|
prop = create.object(template, createLoc);
|
|
if ( isIdValid(prop) )
|
|
{
|
|
setYaw(prop, yaw);
|
|
setInvulnerable(prop, true);
|
|
|
|
static_item.setObjVarString(prop, objVarString);
|
|
static_item.setScriptString(prop, scriptString);
|
|
setStaticItemName(prop, getStaticItemName(token));
|
|
|
|
if ( utils.hasScriptVar(player, "storytellerAssistant") )
|
|
{
|
|
obj_id storytellerId = utils.getObjIdScriptVar(player, "storytellerAssistant");
|
|
string storytellerName = utils.getStringScriptVar(player, "storytellerAssistantName");
|
|
setObjVar(prop, "storytellerid", storytellerId);
|
|
setObjVar(prop, "storytellerName", storytellerName);
|
|
|
|
}
|
|
else
|
|
{
|
|
setObjVar(prop, "storytellerid", player);
|
|
setObjVar(prop, "storytellerName", getName(player));
|
|
}
|
|
|
|
setObjVar(prop, "storytellerCreationLoc", createLoc);
|
|
setObjVar(prop, "storytellerTokenName", itemName);
|
|
|
|
attachScript(prop, STORYTELLER_PROP_CONTROL_SCRIPT);
|
|
setName(prop, finalName);
|
|
|
|
handleTokenUsage(token);
|
|
|
|
string logMsg = "("+player+")"+getName(player)+" is deploying a prop storyteller token: "+getStaticItemName(token)+" at "+createLoc;
|
|
CustomerServiceLog("storyteller", logMsg);
|
|
}
|
|
}
|
|
return prop;
|
|
|
|
}
|
|
|
|
obj_id createPropObjectNoToken(string tokenName, obj_id player, boolean inBuildout, location createLoc, float yaw)
|
|
{
|
|
obj_id prop = null;
|
|
|
|
if ( canDeployStorytellerToken(player, createLoc, tokenName) )
|
|
{
|
|
dictionary dict = new dictionary();
|
|
dictionary dict_m = new dictionary();
|
|
int row = dataTableSearchColumnForString( tokenName , "name", STORYTELLER_DATATABLE);
|
|
if (row == -1)
|
|
return null;
|
|
|
|
dict = dataTableGetRow(STORYTELLER_DATATABLE, tokenName);
|
|
string template = dict.getString("template_name");
|
|
string objVarString = dict.getString("objvar");
|
|
string scriptString = dict.getString("scripts");
|
|
dict_m = dataTableGetRow(STATIC_ITEM_DATATABLE, tokenName);
|
|
string finalName = dict_m.getString("string_name");
|
|
|
|
prop = create.object(template, createLoc);
|
|
if ( isIdValid(prop) )
|
|
{
|
|
setYaw(prop, yaw);
|
|
setInvulnerable(prop, true);
|
|
|
|
static_item.setObjVarString(prop, objVarString);
|
|
static_item.setScriptString(prop, scriptString);
|
|
setStaticItemName(prop, tokenName);
|
|
|
|
if ( utils.hasScriptVar(player, "storytellerAssistant") )
|
|
{
|
|
obj_id storytellerId = utils.getObjIdScriptVar(player, "storytellerAssistant");
|
|
string storytellerName = utils.getStringScriptVar(player, "storytellerAssistantName");
|
|
setObjVar(prop, "storytellerid", storytellerId);
|
|
setObjVar(prop, "storytellerName", storytellerName);
|
|
|
|
}
|
|
else
|
|
{
|
|
setObjVar(prop, "storytellerid", player);
|
|
setObjVar(prop, "storytellerName", getName(player));
|
|
}
|
|
|
|
setObjVar(prop, "storytellerCreationLoc", createLoc);
|
|
setObjVar(prop, "storytellerTokenName", tokenName);
|
|
|
|
attachScript(prop, STORYTELLER_PROP_CONTROL_SCRIPT);
|
|
setName(prop, finalName);
|
|
|
|
string logMsg = "("+player+")"+getName(player)+" is deploying a prop storyteller token: "+tokenName+" at "+createLoc;
|
|
CustomerServiceLog("storyteller", logMsg);
|
|
}
|
|
}
|
|
return prop;
|
|
|
|
}
|
|
|
|
obj_id createNpcAtLocation(obj_id token)
|
|
{
|
|
obj_id player = utils.getContainingPlayer(token);
|
|
float yaw = getYaw(player);
|
|
return createNpcAtLocation(token, player, getLocation(player), yaw);
|
|
}
|
|
|
|
obj_id createNpcAtLocation(obj_id token, obj_id player, location createLoc, float yaw)
|
|
{
|
|
obj_id npc = null;
|
|
|
|
if ( canDeployStorytellerToken(player, createLoc, token) )
|
|
{
|
|
string toCreate = storyteller.getNpcTemplate(token);
|
|
|
|
npc = create.object(toCreate, createLoc);
|
|
if ( isIdValid(npc) )
|
|
{
|
|
if ( utils.hasScriptVar(player, "storytellerAssistant") )
|
|
{
|
|
obj_id storytellerId = utils.getObjIdScriptVar(player, "storytellerAssistant");
|
|
string storytellerName = utils.getStringScriptVar(player, "storytellerAssistantName");
|
|
setObjVar(npc, "storytellerid", storytellerId);
|
|
setObjVar(npc, "storytellerName", storytellerName);
|
|
}
|
|
else
|
|
{
|
|
setObjVar(npc, "storytellerid", player);
|
|
setObjVar(npc, "storytellerName", getName(player));
|
|
}
|
|
|
|
setObjVar(npc, "storytellerCreationLoc", createLoc);
|
|
setObjVar(npc, "storytellerTokenName", getStaticItemName(token));
|
|
|
|
setYaw(npc, yaw);
|
|
|
|
setStaticItemName(npc, getStaticItemName(token));
|
|
|
|
if (storyteller.isFlavorNpc(token))
|
|
setInvulnerable(npc, true);
|
|
|
|
ai_lib.setDefaultCalmBehavior(npc, ai_lib.BEHAVIOR_SENTINEL);
|
|
|
|
if ( hasObjVar(token, "storytellerNpcCombatLevel") )
|
|
{
|
|
int storytellerNpcCombatLevel = getIntObjVar(token, "storytellerNpcCombatLevel");
|
|
if (storytellerNpcCombatLevel < 1 || storytellerNpcCombatLevel > 90)
|
|
{
|
|
storytellerNpcCombatLevel = 1;
|
|
}
|
|
dictionary creatureDict = utils.dataTableGetRow(create.CREATURE_TABLE, toCreate);
|
|
if ( creatureDict != null )
|
|
{
|
|
create.initializeCreature(npc, toCreate, creatureDict, storytellerNpcCombatLevel);
|
|
}
|
|
}
|
|
|
|
attachScript(npc, STORYTELLER_NPC_CONTROL_SCRIPT);
|
|
|
|
string logMsg = "("+player+")"+getName(player)+" is deploying an npc storyteller token: "+getStaticItemName(token)+" at "+createLoc;
|
|
CustomerServiceLog("storyteller", logMsg);
|
|
}
|
|
}
|
|
return npc;
|
|
}
|
|
|
|
obj_id createNpcAtLocationNoToken(string tokenName, obj_id player, location createLoc, float yaw)
|
|
{
|
|
return createNpcAtLocationNoToken(tokenName, player, createLoc, yaw, 0);
|
|
}
|
|
|
|
obj_id createNpcAtLocationNoToken(string tokenName, obj_id player, location createLoc, float yaw, int combatLevel)
|
|
{
|
|
return createNpcAtLocationNoToken(tokenName, player, createLoc, yaw, combatLevel, 0);
|
|
}
|
|
|
|
obj_id createNpcAtLocationNoToken(string tokenName, obj_id player, location createLoc, float yaw, int combatLevel, int difficulty)
|
|
{ obj_id npc = null;
|
|
|
|
if ( canDeployStorytellerToken(player, createLoc, tokenName) )
|
|
{
|
|
string toCreate = storyteller.getNpcTemplate(tokenName);
|
|
|
|
npc = create.object(toCreate, createLoc);
|
|
if ( isIdValid(npc) )
|
|
{
|
|
if ( utils.hasScriptVar(player, "storytellerAssistant") )
|
|
{
|
|
obj_id storytellerId = utils.getObjIdScriptVar(player, "storytellerAssistant");
|
|
string storytellerName = utils.getStringScriptVar(player, "storytellerAssistantName");
|
|
setObjVar(npc, "storytellerid", storytellerId);
|
|
setObjVar(npc, "storytellerName", storytellerName);
|
|
}
|
|
else
|
|
{
|
|
setObjVar(npc, "storytellerid", player);
|
|
setObjVar(npc, "storytellerName", getName(player));
|
|
}
|
|
|
|
setObjVar(npc, "storytellerCreationLoc", createLoc);
|
|
setObjVar(npc, "storytellerTokenName", tokenName);
|
|
|
|
setYaw(npc, yaw);
|
|
|
|
setStaticItemName(npc, tokenName);
|
|
|
|
if (storyteller.isFlavorNpc(tokenName))
|
|
setInvulnerable(npc, true);
|
|
|
|
ai_lib.setDefaultCalmBehavior(npc, ai_lib.BEHAVIOR_SENTINEL);
|
|
|
|
if ( combatLevel > 0 )
|
|
{
|
|
if ( combatLevel > 90)
|
|
combatLevel = 90;
|
|
|
|
dictionary creatureDict = utils.dataTableGetRow(create.CREATURE_TABLE, toCreate);
|
|
if ( creatureDict != null )
|
|
{
|
|
creatureDict.put("difficultyClass", difficulty);
|
|
create.initializeCreature(npc, toCreate, creatureDict, combatLevel);
|
|
setNpcDifficulty(npc, difficulty);
|
|
}
|
|
}
|
|
|
|
attachScript(npc, STORYTELLER_NPC_CONTROL_SCRIPT);
|
|
|
|
string logMsg = "("+player+")"+getName(player)+" is deploying an npc storyteller token: "+tokenName+" at "+createLoc;
|
|
CustomerServiceLog("storyteller", logMsg);
|
|
}
|
|
}
|
|
return npc;
|
|
}
|
|
|
|
boolean isStorytellerNpc(obj_id npc)
|
|
{
|
|
return hasObjVar(npc, "storytellerid");
|
|
}
|
|
|
|
boolean isStorytellerObject(obj_id object)
|
|
{
|
|
return hasObjVar(object, "storytellerid");
|
|
}
|
|
|
|
void removeStorytellerPersistedEffect(obj_id self)
|
|
{
|
|
obj_id[] players = getPlayerCreaturesInRange(getLocation(self), 165.0f);
|
|
if (players != null || players.length > 0)
|
|
{
|
|
stopClientEffectObjByLabel(players, self, "storyteller_persisted_effect", false);
|
|
removeObjVar(self, storyteller.EFFECT_ACTIVE_OBJVAR);
|
|
removeTriggerVolume("storytellerPersistedEffect");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
boolean allowTokenPlacementInInteriors(obj_id token)
|
|
{
|
|
return allowTokenPlacementInInteriors(getStaticItemName(token));
|
|
}
|
|
|
|
boolean allowTokenPlacementInInteriors(string tokenName)
|
|
{
|
|
int allowInInteriors = dataTableGetInt(STORYTELLER_DATATABLE, tokenName, "allow_interior");
|
|
return allowInInteriors == 1;
|
|
}
|
|
|
|
obj_id getStorytellerBeingAssisted(obj_id player)
|
|
{
|
|
obj_id storytellerBeingAssisted = null;
|
|
|
|
if ( utils.hasScriptVar(player, "storytellerAssistant"))
|
|
{
|
|
storytellerBeingAssisted = utils.getObjIdScriptVar(player, "storytellerAssistant");
|
|
}
|
|
|
|
return storytellerBeingAssisted;
|
|
}
|
|
|
|
location rotateLocationXZ(location locOrigin, location locPoint, float fltAngle)
|
|
{
|
|
float dx = locPoint.x - locOrigin.x;
|
|
float dz = locPoint.z - locOrigin.z;
|
|
|
|
float fltRadians = (float)Math.toRadians(fltAngle);
|
|
float fltC = (float)Math.cos(fltRadians);
|
|
float fltS = (float) Math.sin(fltRadians);
|
|
|
|
location locNewOffset = locOrigin;
|
|
|
|
locNewOffset.x += (dx * fltC) + (dz * fltS);
|
|
locNewOffset.y = locPoint.y;
|
|
locNewOffset.z += -(dx * fltS) + (dz * fltC);
|
|
|
|
return locNewOffset;
|
|
}
|
|
|
|
//***********************************************************************
|
|
// Daily Usage (daily_uses column in storyteller_item.tab)
|
|
// if -1, the token may be used without limit (this is pretty much just for event team tokens)
|
|
// if 0, the token expends charges and is destroyed when all uses are expended
|
|
// if > 0, the token is never destroyed, but has a limited number of uses per day as defined by daily_uses
|
|
int getTokenDailyUsageAmount(obj_id token)
|
|
{
|
|
return getTokenDailyUsageAmount(getStaticItemName(token));
|
|
}
|
|
|
|
int getTokenDailyUsageAmount(string tokenName)
|
|
{
|
|
return dataTableGetInt(STORYTELLER_DATATABLE, tokenName, "daily_uses");
|
|
}
|
|
|
|
boolean isTokenFlaggedWithDailyUsage(obj_id token)
|
|
{
|
|
return isTokenFlaggedWithDailyUsage(getStaticItemName(token));
|
|
}
|
|
|
|
boolean isTokenFlaggedWithDailyUsage(string tokenName)
|
|
{
|
|
int dailyUses = getTokenDailyUsageAmount(tokenName);
|
|
if ( dailyUses > 0 )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
int getTokenDailyUsesAvailable(obj_id token)
|
|
{
|
|
int num = 0;
|
|
if ( isTokenFlaggedWithDailyUsage(getStaticItemName(token)) )
|
|
{
|
|
int dailyUses = getTokenDailyUsageAmount(token);
|
|
if ( dailyUses < 0 )
|
|
{
|
|
num = 9999;
|
|
}
|
|
else if ( hasObjVar(token, STORYTELLER_DAILY_COUNT_OBJVAR) )
|
|
{
|
|
int usedUses = getIntObjVar(token, STORYTELLER_DAILY_COUNT_OBJVAR);
|
|
num = dailyUses - usedUses;
|
|
}
|
|
else
|
|
{
|
|
num = dailyUses;
|
|
}
|
|
}
|
|
|
|
return num;
|
|
}
|
|
|
|
boolean hasTokenUsesAvailable(obj_id token)
|
|
{
|
|
int num = 0;
|
|
if ( isTokenFlaggedWithDailyUsage(getStaticItemName(token)) )
|
|
{
|
|
num = getTokenDailyUsesAvailable(token);
|
|
if ( num > 0 )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void handleTokenUsage(obj_id token)
|
|
{
|
|
int dailyUses = getTokenDailyUsageAmount(token);
|
|
if ( dailyUses == 0 )
|
|
{
|
|
decrementCount(token);
|
|
}
|
|
else if ( dailyUses > 0 )
|
|
{
|
|
int dailyCount = 1;
|
|
if ( hasObjVar(token, STORYTELLER_DAILY_COUNT_OBJVAR) )
|
|
{
|
|
dailyCount = getIntObjVar(token, STORYTELLER_DAILY_COUNT_OBJVAR) + 1;
|
|
}
|
|
|
|
setObjVar(token, STORYTELLER_DAILY_COUNT_OBJVAR, dailyCount);
|
|
sendDirtyAttributesNotification(token);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void resetTokenDailyCount(obj_id token)
|
|
{
|
|
if ( isTokenFlaggedWithDailyUsage(token) )
|
|
{
|
|
if ( !hasObjVar(token, storyteller.STORYTELLER_DAILY_COUNT_RESET) )
|
|
{
|
|
setTokenDailyCountResetTime(token);
|
|
}
|
|
else
|
|
{
|
|
int currentTime = getCalendarTime();
|
|
int alarmTime = getIntObjVar(token, storyteller.STORYTELLER_DAILY_COUNT_RESET);
|
|
if ( currentTime >= alarmTime )
|
|
{
|
|
setTokenDailyCountResetTime(token);
|
|
|
|
if ( hasObjVar(token, STORYTELLER_DAILY_COUNT_OBJVAR) )
|
|
{
|
|
removeObjVar(token, STORYTELLER_DAILY_COUNT_OBJVAR);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
void setTokenDailyCountResetTime(obj_id token)
|
|
{
|
|
int currentTime = getCalendarTime();
|
|
int timeUntilAlarm = createDailyAlarmClock(token, "storytellerEffectTokenDailyAlarm", null, 4, 0, 0);
|
|
int alarmStamp = currentTime + timeUntilAlarm;
|
|
setObjVar(token, storyteller.STORYTELLER_DAILY_COUNT_RESET, alarmStamp);
|
|
return;
|
|
}
|
|
|
|
//***********************************************************************
|
|
boolean canDeployStorytellerToken(obj_id player, location here, obj_id token)
|
|
{
|
|
if ( !storyteller.hasTokenUsesAvailable(token) )
|
|
{
|
|
sendSystemMessage(player, new string_id("storyteller", "placement_daily_uses_expended"));
|
|
return false;
|
|
}
|
|
|
|
return canDeployStorytellerToken(player, here, getStaticItemName(token));
|
|
}
|
|
|
|
boolean canDeployStorytellerToken(obj_id player, location here, string tokenName)
|
|
{
|
|
if( !isIdValid(player) || here == null )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// God mode override to allow event team to place storyteller items with more freedom
|
|
if ( isGod(player) )
|
|
{
|
|
string logMsg = "("+player+")"+getName(player)+" is using GodMode override to deploy or movea storyteller object: "+tokenName+" at "+here;
|
|
CustomerServiceLog("storyteller", logMsg);
|
|
|
|
if ( !utils.hasScriptVar(player, "storyteller.godModeStopOverrideMessages") )
|
|
{
|
|
sendSystemMessage(player, new string_id("storyteller", "placement_god_mode"));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if( isFreeTrialAccount(player) )
|
|
{
|
|
sendSystemMessage(player, new string_id("storyteller", "placement_no_trial_accounts"));
|
|
return false;
|
|
}
|
|
|
|
obj_id myCell = here.cell;
|
|
obj_id myContainer = getTopMostContainer(myCell);
|
|
obj_id storytellerBeingAssisted = getStorytellerBeingAssisted(player);
|
|
if ( !isIdValid(storytellerBeingAssisted) )
|
|
{
|
|
storytellerBeingAssisted = player;
|
|
}
|
|
|
|
// At this point in time, storyteller objects are not allowed in any instances.
|
|
if ( instance.isInInstanceArea(player) )
|
|
{
|
|
sendSystemMessage(player, new string_id("storyteller", "placement_not_in_this_location"));
|
|
return false;
|
|
}
|
|
|
|
// *************************************************
|
|
// SPACE
|
|
// block all storyteller object placement in space
|
|
// unless the object is flagged as allowed in interiors and is in a player pob ship
|
|
string planet = here.area;
|
|
if( planet.startsWith("space_") )
|
|
{
|
|
if ( isIdValid(myCell) && allowTokenPlacementInInteriors(tokenName) )
|
|
{
|
|
obj_id owner= getOwner(myContainer);
|
|
if ( !isIdValid(owner) || owner != player || owner != storytellerBeingAssisted )
|
|
{
|
|
sendSystemMessage(player, new string_id("storyteller", "placement_not_ship_owner"));
|
|
return false;
|
|
}
|
|
|
|
if ( getState(player, STATE_SHIP_INTERIOR) != 1 || space_utils.isInStation(player) )
|
|
{
|
|
sendSystemMessage(player, new string_id("storyteller", "placement_not_in_station"));
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessage(player, new string_id("storyteller", "placement_not_in_space"));
|
|
return false;
|
|
}
|
|
}
|
|
// *************************************************
|
|
else
|
|
{
|
|
// *************************************************
|
|
// INTERIORS - inside of a pob
|
|
// block storyteller object placement inside of buildings
|
|
// unless the object is flagged as allowed in interiors
|
|
if( isIdValid(myCell) )
|
|
{
|
|
if ( !allowTokenPlacementInInteriors(tokenName) )
|
|
{
|
|
sendSystemMessage(player, new string_id("storyteller", "placement_not_in_a_building"));
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if ( !player_structure.isAdmin(myContainer, player) && !player_structure.isAdmin(myContainer, storytellerBeingAssisted) )
|
|
{
|
|
sendSystemMessage(player, new string_id("storyteller", "placement_not_building_admin"));
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
// *************************************************
|
|
// Not inside of a building
|
|
else
|
|
{
|
|
// block storyteller object placement on adventure planets
|
|
if ( planet.equals("mustafar") || planet.startsWith("kashyyyk") )
|
|
{
|
|
sendSystemMessage(player, new string_id("storyteller", "placement_not_on_blocked_planet"));
|
|
return false;
|
|
}
|
|
|
|
// block storyteller object placement in nobuild regions
|
|
region[] rgnTest = getRegionsWithBuildableAtPoint(here, regions.BUILD_FALSE );
|
|
if ( rgnTest != null )
|
|
{
|
|
// There are regions at this location with buildable set to true.
|
|
sendSystemMessage(player, new string_id("storyteller", "placement_not_in_municipal_zone"));
|
|
return false;
|
|
}
|
|
|
|
// block storyteller object placement in storyteller blocking regions
|
|
// (any regions with "storytellerblocked" in its name)
|
|
if ( isInStorytellerBlockedRegion(here) )
|
|
{
|
|
sendSystemMessage(player, new string_id("storyteller", "placement_not_in_this_location"));
|
|
return false;
|
|
}
|
|
|
|
// block storyteller object placement on player structure roofs and balconies
|
|
// unless the object is flagged as allowed in interiors
|
|
obj_id whatAmIStandingOn = getStandingOn(player);
|
|
if( isIdValid(whatAmIStandingOn) && player_structure.isBuilding(whatAmIStandingOn) )
|
|
{
|
|
sendSystemMessage(player, new string_id("storyteller", "placement_not_on_a_building"));
|
|
return false;
|
|
}
|
|
|
|
// city or outpost
|
|
// if you are inside of a cell, permission checks have already been made.
|
|
if( locations.isInMissionCity(here) )
|
|
{
|
|
int city_id = getCityAtLocation(here, 0);
|
|
|
|
// It's an NPC city
|
|
if(city_id == 0)
|
|
{
|
|
sendSystemMessage(player, new string_id("storyteller", "placement_not_in_municipal_zone"));
|
|
return false;
|
|
}
|
|
|
|
// Zoning rights for player city
|
|
if ( cityExists(city_id) && city.isCityZoned(city_id) && isIdValid(player))
|
|
{
|
|
if(!city.hasStorytellerZoningRights(player, city_id))
|
|
{
|
|
sendSystemMessage(player, new string_id("storyteller", "placement_no_zoning_rights"));
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
boolean isInStorytellerBlockedRegion(location here)
|
|
{
|
|
region[] regionsHere = getRegionsAtPoint(here);
|
|
if ( regionsHere != null && regionsHere.length > 0 )
|
|
{
|
|
for ( int i = 0; i < regionsHere.length; i++ )
|
|
{
|
|
region testRegion = regionsHere[i];
|
|
string regionName = testRegion.getName();
|
|
|
|
int nameCheck = regionName.indexOf("storytellerblocked");
|
|
if ( nameCheck > -1 )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
boolean allowedToSeeStorytellerObject(obj_id object, obj_id player)
|
|
{
|
|
obj_id storyteller = getObjIdObjVar(object, "storytellerid");
|
|
if ( isIdValid(storyteller) )
|
|
{
|
|
if (allowedToUseStorytellerObject(object, player) )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if ( utils.hasScriptVar(player, "storytellerid") )
|
|
{
|
|
obj_id playersStoryteller = utils.getObjIdScriptVar(player, "storytellerid");
|
|
if ( isIdValid(playersStoryteller) && storyteller == playersStoryteller )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
boolean allowedToUseStorytellerObject(obj_id object, obj_id player)
|
|
{
|
|
obj_id storyteller = getObjIdObjVar(object, "storytellerid");
|
|
if ( isIdValid(storyteller) )
|
|
{
|
|
if ( storyteller == player )
|
|
{
|
|
return true;
|
|
}
|
|
else if ( utils.hasScriptVar(player, "storytellerAssistant") )
|
|
{
|
|
obj_id whoAmIAssisting = utils.getObjIdScriptVar(player, "storytellerAssistant");
|
|
if ( isIdValid(whoAmIAssisting) && storyteller == whoAmIAssisting )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
boolean inSameStory(obj_id target1, obj_id target2)
|
|
{
|
|
obj_id storyteller_id_1 = obj_id.NULL_ID;
|
|
obj_id storyteller_id_2 = obj_id.NULL_ID;
|
|
if ( utils.hasScriptVar(target1, "storytellerid") )
|
|
{
|
|
storyteller_id_1 = utils.getObjIdScriptVar(target1, "storytellerid");
|
|
}
|
|
if ( utils.hasScriptVar(target2, "storytellerid") )
|
|
{
|
|
storyteller_id_2 = utils.getObjIdScriptVar(target2, "storytellerid");
|
|
}
|
|
|
|
// if the storyteller_id of both players is the same, they are in the same story
|
|
//
|
|
// OR if the storyteller_id of one player is equal to the obj_id of the other player,
|
|
// then that player is in the other player's story
|
|
if ( isIdValid(storyteller_id_1) && isIdValid(storyteller_id_2) )
|
|
{
|
|
if ( storyteller_id_1 == storyteller_id_2 )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
else if ( isIdValid(storyteller_id_1) && storyteller_id_1 == target2 )
|
|
{
|
|
return true;
|
|
}
|
|
else if ( isIdValid(storyteller_id_2) && storyteller_id_2 == target1 )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void showStorytellerEffectsInAreaToPlayer(obj_id player, obj_id storytellerPlayer)
|
|
{
|
|
obj_id[] storytellerObjects = getAllObjectsWithObjVar(getLocation(player), 165.0f, "storytellerid");
|
|
if ( storytellerObjects != null && storytellerObjects.length > 0 )
|
|
{
|
|
for ( int i = 0; i < storytellerObjects.length; i++ )
|
|
{
|
|
obj_id object = storytellerObjects[i];
|
|
obj_id myStoryteller = getObjIdObjVar(object, "storytellerid");
|
|
if ( isIdValid(myStoryteller) )
|
|
{
|
|
if ( myStoryteller == storytellerPlayer )
|
|
{
|
|
if ( hasObjVar(object, storyteller.EFFECT_ACTIVE_OBJVAR) && hasObjVar(object, storyteller.EFFECT_TOKEN_NAME) )
|
|
{
|
|
string storytellerTokenName = getStringObjVar(object, storyteller.EFFECT_TOKEN_NAME);
|
|
location here = getLocation(object);
|
|
string effectName = storyteller.getEffectName(storytellerTokenName);
|
|
|
|
obj_id[] playerInStory = { player };
|
|
playClientEffectObj(playerInStory, effectName, object, "", null, "storyteller_persisted_effect");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
void stopStorytellerEffectsInAreaToPlayer(obj_id player, obj_id storytellerPlayer)
|
|
{
|
|
obj_id[] storytellerObjects = getAllObjectsWithObjVar(getLocation(player), 165.0f, "storytellerid");
|
|
if ( storytellerObjects != null && storytellerObjects.length > 0 )
|
|
{
|
|
for ( int i = 0; i < storytellerObjects.length; i++ )
|
|
{
|
|
obj_id object = storytellerObjects[i];
|
|
obj_id myStoryteller = getObjIdObjVar(object, "storytellerid");
|
|
if ( isIdValid(myStoryteller) )
|
|
{
|
|
if ( myStoryteller == storytellerPlayer )
|
|
{
|
|
if ( hasObjVar(object, storyteller.EFFECT_ACTIVE_OBJVAR) && hasObjVar(object, storyteller.EFFECT_TOKEN_NAME) )
|
|
{
|
|
string storytellerTokenName = getStringObjVar(object, storyteller.EFFECT_TOKEN_NAME);
|
|
location here = getLocation(object);
|
|
string effectName = storyteller.getEffectName(storytellerTokenName);
|
|
stopClientEffectObjByLabel(player, object, "storyteller_persisted_effect", false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
// Storyteller Blueprint functions
|
|
|
|
string[] recordBlueprintData(obj_id blueprint, obj_id[] storytellerObjects, obj_id player)
|
|
{
|
|
resizeable string[] blueprintString = new string[0];
|
|
|
|
// Find storyteller objects that belong to the player and are valid to be saved in their blueprint
|
|
resizeable obj_id[] validStorytellerObjects = new obj_id[0];
|
|
for ( int i=0; i < storytellerObjects.length; i++ )
|
|
{
|
|
obj_id object = storytellerObjects[i];
|
|
obj_id objectOwner = getObjIdObjVar(object, "storytellerid");
|
|
|
|
if ( !isIdValid(objectOwner) || objectOwner != player )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ( hasObjVar(object, storyteller.BLUEPRINT_AUTHOR_OBJVAR) )
|
|
{
|
|
obj_id blueprintAuthor = getObjIdObjVar(object, storyteller.BLUEPRINT_AUTHOR_OBJVAR);
|
|
if ( !isIdValid( blueprintAuthor ) || blueprintAuthor != player )
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
string tokenName = getStaticItemName(object);
|
|
if ( tokenName == null || tokenName.length() < 1 )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
string[] excludedTokens = { "st_fn_storyteller_vendor" };
|
|
boolean isExcludedToken = false;
|
|
for ( int q=0; q<excludedTokens.length; q++ )
|
|
{
|
|
if ( tokenName.equals(excludedTokens[q]) || storyteller.getTokenType(tokenName) == storyteller.OTHER )
|
|
{
|
|
isExcludedToken = true;
|
|
}
|
|
}
|
|
if ( isExcludedToken )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
utils.addElement(validStorytellerObjects, object);
|
|
}
|
|
|
|
if ( validStorytellerObjects == null || validStorytellerObjects.length < 1 )
|
|
{
|
|
return blueprintString;
|
|
}
|
|
|
|
// Find the center location of the valid objects to use as a reference point for thier position
|
|
location centerLoc = new location();
|
|
float maxX = -99999.0f;
|
|
float maxZ = -99999.0f;
|
|
float minX = 99999.0f;
|
|
float minZ = 99999.0f;
|
|
for ( int j=0; j < validStorytellerObjects.length; j++ )
|
|
{
|
|
obj_id object = validStorytellerObjects[j];
|
|
obj_id objectOwner = getObjIdObjVar(object, "storytellerid");
|
|
|
|
if ( !isIdValid(objectOwner) || objectOwner != player )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
location objLoc = getLocation(object);
|
|
if ( objLoc.x > maxX )
|
|
maxX = objLoc.x;
|
|
|
|
if ( objLoc.z > maxZ )
|
|
maxZ = objLoc.z;
|
|
|
|
if ( objLoc.x < minX )
|
|
minX = objLoc.x;
|
|
|
|
if ( objLoc.z < minZ )
|
|
minZ = objLoc.z;
|
|
}
|
|
centerLoc = new location(maxX - ((maxX - minX)/2), 0.0f, maxZ - ((maxZ - minZ)/2));
|
|
|
|
// Find the relative position of each valid object
|
|
for ( int i=0; i < validStorytellerObjects.length; i++ )
|
|
{
|
|
obj_id validStoryObject = validStorytellerObjects[i];
|
|
string tokenName = getStaticItemName(validStoryObject);
|
|
|
|
location playerLoc = getLocation(player);
|
|
float playerYaw = getYaw(player);
|
|
|
|
location objLoc = getLocation(validStoryObject);
|
|
float objYaw = getYaw(validStoryObject);
|
|
|
|
if ( playerYaw != 0 )
|
|
{
|
|
objLoc = storyteller.rotateSavedBlueprintDataXZ(playerLoc, objLoc, playerYaw);
|
|
}
|
|
|
|
float yawDiff = playerYaw - objYaw;
|
|
|
|
float terrainHeight = objLoc.y;
|
|
location creationLoc = getLocationObjVar(validStoryObject, "storytellerCreationLoc");
|
|
if ( creationLoc != null )
|
|
{
|
|
terrainHeight = creationLoc.y;
|
|
}
|
|
|
|
float locX = objLoc.x - playerLoc.x;
|
|
float locY = objLoc.y - terrainHeight;
|
|
float locZ = objLoc.z - playerLoc.z;
|
|
|
|
// locY should never have a negative value. Storyteller objects cannot be moved below the terrain.
|
|
// So the only reason it would be negative is if both getElevation() and getHeightAtLocation() failed.
|
|
if ( locY < 0.001f )
|
|
{
|
|
locY = 0.0f;
|
|
}
|
|
|
|
int combatLevel = 0;
|
|
int difficulty = 0;
|
|
if ( isMob(validStoryObject) )
|
|
{
|
|
combatLevel = getLevel(validStoryObject);
|
|
difficulty = getIntObjVar(validStoryObject, "difficultyClass");
|
|
}
|
|
|
|
string effect = "none";
|
|
if ( hasObjVar(validStoryObject, storyteller.EFFECT_ACTIVE_OBJVAR) && hasObjVar(validStoryObject, storyteller.EFFECT_TOKEN_NAME) )
|
|
{
|
|
effect = getStringObjVar(validStoryObject, storyteller.EFFECT_TOKEN_NAME);
|
|
|
|
// The effect token is saved in reference to the object it plays on.
|
|
// This entry is simply to track that an effect token is required and has/hasn't been loaded.
|
|
string effectEntry = buildBlueprintObjectData(storyteller.BLUEPRINT_TOKEN_NEEDED, effect, 0.0f, 0.0f, 0.0f, 0.0f, 0, 0, "none");
|
|
utils.addElement(blueprintString, effectEntry);
|
|
}
|
|
|
|
string newEntry = buildBlueprintObjectData(storyteller.BLUEPRINT_TOKEN_NEEDED, tokenName, locX, locY, locZ, yawDiff, combatLevel, difficulty, effect);
|
|
|
|
utils.addElement(blueprintString, newEntry);
|
|
|
|
if ( blueprintString.length >= BLUEPRINT_MAX_NUM_OBJECTS )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
return blueprintString;
|
|
}
|
|
|
|
location rotateSavedBlueprintDataXZ(location locOrigin, location locPoint, float fltAngle)
|
|
{
|
|
float dx = locPoint.x - locOrigin.x;
|
|
float dz = locPoint.z - locOrigin.z;
|
|
|
|
float fltRadians = (float)Math.toRadians(fltAngle);
|
|
float fltC = (float)Math.cos(fltRadians);
|
|
float fltS = (float) Math.sin(fltRadians);
|
|
|
|
location locNewOffset = locOrigin;
|
|
|
|
locNewOffset.x += -(dx * fltC) + (dz * fltS);
|
|
locNewOffset.y = locPoint.y;
|
|
locNewOffset.z += (dx * fltS) + (dz * fltC);
|
|
|
|
return locNewOffset;
|
|
}
|
|
|
|
string changeBlueprintItemTokenStatus(int tokenStatus, string objectData)
|
|
{
|
|
return buildBlueprintObjectData(tokenStatus, getBlueprintItemName(objectData), getBlueprintItemLocX(objectData), getBlueprintItemLocY(objectData), getBlueprintItemLocZ(objectData), getBlueprintItemYaw(objectData), getBlueprintItemCombatLevel(objectData), getBlueprintItemDifficulty(objectData), getBlueprintItemEffect(objectData));
|
|
}
|
|
|
|
string buildBlueprintObjectData(int tokenLoaded, string tokenName, float locX, float locY, float locZ, float yaw, int combatLevel, int difficulty, string effect)
|
|
{
|
|
return tokenLoaded+"~"+tokenName+"~"+locX+"~"+locY+"~"+locZ+"~"+yaw+"~"+combatLevel+"~"+difficulty+"~"+effect;
|
|
}
|
|
|
|
int getBlueprintObjectDataSize(string blueprintObjectData)
|
|
{
|
|
string[] parse = split(blueprintObjectData, '~');
|
|
return parse.length;
|
|
}
|
|
|
|
int getRequiredBlueprintDataSize()
|
|
{
|
|
string blueprintDataTest = buildBlueprintObjectData(BLUEPRINT_TOKEN_NEEDED, "test_only", 0.0f,0.0f, 0.0f, 0.0f, 0, 0, "none");
|
|
return getBlueprintObjectDataSize(blueprintDataTest);
|
|
}
|
|
|
|
boolean validateBlueprintData(string blueprintObjectData)
|
|
{
|
|
if ( getBlueprintObjectDataSize(blueprintObjectData) == getRequiredBlueprintDataSize() )
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
obj_id createBlueprintObject(string objectData, obj_id blueprintController, obj_id player, location targetLoc, float targetYaw)
|
|
{
|
|
obj_id blueprintObject = obj_id.NULL_ID;
|
|
|
|
string tokenName = getBlueprintItemName(objectData);
|
|
location atLoc = getBlueprintObjectLocation(objectData, targetLoc);
|
|
float yawDiff = getBlueprintItemYaw(objectData);
|
|
|
|
int combatLevel = getBlueprintItemCombatLevel(objectData);
|
|
int difficulty = getBlueprintItemDifficulty(objectData);
|
|
string effect = getBlueprintItemEffect(objectData);
|
|
|
|
if ( targetYaw != 0 )
|
|
{
|
|
atLoc = storyteller.rotateSavedBlueprintDataXZ(targetLoc, atLoc, targetYaw);
|
|
}
|
|
float newYaw = targetYaw - yawDiff;
|
|
|
|
int tokenType = storyteller.getTokenType(tokenName);
|
|
switch(tokenType)
|
|
{
|
|
case storyteller.PROP:
|
|
blueprintObject = storyteller.createPropObjectNoToken(tokenName, player, false, atLoc, newYaw);
|
|
break;
|
|
case storyteller.COMBAT_NPC:
|
|
blueprintObject = storyteller.createNpcAtLocationNoToken(tokenName, player, atLoc, newYaw, combatLevel, difficulty);
|
|
break;
|
|
case storyteller.FLAVOR_NPC:
|
|
blueprintObject = storyteller.createNpcAtLocationNoToken(tokenName, player, atLoc, newYaw, combatLevel, difficulty);
|
|
break;
|
|
case storyteller.STATIC_EFFECT:
|
|
// The effect token is saved in reference to the object it plays on.
|
|
// This entry is simply to track that an effect token is required and has/hasn't been loaded.
|
|
break;
|
|
}
|
|
|
|
if ( isValidId(blueprintObject) )
|
|
{
|
|
// save obj_id of the blueprint author
|
|
if ( hasObjVar(blueprintController, storyteller.BLUEPRINT_AUTHOR_OBJVAR) )
|
|
{
|
|
obj_id blueprintAuthor = getObjIdObjVar(blueprintController, storyteller.BLUEPRINT_AUTHOR_OBJVAR);
|
|
if ( isIdValid(blueprintAuthor) )
|
|
{
|
|
setObjVar(blueprintObject, storyteller.BLUEPRINT_AUTHOR_OBJVAR, blueprintAuthor);
|
|
}
|
|
}
|
|
|
|
// if a persisted effect is being used on the object, play it
|
|
if ( effect.length() > 0 && !effect.equals("none") )
|
|
{
|
|
setObjVar(blueprintObject, storyteller.EFFECT_TOKEN_NAME, effect);
|
|
if ( hasScript(blueprintObject, "systems.storyteller.effect_controller") )
|
|
{
|
|
messageTo(blueprintObject, "handlePlayNewStorytellerEffect", null, 1, false);
|
|
}
|
|
else
|
|
{
|
|
attachScript(blueprintObject, "systems.storyteller.effect_controller");
|
|
}
|
|
}
|
|
|
|
dictionary webster = new dictionary();
|
|
webster.put("yOffset", getBlueprintItemLocY(objectData));
|
|
webster.put("player", player);
|
|
messageTo(blueprintObject, "handleBlueprintElevation", webster, 0.25f, false);
|
|
}
|
|
|
|
if ( isGod(player) )
|
|
{
|
|
utils.setScriptVar(player, "storyteller.godModeStopOverrideMessages", true);
|
|
}
|
|
|
|
return blueprintObject;
|
|
}
|
|
|
|
void handleBlueprintObjectElevation(obj_id blueprintObject, dictionary params)
|
|
{
|
|
if ( params != null || !params.isEmpty() )
|
|
{
|
|
float yOffset = params.getFloat("yOffset");
|
|
obj_id player = params.getObjId("player");
|
|
|
|
location here = getLocation(blueprintObject);
|
|
setObjVar(blueprintObject, "storytellerCreationLoc", here);
|
|
|
|
location newElevationLoc = new location(here.x, here.y + yOffset, here.z);
|
|
setLocation(blueprintObject, newElevationLoc);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
location getBlueprintObjectLocation(string spawnString, location centerLoc)
|
|
{
|
|
float locX = centerLoc.x + getBlueprintItemLocX(spawnString);
|
|
float locZ = centerLoc.z + getBlueprintItemLocZ(spawnString);
|
|
|
|
// sending an incorrect elevation at this point. It will be corrected later during the creation process.
|
|
float locY = centerLoc.y;
|
|
|
|
return new location(locX, locY, locZ, centerLoc.area, null);
|
|
}
|
|
|
|
boolean isBlueprintTokenLoaded(string spawnString)
|
|
{
|
|
string[] parse = split(spawnString, '~');
|
|
|
|
if ( utils.stringToInt(parse[0]) == 1 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
string getBlueprintItemName(string spawnString)
|
|
{
|
|
string[] parse = split(spawnString, '~');
|
|
return parse[1];
|
|
}
|
|
|
|
float getBlueprintItemLocX(string spawnString)
|
|
{
|
|
string[] parse = split(spawnString, '~');
|
|
return utils.stringToFloat(parse[2]);
|
|
}
|
|
|
|
float getBlueprintItemLocY(string spawnString)
|
|
{
|
|
string[] parse = split(spawnString, '~');
|
|
return utils.stringToFloat(parse[3]);
|
|
}
|
|
|
|
float getBlueprintItemLocZ(string spawnString)
|
|
{
|
|
string[] parse = split(spawnString, '~');
|
|
return utils.stringToFloat(parse[4]);
|
|
}
|
|
|
|
float getBlueprintItemYaw(string spawnString)
|
|
{
|
|
string[] parse = split(spawnString, '~');
|
|
return utils.stringToFloat(parse[5]);
|
|
}
|
|
|
|
int getBlueprintItemCombatLevel(string spawnString)
|
|
{
|
|
string[] parse = split(spawnString, '~');
|
|
return utils.stringToInt(parse[6]);
|
|
}
|
|
|
|
int getBlueprintItemDifficulty(string spawnString)
|
|
{
|
|
string[] parse = split(spawnString, '~');
|
|
return utils.stringToInt(parse[7]);
|
|
}
|
|
|
|
string getBlueprintItemEffect(string spawnString)
|
|
{
|
|
string[] parse = split(spawnString, '~');
|
|
return parse[8];
|
|
}
|
|
|
|
void blueprintParseConversion(obj_id blueprint)
|
|
{
|
|
// CTS uses | when packing objvars, so blueprint data cannot use | when recording
|
|
// blueprint object data in its data objvar. This function will convert previously existing blueprints
|
|
// away from splitting their data with | and reset their data to use ~
|
|
|
|
string[] blueprintObjects = utils.getStringBatchObjVar(blueprint, storyteller.BLUEPRINT_OBJECTS_OBJVAR);
|
|
if ( blueprintObjects == null || blueprintObjects.length == 0 )
|
|
{
|
|
// no blueprint found so no need to convert it.
|
|
return;
|
|
}
|
|
|
|
boolean conversionWasRequired = false;
|
|
|
|
for (int i=0; i < blueprintObjects.length; i++)
|
|
{
|
|
string objectData = blueprintObjects[i];
|
|
string[] oldParse = split(objectData, '|');
|
|
if ( oldParse.length > 1 )
|
|
{
|
|
int tokenLoaded = utils.stringToInt(oldParse[0]);
|
|
string tokenName = oldParse[1];
|
|
float locX = utils.stringToFloat(oldParse[2]);
|
|
float locY = utils.stringToFloat(oldParse[3]);
|
|
float locZ = utils.stringToFloat(oldParse[4]);
|
|
float yaw = utils.stringToFloat(oldParse[5]);
|
|
int combatLevel = utils.stringToInt(oldParse[6]);
|
|
int difficulty = utils.stringToInt(oldParse[7]);
|
|
string effect = oldParse[8];
|
|
|
|
string convertedObjectData = buildBlueprintObjectData(tokenLoaded, tokenName, locX, locY, locZ, yaw, combatLevel, difficulty, effect);
|
|
blueprintObjects[i] = convertedObjectData;
|
|
|
|
conversionWasRequired = true;
|
|
}
|
|
}
|
|
|
|
if ( conversionWasRequired )
|
|
{
|
|
utils.setBatchObjVar(blueprint, storyteller.BLUEPRINT_OBJECTS_OBJVAR, blueprintObjects);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
// Auto-decline Storyteller Invites
|
|
boolean doIAutoDeclineStorytellerInvites(obj_id player)
|
|
{
|
|
// is auto-declining all storyteller invites
|
|
if ( hasObjVar(player, storyteller.VAR_AUTODECLINE_STORY_INVITES) )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// is in a battlefield
|
|
if ( utils.hasScriptVar(player, "battlefield.active") )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Storyteller Assistant Invite
|
|
int storyAssistantSui(obj_id storytellerPlayer, string storytellerName, obj_id player)
|
|
{
|
|
string title = utils.packStringId(new string_id("storyteller", "assistant_title"));
|
|
prose_package pp = prose.getPackage(new string_id("storyteller", "assistant_invite"));
|
|
prose.setTO(pp, storytellerName);
|
|
string msg = "\0" + packOutOfBandProsePackage(null, pp);
|
|
int pid = sui.msgbox(storytellerPlayer, player, msg, 2, title, sui.YES_NO, "storyAssistantHandler");
|
|
|
|
return pid;
|
|
}
|
|
|
|
void storyAssistantAcepted(obj_id storytellerPlayer, string storytellerName, obj_id player)
|
|
{
|
|
string_id message = new string_id ("storyteller", "assistant_player_name");
|
|
prose_package pp = prose.getPackage(message, player, player);
|
|
prose.setTO(pp, storytellerName);
|
|
sendSystemMessageProse(player, pp);
|
|
|
|
dictionary webster = new dictionary();
|
|
webster.put("assistantPlayerName", getName(player));
|
|
messageTo(storytellerPlayer, "handleStorytellerAssistantHasBeenAdded", webster, 0, false);
|
|
|
|
utils.setScriptVar(player, "storytellerAssistant", storytellerPlayer);
|
|
utils.setScriptVar(player, "storytellerAssistantName", storytellerName);
|
|
return;
|
|
}
|
|
|
|
// Storyteller Assistant Removal
|
|
void storyPlayerRemoveAssistant(obj_id storytellerPlayer, string storytellerName, obj_id player)
|
|
{
|
|
string_id message = new string_id ("storyteller", "assistant_removed_player");
|
|
prose_package pp = prose.getPackage(message, player, player);
|
|
prose.setTO(pp, storytellerName);
|
|
sendSystemMessageProse(player, pp);
|
|
|
|
utils.removeScriptVar(player, "storytellerAssistant");
|
|
utils.removeScriptVar(player, "storytellerAssistant");
|
|
|
|
dictionary webster = new dictionary();
|
|
webster.put("removedPlayerName", getName(player));
|
|
messageTo(storytellerPlayer, "handleStorytellerAssistantHasBeenRemoved", webster, 0, false);
|
|
return;
|
|
}
|
|
|
|
// Storyteller Invite to Story
|
|
int storyInviteSui(obj_id storytellerPlayer, string storytellerName, obj_id player)
|
|
{
|
|
string title = utils.packStringId(new string_id("storyteller", "sui_invite_title"));
|
|
prose_package pp = prose.getPackage(new string_id("storyteller", "sui_invite_body"));
|
|
prose.setTO(pp, storytellerName);
|
|
string msg = "\0" + packOutOfBandProsePackage(null, pp);
|
|
int pid = sui.msgbox(storytellerPlayer, player, msg, 2, title, sui.YES_NO, "storyInviteHandler");
|
|
|
|
return pid;
|
|
}
|
|
|
|
void storyInviteAcepted(obj_id storytellerPlayer, string storytellerName, obj_id player, obj_id storytellerAssistant)
|
|
{
|
|
string_id message = new string_id ("storyteller", "player_invited_name");
|
|
prose_package pp = prose.getPackage(message, player, player);
|
|
prose.setTO(pp, storytellerName);
|
|
sendSystemMessageProse(player, pp);
|
|
|
|
dictionary webster = new dictionary();
|
|
webster.put("addedPlayerName", getName(player));
|
|
webster.put("storytellerName", storytellerName);
|
|
|
|
if ( isIdValid(storytellerAssistant) )
|
|
{
|
|
messageTo(storytellerAssistant, "handleStorytellerPlayerHasBeenAdded", webster, 0, false);
|
|
}
|
|
else
|
|
{
|
|
messageTo(storytellerPlayer, "handleStorytellerPlayerHasBeenAdded", webster, 0, false);
|
|
}
|
|
|
|
utils.setScriptVar(player, "storytellerid", storytellerPlayer);
|
|
utils.setScriptVar(player, "storytellerName", storytellerName);
|
|
|
|
showStorytellerEffectsInAreaToPlayer(player, storytellerPlayer);
|
|
|
|
return;
|
|
}
|
|
|
|
// Storyteller Removal from Story
|
|
void storyPlayerRemovedFromStory(obj_id storytellerPlayer, string storytellerName, obj_id player)
|
|
{
|
|
string_id message = new string_id ("storyteller", "removed_from_story");
|
|
prose_package pp = prose.getPackage(message, player, player);
|
|
prose.setTO(pp, storytellerName);
|
|
sendSystemMessageProse(player, pp);
|
|
|
|
utils.removeScriptVar(player, "storytellerid");
|
|
utils.removeScriptVar(player, "storytellerName");
|
|
|
|
dictionary webster = new dictionary();
|
|
webster.put("removedPlayerName", getName(player));
|
|
messageTo(storytellerPlayer, "handleStorytellerPlayerHasBeenRemoved", webster, 0, false);
|
|
return;
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
boolean storytellerCombatCheck(obj_id attacker, obj_id target)
|
|
{
|
|
// storyteller combat is a player or his pet/beast fighting an npc.
|
|
// Completely pve, so find out which is the player and which is the npc.
|
|
|
|
if (!isIdValid(attacker) || !exists(attacker) || !isIdValid(target) || !exists(target))
|
|
return false;
|
|
|
|
obj_id storyPlayer = null;
|
|
obj_id storyNpc = null;
|
|
|
|
if ( isPlayer(attacker) )
|
|
{
|
|
// pvp is not effected by storytelling
|
|
if ( isPlayer(target) )
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
storyPlayer = attacker;
|
|
storyNpc = target;
|
|
}
|
|
}
|
|
else if ( isPlayer(target) )
|
|
{
|
|
storyPlayer = target;
|
|
storyNpc = attacker;
|
|
}
|
|
// neither attacker or target are players at this point, but is either a player controlled pet or beast?
|
|
else if ( pet_lib.isPet(attacker) || beast_lib.isBeast(attacker) )
|
|
{
|
|
// pets fighting pets is pvp and not effected by storytelling
|
|
if ( pet_lib.isPet(target) || beast_lib.isBeast(target) )
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
storyPlayer = getMaster(attacker);
|
|
storyNpc = target;
|
|
}
|
|
}
|
|
else if ( pet_lib.isPet(target) || beast_lib.isBeast(target) )
|
|
{
|
|
storyPlayer = getMaster(target);
|
|
storyNpc = attacker;
|
|
}
|
|
|
|
// check for remote egg used for area of effect and delayed attacks
|
|
// or destructible objects
|
|
else if ( !isMob(attacker) )
|
|
{
|
|
if ( hasScript(attacker, "systems.combat.combat_delayed_tracker") )
|
|
{
|
|
storyPlayer = utils.getObjIdScriptVar(attacker, "objOwner");
|
|
storyNpc = target;
|
|
}
|
|
else
|
|
{
|
|
storyNpc = attacker;
|
|
storyPlayer = target;
|
|
}
|
|
}
|
|
else if ( !isMob(target) )
|
|
{
|
|
if ( hasScript(target, "systems.combat.combat_delayed_tracker") )
|
|
{
|
|
storyPlayer = utils.getObjIdScriptVar(target, "objOwner");
|
|
storyNpc = attacker;
|
|
}
|
|
else
|
|
{
|
|
storyNpc = target;
|
|
storyPlayer = attacker;
|
|
}
|
|
}
|
|
// if both attacker and target are mobs, but neither are pets, beasts or players,
|
|
// then check to see if they can assist.
|
|
// Storyteller mobs can only assist against other storyteller mobs
|
|
else if ( hasObjVar(attacker, "storytellerid") || hasObjVar(target, "storytellerid") )
|
|
{
|
|
if ( hasObjVar(attacker, "storytellerid") && hasObjVar(target, "storytellerid") )
|
|
{
|
|
obj_id attackerNpcStoryteller = getObjIdObjVar(attacker, "storytellerid");
|
|
obj_id targetNpcStoryteller = getObjIdObjVar(target, "storytellerid");
|
|
|
|
if ( attackerNpcStoryteller == targetNpcStoryteller )
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// check to see
|
|
if ( isIdValid(storyPlayer) && isIdValid(storyNpc) )
|
|
{
|
|
if ( hasObjVar(storyNpc, "storytellerid") )
|
|
{
|
|
if ( utils.hasScriptVar(storyPlayer, "storytellerid") )
|
|
{
|
|
obj_id playerStorytellerId = utils.getObjIdScriptVar(storyPlayer, "storytellerid");
|
|
obj_id npcStorytellerId = getObjIdObjVar(storyNpc, "storytellerid");
|
|
if ( isIdValid(playerStorytellerId) && isIdValid(npcStorytellerId) && playerStorytellerId == npcStorytellerId )
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/***** Storyteller Vendor functions *************************************************/
|
|
|
|
boolean displayAvailableStorytellerTokenTypes(obj_id player, obj_id storytellerVendor)
|
|
{
|
|
if ( getDistance(storytellerVendor, player) > 10.0f )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
string title = utils.packStringId(new string_id("storyteller", "token_purchase_type_title"));
|
|
string prompt = utils.packStringId(new string_id("storyteller","token_purchase_type_prompt"));
|
|
|
|
int pid = sui.listbox(storytellerVendor, player, prompt, sui.OK_CANCEL, title, getTokenTypeNamesArray(), "msgStorytellerTokenTypeSelected");
|
|
|
|
if ( pid > -1 )
|
|
{
|
|
string scriptvar_path = "storytellerVendor." + player;
|
|
utils.setScriptVar(storytellerVendor, scriptvar_path + ".pid", pid);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
string[] getTokenTypeNamesArray()
|
|
{
|
|
const string[] sid_storytellerTokenTypes = {"token_type_prop",
|
|
"token_type_persisted_effect",
|
|
"token_type_immediate_effect",
|
|
"token_type_combat_npc",
|
|
"token_type_flavor_npc",
|
|
"token_type_other",
|
|
"token_type_costume"};
|
|
|
|
resizeable string[] storytellerTokenTypes = new string[0];
|
|
|
|
for ( int i=0; i < sid_storytellerTokenTypes.length; i++ )
|
|
{
|
|
string tokenType = utils.packStringId(new string_id("storyteller", sid_storytellerTokenTypes[i]));
|
|
storytellerTokenTypes = utils.addElement(storytellerTokenTypes, tokenType);
|
|
}
|
|
|
|
return storytellerTokenTypes;
|
|
}
|
|
|
|
|
|
boolean displayStorytellerTokenPurchaseSUI(obj_id player, int tokenType, obj_id storytellerVendor)
|
|
{
|
|
if ( !isIdValid(player) || !isIdValid(storytellerVendor) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( getDistance(storytellerVendor, player) > 10.0f )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
string scriptvar_path = "storytellerVendor." + player;
|
|
if ( utils.hasScriptVar(storytellerVendor, scriptvar_path + ".pid") )
|
|
{
|
|
int oldpid = utils.getIntScriptVar(storytellerVendor, scriptvar_path + ".pid");
|
|
sui.closeSUI(player, oldpid);
|
|
|
|
utils.removeScriptVar(storytellerVendor, scriptvar_path + ".pid");
|
|
utils.removeBatchScriptVar(storytellerVendor, scriptvar_path + ".tokenReferences");
|
|
utils.removeBatchScriptVar(storytellerVendor, scriptvar_path + ".tokens");
|
|
utils.removeScriptVar(storytellerVendor, scriptvar_path + ".tokenType");
|
|
}
|
|
|
|
resizeable string[] tokenReferences = new string[0];
|
|
|
|
int num_items = dataTableGetNumRows(STORYTELLER_DATATABLE);
|
|
for (int i = 0; i < num_items; i++)
|
|
{
|
|
dictionary row = dataTableGetRow(STORYTELLER_DATATABLE, i);
|
|
if ( row != null && !row.isEmpty() )
|
|
{
|
|
int row_tokenType = row.getInt("type");
|
|
|
|
if ( row_tokenType == tokenType )
|
|
{
|
|
string token_reference = row.getString("name");
|
|
int cost = row.getInt("cost");
|
|
|
|
if ( cost > 0 )
|
|
{
|
|
tokenReferences = utils.addElement(tokenReferences, token_reference);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
string[] tokenTypeNames = getTokenTypeNamesArray();
|
|
|
|
if (tokenReferences == null || tokenReferences.length < 1)
|
|
{
|
|
// There are no items available for the selected token type, so show the type selection sui
|
|
storyteller.displayAvailableStorytellerTokenTypes(player, storytellerVendor);
|
|
|
|
prose_package pp = prose.getPackage(new string_id("storyteller", "token_purchase_none_of_type"), tokenTypeNames[tokenType]);
|
|
sendSystemMessageProse(player, pp);
|
|
return false;
|
|
}
|
|
|
|
string prompt = getString(new string_id("storyteller","token_purchase_select_token"));
|
|
|
|
string[] alphabetizedTokenReferences = getAlphabetizedTokenList(utils.toStaticStringArray(tokenReferences), tokenType);
|
|
string[] alphabetizedTokens = getTokenNamesList(alphabetizedTokenReferences, tokenType, player);
|
|
|
|
string myHandler = "msgStorytellerTokenPurchaseSelected";
|
|
int pid = sui.listbox(storytellerVendor, player, prompt, sui.OK_CANCEL_REFRESH, tokenTypeNames[tokenType], alphabetizedTokens, myHandler, false, false);
|
|
if ( pid > -1 )
|
|
{
|
|
sui.listboxUseOtherButton(pid, "Back");
|
|
sui.showSUIPage(pid);
|
|
|
|
utils.setScriptVar(storytellerVendor, scriptvar_path + ".pid", pid);
|
|
utils.setBatchScriptVar(storytellerVendor, scriptvar_path + ".tokenReferences", alphabetizedTokenReferences);
|
|
utils.setBatchScriptVar(storytellerVendor, scriptvar_path + ".tokens", alphabetizedTokens);
|
|
utils.setScriptVar(storytellerVendor, scriptvar_path + ".tokenType", tokenType);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
string[] getAlphabetizedTokenList(string[] tokenReferences, int tokenType)
|
|
{
|
|
string[] namesColonTokens = new string[tokenReferences.length];
|
|
|
|
for ( int i = 0; i < tokenReferences.length; i++ )
|
|
{
|
|
string temp = getString(new string_id("static_item_n", tokenReferences[i]))+ "|" + tokenReferences[i];
|
|
namesColonTokens[i] = temp;
|
|
}
|
|
|
|
Arrays.sort(namesColonTokens);
|
|
|
|
string[] finalList = new string[namesColonTokens.length];
|
|
for ( int j = 0; j < namesColonTokens.length; j++ )
|
|
{
|
|
string[] splitText = split(namesColonTokens[j], '|');
|
|
finalList[j] = splitText[1];
|
|
}
|
|
|
|
if ( tokenType == COSTUME )
|
|
{
|
|
// Mad, insane hackery...please just look away
|
|
string[] tempList = new string[finalList.length];
|
|
utils.copyArray(finalList, tempList);
|
|
|
|
finalList[0] = "item_costume_kit";
|
|
int nextFinalListSlot = 1;
|
|
for ( int k = 0; k < tempList.length; k++ )
|
|
{
|
|
string ref = tempList[k];
|
|
if ( !ref.equals("item_costume_kit") )
|
|
{
|
|
finalList[nextFinalListSlot] = ref;
|
|
++nextFinalListSlot;
|
|
}
|
|
}
|
|
}
|
|
|
|
return finalList;
|
|
}
|
|
|
|
string[] getTokenNamesList(string[] tokenReferences, int tokenType, obj_id player)
|
|
{
|
|
string[] tokenNamesList = new string[tokenReferences.length];
|
|
|
|
for ( int i = 0; i < tokenReferences.length; i++ )
|
|
{
|
|
string token = tokenReferences[i];
|
|
|
|
dictionary row = dataTableGetRow(STORYTELLER_DATATABLE, token);
|
|
if ( row != null && !row.isEmpty() )
|
|
{
|
|
int cost = row.getInt("cost");
|
|
string tokenName = utils.packStringId(new string_id("static_item_n", token));
|
|
|
|
if ( tokenType == COMBAT_NPC || tokenType == FLAVOR_NPC )
|
|
{
|
|
tokenName = tokenName + " (Cost: " + cost + " per npc)";
|
|
}
|
|
else if ( tokenType == PROP )
|
|
{
|
|
tokenName = tokenName + " (Cost: " + cost + " per prop)";
|
|
}
|
|
else if ( tokenType == COSTUME )
|
|
{
|
|
if ( token.equals("item_costume_kit") )
|
|
{
|
|
tokenName = tokenName + " (Cost: " + cost + " per holoshroud)";
|
|
}
|
|
else
|
|
{
|
|
// if the item is a costume that you alreqady know, list it in red text
|
|
dictionary itemData = new dictionary();
|
|
itemData = dataTableGetRow(static_item.ITEM_STAT_BALANCE_TABLE, token);
|
|
if ( itemData != null && !itemData.isEmpty() )
|
|
{
|
|
string costumeName = itemData.getString("buff_name");
|
|
if ( hasSkill(player, costumeName) )
|
|
{
|
|
string tokenText = utils.packStringId(new string_id("static_item_n", token));
|
|
|
|
string_id contrastText_sid = new string_id("storyteller","costume_already_known");
|
|
prose_package pp = prose.getPackage(contrastText_sid);
|
|
prose.setTO(pp, tokenText);
|
|
prose.setDI(pp, cost);
|
|
|
|
tokenName = "\0" + packOutOfBandProsePackage(null, pp);
|
|
}
|
|
else
|
|
{
|
|
tokenName = tokenName + " (Cost: " + cost + ")";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tokenName = tokenName + " (Cost: " + cost + ")";
|
|
}
|
|
|
|
tokenNamesList[i] = tokenName;
|
|
}
|
|
else
|
|
{
|
|
// this should never happen, but just in case
|
|
tokenNamesList[i] = utils.packStringId(new string_id("storyteller", "unknown_token")) + " : " + token;
|
|
}
|
|
}
|
|
|
|
return tokenNamesList;
|
|
}
|
|
|
|
void storytellerTokenPurchased(dictionary params, obj_id storytellerVendor)
|
|
{
|
|
if ( params == null || params.isEmpty() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
obj_id player = sui.getPlayerId(params);
|
|
if ( !isIdValid(player) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( getDistance(storytellerVendor, player) > 10.0f )
|
|
{
|
|
return;
|
|
}
|
|
|
|
string scriptvar_path = "storytellerVendor." + player;
|
|
if ( !utils.hasScriptVar(storytellerVendor, scriptvar_path + ".pid") )
|
|
{
|
|
return;
|
|
}
|
|
|
|
int oldPid = utils.getIntScriptVar(storytellerVendor, scriptvar_path + ".pid");
|
|
string[] tokenReferences = utils.getStringBatchScriptVar(storytellerVendor, scriptvar_path + ".tokenReferences");
|
|
string[] tokens = utils.getStringBatchScriptVar(storytellerVendor, scriptvar_path + ".tokens");
|
|
int tokenType = utils.getIntScriptVar(storytellerVendor, scriptvar_path + ".tokenType");
|
|
|
|
utils.removeScriptVar(storytellerVendor, scriptvar_path + ".pid");
|
|
utils.removeBatchScriptVar(storytellerVendor, scriptvar_path + ".tokenReferences");
|
|
utils.removeBatchScriptVar(storytellerVendor, scriptvar_path + ".tokens");
|
|
utils.removeScriptVar(storytellerVendor, scriptvar_path + ".tokenType");
|
|
|
|
|
|
if ( tokenReferences == null || tokenReferences.length == 0 )
|
|
{
|
|
LOG("LOG_CHANNEL", "storyteller::storytellerTokenPurchased -- the token reference list is null.");
|
|
return;
|
|
}
|
|
|
|
int button = sui.getIntButtonPressed(params);
|
|
if ( button == sui.BP_CANCEL )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( button == sui.BP_REVERT )
|
|
{
|
|
// Go back the Token Type Selection list
|
|
storyteller.displayAvailableStorytellerTokenTypes(player, storytellerVendor);
|
|
return;
|
|
}
|
|
|
|
int token_selected = sui.getListboxSelectedRow(params);
|
|
if (token_selected < 0)
|
|
return;
|
|
|
|
if (token_selected >= tokenReferences.length)
|
|
return;
|
|
|
|
// Get the selected item.
|
|
string token_reference = tokenReferences[token_selected];
|
|
if (token_reference == null)
|
|
{
|
|
LOG("LOG_CHANNEL", "storyteller::storytellerTokenPurchased -- the item template selected by " + storytellerVendor + " is null.");
|
|
return;
|
|
}
|
|
|
|
// Get token data for the selected item.
|
|
int tokenIdx = dataTableSearchColumnForString(token_reference, "name", STORYTELLER_DATATABLE);
|
|
if (tokenIdx == -1)
|
|
{
|
|
LOG("LOG_CHANNEL", "storyteller::storytellerTokenPurchased -- cannot find " + token_reference + " in the storyteller token datatable.");
|
|
return;
|
|
}
|
|
|
|
// Get static item data for the selected item.
|
|
int staticIdx = dataTableSearchColumnForString(token_reference, "name", STORYTELLER_DATATABLE);
|
|
if (staticIdx == -1)
|
|
{
|
|
LOG("LOG_CHANNEL", "storyteller::storytellerTokenPurchased -- cannot find " + token_reference + " in the static item datatable.");
|
|
return;
|
|
}
|
|
|
|
dictionary tokenData = dataTableGetRow(STORYTELLER_DATATABLE, tokenIdx);
|
|
int cost = tokenData.getInt("cost");
|
|
string tokenName = utils.packStringId(new string_id("static_item_n", token_reference));
|
|
int maxCharges = tokenData.getInt("max_charges");
|
|
|
|
if ( requestNumCharges(tokenType, token_reference) && maxCharges > 1 )
|
|
{
|
|
string prompt = getString(new string_id("storyteller","token_how_many_charges")) + maxCharges;
|
|
int pid = sui.inputbox(storytellerVendor, player, prompt, sui.OK_CANCEL, tokenName, sui.INPUT_NORMAL, null, "msgStorytellerChargesSelected");
|
|
if ( pid > -1 )
|
|
{
|
|
sui.showSUIPage(pid);
|
|
|
|
utils.setScriptVar(storytellerVendor, scriptvar_path + ".pid", pid);
|
|
utils.setScriptVar(storytellerVendor, scriptvar_path + ".tokenChosen", token_reference);
|
|
utils.setScriptVar(storytellerVendor, scriptvar_path + ".tokenType", tokenType);
|
|
return;
|
|
}
|
|
}
|
|
|
|
givePurchasedToken(storytellerVendor, player, token_reference, tokenName, cost, 0);
|
|
|
|
storyteller.displayStorytellerTokenPurchaseSUI(player, tokenType, storytellerVendor);
|
|
return;
|
|
}
|
|
|
|
boolean requestNumCharges(int tokenType, string token_reference)
|
|
{
|
|
if ( tokenType == COMBAT_NPC )
|
|
return true;
|
|
|
|
if ( tokenType == FLAVOR_NPC )
|
|
return true;
|
|
|
|
if ( tokenType == PROP )
|
|
return true;
|
|
|
|
// standard holoshroud
|
|
// if more special case tokens needs to be added, change this to an array to be checked against
|
|
if ( token_reference.equals("item_costume_kit") )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
void storytellerSellTokenWithCharges(dictionary params, obj_id storytellerVendor)
|
|
{
|
|
obj_id player = sui.getPlayerId(params);
|
|
int btn = sui.getIntButtonPressed(params);
|
|
string text = sui.getInputBoxText(params);
|
|
int numCharges = utils.stringToInt(text);
|
|
|
|
string scriptvar_path = "storytellerVendor." + player;
|
|
|
|
string token_reference = utils.getStringScriptVar(storytellerVendor, scriptvar_path + ".tokenChosen");
|
|
int tokenType = utils.getIntScriptVar(storytellerVendor, scriptvar_path + ".tokenType");
|
|
|
|
string tokenName = utils.packStringId(new string_id("static_item_n", token_reference));
|
|
|
|
dictionary tokenData = dataTableGetRow(STORYTELLER_DATATABLE, token_reference);
|
|
int cost = tokenData.getInt("cost");
|
|
int maxCharges = tokenData.getInt("max_charges");
|
|
|
|
if ( btn == sui.BP_CANCEL )
|
|
{
|
|
storyteller.displayStorytellerTokenPurchaseSUI(player, tokenType, storytellerVendor);
|
|
return;
|
|
}
|
|
|
|
if (numCharges < 1 || numCharges > maxCharges)
|
|
{
|
|
string_id message = new string_id ("storyteller", "token_num_charges_invalid");
|
|
prose_package pp = prose.getPackage(message, player, player);
|
|
prose.setDI(pp, maxCharges);
|
|
sendSystemMessageProse(player, pp);
|
|
|
|
string prompt = getString(new string_id("storyteller","token_how_many_charges")) + maxCharges;
|
|
int pid = sui.inputbox(storytellerVendor, player, prompt, sui.OK_CANCEL, tokenName, sui.INPUT_NORMAL, null, "msgStorytellerChargesSelected");
|
|
if ( pid > -1 )
|
|
{
|
|
sui.showSUIPage(pid);
|
|
|
|
utils.setScriptVar(storytellerVendor, scriptvar_path + ".pid", pid);
|
|
utils.setScriptVar(storytellerVendor, scriptvar_path + ".tokenChosen", token_reference);
|
|
utils.setScriptVar(storytellerVendor, scriptvar_path + ".tokenType", tokenType);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
givePurchasedToken(storytellerVendor, player, token_reference, tokenName, cost*numCharges, numCharges);
|
|
|
|
storyteller.displayStorytellerTokenPurchaseSUI(player, tokenType, storytellerVendor);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void givePurchasedToken(obj_id storytellerVendor, obj_id player, string tokenReference, string tokenName, int cost, int numCharges)
|
|
{
|
|
obj_id inv = getObjectInSlot(player, "inventory");
|
|
if ( !isIdValid(inv) )
|
|
{
|
|
LOG("LOG_CHANNEL", "storyteller::storytellerTokenPurchased -- " + player + "'s inventory object is null.");
|
|
return;
|
|
}
|
|
|
|
// Check player for required credits
|
|
if ( !money.hasFunds(player, money.MT_TOTAL, cost) )
|
|
{
|
|
prose_package pp = prose.getPackage(new string_id("storyteller", "token_purchase_not_enough_credits"), tokenName);
|
|
sendSystemMessageProse(player, pp);
|
|
}
|
|
else
|
|
{
|
|
// Check for inventory space.
|
|
int free_space = getVolumeFree(inv);
|
|
if (free_space < 1)
|
|
{
|
|
sendSystemMessage(player, faction_perk.SID_INVENTORY_FULL);
|
|
//factions.addFactionStanding(player, faction, cost);
|
|
return;
|
|
}
|
|
|
|
// Pay the costs
|
|
utils.moneyOutMetric(player, "STORYTELLER_TOKENS", cost);
|
|
money.requestPayment(player, storytellerVendor, cost, "pass_fail", null, true);
|
|
|
|
CustomerServiceLog("storyteller", "(" + player + ")" + getName(player) + " is attempting to purchase item: " + tokenReference);
|
|
CustomerServiceLog("storyteller", "(" + player + ")" + getName(player) + "'s purchase cost: " + cost);
|
|
|
|
// Create the item.
|
|
// Check if it's a static item, if so create with that function instead.
|
|
obj_id item = static_item.createNewItemFunction(tokenReference, inv);
|
|
|
|
if ( !isIdValid(item) )
|
|
{
|
|
LOG("LOG_CHANNEL", "storyteller::storytellerTokenPurchased -- unable to create " + tokenReference + " for " + storytellerVendor);
|
|
//factions.addFactionStanding(player, faction, cost);
|
|
CustomerServiceLog("storyteller", "(" + player + ")" + getName(player) + "'s purchase of " + tokenReference + " has failed!");
|
|
return;
|
|
}
|
|
|
|
if ( numCharges > 0 )
|
|
{
|
|
setCount(item, numCharges);
|
|
}
|
|
|
|
CustomerServiceLog("storyteller", "(" + player + ")" + getName(player) + " has purchased (" + item + ")" + getName(item));
|
|
logBalance("storyteller;" + getGameTime() + ";item;" + tokenReference + ";" + cost);
|
|
|
|
// Send the completion message.
|
|
prose_package pp = prose.getPackage(new string_id("storyteller", "token_purchase_complete"), player, item);
|
|
sendSystemMessageProse(player, pp);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
/***** END Storyteller Vendor functions *************************************************/
|
|
/***************************************************************************/
|
|
|
|
//Confirms the proper amount of time has passed before destroying a storyteller object.
|
|
//this is used in case there is a delayed response from a City when checking for a
|
|
//city specialization (which increases exist time by 12 hours)
|
|
void confirmCleanuptime(obj_id object)
|
|
{
|
|
//initialize variables
|
|
int storytellerCreationTime = 0;
|
|
int existTime = 0;
|
|
//creation time.
|
|
if(hasObjVar(object, "storytellerCreationTime"))
|
|
storytellerCreationTime = getIntObjVar(object, "storytellerCreationTime");
|
|
//length of time it should exist in the world(in seconds)
|
|
if(hasObjVar(object, "storytellerCleanUpTime"))
|
|
existTime = getIntObjVar(object, "storytellerCleanUpTime");
|
|
|
|
if(storytellerCreationTime + existTime > getGameTime())
|
|
{
|
|
int timeRemaining = storytellerCreationTime + existTime - getGameTime();
|
|
//we are not ready to clean up yet - send a new MessageTo with the actual cleanup Time.
|
|
messageTo(object, "prepCleanupProp", null, timeRemaining, false);
|
|
return;
|
|
}
|
|
trial.cleanupObject(object);
|
|
}
|
|
|
|
//City Specialization increases exist time by 12 hours.
|
|
void setBonusExistTime(obj_id self)
|
|
{
|
|
if(hasObjVar(self, "storytellerCleanUpTime"))
|
|
{
|
|
//add bonus time (12 hours) for the specialization
|
|
int cleanUpTime = getIntObjVar(self, "storytellerCleanUpTime");
|
|
cleanUpTime += 43200;
|
|
setObjVar(self, "storytellerCleanUpTime", cleanUpTime);
|
|
}
|
|
}
|
|
|
|
//determines if a ST Prop is in a city and messages city to check specialization status
|
|
void calculatePropBonusExistTime(obj_id object)
|
|
{
|
|
//if we are in a city, we get bonus time
|
|
int cleanUpTime = DEFAULT_PROP_CLEANUP_TIME;
|
|
int city_id = getCityAtLocation(getLocation(object), 0);
|
|
if(city_id > 0)
|
|
{
|
|
//we are in a city
|
|
cleanUpTime += 28800; //give them an extra 8 hours.
|
|
//message the City Hall to see if a Specialization increases time.
|
|
obj_id cityHall = cityGetCityHall(city_id);
|
|
|
|
dictionary outparams = new dictionary();
|
|
outparams.put("queryObject", object);
|
|
messageTo(cityHall, "st_citySpecBonusCheck", outparams, 0.0f, false);
|
|
}
|
|
setObjVar(object, "storytellerCleanUpTime", cleanUpTime);
|
|
}
|
|
|
|
//determines if a ST NPC is in a city and messages city to check specialization status
|
|
void calculateNpcBonusExistTime(obj_id object)
|
|
{
|
|
//if we are in a city, we get bonus time
|
|
int cleanUpTime = DEFAULT_NPC_CLEANUP_TIME;
|
|
int city_id = getCityAtLocation(getLocation(object), 0);
|
|
if(city_id > 0)
|
|
{
|
|
//we are in a city
|
|
cleanUpTime += 28800; //give them an extra 8 hours.
|
|
//message the City Hall to see if a Specialization increases time.
|
|
obj_id cityHall = cityGetCityHall(city_id);
|
|
|
|
dictionary outparams = new dictionary();
|
|
outparams.put("queryObject", object);
|
|
messageTo(cityHall, "st_citySpecBonusCheck", outparams, 0.0f, false);
|
|
}
|
|
setObjVar(object, "storytellerCleanUpTime", cleanUpTime);
|
|
}
|
|
|
|
/***************************************************************************/
|