/**
 * 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;
}