mirror of
https://github.com/SWG-Source/dsrc.git
synced 2026-07-14 23:07:51 -04:00
2328 lines
57 KiB
Plaintext
2328 lines
57 KiB
Plaintext
/**
|
|
* Copyright (c) ©2000,2001 Sony Online Entertainment Inc.
|
|
* All Rights Reserved
|
|
*
|
|
* Title: debugger.script
|
|
* Description: debugger script
|
|
* @author $Author: rpalacio $
|
|
* @version $Revision: #1 $
|
|
*/
|
|
|
|
/***** INCLUDES ********************************************************/
|
|
|
|
include library.debug;
|
|
include library.utils;
|
|
include library.factions;
|
|
include library.firework;
|
|
include library.hue;
|
|
include library.sui;
|
|
include library.powerup;
|
|
include library.ai_lib;
|
|
include library.minigame;
|
|
include library.player_structure;
|
|
include library.structure;
|
|
include library.magic_item;
|
|
include library.loot;
|
|
include library.regions;
|
|
include library.city;
|
|
include library.skill;
|
|
include library.money;
|
|
include library.create;
|
|
include library.pet_lib;
|
|
include library.player_stomach;
|
|
include library.pclib;
|
|
include library.badge;
|
|
include library.xp;
|
|
include library.camping;
|
|
|
|
/***** INHERITS ********************************************************/
|
|
|
|
/***** CONSTANTS *******************************************************/
|
|
|
|
const string DEBUG_EMOTE_TARGET = "debug.emote_target";
|
|
|
|
/***** TEST HANDLERS *******************************************************/
|
|
|
|
|
|
/***** TRIGGERS *******************************************************/
|
|
trigger OnSpeaking(string text)
|
|
{
|
|
boolean foundTrigger = false;
|
|
|
|
obj_id target = getLookAtTarget(self);
|
|
if ( (target == null) || (target == obj_id.NULL_ID) )
|
|
{
|
|
//assume target = self
|
|
target = self;
|
|
}
|
|
|
|
java.util.StringTokenizer st = new java.util.StringTokenizer(text);
|
|
string arg = st.nextToken();
|
|
|
|
|
|
//************** BASE FUNCTIONS ***************************
|
|
if ( arg.equals("") )
|
|
{
|
|
}
|
|
|
|
//************** BASE FUNCTIONS ***************************
|
|
else if ( arg.equals("addJediSlot") )
|
|
{
|
|
addJediSlot(target);
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** BASE FUNCTIONS ***************************
|
|
else if ( arg.equals("insure") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
target = utils.stringToObjId(st.nextToken());
|
|
if ( isIdValid(target) )
|
|
{
|
|
if ( setInsured(target, true) )
|
|
sendSystemMessageTestingOnly(self, target + " insured: " + isInsured(target));
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
}
|
|
else if ( arg.equals("uninsure") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
target = utils.stringToObjId(st.nextToken());
|
|
if ( isIdValid(target) )
|
|
{
|
|
if ( setInsured(target, false) )
|
|
sendSystemMessageTestingOnly(self, target + " uninsured: " + !isInsured(target));
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
}
|
|
else if ( arg.equals("autoinsure") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
target = utils.stringToObjId(st.nextToken());
|
|
if ( isIdValid(target) )
|
|
{
|
|
if ( setAutoInsured(target) )
|
|
sendSystemMessageTestingOnly(self, target + " autoinsured: " + isAutoInsured(target));
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
}
|
|
else if ( arg.equals("setUninsurable") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
target = utils.stringToObjId(st.nextToken());
|
|
if ( isIdValid(target) )
|
|
{
|
|
if ( setUninsurable(target, true) )
|
|
sendSystemMessageTestingOnly(self, target + " uninsurable: " + isUninsurable(target));
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
}
|
|
else if ( arg.equals("clearUninsurable") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
target = utils.stringToObjId(st.nextToken());
|
|
if ( isIdValid(target) )
|
|
{
|
|
if ( setUninsurable(target, false) )
|
|
sendSystemMessageTestingOnly(self, target + " is insurable: " + !isUninsurable(target));
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
}
|
|
|
|
//************** BASE FUNCTIONS ***************************
|
|
else if ( arg.equals("getName") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
obj_id tmp = utils.stringToObjId(st.nextToken());
|
|
if ( isIdValid(tmp) )
|
|
target = tmp;
|
|
}
|
|
|
|
sendSystemMessageTestingOnly(self, target + " name: " + getName(target));
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** TIME FUNCTIONS ***************************
|
|
else if ( arg.equals("setFactionStanding") )
|
|
{
|
|
if ( st.hasMoreTokens() && st.countTokens() == 2 )
|
|
{
|
|
string factionName = st.nextToken();
|
|
int value = utils.stringToInt(st.nextToken());
|
|
if ( value < 1 )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "[DEBUGGER] syntax: setFactionStanding <faction> <value>");
|
|
}
|
|
else
|
|
{
|
|
factions.setFactionStanding(target, factionName, (float)value);
|
|
sendSystemMessageTestingOnly(self, "[DEBUGGER] attempting to setfaction: faction = " + factionName + " val = " + value);
|
|
}
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** TIME FUNCTIONS ***************************
|
|
else if ( arg.equals("getGameTime") )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Current game time = " + getGameTime());
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** TIME FUNCTIONS ***************************
|
|
else if ( arg.equals("pvpCanAttack") )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "pvpCanAttack(self, " + target + ") = " + pvpCanAttack(self, target));
|
|
foundTrigger = true;
|
|
}
|
|
|
|
else if ( arg.equals("pvpCanBeAttacked") )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "pvpCanBeAttacked(" + target + ", self) = " + pvpCanAttack(target,self));
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** LOT FUNCTIONS ***************************
|
|
else if ( arg.equals("clearLots") )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Clearing your lots...");
|
|
int current_lots = getAccountNumLots(getPlayerObject(self));
|
|
adjustLotCount(getPlayerObject(self), -current_lots);
|
|
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("getLots") )
|
|
{
|
|
int current_lots = getAccountNumLots(getPlayerObject(self));
|
|
sendSystemMessageTestingOnly(self, "current account lots = " + current_lots);
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** WEAPON TYPE FUNCTIONS ***************************
|
|
else if ( arg.equals("getWeaponType") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
target = utils.stringToObjId(st.nextToken());
|
|
}
|
|
|
|
if ( isIdValid(target) )
|
|
sendSystemMessageTestingOnly(self, "target weapon type = " + getWeaponType(target));
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** FIREWORK FUNCTIONS ***************************
|
|
else if ( arg.equals("fireworkShow") )
|
|
{
|
|
obj_id inv = utils.getInventoryContainer(self);
|
|
if ( isIdValid(inv) )
|
|
{
|
|
obj_id show = createObject("object/tangible/firework/show.iff", inv, "");
|
|
if ( isIdValid(show) )
|
|
{
|
|
string[] fx_opt = dataTableGetStringColumnNoDefaults(firework.TBL_FX, "name");
|
|
|
|
string[] fxs = new string[firework.SHOW_EVENT_MAX];
|
|
float[] delays = new float[firework.SHOW_EVENT_MAX];
|
|
for ( int i = 0; i < fxs.length; i++ )
|
|
{
|
|
fxs[i] = fx_opt[rand(1,fx_opt.length-1)];
|
|
//delays[i] = rand(0.1f, 10f);
|
|
if ( i == 0 )
|
|
delays[i] = 10f;
|
|
else
|
|
delays[i] = 0.1f;
|
|
}
|
|
|
|
if ( fxs != null && fxs.length > 0 && delays != null && delays.length > 0 )
|
|
{
|
|
setObjVar(show, firework.VAR_SHOW_FX, fxs);
|
|
setObjVar(show, firework.VAR_SHOW_DELAY, delays);
|
|
|
|
setCount(show, firework.SHOW_EVENT_MAX);
|
|
sendSystemMessageTestingOnly(self, "Fireworks show created in your inventory!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
debugSpeakMsg(self, "fireworkShow: unable to create valid object in your inventory!");
|
|
}
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** TIME FUNCTIONS ***************************
|
|
else if ( arg.equals("getPalVars") )
|
|
{
|
|
resizeable string[] entries = new string[0];
|
|
|
|
dictionary d = hue.getPalcolorData(target);
|
|
if ( d != null && !d.isEmpty() )
|
|
{
|
|
java.util.Enumeration keys = d.keys();
|
|
while ( keys.hasMoreElements() )
|
|
{
|
|
string var = (string)keys.nextElement();
|
|
int idx = d.getInt(var);
|
|
|
|
entries = utils.addElement(entries, var + " -> " + idx);
|
|
}
|
|
}
|
|
|
|
if ( entries == null || entries.length == 0 )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "No palcolor data for target: " + target);
|
|
}
|
|
else
|
|
{
|
|
sui.listbox(self, self, "Palvar data for " + target, sui.OK_ONLY, target.toString(), entries, "noHandler");
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** OWNERSHIP FUNCTIONS ***************************
|
|
else if ( arg.equals("getOwner") )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Target(" + target + ") owner = " + getOwner(target));
|
|
foundTrigger = true;
|
|
}
|
|
|
|
else if ( arg.equals("setOwner") )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Attempting to set owner... of Target(" + target + ") to owner = " + self);
|
|
|
|
if (setOwner(target, self))
|
|
sendSystemMessageTestingOnly(self, " Set Owner succeeded");
|
|
else
|
|
sendSystemMessageTestingOnly(self, " Set Owner failed");
|
|
|
|
sendSystemMessageTestingOnly(self, "Target(" + target + ") owner = " + getOwner(target));
|
|
foundTrigger = true;
|
|
}
|
|
|
|
|
|
|
|
//************** OWNERSHIP FUNCTIONS ***************************
|
|
else if ( arg.equals("getContainerType") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
obj_id tmpTarget = utils.stringToObjId(st.nextToken());
|
|
if ( isIdValid(tmpTarget) )
|
|
target = tmpTarget;
|
|
}
|
|
sendSystemMessageTestingOnly(self, "Target(" + target + ") container type = " + getContainerType(target));
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** OWNERSHIP FUNCTIONS ***************************
|
|
else if ( arg.equals("playAnim") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
string anim = st.nextToken();
|
|
sendSystemMessageTestingOnly(self, "Target(" + target + ") attempting to play anim: " + anim);
|
|
ai_lib.doAction(target, anim);
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** OWNERSHIP FUNCTIONS ***************************
|
|
else if ( arg.equals("spawnSignedStructures") )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "attempting to spawn all signed structures...");
|
|
|
|
string[] tpf = dataTableGetStringColumnNoDefaults("datatables/structure/player_structure_sign.iff", "STRUCTURE_APPEARANCE");
|
|
if ( tpf != null && tpf.length > 0 )
|
|
{
|
|
location there = getLocation(self);
|
|
there.x = there.x - 60f;
|
|
|
|
dictionary d= new dictionary();
|
|
d.put("template",tpf);
|
|
d.put("loc", there);
|
|
d.put("cnt", 0);
|
|
|
|
messageTo(self, "handleSignedStructureCreation", d, 3, false);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "unable to locate structure templates");
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** OWNERSHIP FUNCTIONS ***************************
|
|
else if ( arg.equals("setMagicCondition") )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Target(" + target + ") attempting to set condition magic");
|
|
setCondition(target, CONDITION_MAGIC_ITEM);
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("clearMagicCondition") )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Target(" + target + ") attempting to set condition magic");
|
|
clearCondition(target, CONDITION_MAGIC_ITEM);
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** OWNERSHIP FUNCTIONS ***************************
|
|
else if ( arg.equals("getCount") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
target = utils.stringToObjId(st.nextToken());
|
|
if ( isIdValid(target) )
|
|
{
|
|
int cnt = getCount(target);
|
|
sendSystemMessageTestingOnly(self, "Target(" + target + ") get count = " + cnt);
|
|
}
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("setCount") )
|
|
{
|
|
if ( st.hasMoreTokens() && st.countTokens() == 2 )
|
|
{
|
|
target = utils.stringToObjId(st.nextToken());
|
|
int cnt = utils.stringToInt(st.nextToken());
|
|
if ( isIdValid(target) && cnt > 0 )
|
|
{
|
|
setCount(target, cnt);
|
|
sendSystemMessageTestingOnly(self, "Target(" + target + ") set count = " + cnt);
|
|
}
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("incrementCount") )
|
|
{
|
|
if ( st.hasMoreTokens() && st.countTokens() == 2 )
|
|
{
|
|
target = utils.stringToObjId(st.nextToken());
|
|
int cnt = utils.stringToInt(st.nextToken());
|
|
if ( isIdValid(target) && cnt > 0 )
|
|
{
|
|
incrementCount(target, cnt);
|
|
sendSystemMessageTestingOnly(self, "Target(" + target + ") increment count = " + cnt + " total cnt = " + getCount(target));
|
|
}
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** OWNERSHIP FUNCTIONS ***************************
|
|
else if ( arg.equals("baitFishingPole") )
|
|
{
|
|
obj_id held = getObjectInSlot(self, "hold_r");
|
|
if ( !isIdValid(held) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Invalid obj_id reference in slot HELD_R");
|
|
}
|
|
else
|
|
{
|
|
if ( !minigame.isFishingPole(held) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "HELD_R object is not a fishing pole");
|
|
}
|
|
else
|
|
{
|
|
obj_id bait = createObject("object/tangible/fishing/bait/bait_grub.iff", held, "");
|
|
if ( isIdValid(bait) )
|
|
sendSystemMessageTestingOnly(self, "Bait(" + bait + ") created in HELD_R(" + held + ")");
|
|
else
|
|
sendSystemMessageTestingOnly(self, "Unable to create bait(" + bait + ") in HELD_R(" + held + ")");
|
|
}
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("debugCatchFish") )
|
|
{
|
|
if ( minigame.isFishing(self) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Setting caught fish scriptvars...");
|
|
utils.setScriptVar(self, minigame.SCRIPTVAR_STATUS, minigame.FS_CAUGHT);
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("debugCatchLoot") )
|
|
{
|
|
if ( minigame.isFishing(self) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Setting caught fishing loot scriptvars...");
|
|
utils.setScriptVar(self, minigame.SCRIPTVAR_STATUS, minigame.FS_LOOT);
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("makeFish") )
|
|
{
|
|
obj_id fish = minigame.spawnFishingFish(self, getLocation(self));
|
|
if ( isIdValid(fish) )
|
|
sendSystemMessageTestingOnly(self, "creating fish: obj_id = " + fish);
|
|
else
|
|
sendSystemMessageTestingOnly(self, "unable to make fish!");
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** OWNERSHIP FUNCTIONS ***************************
|
|
else if ( arg.equals("makeFirework") )
|
|
{
|
|
obj_id inv = utils.getInventoryContainer(self);
|
|
obj_id fw = createObject("object/tangible/firework/default.iff", inv, "");
|
|
if ( isIdValid(fw) )
|
|
sendSystemMessageTestingOnly(self, "creating firework: obj_id = " + fw);
|
|
else
|
|
sendSystemMessageTestingOnly(self, "unable to make firework!");
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** OWNERSHIP FUNCTIONS ***************************
|
|
else if ( arg.equals("testGetHeadingToLocation") )
|
|
{
|
|
if ( target != self )
|
|
{
|
|
location here = getLocation(self);
|
|
location there = getLocation(target);
|
|
|
|
float range = getDistance(here, there);
|
|
float heading = utils.getHeadingToLocation(here, there);
|
|
|
|
sendSystemMessageTestingOnly(self, "range = " + range + " heading = " + heading);
|
|
sendSystemMessageTestingOnly(self, "If it was successful, an explosion should have lit under your feet!");
|
|
|
|
location testLoc = utils.rotatePointXZ(there, range, heading);
|
|
|
|
createObject("object/static/particle/particle_sm_explosion.iff", testLoc);
|
|
}
|
|
else
|
|
sendSystemMessageTestingOnly(self, "Self is an invalid target for this test trigger");
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** OWNERSHIP FUNCTIONS ***************************
|
|
else if ( arg.equals("openObject") )
|
|
{
|
|
if ( isIdValid(target) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Attempting to open target container...");
|
|
utils.requestContainerOpen(self, target);
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("openInventory") )
|
|
{
|
|
obj_id inv = utils.getInventoryContainer(target);
|
|
if ( isIdValid(inv) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Attempting to open target's inventory...");
|
|
utils.requestContainerOpen(self, inv);
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** OWNERSHIP FUNCTIONS ***************************
|
|
else if ( arg.equals("grenade") )
|
|
{
|
|
obj_id inv = utils.getInventoryContainer(self);
|
|
obj_id grenade = createObject("object/weapon/ranged/grenade/grenade_fragmentation_light.iff", inv, "");
|
|
if ( isIdValid(grenade) )
|
|
sendSystemMessageTestingOnly(self, "Grenade(" + grenade + ") created in your inventory");
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("grenadeMine") )
|
|
{
|
|
obj_id inv = utils.getInventoryContainer(target);
|
|
obj_id grenade = createObject("object/weapon/ranged/grenade/grenade_fragmentation_light.iff", inv, "");
|
|
if ( isIdValid(grenade) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Grenade(" + grenade + ") created AS A MINE in target inventory");
|
|
setObjVar(grenade, "isMine", 1);
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("fillMinefield") )
|
|
{
|
|
obj_id grenade = createObject("object/weapon/mine/wp_mine_drx55.iff", target, "");
|
|
if ( isIdValid(grenade) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "DRX55 MINE(" + grenade + ") created AS A MINE in minefield");
|
|
setObjVar(grenade, "isMine", 1);
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** OWNERSHIP FUNCTIONS ***************************
|
|
else if ( arg.equals("quickDeed") )
|
|
{
|
|
obj_id inv = utils.getInventoryContainer(self);
|
|
obj_id deed = createObject("object/tangible/deed/player_house_deed/tatooine_house_small_deed.iff", inv, "");
|
|
if ( isIdValid(deed) )
|
|
{
|
|
setObjVar(deed, "player_structure.deed.buildtime",15);
|
|
sendSystemMessageTestingOnly(self, "deed set in inventory...");
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "unable to create deed...");
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("sign") )
|
|
{
|
|
if ( st.countTokens() == 1 )
|
|
{
|
|
target = utils.stringToObjId(st.nextToken());
|
|
if ( isIdValid(target) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "attempting to createStructureSign on " + target);
|
|
obj_id sign = player_structure.createStructureSign(target);
|
|
if ( isIdValid(sign) )
|
|
sendSystemMessageTestingOnly(self, "sign(" + sign + ") created...");
|
|
else
|
|
sendSystemMessageTestingOnly(self, "unable to create structure sign...");
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
}
|
|
|
|
|
|
//************** HP FUNCTIONS ***************************
|
|
else if ( arg.equals("rings") )
|
|
{
|
|
obj_id inv = utils.getInventoryContainer(self);
|
|
if ( isIdValid(inv) )
|
|
{
|
|
for ( int i = 1; i < 5; i++ )
|
|
{
|
|
createObject("object/tangible/wearables/ring/ring_s0"+i+".iff", inv, "");
|
|
}
|
|
|
|
sendSystemMessageTestingOnly(self, "Rings created in your inventory...");
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** HP FUNCTIONS ***************************
|
|
else if ( arg.equals("maxhp") )
|
|
{
|
|
int max = getMaxHitpoints(target);
|
|
setHitpoints(target, max);
|
|
|
|
sendSystemMessageTestingOnly(self, "Target(" + target + ") set to max hp!");
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** SOCKET-GEM FUNCTIONS ***************************
|
|
else if ( arg.equals("makeSocketed") )
|
|
{
|
|
int cnt = 0;
|
|
if ( st.countTokens() == 2 )
|
|
{
|
|
target = utils.stringToObjId(st.nextToken());
|
|
}
|
|
|
|
if ( st.countTokens() == 1 )
|
|
{
|
|
cnt = utils.stringToInt(st.nextToken());
|
|
}
|
|
|
|
if ( isIdValid(target) && cnt > 0 )
|
|
{
|
|
int got = getGameObjectType(target);
|
|
//debugSpeakMsg(self, "(" + target + ") got type = " + got + " clothing = " + GOT_clothing);
|
|
if ( isGameObjectTypeOf(got, GOT_clothing) || isGameObjectTypeOf(got, GOT_misc_container_wearable)
|
|
|| isGameObjectTypeOf(got, GOT_armor) )
|
|
{
|
|
setSkillModSockets(target, cnt);
|
|
sendSystemMessageTestingOnly(self, "makeSocketed: setting socket count -> " + cnt);
|
|
}
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("makeGem") )
|
|
{
|
|
obj_id inv = utils.getInventoryContainer(self);
|
|
if ( isIdValid(inv) )
|
|
{
|
|
int lvl = rand(10,60);
|
|
obj_id gem = magic_item.makeGem(inv, lvl);
|
|
if ( isIdValid(gem) )
|
|
sendSystemMessageTestingOnly(self, "Gem succuessfully created: obj_id = " + gem + " lvl = " + lvl);
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** LOOT FUNCTIONS ***************************
|
|
else if ( arg.equals("makeLoot") )
|
|
{
|
|
if ( st.countTokens() == 1 )
|
|
{
|
|
string itemArg = st.nextToken();
|
|
|
|
int lvl = rand(1,60);
|
|
|
|
obj_id inv = null;
|
|
|
|
if ( isMob(target) )
|
|
inv = utils.getInventoryContainer(self);
|
|
else if ( getContainerType(target) > 0 )
|
|
inv = target;
|
|
|
|
if ( isIdValid(inv) )
|
|
{
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
}
|
|
else if ( arg.equals("testRandomLoot") )
|
|
{
|
|
//create backpack
|
|
int[] opt = {1,3,4,5,6};
|
|
int idx = rand(0, opt.length-1);
|
|
string template = "object/tangible/wearables/backpack/backpack_s0" + opt[idx] + ".iff";
|
|
|
|
target = createObject(template, utils.getInventoryContainer(self), "");
|
|
if ( !isIdValid(target) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "unable to create template: " + template);
|
|
}
|
|
else
|
|
{
|
|
setName(target, "lootTest:" + getGameTime());
|
|
|
|
string[] lootTypes = dataTableGetStringColumnNoDefaults("datatables/mob/creatures.iff","miscType");
|
|
if ( (lootTypes != null) && (lootTypes.length > 0) )
|
|
{
|
|
int n=0;
|
|
for ( int i = 0; i < 50; i++ )
|
|
{
|
|
if ( n >= 50 )
|
|
break;
|
|
|
|
int lvl = rand(1,60);
|
|
//string itemArg = lootTypes[rand(0,lootTypes.length - 1)];
|
|
//string itemArg = "datatables/loot/generic.iff:general";
|
|
string itemArg = "datatables/loot/generic.iff:clothing";
|
|
|
|
//LOG("betaDebugger","testRandomLoot: itemArg = " + itemArg);
|
|
//LOG("betaDebugger","testRandomLoot: target = " + target);
|
|
//LOG("betaDebugger","testRandomLoot: lvl = " + lvl);
|
|
}
|
|
|
|
sendSystemMessageTestingOnly(self, "created " + n + " loot items in target = " + target);
|
|
}
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("makeJunk") )
|
|
{
|
|
string itemArg = "datatables/loot/generic.iff:misc";
|
|
if ( st.countTokens() == 1 )
|
|
{
|
|
itemArg = "datatables/loot/generic.iff:" + st.nextToken();
|
|
}
|
|
int lvl = rand(1,60);
|
|
|
|
obj_id inv = utils.getInventoryContainer(self);
|
|
if ( isIdValid(inv) )
|
|
{
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
|
|
//************** CREATE OBJECT FUNCTIONS ***************************
|
|
else if ( arg.equals("createObject") )
|
|
{
|
|
if ( st.countTokens() == 1 )
|
|
{
|
|
string template = st.nextToken();
|
|
obj_id item = createObject(template, getLocation(self));
|
|
if ( isIdValid(item) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "createObject: object created! id = " + item);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "createObject: unable to create object!!");
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
}
|
|
|
|
//************** TIME FUNCTIONS ***************************
|
|
else if ( arg.equals("convertToMagicItem") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
string sTarget = st.nextToken();
|
|
target = utils.stringToObjId(sTarget);
|
|
}
|
|
|
|
if ( !isIdValid(target) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "convertToMagicItem: invalid target!");
|
|
}
|
|
else
|
|
{
|
|
int lvl = rand(5, 250);
|
|
if ( magic_item.convertToMagicItem(target, lvl) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Target(" + target + "): converted to magic item where lvl = " + lvl);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Target(" + target + "): convert failed @ lvl = " + lvl);
|
|
}
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
else if ( arg.equals("magicBackpack") )
|
|
{
|
|
int lvl = rand(5, 250);
|
|
|
|
int[] opt = {1,3,4,5,6};
|
|
int idx = rand(0, opt.length-1);
|
|
string template = "object/tangible/wearables/backpack/backpack_s0" + opt[idx] + ".iff";
|
|
|
|
target = createObject(template, utils.getInventoryContainer(self), "");
|
|
if ( !isIdValid(target) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "unable to create template: " + template);
|
|
}
|
|
else
|
|
{
|
|
if ( magic_item.convertToMagicItem(target, lvl) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Target(" + target + "): converted to magic item where lvl = " + lvl);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Target(" + target + "): convert failed @ lvl = " + lvl);
|
|
}
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** REGION FUNCTIONS ***************************
|
|
else if ( arg.equals("getInventoryContainer") )
|
|
{
|
|
obj_id inv = utils.getInventoryContainer(target);
|
|
if ( isIdValid(inv) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Target = " + target + " Inventory = " + inv);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Unable to locate an inventory for target = " + target);
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** REGION FUNCTIONS ***************************
|
|
else if ( arg.equals("getCityRegion") )
|
|
{
|
|
location here = getLocation(self);
|
|
region[] r = getRegionsWithGeographicalAtPoint(here, regions.GEO_CITY);
|
|
if ( (r == null) || (r.length == 0) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "No city regions located here!");
|
|
}
|
|
|
|
if ( r.length > 1 )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Multiple city regions located here!");
|
|
for ( int i = 0; i < r.length; i++ )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "region[" + i + "] = " + r[i].getName());
|
|
}
|
|
}
|
|
|
|
region city = r[0];
|
|
sendSystemMessageTestingOnly(self, "Primary city region (region[0]) = " + city.getName());
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** FACTION FUNCTIONS ***************************
|
|
else if ( arg.equals("addFaction") )
|
|
{
|
|
if ( st.hasMoreTokens() && st.countTokens() == 2 )
|
|
{
|
|
string faction = st.nextToken();
|
|
string sVal = st.nextToken();
|
|
int val = utils.stringToInt(sVal);
|
|
|
|
if ( val != -1 )
|
|
{
|
|
if ( factions.addFactionStanding(target, faction, val) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Granted " + val + "pts of " + faction + " faction to target: " + target);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Unable to grant faction pts to target. target = " + target);
|
|
sendSystemMessageTestingOnly(self, "faction = " + faction + " val = " + val);
|
|
}
|
|
}
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("getStanding") )
|
|
{
|
|
if ( st.hasMoreTokens() && st.countTokens() == 1 )
|
|
{
|
|
string faction = st.nextToken();
|
|
float val = factions.getFactionStanding(self, faction);
|
|
sendSystemMessageTestingOnly(self, faction + " faction standing for " + target + " = " + val);
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** ATTRIB FUNCTIONS ***************************
|
|
else if ( arg.equals("clearAttribMods") )
|
|
{
|
|
removeAllAttribModifiers(target);
|
|
sendSystemMessageTestingOnly(self, "Attrib mods cleared for target = " + target);
|
|
foundTrigger = true;
|
|
}
|
|
|
|
else if ( arg.equals("getAttrib") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
int attrib = utils.stringToInt(st.nextToken());
|
|
sendSystemMessageTestingOnly(self, "target (" + target + ") attrib (" + attrib + ") value = " + getAttrib(target, attrib));
|
|
sendSystemMessageTestingOnly(self, "max = " + getMaxAttrib(target, attrib) + " wounded max = " + getWoundedMaxAttrib(target, attrib));
|
|
sendSystemMessageTestingOnly(self, "unmod max = " + getUnmodifiedMaxAttrib(target, attrib));
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
|
|
|
|
//************** NAMING FUNCTIONS ***************************
|
|
else if ( arg.equals("getName") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
target = utils.stringToObjId(st.nextToken());
|
|
if ( !isIdValid(target) )
|
|
{
|
|
target = self;
|
|
}
|
|
}
|
|
|
|
sendSystemMessageTestingOnly(self, "(" + target +") target name = " + getName(target));
|
|
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("setName") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
int numTokens = st.countTokens();
|
|
string name = null;
|
|
switch ( numTokens )
|
|
{
|
|
case 2:
|
|
target = utils.stringToObjId(st.nextToken());
|
|
break;
|
|
}
|
|
|
|
name = st.nextToken();
|
|
|
|
if ( isIdValid(target) && ( name != null ) && ( !name.equals("") ) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "renaming (" + target + ")" + getName(target) + " -> " + name);
|
|
setName(target, name);
|
|
}
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** INVENTORY SLOT FUNCTIONS ***************************
|
|
else if ( arg.equals("getItemInSlot") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
string slot = st.nextToken();
|
|
|
|
obj_id item = getObjectInSlot(target, slot);
|
|
if ( (item == null) || (item == obj_id.NULL_ID) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "(" + target +") no object in slot(" + slot + ")");
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "(" + target +") object in slot(" + slot + ") is (" + item + ")" + getName(item));
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
}
|
|
|
|
//************** COMBAT DIFFICULTY FUNCTIONS ***************************
|
|
else if ( arg.startsWith("getCombatDiff") )
|
|
{
|
|
int diff = getLevel(target);
|
|
sendSystemMessageTestingOnly(self, "Target (" + target +") combat difficulty = " + diff);
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** GAME OBJECT TYPE FUNCTIONS ***************************
|
|
else if ( arg.equals("getGOT") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
string sItem = st.nextToken();
|
|
obj_id item = utils.stringToObjId(sItem);
|
|
if ( isIdValid(item) )
|
|
{
|
|
int gotType = getGameObjectType(item);
|
|
sendSystemMessageTestingOnly(self, "(" + item + ")" + getName(item) + " is of object type " + gotType);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "unable to parse valid obj_id");
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
}
|
|
|
|
//************** SLOT-RELATED FUNCTIONS ***************************
|
|
else if ( arg.equals("getObjectInSlot") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
string sTarget = "";
|
|
string slotName = "";
|
|
|
|
switch ( st.countTokens() )
|
|
{
|
|
case 1:
|
|
slotName = st.nextToken();
|
|
break;
|
|
|
|
case 2:
|
|
sTarget = st.nextToken();
|
|
slotName = st.nextToken();
|
|
|
|
target = utils.stringToObjId(sTarget);
|
|
break;
|
|
}
|
|
|
|
if ( isIdValid(target) )
|
|
{
|
|
obj_id itemInSlot = getObjectInSlot(target, slotName);
|
|
if ( isIdValid(itemInSlot) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "(" + target + ") object in slot " + slotName + " = (" + itemInSlot + ") " + getName(itemInSlot));
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "no valid item in slot " + slotName);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "unable to parse valid obj_id");
|
|
}
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** POWERUP FUNCTIONS ***************************
|
|
else if ( arg.equals("powerup") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
int cnt = st.countTokens();
|
|
|
|
if ( cnt == 2 )
|
|
{
|
|
string sItem = st.nextToken();
|
|
string sPup = st.nextToken();
|
|
|
|
obj_id item = utils.stringToObjId(sItem);
|
|
obj_id pup = utils.stringToObjId(sPup);
|
|
|
|
if ( (!isIdValid(item)) || (!isIdValid(pup)) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "unable to parse valid obj_ids");
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
if ( powerup.addToItem(self, item, pup) )
|
|
{
|
|
//sendSystemMessageTestingOnly(self, "powerup applied!");
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "unable to apply powerup!");
|
|
}
|
|
*/
|
|
}
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
}
|
|
|
|
|
|
//************** SCRIPTVAR MANAGEMENT FUNCTIONS ***************************
|
|
else if ( arg.equals("setScriptVar") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
int cnt = st.countTokens();
|
|
|
|
if ( cnt == 2 )
|
|
{
|
|
string path = st.nextToken();
|
|
string val = st.nextToken();
|
|
|
|
if ( utils.setScriptVar(target, path, val) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "scriptvar " + path + " set to " + val + "!");
|
|
}
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
}
|
|
else if ( arg.equals("hasScriptVar") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
int cnt = st.countTokens();
|
|
|
|
string path = st.nextToken();
|
|
|
|
if ( utils.hasScriptVar(target, path) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "hasScriptVar = TRUE");
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "hasScriptVar = FALSE");
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
}
|
|
|
|
else if ( arg.equals("removeScriptVar") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
int cnt = st.countTokens();
|
|
|
|
string path = st.nextToken();
|
|
|
|
utils.removeScriptVar(target, path);
|
|
sendSystemMessageTestingOnly(self, "scriptvar " + path + " removed!");
|
|
|
|
foundTrigger = true;
|
|
}
|
|
}
|
|
else if ( arg.equals("getScriptVar") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
int cnt = st.countTokens();
|
|
|
|
string path = st.nextToken();
|
|
|
|
string val = utils.getStringScriptVar(target, path);
|
|
if ( val == null )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "target does not have scriptvar " + path);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "scriptvar(" + path + ") = " + val);
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
}
|
|
else if ( arg.equals("showScriptVars") )
|
|
{
|
|
debugConsoleMsg(self, "*****************************");
|
|
|
|
//debugSpeakMsg(self, "st has more tokens? " + st.hasMoreTokens());
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
string soid = st.nextToken();
|
|
obj_id tmp = utils.stringToObjId(soid);
|
|
debugSpeakMsg(self, "attempting to parse oid from " + soid);
|
|
if ( isIdValid(tmp) )
|
|
{
|
|
target = tmp;
|
|
}
|
|
else
|
|
{
|
|
debugSpeakMsg(self, "UNABLE to parse oid from " + soid);
|
|
}
|
|
}
|
|
|
|
debugConsoleMsg(self, "showScriptVars: target = " + target);
|
|
|
|
deltadictionary delta = target.getScriptVars();
|
|
if ( delta == null )
|
|
{
|
|
debugConsoleMsg(self, "NONE!");
|
|
}
|
|
else
|
|
{
|
|
debugConsoleMsg(self, "dd = " + delta.toString());
|
|
}
|
|
|
|
sendSystemMessageTestingOnly(self, "Check console for showScriptVars output");
|
|
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("clearScriptVars") )
|
|
{
|
|
deltadictionary delta = target.getScriptVars();
|
|
|
|
java.util.Enumeration keys = delta.keys();
|
|
while ( keys.hasMoreElements() )
|
|
{
|
|
delta.remove(keys.nextElement());
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** CONTAINER MANAGEMENT FUNCTIONS ***************************
|
|
else if ( arg.equals("empty") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
obj_id container = utils.getInventoryContainer(target);
|
|
|
|
string param = st.nextToken();
|
|
if ( param.startsWith("inv") )
|
|
{
|
|
container = utils.getInventoryContainer(self);
|
|
}
|
|
else if ( param.equals("datapad") )
|
|
{
|
|
container = utils.getPlayerDatapad(self);
|
|
}
|
|
else
|
|
{
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
obj_id[] items = getContents(container);
|
|
if ( (items == null) || (items.length == 0) )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
for ( int i = 0; i < items.length; i++ )
|
|
{
|
|
destroyObject(items[i]);
|
|
}
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
}
|
|
|
|
//************** MONEY PAYMENT FUNCTIONS ***************************
|
|
else if ( arg.equals("pay") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
string param = st.nextToken();
|
|
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
string sAmt = st.nextToken();
|
|
int amt = utils.stringToInt(sAmt);
|
|
|
|
if ( amt < 1 )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "[debugger] SYNTAX: pay <acct name>|<obj_id> <amt>");
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
dictionary d = new dictionary();
|
|
|
|
obj_id payTarget = utils.stringToObjId(param);
|
|
if ( (payTarget == null) || (payTarget == obj_id.NULL_ID) )
|
|
{
|
|
money.pay(self, param, amt, "foo", d, true);
|
|
}
|
|
else
|
|
{
|
|
money.pay(self, payTarget, amt, "foo", d, true);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "[debugger] SYNTAX: pay <acct name>|<obj_id> <amt>");
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** OBJECT CREATION FUNCTIONS ***************************
|
|
else if ( arg.equals("lightsaber") )
|
|
{
|
|
createObject("object/weapon/melee/sword/sword_lightsaber_luke.iff", utils.getInventoryContainer(target), "");
|
|
sendSystemMessageTestingOnly(target, "check inv for new lightsaber");
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("lightsaber2h") )
|
|
{
|
|
createObject("object/weapon/melee/sword/sword_lightsaber_luke_2h_test.iff", utils.getInventoryContainer(target), "");
|
|
sendSystemMessageTestingOnly(target, "check inv for new lightsaber");
|
|
foundTrigger = true;
|
|
}
|
|
|
|
else if ( arg.equals("spawn") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
string type = st.nextToken();
|
|
create.object(type, getLocation(self));
|
|
foundTrigger = true;
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "[debugger] SYNTAX: spawn <mob type>");
|
|
return SCRIPT_OVERRIDE;
|
|
}
|
|
}
|
|
|
|
else if ( arg.equals("dataItem") )
|
|
{
|
|
target = self;
|
|
|
|
string tpf = "data_item.iff";
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
string param = st.nextToken();
|
|
if ( param.equals("rebel") )
|
|
{
|
|
tpf = "data_rebel.iff";
|
|
}
|
|
else if ( param.equals("imperial") )
|
|
{
|
|
tpf = "data_imperial.iff";
|
|
}
|
|
else
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
obj_id di = createObject("object/intangible/data_item/" + tpf, utils.getPlayerDatapad(target), "");
|
|
sendSystemMessageTestingOnly(target, "check datapad for new data item(" + di + ") " + tpf);
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** MESSAGING FUNCTIONS ***************************
|
|
else if ( arg.equals("makePet") )
|
|
{
|
|
if ( !isMob(target) )
|
|
{
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
else
|
|
{
|
|
pet_lib.makePet(target, self);
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** MESSAGING FUNCTIONS ***************************
|
|
else if ( arg.equals("message") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
string handler = st.nextToken();
|
|
|
|
sendSystemMessageTestingOnly(self, "messaging " + target + " with handler " + handler);
|
|
messageTo(target, handler, null, 0, false);
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** ROTATION FUNCTIONS ***************************
|
|
else if ( arg.equals("setYaw") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
if ( st.countTokens() == 2 )
|
|
{
|
|
target = utils.stringToObjId(st.nextToken());
|
|
}
|
|
|
|
if ( (target == null) || (target == obj_id.NULL_ID) || (target == self) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "syntax: setYaw <target id> <yaw>");
|
|
}
|
|
else
|
|
{
|
|
string sYaw = st.nextToken();
|
|
|
|
float yaw = utils.stringToFloat(sYaw);
|
|
if ( yaw == Float.NEGATIVE_INFINITY )
|
|
{
|
|
yaw = 0;
|
|
}
|
|
|
|
sendSystemMessageTestingOnly(self, "(" + target + ")" + getName(target) + " rotating to " + yaw);
|
|
setYaw(target, yaw);
|
|
}
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("getYaw") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
target = utils.stringToObjId(st.nextToken());
|
|
}
|
|
|
|
if ( (target == null) || (target == obj_id.NULL_ID) || (target == self) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "syntax: getYaw (<target id>)");
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "(" + target + ")" + getName(target) + " yaw = " + getYaw(target));
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("spin") )
|
|
{
|
|
float yaw = rand(-180, 180);
|
|
sendSystemMessageTestingOnly(self, "(" + target + ")" + getName(target) + " rotating to " + yaw);
|
|
setYaw(target, yaw);
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** REGION-RELATED FUNCTIONS ***************************
|
|
/*COMMENTED OUT DUE TO REGION FUNCTIONALITY CHANGEOVER
|
|
else if ( arg.equals("regions") )
|
|
{
|
|
region[] r = getRegionsAtPoint(getLocation(self));
|
|
if ( (r == null) || (r.length == 0) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "No regions at your location!");
|
|
}
|
|
else
|
|
{
|
|
for ( int i = 0; i < r.length; i++ )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "region " + i + ": " + getString(r[i].getFictionalName()));
|
|
}
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
*/
|
|
|
|
//************** REGION-RELATED FUNCTIONS ***************************
|
|
else if ( arg.equals("pathTo") )
|
|
{
|
|
if ( isMob(target) && !isPlayer(target) )
|
|
{
|
|
location myLoc = getLocation(self);
|
|
sendSystemMessageTestingOnly(self, "pathing (" + target + ")" + getName(target) + " to " + myLoc.toString());
|
|
pathTo(target, myLoc);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "pathTo trigger may only be used on AI-driven mobs");
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("pathFrom") )
|
|
{
|
|
if ( isMob(target) && !isPlayer(target) )
|
|
{
|
|
location myLoc = getLocation(self);
|
|
sendSystemMessageTestingOnly(self, "pathing (" + target + ")" + getName(target) + " away from self: " + myLoc.toString());
|
|
ai_lib.pathAwayFrom(target, self);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "pathFrom trigger may only be used on AI-driven mobs");
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** POSTURE FUNCTIONS ***************************
|
|
else if ( arg.equals("getPosture") )
|
|
{
|
|
debugSpeakMsg(self, "(" + target + ") " + getName(target) + "'s posture = " + getPosture(target));
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("setPosture") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
if ( st.countTokens() == 2 )
|
|
{
|
|
obj_id tmp = utils.stringToObjId(st.nextToken());
|
|
if ( isIdValid(tmp) )
|
|
target = tmp;
|
|
}
|
|
|
|
int posture = utils.stringToInt(st.nextToken());
|
|
if ( posture < 0 )
|
|
{
|
|
debugSpeakMsg(self, "int param must be >= 0");
|
|
}
|
|
else
|
|
{
|
|
setPosture(target, posture);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
debugSpeakMsg(self, "syntax: setPosture <posture(int)>");
|
|
}
|
|
debugSpeakMsg(self, "(" + target + ") " + getName(target) + "'s posture = " + getPosture(target));
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** HEALING FUNCTIONS ***************************
|
|
else if ( arg.equals("fullHeal") )
|
|
{
|
|
healShockWound(target, getShockWound(target));
|
|
setAttrib(target, HEALTH, getUnmodifiedMaxAttrib(target, HEALTH));
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** STOMACH FUNCTIONS ***************************
|
|
else if ( arg.equals("resetStomachs") )
|
|
{
|
|
player_stomach.resetStomachs(target);
|
|
debugSpeakMsg(target, "stomaches reset!");
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** DAMAGE & DEATH FUNCTIONS ***************************
|
|
else if ( arg.equals("incapacitateMob") )
|
|
{
|
|
debug.incapacitateMob(target);
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("deathBlow") || (arg.equals("coup de grace")) )
|
|
{
|
|
pclib.coupDeGrace(target, self);
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("killCreature") )
|
|
{
|
|
debug.killCreature(target);
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("forceSuicide") )
|
|
{
|
|
if ( target != self )
|
|
{
|
|
debug.forceSuicide(target);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "forceSuicide requires a non-self target!");
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("suicide") )
|
|
{
|
|
debug.suicide(self);
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("KILL") )
|
|
{
|
|
if ( isMob(target) )
|
|
{
|
|
kill(target);
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("nuke") )
|
|
{
|
|
if ( !isPlayer(target) )
|
|
{
|
|
destroyObject(target);
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** MISC DAMAGE FUNCTIONS ***************************
|
|
else if ( arg.equals("woundMob") )
|
|
{
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** SKILL-RELATED FUNCTIONS ***************************
|
|
else if ( arg.equals("assignSkillTemplate") )
|
|
{
|
|
string skill_name = st.nextToken();
|
|
skill.assignSkillTemplate(target, skill_name);
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("clearSkills") )
|
|
{
|
|
string[] skill_names = getSkillListingForPlayer(target);
|
|
if ( (skill_names == null) || (skill_names.length == 0) )
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
for ( int i = 0; i < skill_names.length; i++ )
|
|
{
|
|
revokeSkill(target, skill_names[i]);
|
|
}
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("getAllRequiredSkills") )
|
|
{
|
|
string skill_name = st.nextToken();
|
|
string[] skills = skill.getAllRequiredSkills(skill_name);
|
|
if ( (skills == null) || (skills.length == 0) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "error getting required skills for : " + skill_name);
|
|
foundTrigger = true;
|
|
}
|
|
else
|
|
{
|
|
debugConsoleMsg(self, "SKILLS REQUIRED FOR: " + skill_name);
|
|
debugConsoleMsg(self, "****************************************");
|
|
for ( int i = 0; i < skills.length; i++ )
|
|
{
|
|
debugConsoleMsg(self, " * " + skills[i]);
|
|
}
|
|
}
|
|
|
|
sendSystemMessageTestingOnly(self, "Check console for output...");
|
|
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("grantSkill") )
|
|
{
|
|
string skill_name = st.nextToken();
|
|
|
|
if ( grantSkill(self, skill_name) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "grantSkill::skill granted: " + skill_name);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "grantSkill::unable to grant skill: " + skill_name);
|
|
return SCRIPT_OVERRIDE;
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("revokeSkill") )
|
|
{
|
|
string skill_name = st.nextToken();
|
|
|
|
revokeSkill(self, skill_name);
|
|
sendSystemMessageTestingOnly(self, "revokeSkill::skill revoked: " + skill_name);
|
|
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("grantSkillToPlayer") )
|
|
{
|
|
string skill_name = st.nextToken();
|
|
|
|
if ( skill.grantSkillToPlayer(self, skill_name) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "grantSkillToPlayer::skill granted: " + skill_name);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "grantSkillToPlayer::unable to grant skill: " + skill_name);
|
|
return SCRIPT_OVERRIDE;
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("purchaseSkill") )
|
|
{
|
|
string skill_name = st.nextToken();
|
|
|
|
dictionary xpReqs = getSkillPrerequisiteExperience(skill_name);
|
|
|
|
java.util.Enumeration e = xpReqs.keys();
|
|
while ( e.hasMoreElements() )
|
|
{
|
|
string xpType = (string)(e.nextElement());
|
|
int xpCost = xpReqs.getInt(xpType);
|
|
grantExperiencePoints(self, xpType, xpCost);
|
|
}
|
|
|
|
skill.purchaseSkill(self, skill_name);
|
|
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("grantAllSkills") )
|
|
{
|
|
string[] skillList = dataTableGetStringColumn(skill.TBL_SKILL, "NAME");
|
|
if ( skillList != null && skillList.length > 0 )
|
|
{
|
|
dictionary d = new dictionary();
|
|
d.put("skills", skillList);
|
|
d.put("idx", 0);
|
|
|
|
messageTo(self, "handleGrantAllSkills", d, 3f, false);
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** BADGE-RELATED FUNCTIONS ***************************
|
|
else if ( arg.equals("grantBadge") )
|
|
{
|
|
string badgeName = st.nextToken();
|
|
badge.grantBadge(target, badgeName);
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("revokeBadge") )
|
|
{
|
|
string badgeName = st.nextToken();
|
|
badge.revokeBadge(target, badgeName, true);
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** CONTENTS-RELATED FUNCTIONS ***************************
|
|
else if ( arg.equals("getContents") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
obj_id tmp = utils.stringToObjId(st.nextToken());
|
|
if ( isIdValid(tmp) )
|
|
target = tmp;
|
|
}
|
|
|
|
obj_id[] contents = utils.getContents(target, true);
|
|
if ( (contents == null ) || (contents.length == 0) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Unable to retrieve contents of object #" + target);
|
|
}
|
|
else
|
|
{
|
|
string[] names = utils.makeNameList(contents);
|
|
|
|
string[] src = new string[contents.length];
|
|
for ( int i = 0; i < contents.length; i++ )
|
|
{
|
|
src[i] = "(" + contents[i] + ")" + names[i];
|
|
}
|
|
|
|
sui.listbox(self, "Inventory Contents for (" + target + ")" + getName(target), src);
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("getInventoryContents") )
|
|
{
|
|
obj_id inv = utils.getInventoryContainer(target);
|
|
if ( (inv == null) || (inv == obj_id.NULL_ID) )
|
|
{
|
|
foundTrigger = true;
|
|
}
|
|
else
|
|
{
|
|
obj_id[] contents = utils.getContents(inv, true);
|
|
string[] names = utils.makeNameList(contents);
|
|
|
|
string[] src = new string[contents.length];
|
|
for ( int i = 0; i < contents.length; i++ )
|
|
{
|
|
src[i] = "(" + contents[i] + ")" + names[i];
|
|
}
|
|
|
|
sui.listbox(self, "Inventory Contents for (" + target + ")" + getName(target), src);
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** FOLLOW-RELATED FUNCTIONS ***************************
|
|
else if ( arg.equals("follow") )
|
|
{
|
|
if ( isMob(target) )
|
|
{
|
|
ai_lib.aiFollow(target, self);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Follow commands are only usable on non-pc mobs!");
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("stopFollow") )
|
|
{
|
|
if ( isMob(target) )
|
|
{
|
|
ai_lib.aiStopFollowing(target);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Follow commands are only usable on non-pc mobs!");
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** AI BEHAVIOR FUNCTIONS ***************************
|
|
else if ( arg.equals("setBehavior") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
int behavior = -1;
|
|
string sBehavior = st.nextToken();
|
|
|
|
if ( sBehavior.equals("sentinel") )
|
|
{
|
|
behavior = ai_lib.BEHAVIOR_SENTINEL;
|
|
}
|
|
else if ( sBehavior.equals("wander") )
|
|
{
|
|
behavior = ai_lib.BEHAVIOR_WANDER;
|
|
}
|
|
else if ( sBehavior.equals("loiter") )
|
|
{
|
|
behavior = ai_lib.BEHAVIOR_LOITER;
|
|
}
|
|
else
|
|
{
|
|
behavior = utils.stringToInt(sBehavior);
|
|
}
|
|
|
|
if ( behavior > -1 )
|
|
{
|
|
if ( isMob(target) && !isPlayer(target) )
|
|
{
|
|
ai_lib.setDefaultCalmBehavior(target, behavior);
|
|
sendSystemMessageTestingOnly(self, getName(target) + "'s behavior set to " + behavior);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "set behavior commands are only usable on non-pc mobs!");
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
}
|
|
|
|
sendSystemMessageTestingOnly(self, "SYNTAX: setBehavior <int behavior>");
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** CHAT/SOCIAL/MOOD FUNCTIONS ***************************
|
|
else if ( arg.equals("mood") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
string mood = st.nextToken();
|
|
if ( isMob(target) )
|
|
{
|
|
if ( !isPlayer(target) )
|
|
{
|
|
ai_lib.setMood(target, mood);
|
|
sendSystemMessageTestingOnly(self, "Attempting to set " + getName(target) + "'s mood to " + mood);
|
|
}
|
|
else
|
|
{
|
|
if ( queueCommand(target, ##"setMood", null, mood, COMMAND_PRIORITY_DEFAULT) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, getName(target) + "'s mood set to " + mood);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "Unable to set " + getName(target) + "'s mood to " + mood);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "moods commands are only valid for creature objects!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "SYNTAX: mood <mood name>");
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("speak") )
|
|
{
|
|
if ( !isMob(target) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "speak is only usable on mobs!");
|
|
foundTrigger = true;
|
|
}
|
|
|
|
string chat = "none";
|
|
string mood = "none";
|
|
|
|
string msg = "";
|
|
|
|
while ( st.hasMoreTokens() )
|
|
{
|
|
string tok = st.nextToken();
|
|
if ( tok.startsWith("+") )
|
|
{
|
|
chat = tok.substring(1);
|
|
}
|
|
else if ( tok.startsWith("-") )
|
|
{
|
|
mood = tok.substring(1);
|
|
}
|
|
else
|
|
{
|
|
msg += tok + " ";
|
|
}
|
|
}
|
|
|
|
if ( msg.length() == 0 )
|
|
{
|
|
msg = "BLAH";
|
|
}
|
|
else if ( msg.length() > 1 )
|
|
{
|
|
msg = msg.substring(0, msg.length() - 1);
|
|
}
|
|
|
|
msg = chat + " " + mood + " 0" + msg;
|
|
queueCommand(target, ##"spatialChat", null, msg, COMMAND_PRIORITY_DEFAULT);
|
|
|
|
foundTrigger = true;
|
|
}
|
|
else if ( arg.equals("emote") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
string social = st.nextToken();
|
|
if ( social.equals("target") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
string sTarget = st.nextToken();
|
|
obj_id tId = utils.stringToObjId(sTarget);
|
|
if ( (tId != null) && (tId != obj_id.NULL_ID) )
|
|
{
|
|
setObjVar(self, DEBUG_EMOTE_TARGET, tId);
|
|
foundTrigger = true;
|
|
}
|
|
}
|
|
|
|
removeObjVar(self, DEBUG_EMOTE_TARGET);
|
|
foundTrigger = true;
|
|
}
|
|
|
|
string param = "";
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
param = st.nextToken();
|
|
}
|
|
|
|
if ( isMob(target) )
|
|
{
|
|
if ( param.equals("self") )
|
|
{
|
|
queueCommand(target, ##"social", target, social, COMMAND_PRIORITY_DEFAULT);
|
|
}
|
|
else if ( param.equals("me") )
|
|
{
|
|
queueCommand(target, ##"social", self, social, COMMAND_PRIORITY_DEFAULT);
|
|
}
|
|
else if ( param.equals("other") )
|
|
{
|
|
obj_id tId = getObjIdObjVar(self, DEBUG_EMOTE_TARGET);
|
|
if ( (tId != null) && (tId != obj_id.NULL_ID) && (exists(tId)) && (isInWorld(tId)) && (tId.isLoaded()) )
|
|
{
|
|
queueCommand(target, ##"social", tId, social, COMMAND_PRIORITY_DEFAULT);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "invalid DEBUG_EMOTE_TARGET! set it using 'emote target <oid>'");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
queueCommand(target, ##"social", null, social, COMMAND_PRIORITY_DEFAULT);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "emote commands are only valid for creature objects!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "SYNTAX: emote <mood name>");
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** XP-RELATED FUNCTIONS ***************************
|
|
else if ( arg.equals("xp") )
|
|
{
|
|
if ( !isPlayer(target) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "debugger::xp: target must be a player!");
|
|
foundTrigger = true;
|
|
}
|
|
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
string xp_type = st.nextToken();
|
|
int xp_amt = getExperiencePoints(target, xp_type);
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
string sAmt = st.nextToken();
|
|
int amt = 0;
|
|
if ( sAmt.startsWith("+") || sAmt.startsWith("-") )
|
|
{
|
|
amt = utils.stringToInt(sAmt.substring(1));
|
|
if ( amt == -1 )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "debugger::xp: invalid xp delta parameter...");
|
|
foundTrigger = true;
|
|
}
|
|
|
|
if ( sAmt.startsWith("-") )
|
|
{
|
|
amt = -amt;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
amt = utils.stringToInt(sAmt);
|
|
if ( amt == -1 )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "debugger::xp: invalid xp amount...");
|
|
foundTrigger = true;
|
|
}
|
|
|
|
amt = amt - xp_amt;
|
|
}
|
|
|
|
if ( amt != 0 )
|
|
{
|
|
xp.grant(target, xp_type, amt);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string msg = "(" + target + ") " + getName(target) + " has " + xp_amt + "pts of " + xp_type + " experience";
|
|
sendSystemMessageTestingOnly(self, msg);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "SYNTAX: xp <type> (+|-)<amt>");
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** CAMPING-RELATED FUNCTIONS ***************************
|
|
else if ( arg.equals("repelValue") )
|
|
{
|
|
int val = camping.getCampRepelValue(target);
|
|
sendSystemMessageTestingOnly(self, "camp repel value = " + val);
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** CAMPING-RELATED FUNCTIONS ***************************
|
|
else if ( arg.equals("fillInv") )
|
|
{
|
|
obj_id inv = utils.getInventoryContainer(target);
|
|
if ( (inv == null) || (inv == obj_id.NULL_ID) )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
while ( getVolumeFree(inv) > 0 )
|
|
{
|
|
createObject("object/tangible/test/inventory_filler.iff", inv, "");
|
|
}
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** TRIGGER VOLUME-RELATED FUNCTIONS ***************************
|
|
else if ( arg.equals("hasTriggerVolume") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
string vol_name = st.nextToken();
|
|
if ( hasTriggerVolume(target, vol_name) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "(" + target + ") " + getName(target) + " has a trigger volume named " + vol_name);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "(" + target + ") " + getName(target) + " does NOT have a trigger volume named " + vol_name);
|
|
}
|
|
}
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** DISTANCE-RELATED FUNCTIONS ***************************
|
|
else if ( arg.equals("getDistance2D") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
location here = getLocation(target);
|
|
|
|
int cnt = st.countTokens();
|
|
obj_id other = utils.stringToObjId(st.nextToken());
|
|
if ( (other == null) || (other == obj_id.NULL_ID) )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
location there = getLocation(other);
|
|
|
|
float dist = 0f;
|
|
|
|
switch ( cnt )
|
|
{
|
|
case 1:
|
|
dist = utils.getDistance2D(here, there);
|
|
sendSystemMessageTestingOnly(self, "distance between " + target + " and " + other + " = " + dist);
|
|
break;
|
|
|
|
case 2:
|
|
target = utils.stringToObjId(st.nextToken());
|
|
if ( (target == null) || (target == obj_id.NULL_ID) )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
here = getLocation(target);
|
|
|
|
dist = utils.getDistance2D(here, there);
|
|
sendSystemMessageTestingOnly(self, "distance between " + target + " and " + other + " = " + dist);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
float range = utils.getDistance2D(getLocation(self), getLocation(target));
|
|
sendSystemMessageTestingOnly(self, "distance between " + target + " and self = " + range);
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
else if ( arg.equals("getLocation") )
|
|
{
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
obj_id tmp = utils.stringToObjId(st.nextToken());
|
|
if ( isIdValid(tmp) )
|
|
{
|
|
target = tmp;
|
|
}
|
|
}
|
|
|
|
location here = getLocation(target);
|
|
sendSystemMessageTestingOnly(self, "target = " + target + " loc = " + here.toString());
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** COLOR-RELATED FUNCTIONS ***************************
|
|
else if ( arg.equals("color") || arg.equals("hue") )
|
|
{
|
|
boolean ss = false;
|
|
if ( st.hasMoreTokens() )
|
|
{
|
|
|
|
int col = utils.stringToInt (st.nextToken());
|
|
if ( col > -1 )
|
|
{
|
|
hueClothes (target, col);
|
|
}
|
|
else
|
|
{
|
|
sendSystemMessageTestingOnly(self, "[beta.debugger] hue passed invalid color -> randomizing");
|
|
hue.hueObject(target);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ss = true;
|
|
}
|
|
|
|
if ( ss )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "[beta.debugger] syntax: hue <int index>");
|
|
}
|
|
|
|
foundTrigger = true;
|
|
}
|
|
|
|
//************** OTHER TRIGGERS ***************************
|
|
{
|
|
//do nothing!!
|
|
}
|
|
|
|
if ( foundTrigger )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "[beta.debugger] " + text);
|
|
return SCRIPT_OVERRIDE;
|
|
}
|
|
else
|
|
{
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
}
|
|
|
|
|
|
/***** FUNCTIONS *******************************************************/
|
|
|
|
void hueClothes( obj_id newClothes, int col )
|
|
{
|
|
|
|
custom_var[] allVars = getAllCustomVars(newClothes);
|
|
|
|
for ( int i = 0; i < allVars.length; i++ )
|
|
{
|
|
|
|
custom_var cv = allVars[i];
|
|
ranged_int_custom_var ri = (ranged_int_custom_var)cv;
|
|
if (cv != null)
|
|
{
|
|
if ( cv.isPalColor() )
|
|
{
|
|
ri.setValue (col);
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
messageHandler handleSignedStructureCreation()
|
|
{
|
|
string[] tmp = params.getStringArray("template");
|
|
Vector tpf = new Vector(Arrays.asList(tmp));
|
|
string template = (String)(tpf.elementAt(0));
|
|
|
|
location there = params.getLocation("loc");
|
|
|
|
int cnt = params.getInt("cnt");
|
|
|
|
obj_id it = createObject(template, there);
|
|
if ( !isIdValid(it) )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "unable create structure from template: " + template);
|
|
}
|
|
else
|
|
{
|
|
obj_id sign = player_structure.createStructureSign(it);
|
|
if ( !isIdValid(sign) )
|
|
sendSystemMessageTestingOnly(self, "unable create structure sign for template: " + template);
|
|
}
|
|
|
|
tpf = utils.removeElementAt(tpf, 0);
|
|
if ( tpf != null && tpf.size() == 0 )
|
|
{
|
|
params.put("template", tpf);
|
|
|
|
if ( cnt / 5 > 0 )
|
|
{
|
|
there.x = there.x + 300f;
|
|
there.z = there.z + 60f;
|
|
}
|
|
else
|
|
{
|
|
there.x = there.x - 60f;
|
|
params.put("loc", there);
|
|
}
|
|
|
|
cnt++;
|
|
params.put("cnt", cnt);
|
|
|
|
messageTo(self, "handleSignedStructureCreation", params, 3, false);
|
|
}
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
messageHandler handleGrantAllSkills()
|
|
{
|
|
sendSystemMessageTestingOnly(self, "handleGrantAllSkills entered...");
|
|
if ( params == null || params.isEmpty() )
|
|
return SCRIPT_CONTINUE;
|
|
|
|
string[] skillList = params.getStringArray("skills");
|
|
int idx = params.getInt("idx");
|
|
|
|
for ( int i = idx; i < 5; i++ )
|
|
{
|
|
if ( i < skillList.length )
|
|
{
|
|
sendSystemMessageTestingOnly(self, "attempting to grant: " + skillList[i]);
|
|
grantSkill(self, skillList[i]);
|
|
}
|
|
else
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
|
|
params.put("idx", idx+5);
|
|
messageTo(self, "handleGrantAllSkills", params, 3f, false);
|
|
return SCRIPT_CONTINUE;
|
|
}
|