/**
 * Title:        scriptlib
 * Description:  A library containing public general utility functions.
 */

/***** INCLUDES ********************************************************/
include java.util.Arrays;
include java.lang.System;
include java.lang.Math;

//include java.lang.reflect.Arrays;
include java.util.Arrays;
include java.util.Enumeration;
include java.util.HashSet;
include java.util.Iterator;
include java.util.List;
include java.util.Vector;

include java.io.ByteArrayInputStream;
include java.io.ByteArrayOutputStream;
include java.io.IOException;
include java.io.ObjectInputStream;
include java.io.ObjectOutputStream;

include script_entry;

include library.player_structure;
include library.healing;
include library.ai_lib;
include library.pclib;
include library.armor;
include library.chat;
include library.performance;
include library.trial;
include library.cloninglib;
include library.static_item;

/***** CONSTANTS *******************************************************/
const string VERSION = "v0.01.00";

const string VAR_OWNER                        		= "owner";
const string VAR_COOWNERS                     		= "coowners";

const string SLOT_INVENTORY				= "inventory";
const string SLOT_DATAPAD				= "datapad";
const string SLOT_HANGAR				= "hangar";
const string SLOT_BANK					= "bank";
const string SLOT_MISSION_BAG				= "mission_bag";

const string FREE_TRIAL					= "free_trial";
const string TIP					= FREE_TRIAL+".tip";
const string TIP_OUT_NUM				= TIP + ".tip_out_num";
const string TIP_OUT_AMMOUNT				= TIP + ".tip_out_ammount";
const string TIP_IN_NUM					= TIP + ".tip_in_num";
const string TIP_IN_AMMOUNT				= TIP + ".tip_in_ammount";
const string TIP_IN_THACK				= TIP + ".tip_in_timeHack";
const string TIP_OUT_THACK				= TIP + ".tip_out_timeHack";

const string TRIAL_STRUCTURE				= FREE_TRIAL+".trial_structure";

const int TIP_NUM_MAX					= 25;
const int TIP_AMT_MAX					= 100000;

const string NO_TRADE_SCRIPT			= "item.special.nomove";

// retroactive CTS history
const string CTS_OBJVAR_HISTORY         = "ctsRetroHistory";

const int BIT_LIST_SIZE							= 32;

const string_id SID_OBJECT_NOT_ACTIVE      		= new string_id("error_message", "object_not_active");

const string[] WAYPOINT_COLORS				={
								waypoint_colors.blue,
								waypoint_colors.green,
								waypoint_colors.orange,
								waypoint_colors.yellow,
								waypoint_colors.purple,
								waypoint_colors.white
							};

const string_id SID_SECONDS				= new string_id("spam", "seconds");
const string_id SID_MINUTES				= new string_id("spam", "minutes");
const string_id SID_HOURS				= new string_id("spam", "hours");
const string_id SID_DAYS				= new string_id("spam", "days");
const string_id SID_OUT_OF_RANGE			= new string_id("spam", "out_of_range");

const int COMMANDO 					= 1;
const int SMUGGLER 					= 2;
const int MEDIC 					= 3;
const int OFFICER 					= 4;
const int SPY 						= 5;
const int BOUNTY_HUNTER 				= 6;
const int FORCE_SENSITIVE 				= 7;
const int TRADER 					= 8;
const int ENTERTAINER 					= 9;

// Constants for gifts
const string LIFEDAY_OWNER				= "lifeday.owner";
const string XMAS_RECEIVED_V1				= "gift.xmas05";
const string XMAS_RECEIVED_V2				= "gift.xmas05v2";

const string XMAS_RECEIVED_VI1				= "gift.xmas06";
const string XMAS_RECEIVED_VI2				= "gift.xmas06v2";

const string XMAS_RECEIVED_VII1				= "gift.xmas07";
const string XMAS_RECEIVED_VII2				= "gift.xmas07v2";
const string XMAS_NOT_RECEIVED_TUTORIAL			= "gift.xmas06_inTutorialFail";

const string XMAS_RECEIVED_VIII1			= "gift.xmas08";
const string XMAS_RECEIVED_VIII2			= "gift.xmas08v2";

const string XMAS_RECEIVED_IX_01			= "gift.xmas09";

const string EMPIRE_DAY_RECEIVED_VI			= "gift.empire08";

const string_id GIFT_GRANTED 				= new string_id("system_msg", "gift_granted");
const string_id GIFT_GRANTED_SUB 			= new string_id("system_msg", "gift_granted_sub");

// House clean up code constants

const int HOUSE_CURRENT = 0;
const int HOUSE_HISTORY = 1;
const int HOUSE_MAX 	= 2;

// this value comes from TangibleObject.cpp. DO NOT CHANGE!
const obj_id OBJ_ID_BIO_LINK_PENDING = obj_id.getObjId(1);


const string VENDOR_SCRIPT = "terminal.vendor";
const string BAZAAR_SCRIPT = "terminal.bazaar";

/***** FUNCTIONS *******************************************************/
/**
 * @brief return iValue clipped within the specified min/max range
 *
 * @param iValue
 * @param iClipMin
 * @param iClipMax
 *
 * @return integer value clipped within the min/max range
 */
int clipRange( int iValue, int iClipMin, int iClipMax )
{
	return ( iValue < iClipMin ) ? iClipMin : ( iValue > iClipMax ) ? iClipMax : iValue;
}

/**
 * @brief retrieve a location a random angle and distance away from pos, using pos as the locus
 *
 * Note: This function works if either fMaxRadius >= or <= fMinRadius
 *
 * @param pos
 * @param fMinRadius
 * @param fMaxRadius
 *
 * @return a random location within the specified radii from pos
 */
location getRandomAwayLocation( location pos, float fMinRadius, float fMaxRadius )
{
	float fTheta = rand() * (2f * (float)Math.PI);
	float fRadius = Math.min(fMinRadius, fMaxRadius) + rand() * Math.abs(fMaxRadius - fMinRadius);

	pos.x += fRadius * Math.cos(fTheta);
	pos.z += fRadius * Math.sin(fTheta);
	return pos;
}

/**
 * @brief   return the floating point distance between two locations in 2D (elevation/Y is not taken into account)
 *
 * @param location  locTarget1
 * @param location  locTarget2
 *
 * @return float    distance in meters between two locations, -1.00f for invalid result
 */
/*float getDistance2D( location locTarget1, location locTarget2 )
{
	if ( locTarget1 == null || locTarget2 == null)
		return -1.00f;

	float dx = locTarget1.x - locTarget2.x;
	float dz = locTarget1.z - locTarget2.z;

	return (float)Math.sqrt(dx * dx + dz * dz);
}*/

float getDistance2D( location locTarget1, location locTarget2 )
{
	if ( locTarget1 == null || locTarget2 == null)
		return -1.00f;

	location loc1 = (location)locTarget1.clone();
	loc1.y = 0f;

	location loc2 = (location)locTarget2.clone();
	loc2.y = 0f;

	return getDistance(loc1, loc2);
}

float getDistance2D( obj_id hereTarget, obj_id thereTarget )
{
	if ( !isIdValid(hereTarget) || !isIdValid(thereTarget) )
		return -1.00f;

	return getDistance2D(getWorldLocation(hereTarget), getWorldLocation(thereTarget));
}

attrib_mod[] addMindAttribToStim(int power)
{
	attrib_mod[] am = new attrib_mod[2];

	//create attribute mods for HEALTH 0 and ACTION 3 and MIND 6
	for (int i = 0; i < 2; i++)
	{
		am[i] = createHealDamageAttribMod(i * 2, power);
	}
	return am;
}

/**
 * @brief   return an index to random-weighted array of values.
 *
 * Note: An empty or single element array will result in a return value of 0.
 *
 * @param float[]  fArray
 *
 * @return int an index to one of the passed values
 */
int randix( float[] fArray )
{
	// only need processing for multi-element arrays
	if ( fArray.length > 1 )
	{
		// initialize sum and calculate sum of all elements
		float fSum = 0.0f;
		for ( int i = 0; i < fArray.length; i++ )
			fSum += fArray[i];

		// pick a random value in the range of sum
		float fRandom = rand() * fSum;

		// find the array index for the range that value fRandom falls into
		fSum = 0.0f;
		for ( int i = 0; i < fArray.length; i++ )
		{
			fSum += fArray[i];
			if ( fRandom <= fSum )
				return i;
		}
	}

	// return index 0 for single element array, empty array, or first element check
	return 0;
}

//
//  removes all uncerted weapons and armor pieces from the player and sends system messages
//  when something was unequip.  Inventory may be overloaded by this function.
//  returns the number of items that were unequipped
//

boolean isMando (obj_id armor)
// check to see if we are wearing mandalorian armor
{

	if( isIdValid(armor))
	{
		string template = getTemplateName(armor);

		if (template.endsWith("armor_mandalorian_belt.iff") ||
		    template.endsWith("armor_mandalorian_bicep_l.iff")||
		    template.endsWith("armor_mandalorian_bicep_r.iff")||
		    template.endsWith("armor_mandalorian_bracer_l.iff")||
		    template.endsWith("armor_mandalorian_bracer_r.iff")||
		    template.endsWith("armor_mandalorian_chest_plate.iff")||
		    template.endsWith("armor_mandalorian_helmet.iff")||
		    template.endsWith("armor_mandalorian_leggings.iff")||
		    template.endsWith("armor_mandalorian_shoes.iff")||
		    template.endsWith("armor_mandalorian_gloves.iff") )
		 {
			return true;
		 }
	}

	return false;
}



boolean hasSpecialSkills (obj_id player)
// check to see if we have the skills necessary to wear mandalorian armor
{
	boolean skillCheck = false;

	if (hasSkill (player, "class_commando_phase4_master"))
	{
		skillCheck = true;
	}

	if (hasSkill (player, "class_bountyhunter_phase4_master"))
	{
		skillCheck = true;
	}

	return skillCheck;
}

int unequipAndNotifyUncerted(obj_id player)
{
	int totalUnequipped = 0;
	string[] armorSlots = new string[]
		{
			"hat",
			"chest2",
			"bicep_r",
			"bicep_l",
			"bracer_upper_r",
			"bracer_lower_r",
			"bracer_upper_l",
			"bracer_lower_l",
			"gloves",
			"pants2",
			"shoes",
			"chest1",
			"pants1",
			"utility_belt"
		};

	obj_id curArmor = null;
	obj_id inv = utils.getInventoryContainer(player);
	string classTemplate = getSkillTemplate(player);

	for(int i = 0; i < armorSlots.length; i++)
	{
		curArmor = getObjectInSlot(player, armorSlots[i]);
		if ( (isIdValid(curArmor) && !armor.isArmorCertified(player, curArmor))

	       	   ||(isMando(curArmor) && !hasSpecialSkills(player)) )

		{
			totalUnequipped++;
			prose_package pp = new prose_package();
			pp = prose.setStringId(pp, new string_id("spam", "armor_lost_cert"));
			pp = prose.setTT(pp, curArmor);
			sendSystemMessageProse(player, pp);
			putInOverloaded(curArmor, inv);
		}

		if(!isIdNull(curArmor) && hasObjVar(curArmor, "armor.fake_armor") && hasObjVar(curArmor, "dynamic_item.required_skill") )
		{
			string requiredSkill = getStringObjVar(curArmor, "dynamic_item.required_skill");
			if (classTemplate != null && classTemplate != "")
			{
				if (!classTemplate.startsWith(requiredSkill))
				{
					totalUnequipped++;
					prose_package pp = new prose_package();
					pp = prose.setStringId(pp, new string_id("spam", "armor_lost_cert"));
					pp = prose.setTT(pp, curArmor);
					sendSystemMessageProse(player, pp);
					putInOverloaded(curArmor, inv);
				}
			}
		}

	}

	obj_id[] equipSlots = metrics.getWornItems(player);
		if (equipSlots != null && equipSlots.length > 0)
		{
			for(int i = 0; i < equipSlots.length; i++)
			{
				//check to see if we no longer meet level requirements to wear item
				if(!static_item.validateLevelRequired(player,(equipSlots[i])))
				{
					totalUnequipped++;
					prose_package pp = new prose_package();
					pp = prose.setStringId(pp, new string_id("spam", "item_lost_cert"));
					pp = prose.setTT(pp, equipSlots[i]);
					sendSystemMessageProse(player, pp);
					putInOverloaded(equipSlots[i], inv);
				}
				//check to see if we can wear the item but no longer meet the level for the effect
				else if(!static_item.validateLevelRequiredForWornEffect(player,(equipSlots[i])))
				{
					static_item.removeWornBuffs(equipSlots[i], player);
					prose_package pp = new prose_package();
					pp = prose.setStringId(pp, new string_id("spam", "item_lost_cert_effect"));
					pp = prose.setTT(pp, equipSlots[i]);
					sendSystemMessageProse(player, pp);
				}
			}
		}

	// check if still certed for equipped weapon.  unequip if not
	obj_id weapon = getCurrentWeapon(player);
	if(isIdValid(weapon) && !combat.hasCertification(player, weapon))
	{
		totalUnequipped++;
		prose_package pp = new prose_package();
		pp = prose.setStringId(pp, new string_id("spam", "weapon_lost_cert"));
		pp = prose.setTT(pp, weapon);
		sendSystemMessageProse(player, pp);
		putInOverloaded(weapon, inv);
	}

	obj_id hold_l = getObjectInSlot(player, "hold_l");
	obj_id hold_r = getObjectInSlot(player, "hold_r");

	// check left hand dance prop
	if (isIdValid(hold_l) && !performance.isDancePropCertified(player, hold_l))
	{
		totalUnequipped++;
		prose_package pp = new prose_package();
		pp = prose.setStringId(pp, new string_id("spam", "prop_lost_cert"));
		pp = prose.setTT(pp, hold_l);
		sendSystemMessageProse(player, pp);
		putInOverloaded(hold_l, inv);
		hold_l = obj_id.NULL_ID;
	}

	// check right hand dance prop
	if (isIdValid(hold_r) && !performance.isDancePropCertified(player, hold_r))
	{
		totalUnequipped++;
		prose_package pp = new prose_package();
		pp = prose.setStringId(pp, new string_id("spam", "prop_lost_cert"));
		pp = prose.setTT(pp, hold_r);
		sendSystemMessageProse(player, pp);
		putInOverloaded(hold_r, inv);
		hold_r = obj_id.NULL_ID;
	}

	// check dance prop dual wielding
	if(performance.isValidDanceProp(hold_l) && performance.isValidDanceProp(hold_r) && !hasCommand(player, "prop_dual_wield"))
	{
		totalUnequipped++;
		prose_package pp = new prose_package();
		pp = prose.setStringId(pp, new string_id("spam", "dual_prop_lost_cert"));
		pp = prose.setTT(pp, hold_l);
		sendSystemMessageProse(player, pp);
		putInOverloaded(hold_l, inv);
		hold_l = obj_id.NULL_ID;
	}

	// Appearance items
	obj_id [] appearanceItems = getAllItemsFromAppearanceInventory(player);
	if (appearanceItems != null && appearanceItems.length > 0)
	{
		for(int i = 0; i < appearanceItems.length; ++i)
		{
			curArmor = appearanceItems[i];

			if ( (isIdValid(curArmor) && !armor.isArmorCertified(player, curArmor))
			   ||(isMando(curArmor) && !hasSpecialSkills(player)) )
			{
				totalUnequipped++;
				prose_package pp = new prose_package();
				pp = prose.setStringId(pp, new string_id("spam", "armor_lost_cert"));
				pp = prose.setTT(pp, curArmor);
				sendSystemMessageProse(player, pp);
				putInOverloaded(curArmor, inv);
			}
			if(!isIdNull(curArmor) && hasObjVar(curArmor, "armor.fake_armor") && hasObjVar(curArmor, "dynamic_item.required_skill") )
			{
				string requiredSkill = getStringObjVar(curArmor, "dynamic_item.required_skill");
				if (classTemplate != null && classTemplate != "")
				{
					if (!classTemplate.startsWith(requiredSkill))
					{
						totalUnequipped++;
						prose_package pp = new prose_package();
						pp = prose.setStringId(pp, new string_id("spam", "armor_lost_cert"));
						pp = prose.setTT(pp, curArmor);
						sendSystemMessageProse(player, pp);
						putInOverloaded(curArmor, inv);
					}
				}
			}
			//check to see if we no longer meet level requirements to wear item
			if(!static_item.validateLevelRequired(player,curArmor))
			{
				totalUnequipped++;
				prose_package pp = new prose_package();
				pp = prose.setStringId(pp, new string_id("spam", "item_lost_cert"));
				pp = prose.setTT(pp, curArmor);
				sendSystemMessageProse(player, pp);
				putInOverloaded(curArmor, inv);
			}
			//check to see if we can wear the item but no longer meet the level for the effect
			else if(!static_item.validateLevelRequiredForWornEffect(player,curArmor))
			{
				static_item.removeWornBuffs(curArmor, player);
				prose_package pp = new prose_package();
				pp = prose.setStringId(pp, new string_id("spam", "item_lost_cert_effect"));
				pp = prose.setTT(pp, curArmor);
				sendSystemMessageProse(player, pp);
			}

		}
	}

	return totalUnequipped;
}

/**
 * Finds an integer obj_var with a given name on an object.
 * @param object	 the object to search
 * @param name		 the objvar name to search for
 * @param intDefault the integer to return if no objvar exists
 *
 * @return the integer, or 0 if not found
 */
int getIntObjVar( obj_id object, string name, int intDefault )
{
	if ( !hasObjVar( object, name ) )
		return intDefault;
	return getIntObjVar( object, name );
}

/**
 * Finds an integer array obj_var with a given name on an object.
 * @param object	the object to search
 * @param name		the objvar name to search for
 * @param intArrayDefault    the array of integers to return if no objvar exists
 *
 * @return the integer array, or null if not found
 */
int[] getIntArrayObjVar( obj_id object, string name, int[] intArrayDefault )
{
	if ( !hasObjVar( object, name ) )
		return intArrayDefault;
	return getIntArrayObjVar( object, name );
}

/**
 * Finds a float obj_var with a given name on an object.
 * @param object	the object to search
 * @param name		the objvar name to search for
 * @param fltDefault the float to return if no objvar exists
 *
 * @return the float, or 0 if not found
 */
float getFloatObjVar( obj_id object, string name, float fltDefault )
{
	if ( !hasObjVar( object, name ) )
		return fltDefault;
	return getFloatObjVar( object, name );
}

/**
 * Finds a float array obj_var with a given name on an object.
 * @param object	the object to search
 * @param name		the objvar name to search for
 * @param fltArrayDefault    the array of floats to return if no objvar exists
 *
 * @return the float array, or null if not found
 */
float[] getFloatArrayObjVar( obj_id object, string name, float[] fltArrayDefault )
{
	if ( !hasObjVar( object, name ) )
		return fltArrayDefault;
	return getFloatArrayObjVar( object, name );
}

/**
 * Finds a string obj_var with a given name on an object.
 * @param object    the object to search
 * @param name      the objvar name to search for
 * @param strDefault the string to return if no objvar exists
 *
 * @return the string, or null if not found
 */
string getStringObjVar( obj_id object, string name, string strDefault )
{
	if ( !hasObjVar( object, name ) )
		return strDefault;
	return getStringObjVar( object, name );
}

/**
 * Finds a string array obj_var with a given name on an object.
 * @param object	the object to search
 * @param name		the objvar name to search for
 * @param strArrayDefault the array of strings to return if no objvar exists
 *
 * @return the string array, or null if not found
 */
string[] getStringArrayObjVar( obj_id object, string name, string[] strArrayDefault )
{
	if ( !hasObjVar( object, name ) )
		return strArrayDefault;
	return getStringArrayObjVar( object, name );
}

/**
 * Finds an obj_id obj_var with a given name on an object.
 * @param object	the object to search
 * @param name		the objvar name to search for
 * @param idDefault the obj_id to return if no objvar exists
 *
 * @return the obj_id, or null if not found
 */
obj_id getObjIdObjVar( obj_id object, string name, obj_id idDefault )
{
	if ( !hasObjVar( object, name ) )
		return idDefault;
	return getObjIdObjVar( object, name );
}

/**
 * Finds an obj_id array obj_var with a given name on an object.
 * @param object	the object to search
 * @param name		the objvar name to search for
 * @param idArrayDefault the array of obj_id to return if no objvar exists
 *
 * @return the obj_id array, or null if not found
 */
obj_id[] getObjIdArrayObjVar( obj_id object, string name, obj_id[] idArrayDefault )
{
	if ( !hasObjVar( object, name ) )
		return idArrayDefault;
	return getObjIdArrayObjVar( object, name );
}

/**
 * Finds a location obj_var with a given name on an object.
 * @param object	the object to search
 * @param name		the objvar name to search for
 * @param locDefault the location to return if no objvar exists
 *
 * @return the location, or null if not found
 */
location getLocationObjVar( obj_id object, string name, location locDefault )
{
	if ( !hasObjVar( object, name ) )
		return locDefault;
	return getLocationObjVar( object, name );
}

/**
 * Finds a location array obj_var with a given name on an object.
 * @param object	the object to search
 * @param name		the objvar name to search for
 * @param locArrayDefault the array of locations to return if no objvar exists
 *
 * @return the location array, or null if not found
 */
location[] getLocationArrayObjVar( obj_id object, string name, location[] locArrayDefault )
{
	if ( !hasObjVar( object, name ) )
		return locArrayDefault;
	return getLocationArrayObjVar( object, name );
}

/**
 * Finds an boolean obj_var with a given name on an object. Note that since
 * we don't have real boolean objvars we get the value as an int and convert it.
 * @param object	the object to search
 * @param name		the objvar name to search for
 * @param bDefault  the boolean to return if no objvar exists
 *
 * @return the boolean value
 */
boolean getBooleanObjVar( obj_id object, string name, boolean bDefault )
{
	if ( !hasObjVar( object, name ) )
		return bDefault;

	return getBooleanObjVar( object, name );
}

/**
 * @brief Checks to see if an obj_id is in an obj_id array
 *
 * CAUTION! ONLY FINDS THE FIRST OCURRENCE OF THE OBJ_ID
 *
 * @param obj_id[] objArray
 * @param obj_id objTarget
 *
 * @return boolean true if objTarget is found in objIdArray
 */
boolean isObjIdInArray( obj_id[] objIdArray, obj_id objTarget )
{
	if ( objIdArray == null || objIdArray.length == 0 )
		return false;

	for ( int i = 0; i < objIdArray.length; i++ )
		if( objIdArray[ i ] == objTarget )
			return true;

	return false;
}

/**
 * @brief Checks to see if an obj_id is in an obj_id array
 *
 * CAUTION! ONLY FINDS THE FIRST OCURRENCE OF THE OBJ_ID
 *
 * @param obj_id[] objArray
 * @param obj_id objTarget
 *
 * @return boolean true if objTarget is found in objIdArray
 */
boolean isElementInArray( Vector objIdArray, Object objTarget )
{
	if ( objIdArray == null || objIdArray.isEmpty() )
		return false;

	return objIdArray.contains(objTarget);
}

int getElementPositionInArray( Vector array, Object element )
{
	if ( array == null )
		return -1;

	return array.indexOf(element);
}

int getElementPositionInArray( obj_id[] array, obj_id element )
{
	if ( array == null || array.length == 0 )
		return -1;

	for ( int i = 0; i < array.length; i++ )
		if( array[ i ] == element )
			return i;

	return -1;
}

int getElementPositionInArray( int[] array, int element )
{
	if ( array == null || array.length == 0 )
		return -1;

	for ( int i = 0; i < array.length; i++ )
		if( array[ i ] == element )
			return i;

	return -1;
}

int getElementPositionInArray( float[] array, float element )
{
	if ( array == null || array.length == 0 )
		return -1;

	for ( int i = 0; i < array.length; i++ )
		if( array[ i ] == element )
			return i;

	return -1;
}

int getElementPositionInArray( boolean[] array, boolean element )
{
	if ( array == null || array.length == 0 )
		return -1;

	for ( int i = 0; i < array.length; i++ )
		if( array[ i ] == element )
			return i;

	return -1;
}

int getElementPositionInArray( string[] array, string element )
{
	if ( array == null || array.length == 0 )
		return -1;

	for ( int i = 0; i < array.length; i++ )
		if( array[ i ].equals(element) )
			return i;

	return -1;
}

int getElementPositionInArray( region[] array, region element )
{
	if ( array == null || array.length == 0 )
		return -1;

	for ( int i = 0; i < array.length; i++ )
		if( array[ i ] == element )
			return i;

	return -1;
}

int getElementPositionInArray( location[] array, location element )
{
	if ( array == null || array.length == 0 )
		return -1;

	for ( int i = 0; i < array.length; i++ )
		if( array[ i ] == element )
			return i;

	return -1;
}

int getElementPositionInArray( string_id[] array, string_id element )
{
	if ( array == null || array.length == 0 )
		return -1;

	for ( int i = 0; i < array.length; i++ )
		if( array[ i ] == element )
			return i;

	return -1;
}

int getElementPositionInArray( attrib_mod[] array, attrib_mod element )
{
	if ( array == null || array.length == 0 )
		return -1;

	for ( int i = 0; i < array.length; i++ )
		if( array[ i ] == element )
			return i;

	return -1;
}


/**
 * @brief copy the contents of an obj_id array to another obj_id array
 *
 * copy's an array to another array. Useful for resizing an array
 *
 * @param obj_id[] objSourceArray
 * @param obj_id[] objDestinationArray
 *
 * @return obj_id[] on success: objDestinationArray, on failure: null
 */
obj_id[] copyObjIdArray( obj_id[] objSourceArray, obj_id[] objDestinationArray )
{
	// check for error conditions:
	// -- source or destination are null
	// -- source or destination length are invalid
	// -- source is larger than destination
	if ( objSourceArray == null || objDestinationArray == null
		|| objSourceArray.length == 0 || objDestinationArray.length == 0
		|| objSourceArray.length > objDestinationArray.length )
		return null; // BAD DONT DO THAT!

	for ( int i = 0; i < objSourceArray.length; i++ )
		objDestinationArray[ i ] = objSourceArray[ i ];

	return objDestinationArray;
}

obj_id[] copyArray( obj_id[] oldArray, obj_id[] newArray )
{
	if ( oldArray == null || newArray == null
		|| oldArray.length == 0 || newArray.length == 0
		|| oldArray.length > newArray.length )
		return null; // BAD DONT DO THAT!

	for ( int i = 0; i < oldArray.length; i++ )
		newArray[ i ] = oldArray[ i ];

	return newArray;
}

int[] copyArray( int[] oldArray, int[] newArray )
{
	if ( oldArray == null || newArray == null
		|| oldArray.length == 0 || newArray.length == 0
		|| oldArray.length > newArray.length )
		return null; // BAD DONT DO THAT!

	for ( int i = 0; i < oldArray.length; i++ )
		newArray[ i ] = oldArray[ i ];

	return newArray;
}

float[] copyArray( float[] oldArray, float[] newArray )
{
	if ( oldArray == null || newArray == null
		|| oldArray.length == 0 || newArray.length == 0
		|| oldArray.length > newArray.length )
		return null; // BAD DONT DO THAT!

	for ( int i = 0; i < oldArray.length; i++ )
		newArray[ i ] = oldArray[ i ];

	return newArray;
}

boolean[] copyArray( boolean[] oldArray, boolean[] newArray )
{
	if ( oldArray == null || newArray == null
		|| oldArray.length == 0 || newArray.length == 0
		|| oldArray.length > newArray.length )
		return null; // BAD DONT DO THAT!

	for ( int i = 0; i < oldArray.length; i++ )
		newArray[ i ] = oldArray[ i ];

	return newArray;
}

string[] copyArray( string[] oldArray, string[] newArray )
{
	if ( oldArray == null || newArray == null
		|| oldArray.length == 0 || newArray.length == 0
		|| oldArray.length > newArray.length )
		return null; // BAD DONT DO THAT!

	for ( int i = 0; i < oldArray.length; i++ )
		newArray[ i ] = oldArray[ i ];

	return newArray;
}

region[] copyArray( region[] oldArray, region[] newArray )
{
	if ( oldArray == null || newArray == null
		|| oldArray.length == 0 || newArray.length == 0
		|| oldArray.length > newArray.length )
		return null; // BAD DONT DO THAT!

	for ( int i = 0; i < oldArray.length; i++ )
		newArray[ i ] = oldArray[ i ];

	return newArray;
}

location[] copyArray( location[] oldArray, location[] newArray )
{
	if ( oldArray == null || newArray == null
		|| oldArray.length == 0 || newArray.length == 0
		|| oldArray.length > newArray.length )
		return null; // BAD DONT DO THAT!

	for ( int i = 0; i < oldArray.length; i++ )
		newArray[ i ] = oldArray[ i ];

	return newArray;
}

string_id[] copyArray( string_id[] oldArray, string_id[] newArray )
{
	if ( oldArray == null || newArray == null
		|| oldArray.length == 0 || newArray.length == 0
		|| oldArray.length > newArray.length )
		return null; // BAD DONT DO THAT!

	for ( int i = 0; i < oldArray.length; i++ )
		newArray[ i ] = oldArray[ i ];

	return newArray;
}

attrib_mod[] copyArray( attrib_mod[] oldArray, attrib_mod[] newArray )
{
	if ( oldArray == null || newArray == null
		|| oldArray.length == 0 || newArray.length == 0
		|| oldArray.length > newArray.length )
		return null; // BAD DONT DO THAT!

	for ( int i = 0; i < oldArray.length; i++ )
		newArray[ i ] = oldArray[ i ];

	return newArray;
}

/**
 */

 string[] copyArrayOfRange(string[] oldArray, string[] newArray, int startIndex, int stopIndex)
 {
 	if ( oldArray == null || newArray == null
 		|| oldArray.length == 0 || newArray.length == 0
 		|| oldArray.length < stopIndex+1)
 		return null; // BAD DONT DO THAT!

 	int j = 0;
 	for ( int i = startIndex; i <= stopIndex; i++ )
 	{
 		newArray[ j ] = oldArray[ i ];
 		j++;
 	}

	return newArray;
 }


/**
 * @brief sets a bit in an int
 *
 * @param int      intBits
 * @param int      intPos
 *
 * @return int intBits where bit intPos is 1
 */
int setBit(int intBits, int intPos)
{
	if ( intPos < 0 || intPos > 31 )
	{
	 //BAD! invalid intPos!
	 return 0;
	}
	int posVal = 1 << intPos;
	return ( intBits |= posVal );
}

/**
 * @brief clears a bit in an int
 *
 * @param int      intBits
 * @param int      intPos
 *
 * @return int intBits where bit intPos is 0
 */
int clearBit(int intBits, int intPos)
{
	if ( intPos < 0 || intPos > 31 )
	{
	 //BAD! invalid intPos!
	 return ~0;
	}
	int posVal = 1 << intPos;
	return ( intBits &= ~posVal );
}

/**
 * @brief checks a bit in an int to see if it is 1
 *
 * @param int      intBits
 * @param int      intPos
 *
 * @return boolean - true, if bit set
 */
boolean checkBit(int intBits, int intPos)
{
	if ( intPos < 0 || intPos > 31 )
	{
	 //BAD! invalid intPos!
	 return false;
	}
	int posVal = 1 << intPos;
	return ((intBits & posVal) != 0 );
}

/**
 * @brief converts a string to its obj_id equivalent
 *
 * @param string    text
 *
 * @return obj_id
 */
obj_id stringToObjId(string text)
{
// bulletproofing this

	Long lngId;

	try
	{
		lngId = new Long(text); // convert the string to a long so we can make an obj_id
	} // try with error handling
	catch (NumberFormatException err)
	{
		//debugServerConsoleMsg(null, "Long Conversion Failed in stringToObjId");
		return null;
	}
	obj_id objObject = obj_id.getObjId(lngId.longValue()); // doesn't check if it's actually a valid object
	return objObject;
}

obj_id[] stringToObjId(string[] text)
{
 if ( (text == null) || (text.length == 0) )
 	return null;

 obj_id[] ids = new obj_id[text.length];

 for ( int i = 0; i < text.length; i++ )
 {
  ids[i] = stringToObjId(text[i]);
 }

 if ( ids.length == text.length )
 {
  return ids;
 }

 return null;
}

int stringToInt(string text)
{
	if ( text == null || text.equals("") )
		return -1;

	int amt;

	try
	{
		amt = Integer.parseInt(text);
	} // try with error handling
	catch (NumberFormatException err)
	{
		//debugServerConsoleMsg(null, "int conversion failed in stringToInt");
		return -1;
	}

	return amt;
}

long stringToLong(string text)
{
	if ( text == null || text.equals("") )
		return -1;

	long amt;

	try
	{
		amt = Long.parseLong(text);
	} // try with error handling
	catch (NumberFormatException err)
	{
		//debugServerConsoleMsg(null, "int conversion failed in stringToInt");
		return -1;
	}

	return amt;
}



float stringToFloat(string text)
{
	if ( text == null || text.equals("") )
		return Float.NEGATIVE_INFINITY;

	float amt;

	try
	{
		amt = Float.parseFloat(text);
	} // try with error handling
	catch (NumberFormatException err)
	{
		//debugServerConsoleMsg(null, "float conversion failed in stringToFloat");
		return Float.NEGATIVE_INFINITY;
	}

	return amt;
}

string objIdArrayToString(obj_id[] array)
{
	string text = "[ ";

	for (int i = 0; i < array.length; i++)
	{
		text += ""+array[i];

		if (i < array.length-1)
			text += ", ";
	}

	text += " ]";

	return text;
}

Vector removeElementAt( Vector array, int index )
{
	if ( array == null )
		return null;

	if ( index < 0 || index >= array.size() )
		return array;

	array.removeElementAt(index);
	return array;
}

Vector removeElement( Vector array, obj_id element )
{
	if (array == null)
		return null;

	if ( element == null )
		return array;

	array.removeElement(element);
	return array;
}

Vector removeElements( Vector array, obj_id[] elements )
{
	if (array == null)
		return null;

	if ( elements == null || elements.length == 0 )
		return array;

	List collection = Arrays.asList(elements);
	array.removeAll(collection);
	return array;
}

Vector removeElements( obj_id[] array, obj_id[] elements )
{
	if (array == null)
		return null;

	Vector ret = new Vector(Arrays.asList(array));
	if ( ret == null )
		return null;

	if ( elements == null || elements.length == 0 )
		return ret;

	List collection = Arrays.asList(elements);
	ret.removeAll(collection);
	return ret;
}

Vector removeElements( Vector array, Vector elements )
{
	if (array == null)
		return null;

	if ( elements == null || elements.size() == 0 )
		return array;

	array.removeAll(elements);
	return array;
}

Vector addElement( Vector array, Object element )
{
	if ( array == null )
		return addElement(new Vector(), element);

	if ( element == null )
		return array;

	array.add(element);
	return array;
}

Vector addElement( Vector array, boolean element )
{
	return addElement( array, new Boolean(element) );
}

Vector addElement( Vector array, int element )
{
	return addElement( array, new Integer(element) );
}

Vector addElement( Vector array, float element )
{
	return addElement( array, new Float(element) );
}


obj_id[] toStaticObjIdArray(Vector vector)
{
	if ( vector == null || vector.size() == 0 )
		return null;

	obj_id[] ret = new obj_id[vector.size()];
	vector.toArray(ret);
	return ret;
}

string[] toStaticStringArray(Vector vector)
{
	if ( vector == null || vector.size() == 0 )
		return null;

	string[] ret = new string[vector.size()];
	vector.toArray(ret);
	return ret;
}

location[] toStaticLocationArray(Vector vector)
{
	if ( vector == null || vector.size() == 0 )
		return null;

	location[] ret = new location[vector.size()];
	vector.toArray(ret);
	return ret;
}

boolean[] messageTo( obj_id[] targets, string messageName, dictionary params, float time, boolean guaranteed )
{
	if ( targets != null && targets.length > 0 )
	{
		boolean[] results = new boolean[ targets.length ];
		for ( int i = 0; i < targets.length; i++ )
			results[i] = messageTo( targets[i], messageName, params, time, guaranteed );
		return results;
	}
	return null;
}

/************************************************************
 * @brief determines if the location is at least the specified
 *        distance from the provided objects
 *
 * @param location loc
 * @param obj_id[] items
 * @param float    distance
 *
 * @return boolean
 ************************************************************/
boolean isLocSufficientDistanceFromObjects(location loc, obj_id[] items, float dist)
{
 if ( (items == null) || (dist < 0) )
 {
  return false;
 }

 for ( int i = 0; i < items.length; i++ )
 {
  if ( getDistance2D(loc, getLocation(items[i])) < dist )
  	return false;
 }

 return true;
}

/************************************************************
 * @brief concats two obj_id arrays
 *
 * @param obj_id array1
 * @param obj_id array2
 *
 * @return obj_id; null on error
 ************************************************************/
obj_id[] concatArrays(obj_id[] array1, obj_id[] array2)
{
	if(array1 == null)
 		return array2;

	else if(array2 == null)
		return array1;

	obj_id[] toPass = new obj_id[array1.length + array2.length];

	for(int i = 0; i < array1.length; i++)
		toPass[i] = array1[i];

	for(int i = 0; i < array2.length; i++)
		toPass[i + array1.length] = array2[i];

	return toPass;
}

/************************************************************
 * @brief concats two resizeable arrays
 *
 * @param Vector array1
 * @param Vector array2
 *
 * @return Vector; null on error
 ************************************************************/
Vector concatArrays(Vector array1, Vector array2)
{
	if ( array1 == null  )
 		return array2;
	else if (array2 == null)
		return array1;

	array1.addAll(array2);
	return array1;
}

/************************************************************
 * @brief concats a resizeable array and a normal array
 *
 * @param Vector array1
 * @param Vector array2
 *
 * @return Vector; null on error
 ************************************************************/
Vector concatArrays(Vector array1, Object[] array2)
{
	if ( array2 == null  )
 		return array1;

	if ( array1 == null )
		array1 = new Vector(array2.length + 10);

	array1.addAll(Arrays.asList(array2));
	return array1;
}

/************************************************************
 * @brief concats a resizeable array and a normal array
 *
 * @param Vector array1
 * @param Vector array2
 *
 * @return Vector; null on error
 ************************************************************/
Vector concatArrays(Vector array1, int[] array2)
{
	if ( array2 == null  )
 		return array1;

	Object[] toPass = new Object[array2.length];
	for ( int i = 0; i < array2.length; i++ )
		toPass[i] = new Integer(array2[i]);

	return concatArrays(array1, toPass);
}

/************************************************************
 * @brief concats a resizeable array and a normal array
 *
 * @param Vector array1
 * @param Vector array2
 *
 * @return Vector; null on error
 ************************************************************/
Vector concatArrays(Vector array1, float[] array2)
{
	if ( array2 == null  )
 		return array1;

	Object[] toPass = new Object[array2.length];
	for ( int i = 0; i < array2.length; i++ )
		toPass[i] = new Float(array2[i]);

	return concatArrays(array1, toPass);
}

/************************************************************
 * @brief concats a resizeable array and a normal array
 *
 * @param Vector array1
 * @param Vector array2
 *
 * @return Vector; null on error
 ************************************************************/
Vector concatArrays(Vector array1, boolean[] array2)
{
	if ( array2 == null  )
 		return array1;

	Object[] toPass = new Object[array2.length];
	for ( int i = 0; i < array2.length; i++ )
		toPass[i] = new Boolean(array2[i]);

	return concatArrays(array1, toPass);
}


string[] concatArrays(string[] array1, string[] array2)
{
	if ( array1 == null  )
 		return array2;

	if ( array2 == null  )
 		return array1;

	string[] toPass = new string[array1.length + array2.length];
	for ( int i = 0; i < array1.length; i++ )
		toPass[i] = array1[i];

	for ( int i = 0; i < array2.length; i++ )
		toPass[i+array1.length] = array2[i];

	return toPass;
}

/************************************************************
 * @brief validates that array2 is a subset of array1
 *
 * @param obj_id[] array1
 * @param obj_id[] array2
 *
 * @return boolean
 ************************************************************/
boolean isSubset( obj_id[] array1, obj_id[] array2 )
{
 if ( (array1 == null) || (array2 == null) )
	return false;

 Vector v1 = new Vector( Arrays.asList(array1) );
 Vector v2 = new Vector( Arrays.asList(array2) );

 return v1.containsAll(v2);
}

/************************************************************
 * @brief validates that array2 is a subset of array1
 *
 * @param string[] array1
 * @param string[] array2
 *
 * @return boolean
 ************************************************************/
boolean isSubset( string[] array1, string[] array2 )
{
 if ( (array1 == null) || (array2 == null) )
	return false;

 Vector v1 = new Vector( Arrays.asList(array1) );
 Vector v2 = new Vector( Arrays.asList(array2) );

 return v1.containsAll(v2);
}

/************************************************************
 * @brief validates that array2 is a subset of array1
 *
 * @param string_id[] array1
 * @param string_id[] array2
 *
 * @return boolean
 ************************************************************/
boolean isSubset( string_id[] array1, string_id[] array2 )
{
 if ( (array1 == null) || (array2 == null) )
	return false;

 Vector v1 = new Vector( Arrays.asList(array1) );
 Vector v2 = new Vector( Arrays.asList(array2) );

 return v1.containsAll(v2);
}

/************************************************************
 * @brief validates that array2 is a subset of array1
 *
 * @param region[] array1
 * @param region[] array2
 *
 * @return boolean
 ************************************************************/
boolean isSubset( region[] array1, region[] array2 )
{
 if ( (array1 == null) || (array2 == null) )
	return false;

 Vector v1 = new Vector( Arrays.asList(array1) );
 Vector v2 = new Vector( Arrays.asList(array2) );

 return v1.containsAll(v2);
}

/************************************************************
 * @brief validates that array2 is a subset of array1
 *
 * @param location[] array1
 * @param location[] array2
 *
 * @return boolean
 ************************************************************/
boolean isSubset( location[] array1, location[] array2 )
{
 if ( (array1 == null) || (array2 == null) )
	return false;

 Vector v1 = new Vector( Arrays.asList(array1) );
 Vector v2 = new Vector( Arrays.asList(array2) );

 return v1.containsAll(v2);
}

/************************************************************
 * @brief validates that array2 is a subset of array1
 *
 * @param location[] array1
 * @param location[] array2
 *
 * @return boolean
 ************************************************************/
boolean isSubset( attrib_mod[] array1, attrib_mod[] array2 )
{
 if ( (array1 == null) || (array2 == null) )
	return false;

 Vector v1 = new Vector( Arrays.asList(array1) );
 Vector v2 = new Vector( Arrays.asList(array2) );

 return v1.containsAll(v2);
}

/*****************************************************************
 * @brief make name list from obj_id's
 *
 * @param obj_id[] players
 *
 * @return string[]; null on error
 ******************************************************************/
string[] makeNameListFromPlayerObjIdList(obj_id[] players)
{
	 if ( players == null )
		return null;

	 resizeable string[] nameList = new string[0];

	 for ( int i = 0; i < players.length; i++ )
	 {
		  if ( isPlayer(players[i]) )
		  {
			   nameList = addElement(nameList, getName(players[i]));
		  }
	 }

	 if ( nameList.length == players.length )
	 {
		  return nameList;
	 }
	 else
	 {
		  return null;
	 }
}

/*****************************************************************
 * @brief make name list from obj_id's
 *
 * @param obj_id[] targets
 *
 * @return string[]; null on error
 ******************************************************************/
string[] makeNameList(obj_id[] targets)
{
	 if ( targets == null )
		return null;

	 resizeable string[] nameList = new string[0];

	 obj_id self = getSelf();

	 for ( int i = 0; i < targets.length; i++ )
	 {
		  if ( isIdValid(targets[i]) )
		  {
				string itemName = getEncodedName(targets[i]);
				if ( itemName != null )
				{
			   		nameList = addElement(nameList, itemName);
			   	}
		  }
	 }

	 if ( nameList.length == targets.length )
	 {
		  return nameList;
	 }
	 else
	 {
		  return null;
	 }
}

/*****************************************************************
 * @brief make name list from obj_id's
 *
 * @param Vector targets
 *
 * @return string[]; null on error
 ******************************************************************/
string[] makeNameList(Vector targets)
{
	if ( targets == null || targets.isEmpty() )
		return null;

	obj_id[] targetsArray = new obj_id[targets.size()];
	targetsArray = (obj_id[])targets.toArray(targetsArray);
	return makeNameList(targetsArray);
}


/*****************************************************************
 * @brief determines if the target object is owned by the player
 *
 * @param obj_id target
 * @param obj_id player
 *
 * @return boolean
 ******************************************************************/
boolean isOwner(obj_id target, obj_id player)
{
	if ( (!isIdValid(target)) || (!isIdValid(player)) )
		return false;

	if ( getOwner(target) == player )
	{
		return true;
	}

	if ( getObjIdObjVar(target, VAR_OWNER) == player )
	{
		return true;
	}

	return false;
}

/*****************************************************************
 * @brief determines if the target object is coowned by the player
 *
 * @param obj_id target
 * @param obj_id player
 *
 * @return boolean
 ******************************************************************/
boolean isCoOwner(obj_id target, obj_id player)
{
	 if ( (target == null) || (!isIdValid(player)) )
		return false;

	 obj_id[] coowners = getObjIdArrayObjVar(target, VAR_COOWNERS);
	 if ( coowners == null )
		return false;

	 if ( getElementPositionInArray(coowners, player) > -1 )
		return true;

	 return false;
}

/*****************************************************************
 * @brief optional recursion getContents()
 *
 * @param obj_id  container
 * @param boolean recurse
 *
 * @return obj_id[]; null on error/nothing found
 ******************************************************************/
obj_id[] getContents(obj_id container, boolean recurse, Vector excludedNodes)
{
	resizeable obj_id[] contents = getResizeableContents(container, recurse, excludedNodes);
	return contents;
}

/*****************************************************************
 * @brief optional recursion getContents()
 *
 * @param obj_id  container
 * @param boolean recurse
 *
 * @return obj_id[]; null on error/nothing found
 ******************************************************************/
obj_id[] getContents(obj_id container, boolean recurse)
{
	resizeable obj_id[] contents = getResizeableContents(container, recurse, null);
	return contents;
}

/*****************************************************************
 * @brief optional recursion getContents()
 *
 * @param obj_id  container
 * @param boolean recurse
 *
 * @return obj_id[]; null on error/nothing found
 ******************************************************************/
Vector getResizeableContents(obj_id container, boolean recurse, Vector excludedNodes)
{
	 if ( (!isIdValid(container)) || (getContainerType(container) == 0) )
	 {
		  return null;
	 }

	 if ( !recurse )
	 {
		  return getResizeableContents(container);
	 }
	 else
	 {
		  resizeable obj_id[] contents = getResizeableContents(container);
		  if ( contents == null )
			return null;

			boolean exclude = true;
		  	if ( (excludedNodes == null) || excludedNodes.isEmpty() )
		  	{
		  		exclude = false;
		  	}

		  for ( int i = 0; i < contents.length; i++ )
		  {
		  		obj_id item = contents[i];
		  		if ( isIdValid(item) )
		  		{

		  			boolean keepItem = true;
		  			if ( exclude )
		  			{
		  				int idx = excludedNodes.indexOf(item);
		  				if ( idx > -1 )
		  				{
		  					contents = removeElementAt(contents, i);
		  					i--;
		  					keepItem = false;
		  				}
					}

					if ( keepItem)
					{
						// don't recurse into the contents of a factory crate
						int itemGameObjectType = getGameObjectType(item);
						if ( itemGameObjectType != GOT_misc_factory_crate && itemGameObjectType != GOT_chronicles_quest_holocron )
						{
							int containerType = getContainerType(item);
							if ( containerType != 0 )
							{
								obj_id[] newContents = getContents(item);
								if ( newContents != null )
								{
								 	contents = concatArrays(contents, newContents);
								}
							}
						}
					}
				}
		  }
		  return contents;
	 }
}


/******************************************************************
* obj_id object the objects you want the same container objects for
*
* return obj_id[] shared container contents if any or null if object is not contained
*******************************************************************/

obj_id[] getSharedContainerObjects(obj_id object)
{
	if (!isIdValid(object) || !exists(object))
		return null;

	obj_id container = getContainedBy(object);
	if (!isIdValid(container) || !exists(container))
		return null;

	return getContents(container);
}

/*****************************************************************
 * @brief optional recursion getContents()
 *
 * @param obj_id  container
 * @param boolean recurse
 *
 * @return obj_id[]; null on error/nothing found
 ******************************************************************/
Vector getResizeableContents(obj_id container, boolean recurse)
{
	return getResizeableContents(container, recurse, null);
}

/*****************************************************************
 * @brief optional recursion getContents()
 *
 * @param obj_id  container
 *
 * @return obj_id[]; null on error/nothing found
 ******************************************************************/
obj_id[] getNonBankPlayerContents(obj_id player)
{
	if ( !isIdValid(player) )
	{
		return null;
	}

	obj_id bank = getPlayerBank(player);
	if ( !isIdValid(bank) )
	{
		return null;
	}

	resizeable obj_id[] toExclude = addElement(null, bank);
	obj_id[] contents = getContents(player, true, toExclude);
	return contents;
}

/*****************************************************************
 * @brief optional recursion getContents()
 *
 * @param obj_id  container
 *
 * @return obj_id[]; null on error/nothing found
 ******************************************************************/
obj_id[] getFilteredPlayerContents(obj_id player)
{
	if ( !isIdValid(player) )
	{
		return null;
	}

	resizeable obj_id[] toExclude = null;

	obj_id bank = getPlayerBank(player);
	if ( isIdValid(bank) )
	{
		toExclude = addElement(toExclude, bank);
	}

	obj_id missionBag = getMissionBag(player);
	if ( isIdValid(missionBag) )
	{
		toExclude = addElement(toExclude, missionBag);
	}

	obj_id datapad = getPlayerDatapad(player);
	if ( isIdValid(datapad) )
	{
		toExclude = addElement(toExclude, datapad);
	}

	return getContents(player, true, toExclude);
}

/*****************************************************************
 * @brief determines if the target object is coowned by the player
 *
 * @param obj_id  container
 * @param obj_id  player
 *
 * @return obj_id[]; null on error/nothing found
 ******************************************************************/
obj_id[] getAllContentsOwnedByPlayer(obj_id container, obj_id player)
{
	 if ( (!isIdValid(container)) || (container == obj_id.NULL_ID) || (!isIdValid(player)) )
		return null;

	 resizeable obj_id[] ownedObjects = new obj_id[0];
	 obj_id[] allObjects = getContents(container, true);

	 if ( allObjects == null )
		return null;

	 for ( int i = 0; i < allObjects.length; i++ )
	 {
		  if ( getObjIdObjVar(allObjects[i], VAR_OWNER) == player )
		  {
			   ownedObjects = addElement(ownedObjects, allObjects[i]);
		  }
	 }

	 if ( ownedObjects.length > 0 )
	 {
		  return ownedObjects;
	 }

	 return null;
}

boolean isNestedWithin(obj_id item, obj_id container)
{
	if ( !isIdValid(item) || !isIdValid(container) )
	{
		return false;
	}

	obj_id containedBy = getContainedBy(item);
	if ( !isIdValid(containedBy) )
	{
		return false;
	}
	else if ( containedBy == container )
	{
		return true;
	}

	return isNestedWithin(containedBy, container);
}

boolean isNestedWithinAPlayer(obj_id item)
{
	return isNestedWithinAPlayer(item, true);
}

//allows the search to not count the bank as part of the players inventory
boolean isNestedWithinAPlayer(obj_id item, boolean searchBank)
{
	if ( !isIdValid(item) )
	{
		return false;
	}

	if ( isIdValid(getContainingPlayer(item)) )
	{
		if(searchBank)
		{
			return true;
		}
		else
		{
			obj_id player = getContainingPlayer(item);
			obj_id bank = getPlayerBank(player);

			if(isIdValid(bank))
			{
				obj_id containedBy = getContainedBy(item);

				if(containedBy == bank)
				{
					return false;
				}
				else
				{
					return true;
				}
			}
			else
			{
				return true;
			}
		}
	}

	return false;
}

obj_id getContainingPlayer(obj_id item)
{
	obj_id containedBy = getContainedBy(item);
	if ( !isIdValid(containedBy) )
	{
		return null;
	}
	else if ( isPlayer(containedBy) )
	{
		return containedBy;
	}
	return getContainingPlayer(containedBy);
}


boolean isNestedWithinANpcCreature(obj_id item)
{
	if ( !isIdValid(item) )
	{
		return false;
	}

	if ( isIdValid(getContainingNpcCreature(item)) )
		return true;

	return false;
}

obj_id getContainingNpcCreature(obj_id item)
{
	obj_id containedBy = getContainedBy(item);
	if ( !isIdValid(containedBy) )
	{
		return null;
	}
	else if ( isNpcCreature(containedBy) )
	{
		return containedBy;
	}

	return getContainingNpcCreature(containedBy);
}

obj_id getContainingPlayerOrCreature(obj_id item)
{
	obj_id containedBy = getContainedBy(item);
	if ( !isIdValid(containedBy) )
	{
		return null;
	}
	else if ( isNpcCreature(containedBy) || isPlayer(containedBy))
	{
		return containedBy;
	}

	return getContainingPlayerOrCreature(containedBy);
}


// -------------------------------------
// Checking player for an item based on template name
//
// just checking player inventory
boolean playerHasItemByTemplate(obj_id objPlayer, string strTemplate)
{
	obj_id objInventory = getInventoryContainer(objPlayer);
	if( isIdValid(objInventory) )
	{
		obj_id[] objContents = getContents(objInventory, true);

		if( objContents != null )
		{
			for( int intI = 0; intI<objContents.length; intI++ )
			{
				string strItemTemplate = getTemplateName(objContents[intI]);
				if( strItemTemplate==strTemplate )
				{
					return true;
				}
			}
		}
	}
	return false;
}

boolean playerHasItemByTemplateInDataPad(obj_id objPlayer, string strTemplate)
{
	obj_id pDataPad = getPlayerDatapad(objPlayer);
	if( isIdValid(pDataPad) )
	{
		LOG("utils", "playerHasItemByTemplateInDataPad::pDataPad " + pDataPad);
		obj_id[] objContents = getContents(pDataPad, true);
		LOG("utils", "playerHasItemByTemplateInDataPad::objContents.length " + objContents.length);
		if( objContents != null )
		{
			for( int intI = 0; intI < objContents.length; intI++ )
			{
				string strItemTemplate = getTemplateName(objContents[intI]);
				LOG("utils", "playerHasItemByTemplateInDataPad::strItemTemplate " + strItemTemplate);
				LOG("utils", "playerHasItemByTemplateInDataPad::strTemplate " + strTemplate);
				if( strItemTemplate==strTemplate )
				{
					return true;
				}
			}
		}
	}
	else
		LOG("utils", "playerHasItemByTemplateInDataPad::Dpad was invalid");
	return false;
}

int playerHasHowManyItemByTemplateInDataPad(obj_id objPlayer, string strTemplate, boolean recurse)
{
	int count = 0;
	obj_id pDataPad = getPlayerDatapad(objPlayer);
	if( isIdValid(pDataPad) )
	{
		obj_id[] objContents = getContents(pDataPad, recurse);
		if( objContents != null )
		{
			for( int intI = 0; intI < objContents.length; intI++ )
			{
				string strItemTemplate = getTemplateName(objContents[intI]);
				if( strItemTemplate.equals(strTemplate) )
				{
					++count;
				}
			}
		}
	}

	return count;
}

boolean playerHasItemByTemplateInInventoryOrEquipped(obj_id player, string desiredTemplate)
{
	obj_id[] contents = getInventoryAndEquipment(player);

	if (contents != null)
	{
		for(int i = 0;i<contents.length;i++)
		{
			string inventoryObject = getTemplateName(contents[i]);
			if(inventoryObject.equals(desiredTemplate))
				return true;
		}
	}

	return false;
}

obj_id getItemByTemplateInInventoryOrEquipped(obj_id player, string desiredTemplate)
{
	obj_id[] contents = getInventoryAndEquipment(player);
	if(contents != null)
	{

		for(int i = 0;i<contents.length;i++)
		{
			string inventoryObject = getTemplateName(contents[i]);
			if(inventoryObject.equals(desiredTemplate))
				return contents[i];
		}
	}

	return null;
}

boolean playerHasItemWithObjVarInInventoryOrEquipped(obj_id player, string desiredObjVar)
{
	obj_id[] contents = getInventoryAndEquipment(player);

	if (contents != null)
	{
		for(int i = 0;i<contents.length;i++)
		{
			if(hasObjVar(contents[i], desiredObjVar))
				return true;
		}
	}
	return false;
}

boolean playerHasItemByTemplateWithObjVarInInventoryOrEquipped(obj_id player, string desiredTemplate, string desiredObjVar)
{
	obj_id[] contents = getInventoryAndEquipment(player);

	if (contents != null)
	{
		for(int i = 0;i<contents.length;i++)
		{
			string inventoryObject = getTemplateName(contents[i]);
			if(inventoryObject.equals(desiredTemplate))
			{
				if(hasObjVar(contents[i], desiredObjVar))
					return true;
			}
		}
	}
	return false;
}

// just checking player bank
boolean playerHasItemByTemplateInBank(obj_id objPlayer, string strTemplate)
{
	obj_id objBank = getPlayerBank(objPlayer);
	if( isIdValid(objBank) )
	{
		obj_id[] objContents = getContents(objBank, true);

		if( objContents != null )
		{
			for( int i = 0; i < objContents.length; i++ )
			{
				string strItemTemplate = getTemplateName(objContents[i]);
				if( strItemTemplate==strTemplate )
				{
					return true;
				}
			}
		}
	}
	return false;
}

// checking player bank and inventory
boolean playerHasItemByTemplateInBankOrInventory(obj_id objPlayer, string strTemplate)
{
	if ( playerHasItemByTemplate(objPlayer, strTemplate) )
		return true;

	else if ( playerHasItemByTemplateInBank( objPlayer, strTemplate) )
		return true;

	return false;
}

// checking player bank and inventory
boolean playerHasStaticItemInBankOrInventory(obj_id player, string staticItem)
{
	return (isIdValid(getStaticItemInBankOrInventory(player, staticItem)));
}

obj_id getStaticItemInBankOrInventory(obj_id player, string staticItem)
{
	obj_id[] contents = getInventoryAndEquipment(player);
	if (contents != null && contents.length > 0)
	{
		for(int i = 0;i < contents.length;i++)
		{
			string itemName = getStaticItemName(contents[i]);
			if (itemName != null && staticItem != null && staticItem.equals(itemName))
				return contents[i];
		}
	}

	obj_id bank = getPlayerBank(player);
	if (isIdValid(bank))
	{
		contents = getContents(bank, true);

		if (contents != null && contents.length > 0)
		{
			for (int i = 0; i < contents.length; i++ )
			{
				string itemName = static_item.getStaticItemName(contents[i]);
				if (itemName != null && staticItem != null && staticItem.equals(itemName))
					return contents[i];
			}
		}
	}

	return null;
}

// checking player bank and inventory
boolean playerHasStaticItemInAppearanceInventory(obj_id player, string staticItem)
{
	return (isIdValid(getStaticItemInAppearanceInventory(player, staticItem)));
}

obj_id getStaticItemInAppearanceInventory(obj_id player, string staticItem)
{
	obj_id [] contents = getAllItemsFromAppearanceInventory(player);
	{
		if(contents != null && contents.length > 0)
		{
			for(int i = 0;i < contents.length;i++)
			{
				string itemName = getStaticItemName(contents[i]);
				if (itemName != null && staticItem != null && staticItem.equals(itemName))
					return contents[i];
			}
		}
	}

	return null;
}

//gets all static items of the same type in the players inventory and returns them in an array

obj_id[] getAllStaticItemsInPlayerInventory(obj_id player, string staticItem)
{
	resizeable obj_id[] objectList = new Vector ();

	obj_id inventory = getInventoryContainer(player);
	if( isIdValid(inventory) )
	{
		obj_id[] contents = getInventoryAndEquipment(player);

		if( contents != null && contents.length > 0 )
		{
			for( int i = 0; i < contents.length; i++ )
			{
				if (contents[i] != null)
				{
					if (static_item.isStaticItem(contents[i]))
					{
						string itemName = getStaticItemName(contents[i]);
						if( itemName==staticItem )
						{
							objectList = addElement (objectList, contents[i]);
						}
					}
				}
			}
		}
	}

	if (objectList.size () > 0)
	{
		obj_id[] staticList = new obj_id[objectList.size()];
		objectList.toArray (staticList);
		return staticList;
	}

	return null;
}

obj_id getStaticItemInInventory(obj_id player, string staticItem)
{
	obj_id[] contents = getInventoryAndEquipment(player);
	if (contents != null && contents.length > 0)
	{
		for(int i = 0;i < contents.length;i++)
		{
			string itemName = getStaticItemName(contents[i]);
			if (itemName != null && staticItem != null && staticItem.equals(itemName))
				return contents[i];
		}
	}

	return null;
}
//gets the total amount of stackable objects from an array list

int countOfStackedItemsInArray(obj_id[] items)
{
	int totalCount = 0;

	for( int i = 0; i < items.length; i++ )
	{
		int itemCount = getCount(items[i]);
		totalCount = itemCount + totalCount;
	}
	return totalCount;
}

// just checking player inventory
obj_id getItemPlayerHasByTemplate(obj_id objPlayer, string strTemplate)
{
	obj_id objInventory = getInventoryContainer(objPlayer);
	if( isIdValid(objInventory) )
	{
		obj_id[] objContents = getContents(objInventory, true);

		if( objContents != null )
		{
			for( int i = 0; i < objContents.length; i++ )
			{
				string strItemTemplate = getTemplateName(objContents[i]);
				if( strItemTemplate==strTemplate )
				{
					return objContents[i];
				}
			}
		}
	}
	return null;
}

obj_id getItemPlayerHasByTemplateInDatapad(obj_id objPlayer, string strTemplate)
{
	obj_id pDataPad = getPlayerDatapad(objPlayer);
	if( isIdValid(pDataPad) )
	{
		obj_id[] objContents = getContents(pDataPad, true);

		if( objContents != null )
		{
			for( int i = 0; i < objContents.length; i++ )
			{
				string strItemTemplate = getTemplateName(objContents[i]);
				if( strItemTemplate==strTemplate )
				{
					return objContents[i];
				}
			}
		}
	}
	return null;
}


// just checking player bank
obj_id getItemPlayerHasByTemplateInBank(obj_id objPlayer, string strTemplate)
{
	obj_id objBank = getPlayerBank(objPlayer);
	if( isIdValid(objBank) )
	{
		obj_id[] objContents = getContents(objBank, true);

		if( objContents != null )
		{
			for( int i = 0; i < objContents.length; i++ )
			{
				string strItemTemplate = getTemplateName(objContents[i]);
				if( strItemTemplate==strTemplate )
				{
					return objContents[i];
				}
			}
		}
	}
	return null;
}

// checking player bank and inventory. Inventory checked first.
obj_id getItemPlayerHasByTemplateInBankOrInventory(obj_id objPlayer, string strTemplate)
{
	obj_id itemObj = getItemPlayerHasByTemplate(objPlayer, strTemplate);
	if ( isIdValid( itemObj ) )
	{
		return itemObj;
	}
	else
	{
		itemObj = getItemPlayerHasByTemplateInBank(objPlayer, strTemplate);
		if ( isIdValid(itemObj) )
		{
			return itemObj;
		}
	}
	return null;
}

// just checking player inventory
obj_id[] getAllItemsPlayerHasByTemplate(obj_id objPlayer, string strTemplate)
{
	obj_id objInventory = getInventoryContainer(objPlayer);
	if( isIdValid(objInventory) )
		return getAllItemsInContainerByTemplate( objInventory, strTemplate, true);
	else
		return null;
}

// just checking player bank
obj_id[] getAllItemsPlayerHasByTemplateInBank(obj_id objPlayer, string strTemplate)
{
	obj_id objBank = getPlayerBank(objPlayer);
	if( isIdValid(objBank) )
		return getAllItemsInContainerByTemplate( objBank, strTemplate, true );
	else
		return null;
}
obj_id[] getAllItemsInContainerByTemplate( obj_id container, string template, boolean recurse )
{
	return getAllItemsInContainerByTemplate(container, template, recurse, true);
}

obj_id[] getAllItemsInContainerByTemplate( obj_id container, string template, boolean recurse, boolean allowEquipped )
{
	resizeable obj_id[] objectList = new Vector ();
	if( isIdValid(container) )
	{
		obj_id[] objContents = getContents(container, recurse);
		if( objContents != null )
		{
			for( int intI = 0; intI<objContents.length; intI++ )
			{
				string itemTemplate = getTemplateName(objContents[intI]);
				if( itemTemplate == template )
				{
					if(!allowEquipped)
					{
						if(isEquipped(objContents[intI]))
							continue;
					}
					objectList = addElement (objectList, objContents[intI]);
				}
			}
		}
	}

	if (objectList.size () > 0)
	{
		obj_id[] staticList = new obj_id[objectList.size()];
		objectList.toArray (staticList);
		return staticList;
	}
	else
		return null;
}

// just checking player inventory for item templates that starts with
obj_id[] getAllItemsPlayerHasByTemplateStartsWith(obj_id objPlayer, string strTemplate)
{
	obj_id objInventory = getInventoryContainer(objPlayer);
	if( isIdValid(objInventory) )
		return getAllItemsInContainerByTemplateStartsWith( objInventory, strTemplate, true);
	else
		return null;
}

// just checking player bank for item templates that starts with
obj_id[] getAllItemsPlayerHasByTemplateInBankStartsWith(obj_id objPlayer, string strTemplate)
{
	obj_id objBank = getPlayerBank(objPlayer);
	if( isIdValid(objBank) )
		return getAllItemsInContainerByTemplateStartsWith( objBank, strTemplate, true );
	else
		return null;
}

obj_id[] getAllItemsInContainerByTemplateStartsWith( obj_id container, string template, boolean recurse )
{
	resizeable obj_id[] objectList = new Vector ();
	if( isIdValid(container) )
	{
		obj_id[] objContents = getContents(container, recurse);
		if( objContents != null )
		{
			for( int intI = 0; intI<objContents.length; intI++ )
			{
				string itemTemplate = getTemplateName(objContents[intI]);
				if( itemTemplate.startsWith (template))
				{
					objectList = addElement (objectList, objContents[intI]);
				}
			}
		}
	}

	if (objectList.size () > 0)
	{
		obj_id[] staticList = new obj_id[objectList.size()];
		objectList.toArray (staticList);
		return staticList;
	}
	else
		return null;
}

// checking player bank and inventory
obj_id[] getAllItemsPlayerHasByTemplateInBankAndInventory(obj_id objPlayer, string strTemplate)
{
	resizeable obj_id[] objectList = new Vector ();

	obj_id objInventory = getInventoryContainer(objPlayer);
	if( isIdValid(objInventory) )
	{
		obj_id[] objContents = getContents(objInventory, true);

		if( objContents != null )
		{
			for( int i = 0; i < objContents.length; i++ )
			{
				string strItemTemplate = getTemplateName(objContents[i]);
				if( strItemTemplate==strTemplate )
				{
					objectList = addElement (objectList, objContents[i]);
				}
			}
		}
	}

	obj_id objBank = getPlayerBank(objPlayer);
	if( isIdValid(objBank) )
	{
		obj_id[] objContents = getContents(objBank, true);

		if( objContents != null )
		{
			for( int j = 0; j < objContents.length; j++ )
			{
				string strItemTemplate = getTemplateName(objContents[j]);
				if( strItemTemplate==strTemplate )
				{
					objectList = addElement (objectList, objContents[j]);
				}
			}
		}
	}
	if (objectList.size () > 0)
	{
		obj_id[] staticList = new obj_id[objectList.size()];
		objectList.toArray (staticList);
		return staticList;
	}

	return null;
}

obj_id[] getAllItemsInBankAndInventory(obj_id objPlayer)
{
	resizeable obj_id[] objectList = new Vector ();

	obj_id[] objContents = getInventoryAndEquipment(objPlayer);

	if( objContents != null )
	{
		for( int i = 0; i < objContents.length; i++ )
		{
			objectList = addElement (objectList, objContents[i]);
		}
	}

	obj_id objBank = getPlayerBank(objPlayer);
	if( isIdValid(objBank) )
	{
		objContents = getContents(objBank, true);

		if( objContents != null )
		{
			for( int j = 0; j < objContents.length; j++ )
			{
				objectList = addElement (objectList, objContents[j]);
			}
		}
	}
	if (objectList.size () > 0)
	{
		obj_id[] staticList = new obj_id[objectList.size()];
		objectList.toArray (staticList);
		return staticList;
	}

	return null;
}

//
// -------------------------------------


location getRandomLocationInRing(location locOrigin, float fltMinDistance, float fltMaxDistance)
{


	// we need to calculate the distance
	// becuase rand only works with ints, we have to use the uglier float version
	float fltRand = rand();

	float fltDistance = (fltMaxDistance - fltMinDistance) * fltRand +fltMinDistance; // nasty
	obj_id objTest = null;
	debugServerConsoleMsg(objTest, "fltDistance is "+fltDistance);

	float fltAngle = rand(0, 360); // angle in degrees
	locOrigin = rotatePointXZ(locOrigin, fltDistance, fltAngle);


	return locOrigin;
}


location rotatePointXZ(location locOrigin, float fltDistance, float fltAngle)
{
	location locOffset = (location)locOrigin.clone();
	locOffset.x = locOrigin.x + fltDistance;
	locOffset.z = locOrigin.z;

	return rotatePointXZ(locOrigin, locOffset, fltAngle);
}

location rotatePointXZ(location locOrigin, location locPoint, float fltAngle)
{
	float dx = locPoint.x - locOrigin.x;
	float dz = locPoint.z - locOrigin.z;

	float fltRadians = (float)Math.toRadians(fltAngle);
	float fltC = (float)Math.cos(fltRadians);
	float fltS = (float) Math.sin(fltRadians);

  	location locNewOffset = (location)locOrigin.clone();
  	locNewOffset.x += (dx * fltS) - (dz * fltC);
  	locNewOffset.y = locPoint.y;
  	locNewOffset.z += (dx * fltC) + (dz * fltS);

	return locNewOffset;
}


location rotatePointXZ(location locPoint, float fltAngle)
{
	//LOG("player_spawner", "rotating point");
	float fltRadians = (float) Math.toRadians(fltAngle);
	float fltC = (float) Math.cos(fltRadians);
	float fltS = (float) Math.sin(fltRadians);
	//LOG("player_spawner", "locPoint is "+locPoint);
	location locNewPoint = (location)locPoint.clone();
	locNewPoint.x += (locPoint.x * fltC) - (locPoint.z * fltS);
	locNewPoint.z += (locPoint.x * fltS) + (locPoint.z * fltC);

	return locNewPoint;
}

float getHeadingToLocation(location here, location there)
{
	if ( here == null || there == null )
		return -1f;

	float dx = there.x - here.x;
	float dz = there.z - here.z;

	double radHeading = Math.atan2(-dx, dz);
	double degreeHeading = Math.toDegrees(radHeading);
	return (float)(degreeHeading);
}

/*****************************************************************
 * @brief determines the location at the proper location in front of target
 *
 * @param obj_id    target
 * @param distance  distance
 *
 * @return location, null on error
 ******************************************************************/
location findLocInFrontOfTarget(obj_id target, float distance)
{
	 if ( target == null || !exists(target))
		return null;

	location origin = getLocation(target);

	if(origin == null)
		return null;

	float yaw = getYaw(target);

	location newLoc = rotatePointXZ(origin, distance, yaw);

	return newLoc;
}

/*****************************************************************
 * @brief	creates an attrib modifier from its constituent parts
 *
 * @param	int 	attrib
 * @param	int 	value
 * @param	float 	duration
 * @param	float 	attack
 * @param	float 	decay
 *
 * @return    	attrib_mod
 *****************************************************************/
attrib_mod createAttribMod(int attrib, int value, float duration, float attack, float decay)
{
 	return new attrib_mod(attrib, value, duration, attack, decay);
}

/*****************************************************************
 * @brief	creates an attrib modifier from its constituent parts
 *
 * @param	int 	attrib
 * @param	int 	value
 * @param	float 	duration
 * @param	float 	attack
 * @param	float 	decay
 *
 * @return    	attrib_mod
 *****************************************************************/
attrib_mod createAttribMod(int attrib, int value, float duration, float attack)
{
 	return new attrib_mod(attrib, value, duration, attack, 0.0f);
}

/*****************************************************************
 * @brief	creates an attrib modifier from its constituent parts
 *
 * @param	int 	attrib
 * @param	int 	value
 * @param	float 	duration
 * @param	float 	attack
 *
 * @return    	attrib_mod
 *****************************************************************/
attrib_mod createAttribMod(int attrib, int value, float duration)
{
 	return new attrib_mod(attrib, value, duration, 0.0f, 0.0f);
}

/*****************************************************************
 * @brief	creates an attrib modifier from its constituent parts
 *
 * @param	int 	attrib
 * @param	int 	value
 * @param	float 	duration
 * @param	float 	attack
 *
 * @return    	attrib_mod
 *****************************************************************/
attrib_mod createHealDamageAttribMod(int attrib, int value)
{
	if ( (value < 1) || (attrib % 3 != 0) )
	{
		return null;
	}

 	return new attrib_mod(attrib, value, 0.0f, 0.0f, MOD_POOL);
}

/*****************************************************************
 * @brief	creates an attrib modifier from its constituent parts
 *
 * @param	int 	attrib
 * @param	int 	value
 * @param	float 	duration
 * @param	float 	attack
 *
 * @return    	attrib_mod
 *****************************************************************/
attrib_mod createHealWoundAttribMod(int attrib, int value)
{
	if ( value < 1 )
	{
		return null;
	}

 	return new attrib_mod(attrib, value, 0.0f, healing.AM_HEAL_WOUND, 0.0f);
}

/*****************************************************************
 * @brief	creates an attrib modifier from its constituent parts
 *
 * @param	int 	attrib
 * @param	int 	value
 * @param	float 	duration
 * @param	float 	attack
 *
 * @return    	attrib_mod
 *****************************************************************/
attrib_mod createHealShockAttribMod(int value)
{
	if ( value < 1 )
	{
		return null;
	}

	return new attrib_mod(0, value, 0.0f, healing.AM_HEAL_SHOCK, 0.0f);
}

/*****************************************************************
 * @brief	creates an attrib modifier from its constituent parts
 *
 * @param	int 	attrib
 * @param	int 	value
 * @param	float 	duration
 * @param	float 	attack
 *
 * @return    	attrib_mod
 *****************************************************************/
attrib_mod createAddShockAttribMod(int value)
{
	if ( value < 1 )
	{
		return null;
	}

	return new attrib_mod(0, value, 0.0f, healing.AM_ADD_SHOCK, 0.0f);
}

/*****************************************************************
 * @brief	creates an attrib modifier from its constituent parts
 *
 * @param	int 	attrib
 * @param	int 	value
 * @param	float 	duration
 * @param	float 	attack
 *
 * @return    	attrib_mod
 *****************************************************************/
attrib_mod createWoundAttribMod(int attrib, int value)
{
	if ( value < 1 )
	{
		return null;
	}

 	return new attrib_mod(attrib, value, 0.0f, 0.0f, MOD_WOUND);
}

/*****************************************************************
 * @brief	creates an attrib modifier from its constituent parts
 *
 * @param	int 	attrib
 * @param	int 	value
 * @param	float 	duration
 * @param	float 	attack
 *
 * @return    	attrib_mod
 *****************************************************************/
attrib_mod createAntidoteAttribMod(int attrib)
{
 	return new attrib_mod(attrib, 0, 0.0f, 0.0f, MOD_ANTIDOTE);
}

/*****************************************************************
 * @brief	overload function for addAttribModifier
 *
 * @param	obj_id	target
 * @param	int 	attrib
 * @param	int 	value
 * @param	float 	duration
 *
 * @return    	boolean; false on error
 *****************************************************************/
boolean addAttribMod(obj_id target, int attrib, int value, float duration)
{
 	return addAttribModifier(target, attrib, value, duration, 0.0f, 0.0f);
}

/*****************************************************************
 * @brief	overload function for addAttribMod
 *
 * @param	obj_id		player
 * @param	obj_id		target
 * @param	attrib_mod	am
 *
 * @return    	boolean; false on error
 *****************************************************************/
boolean addAttribMod(obj_id target, attrib_mod am)
{
	if(target == null || am == null)
		return false;

	boolean litmus = true;

	int attrib = am.getAttribute();
	float duration = am.getDuration();

	int amt = am.getValue();
	int attack = (int)(am.getAttack());
	int decay = (int)(am.getDecay());

	if ( attack < 0 )
	{
		switch (attack)
		{
			case (int)healing.AM_HEAL_WOUND:
				if ( amt < 0 )
				{
					amt = 0;
				}
				break;

			case (int)healing.AM_HEAL_SHOCK:
				if ( amt < 0 )
				{
					amt = 0;
				}
				litmus &= healShockWound(target, amt);
				break;

			case (int)healing.AM_ADD_SHOCK:
				if ( amt < 0 )
				{
					amt = 0;
				}
				litmus &= addShockWound(target, amt);
				break;
		}
	}
	/*else if ( decay < 0 )
	{
		switch (decay)
		{
			case (int)MOD_POOL:
			case (int)MOD_WOUND:
			case (int)MOD_ANTIDOTE:
				return addAttribModifier(target, am.getAttribute(), am.getValue(), am.getDuration(), am.getAttack(), am.getDecay());
		}
	}*/
	else
	{
		if (!addAttribModifier(target, attrib, amt, duration, am.getAttack(), am.getDecay()))
		{
			//debugSpeakMsg(target, "unable to add attrib mod...");
			litmus = false;
		}
	}
 	return litmus;
}


/*****************************************************************
 * @brief	applies each of the attrib mods in an attrib mod array
 *
 * @param	obj_id		target
 * @param	attrib_mod[]	am
 *
 * @return    	boolean; false on error
 *****************************************************************/
boolean addAttribMod(obj_id target, attrib_mod[] am)
{
 if ( (target == null) || (am == null) || (am.length == 0) )
 	return false;

 boolean ret = true;

 for ( int i = 0; i < am.length; i++ )
 {
  ret &= addAttribMod(target, am[i]);
 }

 return ret;
}


/*****************************************************************
 * @brief	rotates an object
 *
 * @param	obj_id		target
 * @param	float		heading (in degrees)
 *
 * @return    	boolean; false on error
 *****************************************************************/
boolean setHeading(obj_id target, float heading)
{
	if ( target == null )
		return false;

	return setYaw(target, heading);
}


/*****************************************************************
 * @brief	parses a string in the  format "<key1>=<val1>,<key2>=<val2>,..."
 *			NOTE: only use this function for STRING->INT key pair mappings
 *
 * @param	string	keyPairList
 * @param	string	delim
 *
 * @return 	dictionary; null on error
 *****************************************************************/
dictionary parseKeyPairList(string keyPairList, char delim)
{
	if ( keyPairList.equals("") )
	{
		return null;
	}

	dictionary d = new dictionary();

	string[] pairs = split(keyPairList, delim);
	if ( (pairs == null) || (pairs.length == 0) )
	{
		return null;
	}

	for ( int i = 0; i < pairs.length; i++ )
	{
		string[] tmp = split(pairs[i], '=');
		if ( (tmp != null) && (tmp.length == 2) )
		{
			int val = stringToInt(tmp[1]);
			if ( val != -1 )
			{
				d.put(tmp[0],val);
			}
		}
	}

	return d;
}

/*****************************************************************
 * @brief	overload for parseKeyPairList(string, char)
 *
 * @param	string	keyPairList
 *
 * @return 	dictionary; null on error
 *****************************************************************/
dictionary parseKeyPairList(string keyPairList)
{
	return parseKeyPairList(keyPairList, ',');
}

/*****************************************************************
 * @brief	attempts to put an item into a player's inventory
 *
 * @param	obj_id	player
 * @param	obj_id	item
 *
 * @return 	boolean; false on error
 *****************************************************************/
boolean putInPlayerInventory(obj_id player, obj_id item)
{
	if ( (!isIdValid(player)) || (!isPlayer(player)) || (item == null) )
	{
		return false;
	}

	obj_id inventory = getObjectInSlot(player, SLOT_INVENTORY);
	if ( inventory == null )
	{
		return false;
	}

	return putIn(item, inventory);
}


/*****************************************************************
 * @brief	attempts to put an item into a player's inventory
 *
 * @param	obj_id	player
 * @param	obj_id	item
 *
 * @return 	boolean; false on error
 *****************************************************************/
boolean putInPlayerDatapad(obj_id player, obj_id item)
{
	if ( (!isIdValid(player)) || (!isPlayer(player)) || (item == null) )
	{
		//debugSpeakMsg(player, "putInPlayerDatapad: invalid args");
		return false;
	}

	obj_id datapad = getObjectInSlot(player, SLOT_DATAPAD);
	if ( datapad == null )
	{
		//debugSpeakMsg(player, "putInPlayerDatapad: unable to determine player's datapad");
		return false;
	}

	return putIn(item, datapad);
}


/*****************************************************************
 * @brief	attempts to retrieve the obj_id of a mob's inventory container
 *
 * @param	obj_id	target
 *
 * @return 	obj_id; null on error
 *****************************************************************/
obj_id getInventoryContainer(obj_id target)
{
	if(!isIdValid(target))
	{
		return null;
	}

	return getObjectInSlot(target, SLOT_INVENTORY);
}

obj_id getDroidInventoryContainer(obj_id droid)
{
	if(!isIdValid(droid))
	{
		return null;
	}

	if(callable.hasCallableCD(droid))
	{
		return getObjectInSlot(callable.getCallableCD(droid), SLOT_INVENTORY);
	}
	else
	{
		return null;
	}

}

// GETS PLAYER MISSION BAG
obj_id getMissionBag(obj_id objPlayer)
{
	if(!isIdValid(objPlayer))
	{
		return null;
	}

	return getObjectInSlot(objPlayer, SLOT_MISSION_BAG);

}

/*****************************************************************
 * @brief	attempts to retrieve the obj_id of a player's datapad
 *
 * @param	obj_id	target
 *
 * @return 	obj_id; null on error
 *****************************************************************/
obj_id getDatapad(obj_id target)
{
	if(!isIdValid(target))
	{
		return null;
	}

	return getObjectInSlot(target, SLOT_DATAPAD);
}

/*****************************************************************
 * @brief	attempts to retrieve the obj_id of a player's datapad
 *
 * @param	obj_id	target
 *
 * @return 	obj_id; null on error
 *****************************************************************/
obj_id getPlayerDatapad(obj_id player)
{
	if(!isIdValid(player) || !isPlayer(player))
	{
		return null;
	}

	return getObjectInSlot(player, SLOT_DATAPAD);
}

/*****************************************************************
 * @brief	attempts to retrieve the obj_id of a player's hangar
 *
 * @param	obj_id	target
 *
 * @return 	obj_id; null on error
 *****************************************************************/
obj_id getPlayerHangar(obj_id player)
{
	if(!isIdValid(player) || !isPlayer(player))
	{
		return null;
	}

	return getObjectInSlot(player, SLOT_HANGAR);
}

/*****************************************************************
 * @brief	attempts to retrieve the obj_id of a player's datapad
 *
 * @param	obj_id	target
 *
 * @return 	obj_id; null on error
 *****************************************************************/
obj_id getPlayerBank(obj_id player)
{
	if(!isIdValid(player) || !isPlayer(player))
	{
		return null;
	}

	return getObjectInSlot(player, SLOT_BANK);
}

/*****************************************************************
 * @brief	wrapper for messaging that an object or item is not active
 *
 * @param	obj_id	target
 *
 * @return 	obj_id; null on error
 *****************************************************************/
boolean itemNotActive(obj_id player)
{
	if ( (!isIdValid(player)) || (!isPlayer(player))  )
	{
		return false;
	}

	sendSystemMessage(player, SID_OBJECT_NOT_ACTIVE);
	return true;
}


/*****************************************************************
 * @brief	wrapper for enqueueing a request to open a container
 *
 * @param	obj_id	target
 *
 * @return 	obj_id; null on error
 *****************************************************************/
boolean requestContainerOpen(obj_id player, obj_id container)
{
	if ( (!isIdValid(player)) || (!isPlayer(player)) || (!isIdValid(container)) || (getContainerType(container) == 0) )
	{
		return false;
	}

	queueCommand(player, ##"openContainer", container, "", COMMAND_PRIORITY_DEFAULT);
	return true;
}

// packs a string id into a format usable by the sui system
string packStringId(string_id strId)
{
	if(strId==null)
	{

		return null;
	}

	if ( !strId.isValid() )
	{
		return null;
	}

	string strPackedId = "@"+strId.getTable()+":"+strId.getAsciiId();
	return strPackedId;

}
string_id unpackString(string strId)
{
	if ( strId == null || strId.equals("") )
		return null;

	if ( strId.startsWith("@") )
		strId = strId.substring(1);

	string[] s = split(strId, ':');
	if ( s != null && s.length == 2 )
	{
		return new string_id(s[0], s[1]);
	}

	return null;
}

// ----------------------------------------------------------------------

obj_id getNearbyPlayerByName(obj_id actor, string name)
{
	java.util.StringTokenizer st = new java.util.StringTokenizer(name);
	if (st.hasMoreTokens())
	{
		string compareName = toLower(st.nextToken());

		obj_id[] players = getPlayerCreaturesInRange(actor, 128.0f);
		if (players != null)
		{
			for (int i = 0; i < players.length; ++i)
			{
				java.util.StringTokenizer st2 = new java.util.StringTokenizer(getName(players[i]));
				string playerName = toLower(st2.nextToken());
				if (compareName == playerName)
					return players[i];
			}
		}
	}
	return obj_id.NULL_ID;
}

void sendPostureChange(obj_id objCreature, int intPosture) // USE THIS TO CHANGE POSTURE AND SEND DOWN THE ANIMATION MESSAGE TO THE CLIENT.
{
	attacker_results cbtAttackerResults = new attacker_results();

	setPosture(objCreature, intPosture);
	string strPlayback = "change_posture";
	cbtAttackerResults.id = objCreature;
	cbtAttackerResults.endPosture = intPosture;
	cbtAttackerResults.weapon = null;
	doCombatResults(strPlayback, cbtAttackerResults, null);
	return;
}

/*****************************************************************
 * @brief	gets all objects with non-null getCellNames() returns
 *
 * @param	obj_id[]	items
 *
 * @return 	obj_id[]; null on error
 *****************************************************************/
obj_id[] getBuildingsInObjIdList(obj_id[] items)
{
	if ( (items == null) || (items.length == 0) )
	{
		return null;
	}

	resizeable obj_id[] buildings = new obj_id[0];

	for ( int i = 0; i < items.length; i++ )
	{
		if ( getCellNames(items[i]) == null )
		{
		}
		else
		{
			buildings = addElement(buildings, items[i]);
		}
	}

	if ( (buildings == null) || (buildings.length == 0) )
	{
		return null;
	}
	else
	{
		return buildings;
	}
}
/*****************************************************************
 * @brief	gets all objects with non-null getCellNames() returns
 *
 * @param	obj_id[]	items
 *
 * @return 	obj_id[]; null on error
 *****************************************************************/
obj_id[] getContainedGOTObjects(obj_id container, int got, boolean recurse, boolean allowDerived)
{
	if ( !isIdValid(container) || (got < 0) )
	{
		return null;
	}

	if ( getContainerType(container) == 0 )	//container type == CT_none
	{
		//not a container!
		return null;
	}

	obj_id[] contents = getContents(container, recurse);
	if ( (contents == null) || (contents.length == 0) )
	{
		return null;
	}

	resizeable obj_id[] ret = new obj_id[0];
	for ( int i = 0; i < contents.length; i++ )
	{
		int myType = getGameObjectType(contents[i]);
		if ( !allowDerived )
		{
			if ( myType == got )
			{
				ret = addElement(ret, contents[i]);
			}
		}
		else
		{
			if ( isGameObjectTypeOf(myType, got) )
			{
				ret = addElement(ret, contents[i]);
			}
		}
	}
	if ( (ret == null) || (ret.length == 0) )
		return null;
	return ret;
}

obj_id[] getContainedGOTObjects(obj_id container, int got, boolean recurse)
{
	return getContainedGOTObjects(container, got, recurse, false);
}

obj_id[] getContainedGOTObjects(obj_id container, int got)
{
	return getContainedGOTObjects(container, got, false);
}

obj_id[] getContainedObjectsWithObjVar(obj_id container, string var, boolean recurse)
{
	if(!isIdValid(container))
		return null;

	if(getContainerType(container) == 0)
		return null;

	if(var == null || var.equals(""))
		return null;

	obj_id[] contents = getContents(container, recurse);
	if(contents == null || contents.length == 0)
		return null;

	resizeable obj_id[] ret = new obj_id[0];
	for(int i = 0; i < contents.length; i++)
	{
		if(hasObjVar(contents[i], var))
			ret = addElement(ret, contents[i]);
	}

	if((ret == null) || (ret.length == 0))
		return null;

	return ret;
}

obj_id[] getContainedObjectsWithObjVar(obj_id container, string var)
{
	return getContainedObjectsWithObjVar(container, var, false);
}

obj_id[] getContainedObjectsWithScript(obj_id container, string script, boolean recurse)
{
	if(!isIdValid(container))
		return null;

	if(getContainerType(container) == 0)
		return null;

	if(script == null || script.equals(""))
		return null;

	obj_id[] contents = getContents(container, recurse);
	if(contents == null || contents.length == 0)
		return null;

	resizeable obj_id[] ret = new obj_id[0];
	for(int i = 0; i < contents.length; i++)
	{
		if(hasScript(contents[i], script))
			ret = addElement(ret, contents[i]);
	}

	if((ret == null) || (ret.length == 0))
		return null;

	return ret;
}

obj_id[] getContainedObjectsWithScript(obj_id container, string script)
{
	return getContainedObjectsWithScript(container, script, false);
}

/*************************************************************************************
 * @brief	Wrapper for sending Persistent chat messages (Emails)
 *
 * @params	string_id subject = The title of your email, saved in
 *		a stringfile, just like in a conversation.
 *
 *		string_id body = The actual message of your email, same as above
 *
 *		string to = The person receiving the mail.  Find this by using
 *		getFirstName (Obj_Id) of the person you want to send the mail to.
 *		Just use the first name, they're unique.
 *
 *		string from = Just a string.  Can be anything, Its just who the mail
 *		is from (Bib Fortuna, Jabba, Darth Vader, Joe the Butcher, etc.)
 *
 * @return 	void
 *
 * @Author	Tbailey (1/13/03) W/Help from J.Watson and M.Siverston
 ************************************************************************************/

void sendMail (string_id subject, string_id body, string to, string from)
{
	string body_oob    = chatMakePersistentMessageOutOfBandBody(null, body);
	string subject_str = "@" + subject.toString ();

	chatSendPersistentMessage( from, to, subject_str, null, body_oob );

	return;
}

//----------------------------------------------------------------------------------

void sendMail( string_id subject, string_id body, obj_id to, string from )
{
	string body_oob    = chatMakePersistentMessageOutOfBandBody(null, body);
	string subject_str = "@" + subject.toString ();

	chatSendPersistentMessage( from, to, subject_str, null, body_oob );
}

//----------------------------------------------------------------------------------

void sendMail( string_id subject, prose_package body, obj_id to, string from )
{
	string body_oob    = chatMakePersistentMessageOutOfBandBody(null, body);
	string subject_str = "@" + subject.toString ();

	chatSendPersistentMessage( from, to, subject_str, null, body_oob );
}

//----------------------------------------------------------------------------------

void sendMail( string_id subject, prose_package body, string to, string from )
{
	string body_oob    = chatMakePersistentMessageOutOfBandBody(null, body);
	string subject_str = "@" + subject.toString ();

	chatSendPersistentMessage( from, to, subject_str, null, body_oob );
}

//----------------------------------------------------------------------------------

boolean isNightTime()
{
	if (getLocalTime () < getLocalDayLength ())
	{
		//-- it's day time
		return false;
	}
	else
	{
		return true;
		//-- it's night time
	}
}

//--------------------------group system message function---------------------------
void sendSystemMessageTestingOnly(obj_id[] players, string message)
{
	if (players == null || players.length == 0)
		return;

	for (int i=0;i< players.length; i++)
	{
		if (isIdValid(players[i]) && exists(players[i]))
		{
			sendSystemMessageTestingOnly(players[i], message);
		}
	}
}

void sendSystemMessage(obj_id[] players, string_id message)
{
	if (players == null || players.length == 0)
		return;

	for (int i=0;i< players.length; i++)
	{
		if (isIdValid(players[i]) && exists(players[i]))
		{
			sendSystemMessage(players[i], message);
		}
	}
}

void sendSystemMessageProse(obj_id[] players, prose_package message)
{
	if (players == null || players.length == 0)
		return;

	for (int i=0;i< players.length; i++)
	{
		if (isIdValid(players[i]) && exists(players[i]))
		{
			sendSystemMessageProse(players[i], message);
		}
	}
}

void sendSystemMessagePob(obj_id pob, string_id message)
{
	obj_id[] players = trial.getPlayersInDungeon(pob);
	if (players != null && players.length > 0)
		utils.sendSystemMessage(players, message);
}

void sendSystemMessageProsePob(obj_id pob, prose_package message)
{
	obj_id[] players = trial.getPlayersInDungeon(pob);
	if (players != null && players.length > 0)
		utils.sendSystemMessageProse(players, message);
}

/**
* Wraps a string_id into a prose package and send the message in the space taunt window
*
* obj_id source			The NPC sending the message
* obj_id player			The player to message
* string_id message		The string to wrap
* string templateOverride	A template to use instead of the source
*
* return			void
**/
void messagePlayer(obj_id source, obj_id player, string_id message, string templateOverride)
{
	prose_package pp = new prose_package();
	pp.stringId = message;

	if (templateOverride.equals("none"))
		commPlayer(source, player, pp);
	else
		commPlayer(source, player, pp, templateOverride);
}

void messagePlayer(obj_id source, obj_id player, string_id message)
{
	messagePlayer(source, player, message, "none");
}

void messagePlayer(obj_id source, obj_id[] players, string_id message, string templateOverride)
{
	prose_package pp = new prose_package();
	pp.stringId = message;

	if (templateOverride.equals("none"))
		commPlayers(source, players, pp);
	else
		commPlayers(source, players, pp, templateOverride);
}

void messagePlayer(obj_id source, obj_id[] players, string_id message, string templateOverride, float duration)
{
	prose_package pp = new prose_package();
	pp.stringId = message;

	if(templateOverride.equals("none"))
	{
		commPlayers(source, players, pp);
		return;
	}

	if(duration <= 0.0f)
	{
		commPlayers(source, players, pp, templateOverride);
	}
	else
	{
		commPlayers(source, templateOverride, null, duration, players, pp);
	}
}

void messagePlayer(obj_id source, obj_id[] players, string_id message)
{
	messagePlayer(source, players, message, "none");
}

// OBJECT DICTIONARY FUNCTIONS
// These mirror LocalVars, but are not proxied. they are fast, but completely local, and wont work multiserver
boolean setLocalVar(obj_id target, string path, Vector val)
{
	// this function sucks
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;
	if ( val == null || val.isEmpty() )
		return false;
	// get a sample value from the vector so we can find out what type of data we've got
	Object sample = val.get(0);
	if ( sample == null )
		return false;

	// call a type-specific setLocalVar
	boolean result = false;
	if ( sample instanceof Integer )
	{
		int count = val.size();
		int[] tempVal = new int[count];
		for ( int i = 0; i < count; ++i )
			tempVal[i] = ((Integer)val.get(i)).intValue();
		result = setLocalVar(target, path, tempVal);
	}
	else if ( sample instanceof Boolean )
	{
		int count = val.size();
		boolean[] tempVal = new boolean[count];
		for ( int i = 0; i < count; ++i )
			tempVal[i] = ((Boolean)val.get(i)).booleanValue();
		result = setLocalVar(target, path, tempVal);
	}
	else if ( sample instanceof Float )
	{
		int count = val.size();
		float[] tempVal = new float[count];
		for ( int i = 0; i < count; ++i )
			tempVal[i] = ((Float)val.get(i)).intValue();
		result = setLocalVar(target, path, tempVal);
	}
	else if ( sample instanceof string )
	{
		string[] tempVal = new string[val.size()];
		tempVal = (string[])val.toArray(tempVal);
		result = setLocalVar(target, path, tempVal);
	}
	else if ( sample instanceof obj_id )
	{
		obj_id[] tempVal = new obj_id[val.size()];
		tempVal = (obj_id[])val.toArray(tempVal);
		result = setLocalVar(target, path, tempVal);
	}
	else if ( sample instanceof location )
	{
		location[] tempVal = new location[val.size()];
		tempVal = (location[])val.toArray(tempVal);
		result = setLocalVar(target, path, tempVal);
	}
	else if ( sample instanceof transform )
	{
		transform[] tempVal = new transform[val.size()];
		tempVal = (transform[])val.toArray(tempVal);
		result = setLocalVar(target, path, tempVal);
	}
	else if ( sample instanceof vector)
	{
		vector[] tempVal = new vector[val.size()];
		tempVal = (vector[])val.toArray(tempVal);
		result = setLocalVar(target, path, tempVal);
	}

	return result;
}


boolean setLocalVar(obj_id target, string path, location val)
{

	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	dictionary dd = target.getScriptDictionary();
	dd.put(path, val );
	return true;
	//return setLocalVar(target, path, new Integer(val));
}
boolean setLocalVar(obj_id target, string path, location[] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	dictionary dd = target.getScriptDictionary();
	dd.put(path, val );
	return true;
	//return setLocalVar(target, path, new Integer(val));
}

boolean setLocalVar(obj_id target, string path, string val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	dictionary dd = target.getScriptDictionary();
	dd.put(path, val );
	return true;
	//return setLocalVar(target, path, new Integer(val));
}
boolean setLocalVar(obj_id target, string path, string[] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	dictionary dd = target.getScriptDictionary();
	dd.put(path, val );
	return true;
	//return setLocalVar(target, path, new Integer(val));
}

boolean setLocalVar(obj_id target, string path, obj_id val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	dictionary dd = target.getScriptDictionary();
	dd.put(path, val );
	return true;
	//return setLocalVar(target, path, new Integer(val));
}
boolean setLocalVar(obj_id target, string path, obj_id[] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	dictionary dd = target.getScriptDictionary();
	dd.put(path, val );
	return true;
	//return setLocalVar(target, path, new Integer(val));
}

boolean setLocalVar(obj_id target, string path, int val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	dictionary dd = target.getScriptDictionary();
	dd.put(path, val );
	return true;
	//return setLocalVar(target, path, new Integer(val));
}
boolean setLocalVar(obj_id target, string path, int[] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	dictionary dd = target.getScriptDictionary();
	dd.put(path, val );
	return true;
	//return setLocalVar(target, path, new Integer(val));
}

boolean setLocalVar(obj_id target, string path, float val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	dictionary dd = target.getScriptDictionary();
	dd.put(path, val );
	return true;
	//return setLocalVar(target, path, new Float(val));
}
boolean setLocalVar(obj_id target, string path, float[] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	dictionary dd = target.getScriptDictionary();
	dd.put(path, val );
	return true;
	//return setLocalVar(target, path, new Float(val));
}

boolean setLocalVar(obj_id target, string path, boolean val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	dictionary dd = target.getScriptDictionary();
	dd.put(path, val );
	return true;
//	return setLocalVar(target, path, new Boolean(val));
}
boolean setLocalVar(obj_id target, string path, transform val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	dictionary dd = target.getScriptDictionary();
	dd.put(path, val );
	return true;
}

boolean setLocalVar(obj_id target, string path, transform[] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	dictionary dd = target.getScriptDictionary();
	dd.put(path, val );
	return true;
}

boolean setLocalVar(obj_id target, string path, vector val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	dictionary dd = target.getScriptDictionary();
	dd.put(path, val );
	return true;
}

boolean setLocalVar(obj_id target, string path, vector[] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	dictionary dd = target.getScriptDictionary();
	dd.put(path, val );
	return true;
}

boolean setLocalVar(obj_id target, string path, boolean[] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	dictionary dd = target.getScriptDictionary();
	dd.put(path, val );
	return true;
//	return setLocalVar(target, path, new Boolean(val));
}

boolean setLocalVar(obj_id target, string path, dictionary val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	dictionary dd = target.getScriptDictionary();
	dd.put(path, val);
	return true;
}

boolean hasLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	return dd.containsKey(path);
}

boolean removeLocalVar(obj_id target, string path)
{
	if ( (target == null) || (target == obj_id.NULL_ID) )
	{
		return false;
	}

	if ( (path == null) || (path.equals("")) )
	{
		return false;
	}

	dictionary dd = target.getScriptDictionary();
	dd.remove(path);

	return true;
}

int getIntLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	return dd.getInt(path);
}

int[] getIntArrayLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	return dd.getIntArray(path);
}

float getFloatLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	return dd.getFloat(path);
}

float[] getFloatArrayLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	return dd.getFloatArray(path);
}

string getStringLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	return dd.getString(path);
}

string[] getStringArrayLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	return dd.getStringArray(path);
}

transform[] getTransformArrayLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	return dd.getTransformArray(path);
}

boolean getBooleanLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	return dd.getBoolean(path);
}

boolean[] getBooleanArrayLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	return dd.getBooleanArray(path);
}

location getLocationLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	return dd.getLocation(path);
}

location[] getLocationArrayLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	return dd.getLocationArray(path);
}

obj_id getObjIdLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	return dd.getObjId(path);
}

obj_id[] getObjIdArrayLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	return dd.getObjIdArray(path);
}

Vector getResizeableObjIdArrayLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	obj_id[] objArray = dd.getObjIdArray(path);
	return new Vector(Arrays.asList(objArray));
}

Vector getResizeableLocationArrayLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	location[] locArray = dd.getLocationArray(path);
	return new Vector(Arrays.asList(locArray));
}


Vector getResizeableIntArrayLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	int[] intArray = dd.getIntArray(path);
	Vector rszArray = new Vector(intArray.length + 1);
	for ( int i = 0; i < intArray.length; ++i )
		rszArray.add(new Integer(intArray[i]));
	return rszArray;
}

Vector getResizeableFloatArrayLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	float[] fltArray= dd.getFloatArray(path);
	Vector rszArray = new Vector(fltArray.length + 10);
	for ( int i = 0; i < fltArray.length; ++i )
		rszArray.add(new Float(fltArray[i]));
	return rszArray;
}

Vector getResizeableStringArrayLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	string[] strArray = dd.getStringArray(path);
	return new Vector(Arrays.asList((String[])strArray));
}

Vector getResizeableTransformArrayLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	transform[] trArray= dd.getTransformArray(path);
	Vector v1 = new Vector( Arrays.asList(trArray));

	return v1;
}

Vector getResizeableVectorArrayLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	vector[] vctArray = dd.getVectorArray(path);
	Vector v1 = new Vector( Arrays.asList(vctArray));
	return v1;
}

string_id getStringIdLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	return dd.getStringId(path);
}

string_id[] getStringIdArrayLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	return dd.getStringIdArray(path);
}

dictionary getDictionaryLocalVar(obj_id target, string path)
{
	dictionary dd = target.getScriptDictionary();
	return dd.getDictionary(path);
}

// END LOCALVARS

/*****************************************************************
 * @brief	sets a scriptvar on a player
 *
 * @param	obj_id	target
 * @param	string	path
 * @param	Object	val
 *
 * @return 	boolean; false on error
 *****************************************************************/
/*boolean setScriptVar(obj_id target, string path, Object val)
{
	debugServerConsoleMsg(target, "utils:setScriptVar: entered...");
	if ( (target == null) || (target == obj_id.NULL_ID) )
	{
		return false;
	}

	if ( (path == null) || (path.equals("")) )
	{
		return false;
	}

	debugServerConsoleMsg(target, "utils:setScriptVar: retrieving scriptvars...");

	deltadictionary dd = target.getScriptVars();

	debugServerConsoleMsg(target, "utils:setScriptVar: attempting to set scriptvar " + path + " to " + val.toString());
	dd.put(path, val);

	return true;
}*/

boolean setScriptVar(obj_id target, string path, location val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, location[] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, string val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, string[] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, string[][] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val);
	return true;
}

boolean setScriptVar(obj_id target, string path, obj_id val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, obj_id[] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, int val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, int[] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, long val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, long[] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, double val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, double[] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, float val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, float[] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, boolean val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, transform val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, transform[] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, vector val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, vector[] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, boolean[] val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val );
	return true;
}

boolean setScriptVar(obj_id target, string path, Vector val)
{
	// this function sucks
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;
	if ( val == null || val.isEmpty() )
		return false;
	// get a sample value from the vector so we can find out what type of data we've got
	Object sample = val.get(0);
	if ( sample == null )
		return false;

	// call a type-specific setScriptVar
	boolean result = false;
	if ( sample instanceof Integer )
	{
		int count = val.size();
		int[] tempVal = new int[count];
		for ( int i = 0; i < count; ++i )
			tempVal[i] = ((Integer)val.get(i)).intValue();
		result = setScriptVar(target, path, tempVal);
	}
	else if ( sample instanceof Boolean )
	{
		int count = val.size();
		boolean[] tempVal = new boolean[count];
		for ( int i = 0; i < count; ++i )
			tempVal[i] = ((Boolean)val.get(i)).booleanValue();
		result = setScriptVar(target, path, tempVal);
	}
	else if ( sample instanceof Float )
	{
		int count = val.size();
		float[] tempVal = new float[count];
		for ( int i = 0; i < count; ++i )
			tempVal[i] = ((Float)val.get(i)).intValue();
		result = setScriptVar(target, path, tempVal);
	}
	else if ( sample instanceof string )
	{
		string[] tempVal = new string[val.size()];
		tempVal = (string[])val.toArray(tempVal);
		result = setScriptVar(target, path, tempVal);
	}
	else if ( sample instanceof obj_id )
	{
		obj_id[] tempVal = new obj_id[val.size()];
		tempVal = (obj_id[])val.toArray(tempVal);
		result = setScriptVar(target, path, tempVal);
	}
	else if ( sample instanceof location )
	{
		location[] tempVal = new location[val.size()];
		tempVal = (location[])val.toArray(tempVal);
		result = setScriptVar(target, path, tempVal);
	}
	else if ( sample instanceof transform )
	{
		transform[] tempVal = new transform[val.size()];
		tempVal = (transform[])val.toArray(tempVal);
		result = setScriptVar(target, path, tempVal);
	}
	else if ( sample instanceof vector)
	{
		vector[] tempVal = new vector[val.size()];
		tempVal = (vector[])val.toArray(tempVal);
		result = setScriptVar(target, path, tempVal);
	}

	return result;
}

boolean setScriptVar(obj_id target, string path, dictionary val)
{
	if ( !isIdValid(target) )
		return false;
	if ( (path == null) || (path.equals("")) )
		return false;

	deltadictionary dd = target.getScriptVars();
	dd.put(path, val);
	return true;
}

/*****************************************************************
 * @brief	checks whether a scriptvar exists on the target
 *
 * @param	obj_id	target
 * @param	string	path
 *
 * @return 	boolean; false on error
 *****************************************************************/
boolean hasScriptVar(obj_id target, string path)
{
	return target.hasScriptVar( path );
}

/*****************************************************************
 * @brief	checks whether a scriptvar tree exists on the target
 *
 * @param	obj_id	target
 * @param	string	path
 *
 * @return 	boolean; false on error
 *****************************************************************/
boolean hasScriptVarTree(obj_id target, string path)
{
	if ( (target == null) || (target == obj_id.NULL_ID) )
	{
		return false;
	}

	if ( (path == null) || (path.equals("")) )
	{
		return false;
	}

	deltadictionary dd = target.getScriptVars();
	Enumeration keys = dd.keys();
	while ( keys.hasMoreElements() )
	{
		string key = (string)(keys.nextElement());
		if ( key.equals(path) || key.startsWith(path + ".") )
			return true;
	}

	return false;
}

/*****************************************************************
 * @brief	removes a scriptvar from a player
 *
 * @param	obj_id	target
 * @param	string	path
 *
 * @return 	boolean; false on error
 *****************************************************************/
boolean removeScriptVar(obj_id target, string path)
{
	if ( (target == null) || (target == obj_id.NULL_ID) )
	{
		return false;
	}

	if ( (path == null) || (path.equals("")) )
	{
		return false;
	}

	deltadictionary dd = target.getScriptVars();
	dd.remove(path);

	return true;
}

/*****************************************************************
 * @brief	removes a scriptvar from a player
 *
 * @param	obj_id	target
 * @param	string	path
 *
 * @return 	boolean; false on error
 *****************************************************************/
boolean removeScriptVarTree(obj_id target, string path)
{
	if ( (target == null) || (target == obj_id.NULL_ID) )
	{
		return false;
	}

	if ( (path == null) || (path.equals("")) )
	{
		return false;
	}

	deltadictionary dd = target.getScriptVars();
	Enumeration keys = dd.keys();
	while ( keys.hasMoreElements() )
	{
		string key = (string)(keys.nextElement());
		if ( key.equals(path) || key.startsWith(path + ".") )
			dd.remove(key);
	}

	return true;
}

/*****************************************************************
 * @brief	gets a scriptvar from a player
 *
 * @param	obj_id	target
 * @param	string	path
 *
 * @return 	boolean; false on error
 *****************************************************************/
int getIntScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getInt(path);
}

int[] getIntArrayScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getIntArray(path);
}

float getFloatScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getFloat(path);
}

float[] getFloatArrayScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getFloatArray(path);
}

long getLongScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getLong(path);
}

long[] getLongArrayScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getLongArray(path);
}

double getDoubleScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getDouble(path);
}

double[] getDoubleArrayScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getDoubleArray(path);
}

string getStringScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getString(path);
}

string[] getStringArrayScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getStringArray(path);
}

string[][] getStringArrayArrayScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getStringArrayArray(path);
}

transform[] getTransformArrayScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getTransformArray(path);
}

transform getTransformScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getTransform(path);
}
boolean getBooleanScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getBoolean(path);
}

boolean[] getBooleanArrayScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getBooleanArray(path);
}

location getLocationScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getLocation(path);
}

location[] getLocationArrayScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getLocationArray(path);
}

obj_id getObjIdScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getObjId(path);
}

obj_id[] getObjIdArrayScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getObjIdArray(path);
}

Vector getResizeableObjIdArrayScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getResizeableObjIdArray(path);
}

Vector getResizeableLocationArrayScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getResizeableLocationArray(path);
}

Vector getResizeableIntArrayScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getResizeableIntArray(path);
}

Vector getResizeableFloatArrayScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getResizeableFloatArray(path);
}

Vector getResizeableStringArrayScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getResizeableStringArray(path);
}

Vector getResizeableTransformArrayScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getResizeableTransformArray(path);
}

Vector getResizeableVectorArrayScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getResizeableVectorArray(path);
}

string_id getStringIdScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getStringId(path);
}

string_id[] getStringIdArrayScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getStringIdArray(path);
}

dictionary getDictionaryScriptVar(obj_id target, string path)
{
	deltadictionary dd = target.getScriptVars();
	return dd.getDictionary(path);
}

/*****************************************************************
 * @brief	empties a container of all objects
 *
 * @param	obj_id	target
 *
 * @return 	boolean; false on error
 *****************************************************************/
boolean emptyContainer(obj_id target)
{
	if ( (target == null) || (target == obj_id.NULL_ID) )
	{
		return false;
	}

	obj_id[] contents = getContents(target);
	if ( (contents == null) || (contents.length == 0) )
	{
		return false;
	}

	for ( int i = 0; i < contents.length; i++ )
	{
		destroyObject(contents[i]);
	}

	return true;
}

boolean emptyContainerExceptStorytellerLoot(obj_id target)
{
	if ( (target == null) || (target == obj_id.NULL_ID) )
	{
		return false;
	}

	obj_id[] contents = getContents(target);
	if ( (contents == null) || (contents.length == 0) )
	{
		return false;
	}

	for ( int i = 0; i < contents.length; i++ )
	{
		obj_id contentsItem = contents[i];
		if ( !utils.hasScriptVar(contentsItem, "storytellerLoot") )
		{
			destroyObject(contentsItem);
		}
	}

	return true;
}

/*
	3 arguments, middle angle, 1/2 size of arc (left/right size), and distance out from the start location
*/
location getLocationInArc(obj_id objPlayer, float fltStartAngle, float fltArcSize, float fltDistance)
{

	location locHeading = getHeading(objPlayer);
	location locCenter = getLocation(objPlayer);

	locHeading.x  = locHeading.x * fltDistance;
	locHeading.z  = locHeading.z * fltDistance; // pushed out along the correct scale since it's 0 based

	locHeading.y = locCenter.y;
	locHeading.cell = locCenter.cell;
	locHeading.area = locCenter.area;


	float fltAngle = rand(fltStartAngle - fltArcSize, fltStartAngle + fltArcSize);
	//LOG("spawn_player", "locHEading is "+locHeading);

	location locNewHeading = rotatePointXZ(locHeading, fltAngle);

	locNewHeading.x = locCenter.x + locNewHeading.x;
	locNewHeading.z = locCenter.z + locNewHeading.z;

	return locNewHeading;

}


float getHeadingDegrees(obj_id objTarget) // gets heading in degrees.. duh
{
	location locStart = getLocation(objTarget);
	location locHeading = getHeading(objTarget);
	locHeading.x = locStart.x + locHeading.x;
	locHeading.z = locStart.z + locHeading.z;
	locHeading.y = locStart.y + locHeading.y;

	float fltAngle = thetaDegrees(locStart, locHeading);
	return fltAngle;

}

float thetaDegrees (location direction)
{
	return (float) Math.toDegrees (Math.atan2 (direction.x, direction.z));
}

float thetaDegrees (location start, location end)
{
	location direction = new location ();
	direction.x = end.x - start.x;
	direction.y = end.y - start.y;
	direction.z = end.z - start.z;

	return thetaDegrees (direction);
}

int countSubStringObjVars(obj_id[] objObjects, string strObjVar, string strSubString)
{ // this looks for all of our objects it checks a speciufic objvar vfor a specific substring and returns the count
	if(objObjects==null)
	{

		return 0; // NONE!
	}
	int intCount = 0;
	for(int intI = 0; intI<objObjects.length; intI++)
	{
		string strString = getStringObjVar(objObjects[intI], strObjVar);
		if(strString!=null)
		{
			int intIndex = strString.indexOf(strSubString);
			if(intIndex>-1)
			{
				intCount = intCount +1; // we found one
			}
		}
	}
	return intCount;
}

dictionary addObjVarToDictionary(obj_var ov, dictionary d, string basePath)
{
	if ( ov == null || d == null )
	{
		return d;
	}

	if ( basePath == null )
	{
		basePath = "";
	}

	Object dta = ov.getData();
	if ( dta == null )
	{
		return d;
	}

	string name = ov.getName();
	string path = basePath + name;

	if ( dta instanceof int )
	{
		int iVal = ov.getIntData();
		int iCur = d.getInt(path);

		iVal += iCur;

		d.put(path, iVal);
	}
	else if ( dta instanceof float )
	{
		float fVal = ov.getFloatData();
		float fCur = d.getFloat(path);

		fVal += fCur;

		d.put(path, fVal);
	}
	else if ( dta instanceof int[] )
	{
		int[] iaVal = ov.getIntArrayData();
		int[] iaCur = d.getIntArray(path);
		if ( (iaCur == null) || (iaCur.length == 0) )
		{
			d.put(path, iaVal);
		}
		else
		{
			if ( iaVal.length == iaCur.length )
			{
				for ( int z = 0; z < iaVal.length; z++ )
				{
					iaVal[z] += iaCur[z];
				}

				d.put(path, iaVal);
			}
		}
	}
	else if ( dta instanceof float[] )
	{
		float[] faVal = ov.getFloatArrayData();
		float[] faCur = d.getFloatArray(path);
		if ( (faCur == null) || (faCur.length == 0) )
		{
			d.put(path, faVal);
		}
		else
		{
			if ( faVal.length == faCur.length )
			{
				for ( int z = 0; z < faVal.length; z++ )
				{
					faVal[z] += faCur[z];
				}

				d.put(path, faVal);
			}
		}
	}

	return d;
}

dictionary addObjVarToDictionary(obj_var ov, dictionary d)
{
	return addObjVarToDictionary(ov, d, null);
}

dictionary addObjVarListToDictionary(obj_var_list ovl, dictionary d, string basePath)
{
	if ( ovl == null || d == null )
	{
		return d;
	}

	if ( basePath == null )
	{
		basePath = "";
	}

	string name = ovl.getName();
	string path = basePath + name;

	boolean litmus = true;

	int numItems = ovl.getNumItems();
	for ( int i = 0; i < numItems; i++ )
	{
		obj_var ov = ovl.getObjVar(i);
		if ( ov != null )
		{
			if ( ov instanceof obj_var_list )
			{
				d = addObjVarListToDictionary((obj_var_list)(ov), d, path + ".");
			}
			else
			{
				d = addObjVarToDictionary(ov, d, path + ".");
			}
		}
	}

	return d;
}

dictionary addObjVarListToDictionary(obj_var_list ovl, dictionary d)
{
	return addObjVarListToDictionary(ovl, d, null);
}

obj_id cloneObject(obj_id template, obj_id container)
{
	string templateName = getTemplateName(template);
	obj_id clone = createObject(templateName, container, "");
	if(!isIdValid(clone))
	{
		return null;
	}

	copyObjectData(template, clone);
	return clone;
}

obj_id cloneObject(obj_id template, location loc)
{
	string templateName = getTemplateName(template);
	obj_id clone = createObject(templateName, loc);
	if(!isIdValid(clone))
	{
		return null;
	}

	copyObjectData(template, clone);
	return clone;
}

void copyObjectData(obj_id template, obj_id clone)
{
	/* this block of code seems to cause an exception
	string[] scripts = getScriptList(template);
	for(int i = 0; i < scripts.length; i++)
	{
		if(!hasScript(clone, scripts[i]))
		{
			attachScript(clone, scripts[i]);
		}
	}
	*/

	obj_var_list ovl = getObjVarList(clone, "");

	if(ovl == null)
	{
		return;
	}

	int numItems = ovl.getNumItems();
	for(int x = 0; x < numItems; x++)
	{
		obj_var ov = ovl.getObjVar(x);
		if(ov != null)
		{
			copyObjVar(template, clone, ov.getName());
		}
	}
}



boolean copyObjVar(obj_id target, string basePath, obj_var ov)
{
	if ( !isIdValid(target) )
	{
		return false;
	}

	if ( basePath == null )
	{
		basePath = "";
	}

	if ( ov == null )
	{
		return false;
	}

	string name = ov.getName();
	string path = basePath + name;

	Object dta = ov.getData();
	if ( dta instanceof int )
	{
		int val = ov.getIntData();
		return setObjVar(target, path, val);
	}
	else if ( dta instanceof int[] )
	{
		int[] val = ov.getIntArrayData();
		return setObjVar(target, path, val);
	}
	else if ( dta instanceof float )
	{
		float val = ov.getFloatData();
		return setObjVar(target, path, val);
	}
	else if ( dta instanceof float[] )
	{
		float[] val = ov.getFloatArrayData();
		return setObjVar(target, path, val);
	}
	else if ( dta instanceof Boolean )
	{
		boolean val = ov.getBooleanData();
		return setObjVar(target, path, val);
	}
	else if ( dta instanceof Boolean[] )
	{
		boolean[] val = ov.getBooleanArrayData();
		return setObjVar(target, path, val);
	}
	else if ( dta instanceof string )
	{
		string val = ov.getStringData();
		return setObjVar(target, path, val);
	}
	else if ( dta instanceof string[] )
	{
		string[] val = ov.getStringArrayData();
		return setObjVar(target, path, val);
	}
	else if ( dta instanceof obj_id )
	{
		obj_id val = ov.getObjIdData();
		return setObjVar(target, path, val);
	}
	else if ( dta instanceof obj_id[] )
	{
		obj_id[] val = ov.getObjIdArrayData();
		return setObjVar(target, path, val);
	}
	else if ( dta instanceof location )
	{
		location val = ov.getLocationData();
		return setObjVar(target, path, val);
	}
	else if ( dta instanceof location[] )
	{
		location[] val = ov.getLocationArrayData();
		return setObjVar(target, path, val);
	}
	else if ( dta instanceof string_id )
	{
		string_id val = ov.getStringIdData();
		return setObjVar(target, path, val);
	}
	else if ( dta instanceof string_id[] )
	{
		string_id[] val = ov.getStringIdArrayData();
		return setObjVar(target, path, val);
	}
	else if ( dta instanceof attrib_mod )
	{
		attrib_mod val = ov.getAttribModData();
		return setObjVar(target, path, val);
	}
	else if ( dta instanceof attrib_mod[] )
	{
		attrib_mod[] val = ov.getAttribModArrayData();
		return setObjVar(target, path, val);
	}

	return false;
}

boolean[] removeObjVarList(obj_id object, string[] objVarList)
{
	boolean[] result = new boolean[objVarList.length];

	for (int i=0;i<objVarList.length;i++)
	{
		if (!hasObjVar(object, objVarList[i]))
		{
			result[i] = false;
		}
		else
		{
			removeObjVar(object, objVarList[i]);
			result[i] = true;
		}
	}

	if (result == null || result.length == 0)
		result[0] = false;

	return result;
}

/**
 * Saves the data in a dictionary as objvars on an object.
 * !!! ONLY SUPPORTS INT, FLOAT, AND SUB-DICTIONARY DATA !!!
 *
 * @param object		the object to write the objvars to
 * @param rootName		the objvar root name for the dictionary; null or empty string will place the dictionary data at the root level
 * @param dict			the dictionary data to write
 *
 * @return true on success, false if there was an error
 */
boolean saveDictionaryAsObjVar(obj_id object, string rootName, dictionary dict)
{
	if ( !isIdValid(object) || dict == null )
		return false;

	// make sure the root name is valid
	if ( rootName == null )
		rootName = "";
	else if ( rootName != null && rootName.length() > 0 )
	{
		if ( !Character.isLetterOrDigit(rootName.charAt(0)) )
			return false;
		if ( rootName.charAt(rootName.length() - 1) != '.' )
			rootName = rootName + ".";
	}

	Enumeration keys = dict.keys();
	while ( keys.hasMoreElements() )
	{
		string key = null;
		try
		{
			key = (string)keys.nextElement();
		}
		catch ( ClassCastException err )
		{
			return false;
		}
		Object data = dict.get(key);
		if ( data instanceof Integer )
		{
			//debugServerConsoleMsg(null, "\tsaveDictionaryAsObjVar -> "+rootName+key+" (Integer) = "+ data.toString());
			setObjVar(object, rootName + key, ((Integer)data).intValue());
		}
		else if ( data instanceof Float )
		{
			//debugServerConsoleMsg(null, "\tsaveDictionaryAsObjVar -> "+rootName+key+" (Float) = "+ data.toString());
			setObjVar(object, rootName + key, ((Float)data).floatValue());
		}
		else if ( data instanceof string )
		{
			//debugServerConsoleMsg(null, "\tsaveDictionaryAsObjVar -> "+rootName+key+" (string) = "+ data.toString());
			setObjVar(object, rootName + key, (string)data);
		}
		else if ( data instanceof int[] )
		{
			//debugServerConsoleMsg(null, "\tsaveDictionaryAsObjVar -> "+rootName+key+" (int[]) = "+ data.toString());
			setObjVar(object, rootName + key, (int[])data);
		}
		else if ( data instanceof float[] )
		{
			//debugServerConsoleMsg(null, "\tsaveDictionaryAsObjVar -> "+rootName+key+" (float[]) = "+ data.toString());
			setObjVar(object, rootName + key, (float[])data);
		}
		else if ( data instanceof dictionary )
		{
			//debugServerConsoleMsg(null, "\tsaveDictionaryAsObjVar -> "+rootName+key+" (dictionary) = "+ data.toString());
			saveDictionaryAsObjVar(object, rootName + key, (dictionary)data);
		}
		else
		{
			//debugServerConsoleMsg(null, "\tsaveDictionaryAsObjVar -> "+rootName+key+" (unknown) = "+ data.getClass().getName());
			//return false;
		}
	}
	return true;
}

string getFactionSubString(string strSearchString) // THIS FINDS THE SUBSTRING IN A BASE STRING AND RETURNS THE CORRECT FACTION
{
	if(strSearchString==null)
	{
		return null;
	}
	string strTestString = toLower(strSearchString);
	const string[] FACTION_SEARCH_STRINGS = {factions.FACTION_IMPERIAL, factions.FACTION_REBEL};
	for(int intI = 0; intI<FACTION_SEARCH_STRINGS.length; intI++)
	{

		int intIndex = strTestString.indexOf(toLower(FACTION_SEARCH_STRINGS[intI]));
		if(intIndex>-1)
		{
			return FACTION_SEARCH_STRINGS[intI];
		}


	}
	return null;
}

boolean setBatchObjVar(obj_id target, string base_path, Object[] array)
{
	if ( !isIdValid(target) )
	{
		return false;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		return false;
	}

	if ( (array == null) || (array.length == 0) )
	{
		return false;
	}

	if ( hasObjVar(target, base_path) )
		removeObjVar(target, base_path);

	int BatchSize = 10;

	boolean litmus = true;
	int n = 0;
	Vector toSet = new Vector();
	for ( int i = 0; i < array.length; i++ )
	{
		toSet.add(array[i]);
		if ( toSet.size() >= BatchSize )
		{
			litmus &= setObjectArrayObjVar(target, base_path + "." + n, toSet);
			toSet.clear();
			n++;
		}
	}

	litmus &= setObjectArrayObjVar(target, base_path + "." + n, toSet);

	return litmus;
}

void removeBatchObjVar(obj_id target, string base_path)
{
	if ( !isIdValid(target) )
	{
		return;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		return;
	}

	if ( !hasObjVar(target, base_path) )
	{
		return;
	}

	if (hasObjVar(target, base_path))
		removeObjVar(target, base_path);

	obj_var_list list = getObjVarList(target, null);

	if (list == null)
		return;

	int listLength = list.getNumItems();
	int intQ = 0;

	for (int i=0;i<listLength;i++)
	{
		if (hasObjVar(target, base_path+"."+intQ))
		{
			removeObjVar(target, base_path+"."+intQ);
			intQ++;
		}

	}

}

boolean setBatchObjVar(obj_id target, string base_path, int[] array)
{
	if ( !isIdValid(target) )
	{
		return false;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		return false;
	}

	if ( (array == null) || (array.length == 0) )
	{
		return false;
	}

	if ( hasObjVar(target, base_path) )
		removeObjVar(target, base_path);

	int BatchSize = 10;

	boolean litmus = true;
	int n = 0;
	Vector toSet = new Vector();
	for ( int i = 0; i < array.length; i++ )
	{
		toSet.add(new Integer(array[i]));
		if ( toSet.size() >= BatchSize )
		{
			litmus &= setObjectArrayObjVar(target, base_path + "." + n, toSet);
			toSet.clear();
			n++;
		}
	}

	litmus &= setObjectArrayObjVar(target, base_path + "." + n, toSet);

	return litmus;
}

boolean setResizeableBatchObjVar(obj_id target, string base_path, Vector vector)
{
	if ( !isIdValid(target) )
	{
		return false;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		//debugSpeakMsg(target, "setResizeableBatchObjVar: invalid base path!");
		return false;
	}

	if ( (vector == null) || (vector.size() == 0) )
	{
		//debugSpeakMsg(target, "setResizeableBatchObjVar: invalid vector!");
		return false;
	}

	if ( hasObjVar(target, base_path) )
		removeObjVar(target, base_path);

	int BatchSize = 10;

	boolean litmus = true;
	int n = 0;
	Vector toSet = new Vector();
	for ( int i = 0; i < vector.size(); i++ )
	{
		toSet.add(vector.get(i));
		if ( toSet.size() >= BatchSize )
		{
			litmus &= setObjectArrayObjVar(target, base_path + "." + n, toSet);
			toSet.clear();
			n++;
		}
	}

	//debugSpeakMsg(target, "attempting to set final objvar: n = " + n + " toSet.size = " + toSet.size());
	litmus &= setObjectArrayObjVar(target, base_path + "." + n, toSet);

	return litmus;
}

boolean setObjectArrayObjVar(obj_id target, string path, Vector vec)
{
	if ( !isIdValid(target) )
	{
		return false;
	}

	if ( (path == null) || (path.equals("")) )
	{
		return false;
	}

	if ( (vec == null) || (vec.size() == 0) )
	{
		return false;
	}

	int size = vec.size();

	Object test = vec.elementAt(0);

	if ( test instanceof string )
	{
		string[] tmp = new string[size];
		vec.toArray(tmp);
		return setObjVar(target, path, tmp);
	}
	else if ( test instanceof string_id )
	{
		string_id[] tmp = new string_id[size];
		vec.toArray(tmp);
		return setObjVar(target, path, tmp);
	}
	else if ( test instanceof obj_id )
	{
		obj_id[] tmp = new obj_id[size];
		vec.toArray(tmp);
		return setObjVar(target, path, tmp);
	}
	else if ( test instanceof attrib_mod )
	{
		attrib_mod[] tmp = new attrib_mod[size];
		vec.toArray(tmp);
		return setObjVar(target, path, tmp);
	}
	else if ( test instanceof location )
	{
		location[] tmp = new location[size];
		vec.toArray(tmp);
		return setObjVar(target, path, tmp);
	}
	else if ( test instanceof int )
	{
		int[] tmp = new int[size];
		for ( int i = 0; i < vec.size(); i ++ )
			tmp[i] = ((Integer)(vec.get(i))).intValue();
		return setObjVar(target, path, tmp);
	}

	return false;
}

string[] getStringBatchObjVar(obj_id target, string base_path)
{
	if ( !isIdValid(target) )
	{
		return null;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		return null;
	}

	if ( !hasObjVar(target, base_path) )
	{
		return null;
	}

	resizeable string[] ret = new string[0];
	obj_var_list ovl = getObjVarList(target, base_path);
	if ( (ovl == null) || (ovl.getNumItems() == 0) )
	{
		return null;
	}

	int numItems = ovl.getNumItems();
	for ( int i = 0; i < numItems; i++ )
	{
		string[] tmp = getStringArrayObjVar(target, base_path + "." + i);
		if ( (tmp != null) && (tmp.length > 0) )
		{
			ret = concatArrays(ret, tmp);
		}
	}

	if ( (ret != null) && (ret.length > 0) )
	{
		return ret;
	}

	return null;
}

Vector getResizeableStringBatchObjVar(obj_id target, string base_path)
{
	if ( !isIdValid(target) )
	{
		return null;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		return null;
	}

	if ( !hasObjVar(target, base_path) )
	{
		return null;
	}

	resizeable string[] ret = new string[0];
	obj_var_list ovl = getObjVarList(target, base_path);
	if ( (ovl == null) || (ovl.getNumItems() == 0) )
	{
		return null;
	}

	int numItems = ovl.getNumItems();
	for ( int i = 0; i < numItems; i++ )
	{
		string[] tmp = getStringArrayObjVar(target, base_path + "." + i);
		if ( (tmp != null) && (tmp.length > 0) )
		{
			ret = concatArrays(ret, tmp);
		}
	}

	if ( (ret != null) && (ret.length > 0) )
	{
		return ret;
	}

	return null;
}

string_id[] getStringIdBatchObjVar(obj_id target, string base_path)
{
	if ( !isIdValid(target) )
	{
		return null;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		return null;
	}

	if ( !hasObjVar(target, base_path) )
	{
		return null;
	}

	resizeable string_id[] ret = new string_id[0];
	obj_var_list ovl = getObjVarList(target, base_path);
	if ( (ovl == null) || (ovl.getNumItems() == 0) )
	{
		return null;
	}

	int numItems = ovl.getNumItems();
	for ( int i = 0; i < numItems; i++ )
	{
		string_id[] tmp = getStringIdArrayObjVar(target, base_path + "." + i);
		if ( (tmp != null) && (tmp.length > 0) )
		{
			ret = concatArrays(ret, tmp);
		}
	}

	if ( (ret != null) && (ret.length > 0) )
	{
		return ret;
	}

	return null;
}

obj_id[] getObjIdBatchObjVar(obj_id target, string base_path)
{
	if ( !isIdValid(target) )
	{
		return null;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		return null;
	}

	if ( !hasObjVar(target, base_path) )
	{
		return null;
	}

	resizeable obj_id[] ret = new obj_id[0];
	obj_var_list ovl = getObjVarList(target, base_path);
	if ( (ovl == null) || (ovl.getNumItems() == 0) )
	{
		return null;
	}

	int numItems = ovl.getNumItems();
	for ( int i = 0; i < numItems; i++ )
	{
		obj_id[] tmp = getObjIdArrayObjVar(target, base_path + "." + i);
		if ( (tmp != null) && (tmp.length > 0) )
		{
			ret = concatArrays(ret, tmp);
		}
	}

	if ( (ret != null) && (ret.length > 0) )
	{
		return ret;
	}

	return null;
}

Vector getResizeableObjIdBatchObjVar(obj_id target, string base_path)
{
	if ( !isIdValid(target) )
	{
		return null;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		return null;
	}

	if ( !hasObjVar(target, base_path) )
	{
		return null;
	}

	resizeable obj_id[] ret = new obj_id[0];
	obj_var_list ovl = getObjVarList(target, base_path);
	if ( (ovl == null) || (ovl.getNumItems() == 0) )
	{
		return null;
	}

	int numItems = ovl.getNumItems();
	for ( int i = 0; i < numItems; i++ )
	{
		obj_id[] tmp = getObjIdArrayObjVar(target, base_path + "." + i);
		if ( (tmp != null) && (tmp.length > 0) )
		{
			ret = concatArrays(ret, tmp);
		}
	}

	if ( (ret != null) && (ret.length > 0) )
	{
		return ret;
	}

	return null;
}

int[] getIntBatchObjVar(obj_id target, string base_path)
{
	if ( !isIdValid(target) )
	{
		return null;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		return null;
	}

	if ( !hasObjVar(target, base_path) )
	{
		return null;
	}

	resizeable int[] ret = new int[0];
	obj_var_list ovl = getObjVarList(target, base_path);
	if ( (ovl == null) || (ovl.getNumItems() == 0) )
	{
		return null;
	}

	int numItems = ovl.getNumItems();
	for ( int i = 0; i < numItems; i++ )
	{
		int[] tmp = getIntArrayObjVar(target, base_path + "." + i);
		if ( (tmp != null) && (tmp.length > 0) )
		{
			ret = concatArrays(ret, tmp);
		}
	}

	if ( (ret != null) && (ret.length > 0) )
	{
		return ret;
	}

	return null;
}

Vector getResizeableIntBatchObjVar(obj_id target, string base_path)
{
	if ( !isIdValid(target) )
	{
		return null;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		return null;
	}

	if ( !hasObjVar(target, base_path) )
	{
		return null;
	}

	resizeable int[] ret = new int[0];
	obj_var_list ovl = getObjVarList(target, base_path);
	if ( (ovl == null) || (ovl.getNumItems() == 0) )
	{
		return null;
	}

	int numItems = ovl.getNumItems();
	for ( int i = 0; i < numItems; i++ )
	{
		int[] tmp = getIntArrayObjVar(target, base_path + "." + i);
		if ( (tmp != null) && (tmp.length > 0) )
		{
			ret = concatArrays(ret, tmp);
		}
	}

	if ( (ret != null) && (ret.length > 0) )
	{
		return ret;
	}

	return null;
}

attrib_mod[] getAttribModBatchObjVar(obj_id target, string base_path)
{
	if ( !isIdValid(target) )
	{
		return null;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		return null;
	}

	if ( !hasObjVar(target, base_path) )
	{
		return null;
	}

	obj_var_list ovl = getObjVarList(target, base_path);
	if ( (ovl == null) || (ovl.getNumItems() == 0) )
	{
		return null;
	}

	resizeable attrib_mod[] ret = new attrib_mod[0];
	int numItems = ovl.getNumItems();
	for ( int i = 0; i < numItems; i++ )
	{
		attrib_mod[] tmp = getAttribModArrayObjVar(target, base_path + "." + i);
		if ( (tmp != null) && (tmp.length > 0) )
		{
			ret = concatArrays(ret, tmp);
		}
	}

	if ( (ret != null) && (ret.length > 0) )
	{
		return ret;
	}

	return null;
}

location[] getLocationBatchObjVar(obj_id target, string base_path)
{
	if ( !isIdValid(target) )
	{
		return null;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		return null;
	}

	if ( !hasObjVar(target, base_path) )
	{
		return null;
	}

	resizeable location[] ret = new location[0];
	obj_var_list ovl = getObjVarList(target, base_path);
	if ( (ovl == null) || (ovl.getNumItems() == 0) )
	{
		return null;
	}

	int numItems = ovl.getNumItems();
	for ( int i = 0; i < numItems; i++ )
	{
		location[] tmp = getLocationArrayObjVar(target, base_path + "." + i);
		if ( (tmp != null) && (tmp.length > 0) )
		{
			ret = concatArrays(ret, tmp);
		}
	}

	if ( (ret != null) && (ret.length > 0) )
	{
		return ret;
	}

	return null;
}

boolean hasStringBatchObjVar(obj_id target, string base_path)
{
	return getStringBatchObjVar(target, base_path) != null;
}

boolean hasResizeableStringBatchObjVar(obj_id target, string base_path)
{
	return getResizeableStringBatchObjVar(target, base_path) != null;
}

boolean hasStringIdBatchObjVar(obj_id target, string base_path)
{
	return getStringIdBatchObjVar(target, base_path) != null;
}

boolean hasObjIdBatchObjVar(obj_id target, string base_path)
{
	return getObjIdBatchObjVar(target, base_path) != null;
}

boolean hasResizeableObjIdBatchObjVar(obj_id target, string base_path)
{
	return getResizeableObjIdBatchObjVar(target, base_path) != null;
}

boolean hasIntBatchObjVar(obj_id target, string base_path)
{
	return getIntBatchObjVar(target, base_path) != null;
}

boolean hasResizeableIntBatchObjVar(obj_id target, string base_path)
{
	return getResizeableIntBatchObjVar(target, base_path) != null;
}

boolean hasAttribModBatchObjVar(obj_id target, string base_path)
{
	return getAttribModBatchObjVar(target, base_path) != null;
}

boolean hasLocationBatchObjVar(obj_id target, string base_path)
{
	return getLocationBatchObjVar(target, base_path) != null;
}


boolean setBatchScriptVar(obj_id target, string base_path, Vector array)
{
	if ( !isIdValid(target) )
	{
		return false;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		return false;
	}

	if ( (array == null) || (array.size() == 0) )
	{
		return false;
	}

	deltadictionary dd = target.getScriptVars();

	int BatchSize = 10;

	int n = 0;
	Vector toSet = new Vector();
	for ( int i = 0; i < array.size(); i++ )
	{
		toSet.add(array.elementAt(i));
		if ( toSet.size() >= BatchSize )
		{
			dd.put(base_path + "." + n, toSet);
			toSet.clear();
			n++;
		}
	}

	if ( toSet.size() > 0 )
	{
		dd.put(base_path + "." + n, toSet);
		n++;
	}

	dd.put(base_path, n);
	return true;
}

boolean setBatchScriptVar(obj_id target, string base_path, obj_id[] array)
{
	if ( (array == null) || (array.length == 0) )
		return false;

	Vector vArray = new Vector(Arrays.asList(array));
	return setBatchScriptVar(target, base_path, vArray);
}

boolean setBatchScriptVar(obj_id target, string base_path, string[] array)
{
	if ( (array == null) || (array.length == 0) )
		return false;

	Vector vArray = new Vector(Arrays.asList(array));
	return setBatchScriptVar(target, base_path, vArray);
}

boolean setBatchScriptVar(obj_id target, string base_path, string_id[] array)
{
	if ( (array == null) || (array.length == 0) )
		return false;

	Vector vArray = new Vector(Arrays.asList(array));
	return setBatchScriptVar(target, base_path, vArray);
}

boolean setBatchScriptVar(obj_id target, string base_path, location[] array)
{
	if ( (array == null) || (array.length == 0) )
		return false;

	Vector vArray = new Vector(Arrays.asList(array));
	return setBatchScriptVar(target, base_path, vArray);
}

Vector getResizeableObjIdBatchScriptVar(obj_id target, string base_path)
{
	if ( !isIdValid(target) )
	{
		return null;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		return null;
	}

	if ( !hasScriptVar(target, base_path) )
	{
		return null;
	}

	int cnt = getIntScriptVar(target, base_path);
	deltadictionary dd = target.getScriptVars();

	Vector ret = new Vector();
	for ( int i = 0; i < cnt; i++ )
	{
		Vector tmp = dd.getResizeableObjIdArray(base_path + "." + i);
		if ( (tmp != null) && (tmp.size() > 0) )
		{
			ret.addAll(tmp);
		}
	}

	if ( (ret != null) && (ret.size() > 0) )
	{
		return ret;
	}

	return null;
}

obj_id[] getObjIdBatchScriptVar(obj_id target, string base_path)
{
	Vector ret = getResizeableObjIdBatchScriptVar(target, base_path);
	if ( (ret != null) && (ret.size() > 0) )
	{
		return toStaticObjIdArray(ret);
	}

	return null;
}

Vector getResizeableStringBatchScriptVar(obj_id target, string base_path)
{
	if ( !isIdValid(target) )
	{
		return null;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		return null;
	}

	if ( !hasScriptVar(target, base_path) )
	{
		return null;
	}

	int cnt = getIntScriptVar(target, base_path);
	deltadictionary dd = target.getScriptVars();

	Vector ret = new Vector();
	for ( int i = 0; i < cnt; i++ )
	{
		Vector tmp = dd.getResizeableStringArray(base_path + "." + i);
		if ( (tmp != null) && (tmp.size() > 0) )
		{
			ret.addAll(tmp);
		}
	}

	if ( (ret != null) && (ret.size() > 0) )
	{
		return ret;
	}

	return null;
}

string[] getStringBatchScriptVar(obj_id target, string base_path)
{
	Vector ret = getResizeableStringBatchScriptVar(target, base_path);
	if ( (ret != null) && (ret.size() > 0) )
	{
		return toStaticStringArray(ret);
	}

	return null;
}

Vector getResizeableLocationBatchScriptVar(obj_id target, string base_path)
{
	if ( !isIdValid(target) )
	{
		return null;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		return null;
	}

	if ( !hasScriptVar(target, base_path) )
	{
		return null;
	}

	int cnt = getIntScriptVar(target, base_path);
	deltadictionary dd = target.getScriptVars();

	Vector ret = new Vector();
	for ( int i = 0; i < cnt; i++ )
	{
		Vector tmp = dd.getResizeableLocationArray(base_path + "." + i);
		if ( (tmp != null) && (tmp.size() > 0) )
		{
			ret.addAll(tmp);
		}
	}

	if ( (ret != null) && (ret.size() > 0) )
	{
		return ret;
	}

	return null;
}

Vector getResizeableIntBatchScriptVar(obj_id target, string base_path)
{
	if ( !isIdValid(target) )
	{
		return null;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		return null;
	}

	if ( !hasScriptVar(target, base_path) )
	{
		return null;
	}

	int cnt = getIntScriptVar(target, base_path);
	deltadictionary dd = target.getScriptVars();

	Vector ret = new Vector();
	for ( int i = 0; i < cnt; i++ )
	{
		Vector tmp = dd.getResizeableIntArray(base_path + "." + i);
		if ( (tmp != null) && (tmp.size() > 0) )
		{
			ret.addAll(tmp);
		}
	}

	if ( (ret != null) && (ret.size() > 0) )
	{
		return ret;
	}

	return null;
}

location[] getLocationBatchScriptVar(obj_id target, string base_path)
{
	Vector ret = getResizeableLocationBatchScriptVar(target, base_path);
	if ( (ret != null) && (ret.size() > 0) )
	{
		return toStaticLocationArray(ret);
	}

	return null;
}

int[] getIntBatchScriptVar(obj_id target, string base_path)
{
	resizeable int[] ret = getResizeableIntBatchScriptVar(target, base_path);
	if ( (ret != null) && (ret.length > 0) )
	{
		return ret;
	}

	return null;
}

void removeBatchScriptVar(obj_id target, string base_path)
{
	if ( !isIdValid(target) )
	{
		return;
	}

	if ( (base_path == null) || (base_path.equals("")) )
	{
		return;
	}

	if ( !hasScriptVar(target, base_path) )
	{
		return;
	}

	int cnt = getIntScriptVar(target, base_path);
	deltadictionary dd = target.getScriptVars();
	dd.remove(base_path);

	for ( int i = 0; i < cnt; i++ )
	{
		dd.remove(base_path + "." + i);
	}
}

boolean hasResizeableObjIdBatchScriptVar(obj_id target, string base_path)
{
	return getResizeableObjIdBatchScriptVar(target, base_path) != null;
}

boolean hasObjIdBatchScriptVar(obj_id target, string base_path)
{
	return getObjIdBatchScriptVar(target, base_path) != null;
}

boolean hasResizeableStringBatchScriptVar(obj_id target, string base_path)
{
	return getResizeableStringBatchScriptVar(target, base_path) != null;
}

boolean hasStringBatchScriptVar(obj_id target, string base_path)
{
	return getStringBatchScriptVar(target, base_path) != null;
}

boolean hasResizeableLocationBatchScriptVar(obj_id target, string base_path)
{
	return getResizeableLocationBatchScriptVar(target, base_path) != null;
}

boolean hasResizeableIntBatchScriptVar(obj_id target, string base_path)
{
	return getResizeableIntBatchScriptVar(target, base_path) != null;
}

boolean hasLocationBatchScriptVar(obj_id target, string base_path)
{
	return getLocationBatchScriptVar(target, base_path) != null;
}

boolean hasIntBatchScriptVar(obj_id target, string base_path)
{
	return getIntBatchScriptVar(target, base_path) != null;
}

int getIntConfigSetting(String section, String key)
{
	String setting = getConfigSetting(section, key);
	if ( setting == null || setting.length() == 0 )
		return 0;

	try
	{
		return Integer.parseInt(setting);
	}
	catch ( NumberFormatException err)
	{
	}
	return 0;
}

float getFloatConfigSetting(String section, String key)
{
	String setting = getConfigSetting(section, key);
	if ( setting == null || setting.length() == 0 )
		return 0;

	try
	{
		return Float.parseFloat(setting);
	}
	catch ( NumberFormatException err)
	{
	}
	return 0;
}

boolean checkConfigFlag(string strSection, string strConfigSetting)
{
	// looks for true/false
	string strTest = getConfigSetting(strSection, strConfigSetting);
	if(strTest!=null)
	{
		strTest = toLower(strTest);
		if(strTest=="true")
		{
			return true;

		}
		if(strTest=="1")
		{
			return true;

		}
		return false;

	}
	else
	{
		return false;
	}

}
boolean checkServerSpawnLimits()
{
	const int intServerSpawnLimit = getServerSpawnLimit();
	const int intNumCreatures = utils.getNumCreaturesForSpawnLimit();
	const int intNumPlayers = getNumPlayers();
	if(intNumPlayers>0)
	{

		if(intServerSpawnLimit>0)
		{

			if(intNumCreatures>intServerSpawnLimit)
			{
				return false;

			}
		}
		else
		{
			if(intNumPlayers<200000) // JUSTIN CAHNGE THIS TO <20, AND THE NUMCREATURES TO WHAT YOU WANT.
			{
				//////LOG("spawning", "no ratio");
				if(intNumCreatures>5000)
				{
					return false;

				}

			}
			else
			{
				float fltRatio = (float)(intNumCreatures/intNumPlayers);

				//////LOG("spawning", "fltRatio is "+fltRatio);
				if(fltRatio>10) // RAIO
				{
					return false;

				}
			}
		}
	}
	return true;
}

string formatTimeVerbose(int seconds)
{
	if ( seconds < 1 )
	{
		return "";
	}

	int[] convert_time = player_structure.convertSecondsTime(seconds);

	int idx = 0;
	for ( int i = 0; i < convert_time.length; i++ )
	{
		if ( convert_time[i] > 0 )
		{
			idx = i;
			break;
		}
	}

	if ( idx == convert_time.length - 1)
	{
		idx--;
	}

	string time_str = "";
	string[] verboseIndex =
			{
				" days ",
				" hours ",
				" minutes ",
				" seconds "
			};

	for ( int n = idx; n < convert_time.length; n++ )
	{

		time_str += convert_time[n]+verboseIndex[n];

		if ( n < convert_time.length - 1 )
		{
			time_str += ", ";
		}
	}

	if ( time_str != null && !time_str.equals("") )
	{
		return time_str;
	}

	return "";
}

string formatTimeVerboseNoSpaces(int seconds)
{
	if ( seconds < 1 )
	{
		return "";
	}

	int[] convert_time = player_structure.convertSecondsTime(seconds);

	int idx = 0;
	for ( int i = 0; i < convert_time.length; i++ )
	{
		if ( convert_time[i] > 0 )
		{
			idx = i;
			break;
		}
	}

	if ( idx == convert_time.length - 1)
	{
		idx--;
	}

	string time_str = "";
	string[] verboseIndex =
			{
				" days",
				" hours",
				" minutes",
				" seconds"
			};

	for ( int n = idx; n < convert_time.length; n++ )
	{

		time_str += convert_time[n]+verboseIndex[n];

		if ( n < convert_time.length - 1 )
		{
			time_str += ", ";
		}
	}

	if ( time_str != null && !time_str.equals("") )
	{
		return time_str;
	}

	return "";
}

string formatTime(int seconds)
{
	if ( seconds < 1 )
	{
		return "";
	}

	int[] convert_time = player_structure.convertSecondsTime(seconds);
	//string time_str = player_structure.assembleTimeRemaining(convert_time);

	//find first non-zero index
	int idx = 0;
	for ( int i = 0; i < convert_time.length; i++ )
	{
		if ( convert_time[i] > 0 )
		{
			idx = i;
			break;
		}
	}

	if ( idx == convert_time.length - 1)
	{
		idx--;
	}

	string time_str = "";
	for ( int n = idx; n < convert_time.length; n++ )
	{

		time_str += convert_time[n];

		if ( n < convert_time.length - 1 )
		{
			time_str += ":";
		}
	}

	if ( time_str != null && !time_str.equals("") )
	{
		return time_str;
	}

	return "";
}

string formatTime(float fTime)
{
	int iTime = (int)fTime;

	float diff = fTime - iTime;
	int decimals = (int)(diff*100);

	if ( iTime > 0 )
	{
		string sTime = formatTime(iTime);
		sTime += "." + decimals;
		return sTime;
	}
	else
	{
		return "0." + decimals;
	}
}

string padTimeDHMS(int seconds)
{
	if(seconds < 0)
	{
		return null;
	}

	int days = seconds / (3600 * 24);

	string daysText = "" + days;

	if(daysText.length() <= 4)
	{
		daysText = "0000".substring(0, 4 - daysText.length()) + daysText;
	}

	seconds = seconds % (3600 * 24);

	int hours = seconds / 3600;

	string hoursText = "" + hours;

	if(hoursText.length() <= 2)
	{
		hoursText = "00".substring(0,2 - hoursText.length()) + hoursText;
	}

	seconds = seconds % 3600;

	int minutes = seconds / 60;

	string minutesText = "" + minutes;

	if(minutesText.length() <= 2)
	{
		minutesText = "00".substring(0,2 - minutesText.length()) + minutesText;
	}

	seconds = seconds % 60;

	string secondsText = "" + seconds;

	if(secondsText.length() <= 2)
	{
		secondsText = "00".substring(0,2 - secondsText.length()) + secondsText;
	}

	return daysText + "d:" + hoursText + "h:" + minutesText + "m:" + secondsText + "s";
}

string padTimeHM(int seconds)
{
	seconds = seconds % (3600 * 24);

	int hours = seconds / 3600;

	string hoursText = "" + hours;

	if(hoursText.length() <= 2)
	{
		hoursText = "00".substring(0,2 - hoursText.length()) + hoursText;
	}

	seconds = seconds % 3600;

	int minutes = seconds / 60;

	string minutesText = "" + minutes;

	if(minutesText.length() <= 2)
	{
		minutesText = "00".substring(0,2 - minutesText.length()) + minutesText;
	}
	
	return hoursText + "h:" + minutesText + "m";
}

void sendDelayedSystemMessage(obj_id target, string_id sid, float delay)
{
	if ( !isIdValid(target) || (sid == null) || (delay < 0f) )
		return;

	dictionary msg = new dictionary();
	msg.put("sidMsg", sid);

	messageTo(target, "handleDelayedSystemMessage", msg, delay, false);
}

void sendDelayedSystemMessage(obj_id target, string sid, float delay)
{
	if ( !isIdValid(target) || (sid == null) || sid.equals("") || (delay < 0f) )
		return;

	dictionary msg = new dictionary();
	msg.put("stringMsg", sid);

	messageTo(target, "handleDelayedSystemMessage", msg, delay, false);
}

void sendDelayedProseMessage(obj_id msgTarget, string_id sid,
						obj_id actor,  string actorString,  string_id actorStringId,
						obj_id target, string targetString, string_id targetStringId,
						obj_id other,  string otherString,  string_id otherStringId,
						int di, float df,
						float delay)
{
	if ( !isIdValid(msgTarget) || (sid == null) || (delay < 0f) )
		return;

	dictionary msg = new dictionary();
	msg.put("sid", sid);

	msg.put("actor", actor);
	msg.put("actorString", actorString);
	msg.put("actorStringId", actorStringId);

	msg.put("target", target);
	msg.put("targetString", targetString);
	msg.put("targetStringId", targetStringId);

	msg.put("other", other);
	msg.put("otherString", otherString);
	msg.put("otherStringId", otherStringId);

	msg.put("di", di);
	msg.put("df", df);

	messageTo(msgTarget, "handleDelayedProseMessage", msg, delay, false);
}

Vector alphabetizeStringArray(string[] array)
{
	if ( (array == null) || (array.length == 0) )
		return null;

	Vector tmp = new Vector();
	java.text.Collator myCol = java.text.Collator.getInstance();
	for ( int i = 0; i < array.length; i++ )
	{
		boolean inserted = false;
		for ( int n = 0; n < tmp.size(); n++ )
		{
			if ( myCol.compare(array[i], tmp.elementAt(n)) < 0 )	//insert element at n
			{
				tmp.add(n, array[i]);
				inserted = true;
				break;
			}
		}

		if ( !inserted )
		{
			tmp.add(array[i]);
		}
	}

	if ( (tmp == null) || (tmp.size() == 0) )
		return null;

	return tmp;
}

Vector alphabetizeStringArray(Vector array)
{
	if ( (array == null) || (array.size() == 0) )
		return null;

	string[] toPass = toStaticStringArray(array);
	if ( (toPass == null) || (toPass.length == 0) )
		return null;

	return alphabetizeStringArray(toPass);
}

string getPlayerSpeciesName(int species)
{
	switch (species)
	{
		case SPECIES_HUMAN:
			return "human";

		case SPECIES_BOTHAN:
			return "bothan";

		case SPECIES_RODIAN:
			return "rodian";

		case SPECIES_TWILEK:
			return "twilek";

		case SPECIES_TRANDOSHAN:
			return "trandoshan";

		case SPECIES_MON_CALAMARI:
			return "moncalamari";

		case SPECIES_WOOKIEE:
			return "wookiee";

		case SPECIES_ZABRAK:
			return "zabrak";
		case SPECIES_ITHORIAN:
			return "ithorian";
		case SPECIES_SULLUSTAN:
			return "sullustan";
		default:
			return "unknown";
	}
}





void addListener(string strObjVar, obj_id objListener, obj_id objTarget)
{

	if(strObjVar==null)
	{
		LOG("DESIGNER_FATAL", "Null objVar paseed into addListener");
		return;

	}
	if(!isIdValid(objTarget))
	{
		LOG("DESIGNER_FATAL", "Null owner paseed into addListener");
		return;
	}
	if(!isIdValid(objListener))
	{

		LOG("DESIGNER_FATAL", "Null listener paseed into addListener");
	}


	dictionary dctParams = new dictionary();
	dctParams.put("objListener", objListener);
	dctParams.put("strObjVar", strObjVar);
	messageTo(objTarget, "addListener", dctParams, 0, true);
	return;


}


void removeListener(string strObjVar, obj_id objListener, obj_id objTarget)
{
	if(strObjVar==null)
	{
		LOG("DESIGNER_FATAL", "Null objVar paseed into removeListener");
		return;

	}
	if(!isIdValid(objTarget))
	{
		LOG("DESIGNER_FATAL", "Null target paseed into removeListener");
		return;
	}
	if(!isIdValid(objListener))
	{

		LOG("DESIGNER_FATAL", "Null listener paseed into removeListeer");
	}


	dictionary dctParams = new dictionary();
	dctParams.put("objListener", objListener);
	dctParams.put("strObjVar", strObjVar);
	messageTo(objTarget, "removeListener", dctParams, 0, true);
	return;

}


void messageListeners(string strObjVar, obj_id objOwner, string strMessageName, dictionary dctParams)
{

// this messages all of the listeners with the specified message
	if(strObjVar==null)
	{
		LOG("DESIGNER_FATAL", "Null objVar paseed into messageListeners");
		return;

	}
	if(!isIdValid(objOwner))
	{
		LOG("DESIGNER_FATAL", "Null owner paseed into messageListeners");
		return;
	}
	if(strMessageName==null)
	{
		LOG("DESIGNER_FATAL", "Null messageName paseed into messageListeners");

	}


	if(hasObjVar(objOwner, strObjVar))
	{

		int intI = 0;
		obj_id objListeners[] = getObjIdArrayObjVar(objOwner, "mission.objListeners");
		while(intI<objListeners.length)
		{
			//debugServerConsoleMsg(objListeners[intI], "messaging "+objListeners[intI].toString()+ "with "+strMessageName+" and params of "+dctParams.toString());
			//debugServerConsoleMsg(objOwner, "intI is "+intI);
			//debugServerConsoleMsg(objOwner, "length is "+objListeners.length);
			messageTo(objListeners[intI], strMessageName, dctParams, 0, true);
			intI = intI+1;
		}
	}

	return;



}

int getTheaterSize(string strLairType)
{
	if(isTheater(strLairType))
	{
		int intIndex = strLairType.indexOf("medium");
		if(intIndex>0)
		{
			return 40;

		}
		intIndex = strLairType.indexOf("small");
		if(intIndex>0)
		{
			return 24;

		}
		intIndex = strLairType.indexOf("large");
		if(intIndex>0)
		{
			return 72;

		}

		return 24;
	}
	return -1;


}

boolean isTheater(string strLairType)
{


	if(strLairType==null)
	{
		return false;
	}
	int intIndex = strLairType.indexOf("theater");
	if(intIndex>0)
	{
		return true;
	}
	return false;
}

boolean isAppropriateName(string name)
{
	if ( name == null || name.equals("") )
		return false;

	java.util.StringTokenizer st = new java.util.StringTokenizer(name);
	while ( st.hasMoreTokens() )
	{
		string tkn = st.nextToken();
		if ( stringToFloat(tkn) == Float.NEGATIVE_INFINITY )
		{
			if ( isObscene(tkn) || !isAppropriateText(tkn) )
				return false;
		}
	}

	return true;
}

boolean setNonProfaneName(obj_id target, string name)
{
	if ( !isIdValid(target) || name == null || name.equals("") )
		return false;

	if ( !isAppropriateName(name) )
		return false;

	return setName(target, name);
}

boolean setNonReservedName(obj_id target, string name)
{
	if ( !isIdValid(target) || name == null || name.equals("") )
		return false;

	if ( !isNameReserved(name) )
		return setName(target, name);

	return false;
}


boolean setFilteredName(obj_id target, string name)
{
	if ( !isIdValid(target) || name == null || name.equals("") )
		return false;

	if ( !isNameReserved(name) )
		return setNonProfaneName(target, name);

	return false;
}

void destroyObjects(obj_id[] objects)
{
	if ( objects == null || objects.length == 0 )
		return;

	for ( int i = 0; i < objects.length; i++ )
	{
		if ( isIdValid(objects[i]) )
			destroyObject(objects[i]);
	}
}

string getTemplateFilenameNoPath(obj_id target)
{
	if ( !isIdValid(target) )
		return null;

	string filename = null;
	string fullPath = getTemplateName(target);
	if ( fullPath != null && !fullPath.equals("") )
	{
		string[] tmp = split(fullPath, '/');
		if ( tmp != null && tmp.length > 0 )
		{
			filename = tmp[tmp.length - 1];
		}
	}

	return filename;
}

int getFirstNonValidIdIndex(obj_id[] ids)
{
	if ( ids == null || ids.length == 0 )
		return -1;

	for ( int i = 0; i < ids.length; i++ )
	{
		if ( !isIdValid(ids[i]) )
			return i;
	}

	return -1;
}

int getFirstValidIdIndex(obj_id[] ids)
{
	if ( ids == null || ids.length == 0 )
		return -1;

	for (int i = 0; i < ids.length; i++ )
	{
		if ( isIdValid(ids[i]) )
			return i;
	}

	return -1;
}

void moneyInMetric (obj_id objTransferer, string strAccount, int intAmount)
{
	// receiver, acct, amt
	int intTime = getGameTime();
	string strSpam = "moneyIn;"+intTime+";"+objTransferer+";"+strAccount+";"+intAmount;
	logBalance(strSpam);
	return;
}

void moneyOutMetric(obj_id objTransferer, string strAccount, int intAmount)
{
	int intTime = getGameTime();
	string strSpam = "moneyOut;"+intTime+";"+objTransferer+";"+strAccount+";"+intAmount;
	logBalance(strSpam);
	return;
}

int getValidAttributeIndex(string[] array)
{
	for (int i = 0; i < array.length; i++)
	{
		if (array[i] == null || array[i].equals(""))
			return i;
	}
	return -1;
}

string getStringName(obj_id target)
{
	if ( !isIdValid(target) )
		return null;

	string name = getEncodedName(target);
	string_id sid_name = unpackString(name);
	if ( sid_name != null )
		name = getString(sid_name);

	return name;
}

void warpPlayer( obj_id player, location dest )
{
	if (isIdValid(dest.cell))
		warpPlayer (player, dest.area, 0.0f, 0.0f, 0.0f, dest.cell, dest.x, dest.y, dest.z);
	else
		warpPlayer (player, dest.area, dest.x, dest.y, dest.z, null, 0.0f, 0.0f, 0.0f);
}

void warpPlayer( obj_id player, string planet, location dest )
{
		warpPlayer (player, planet, dest.x, dest.y, dest.z, null, 0.0f, 0.0f, 0.0f);
}

boolean copyObjVarList(obj_id from, obj_id to, string listpath)
{
	if ( !isIdValid(from) || !isIdValid(to) || listpath == null || listpath.equals("") )
		return false;

	obj_var_list ovl = getObjVarList(from, listpath);
	if ( ovl == null )
		return false;

	boolean litmus = true;

	int numItems = ovl.getNumItems();
	for ( int i = 0; i < numItems; i++ )
	{
		obj_var ov = ovl.getObjVar(i);
		if ( ov != null )
			litmus &= copyObjVar(from, to, listpath + "." + ov.getName());
	}

	return litmus;
}


string_id getCardinalDirectionForPoints(location locTest1, location locTest2)
{
	string cardinalString = getStringCardinalDirection(locTest1, locTest2);
	if ( cardinalString == null || cardinalString.equals("") )
		return null;

	return new string_id("mission/mission_generic", cardinalString);
}

string getStringCardinalDirection(location locTest1, location locTest2, boolean abbreviated)
{
	if ( locTest1 == null || locTest2 == null )
		return null;

	float fltAngle =getHeadingToLocation(locTest1, locTest2);

	// north is 0
	// west is 90
	// south is -180
	// east is -90
	// we use 1/2 of each of those..
	// so we end up with 45 degree arcs for each of these

	if((fltAngle>=-22.5)&&(fltAngle<=22.5))
	{
		if ( !abbreviated )
			return "north";
		else
			return "N";
	}
	else if((fltAngle>=-67.5)&&(fltAngle<=-22.5))
	{
		if ( !abbreviated )
			return "northeast";
		else
			return "NE";
	}
	else if ((fltAngle>=-112.5)&&(fltAngle<=-67.5))
	{
		if ( !abbreviated )
			return "east";
		else
			return "E";
	}
	else if((fltAngle>=-157.5)&&(fltAngle<=-112.5))
	{
		if ( !abbreviated )
			return "southeast";
		else
			return "SE";
	}
	// south is the fallback, so it's below (its -180/180 so the math is yucky
	else if((fltAngle>=22.5)&&(fltAngle<=67.5))
	{
		if ( !abbreviated )
			return "northwest";
		else
			return "NW";
	}
	else if((fltAngle>=67.5)&&(fltAngle<=112.5))
	{
		if ( !abbreviated )
			return "west";
		else
			return "W";
	}
	else if((fltAngle>=112.5)&&(fltAngle<=157.5))
	{
		if ( !abbreviated )
			return "southwest";
		else
			return "SW";
	}
	else
	{
		if ( !abbreviated )
			return "south";
		else
			return "S";
	}
}

string getStringCardinalDirection(location locTest1, location locTest2)
{
	return getStringCardinalDirection(locTest1, locTest2, false);
}

boolean isContainer(obj_id target)
{
	if ( isIdValid(target) )
		return (getContainerType(target)!=0);

	return false;
}

boolean noIncapDrainAttributes(obj_id target, int actionCost, int mindCost)
{
	if ( !isIdValid(target) || actionCost < 0)
		return false;

	if ( getAttrib(target, ACTION) < actionCost )
	{
		//sendSystemMessageTestingOnly(target, "You lack the necessary ACTION to perform that action");
		return false;
	}

	return drainAttributes(target, actionCost, 0);
}

int getUnbuffedWoundedMaxAttrib(obj_id target, int attrib)
{
	if ( !isIdValid(target) || attrib < HEALTH || attrib > WILLPOWER )
		return -1;

	int unmodmax = getUnmodifiedMaxAttrib(target, attrib);
	return unmodmax;
}

boolean validatePlayerHairStyle(obj_id player)
{
	if (!isIdValid(player))
		return false;

	string hair_table = "datatables/customization/hair_assets_skill_mods.iff";
	//LOG("LOG_CHANNEL", "num_rows ->" + dataTableGetNumRows(hair_table));
	obj_id hair = getObjectInSlot(player, "hair");
	//LOG("LOG_CHANNEL", "hair ->" + hair);
	if (!isIdValid(hair))
		return false;

	string hair_template = getTemplateName(hair);
	//LOG("LOG_CHANNEL", "hair_template ->" + hair_template);
	int idx = dataTableSearchColumnForString(hair_template, "SERVER_TEMPLATE", hair_table);
	//LOG("LOG_CHANNEL", "idx ->" + idx);

	if (idx < 0)
		return false;

	string required_template = dataTableGetString(hair_table, idx, "SERVER_PLAYER_TEMPLATE");
	//LOG("LOG_CHANNEL", "required_template ->" + required_template);
	if (required_template == null)
		return false;

	string player_template = getTemplateName(player);
	//LOG("LOG_CHANNEL", "player_template ->" + player_template);

	if (player_template != required_template)
	{
		// If the player is not of the required template, he has an illegal hair style.
		// We use the first one that we can find in the datatable.
		int new_hair_idx = dataTableSearchColumnForString(player_template, "SERVER_PLAYER_TEMPLATE", hair_table);
		//LOG("LOG_CHANNEL", "new_hair_idx ->" + new_hair_idx);
		string new_hair_template = dataTableGetString(hair_table, new_hair_idx, "SERVER_TEMPLATE");
		//LOG("LOG_CHANNEL", "new_hair_template ->" + new_hair_template);
		if (new_hair_template == null)
		{
			CustomerServiceLog("imageDesigner", getFirstName(player) + "(" + player + ") has an invalid hairstyle, but a replacement cannot be found!");
			return false;
		}

		destroyObject(hair);
		createObject(new_hair_template, player, "hair");
		CustomerServiceLog("imageDesigner", getFirstName(player) + "(" + player + ") has an invalid hairstyle. It has been replaced with a default style.");
		sendSystemMessageTestingOnly(player, "An illegal hairstyle has been detected on your character. This has been corrected.");
	}

	return true;
}

string getPackedScripts(obj_id objObject)
{
	string strTest = "";
	string[] strScripts = getScriptList(objObject);
	if(strScripts.length>0)
	{
		for(int intI = 0; intI<strScripts.length; intI++)
		{
			strTest = strTest + strScripts[intI];
			if(intI<strScripts.length-1)
			{
				strTest = strTest + ",";
			}
		}
	}
	return strTest;
}
string[] getUsableScriptList(obj_id objObject)
{
	string strTest = "";
	string[] strScripts = getScriptList(objObject);
	debugSpeakMsg(objObject, "script list is "+strScripts.length);
	if(strScripts.length>0)
	{
		debugSpeakMsg(objObject, "list length is "+strScripts.length);
		string[] strCorrectArray = new string[strScripts.length];
		for(int intI = 0; intI<strScripts.length; intI++)
		{
			string script = strScripts[intI];
			if ( script.indexOf( "script." ) > -1 )
			{
				script = script.substring( 7 );
				debugSpeakMsg(objObject, "setting array to  "+script);
				strCorrectArray[intI] = script;
			}
		}
		return strCorrectArray;
	}
	return null;


}

string[] unpackScriptString(string strScripts)
{
	string[] strTest = split(strScripts, ',');
	return strTest;
}

boolean isEquipped(obj_id item)
{
	if ( !isIdValid(item) )
		return false;

	obj_id containedBy = getContainedBy(item);
	return ( isIdValid(containedBy) && getContainerType(containedBy) == 1 ); //container type 1 = CT_slotted
}

obj_id unequipWeaponHand(obj_id player)
{
	return unequipSlot(player, "hold_r");
}

obj_id unequipOffHand(obj_id player)
{
	return unequipSlot(player, "hold_l");
}

obj_id unequipSlot(obj_id player, string slot)
{
	obj_id equipment = getObjectInSlot(player, slot);
	if ( isIdValid(equipment) )
	{
		obj_id playerInv = utils.getInventoryContainer(player);
		if ( isIdValid(playerInv) )
		{
			putInOverloaded(equipment, playerInv);
			return equipment;
		}
	}
	return obj_id.NULL_ID;
}



obj_id[] getAttackableTargetsInRadius(obj_id attacker, int radius, boolean player_targets)
{
	// Returns all mobs within a specified radius that are pvpCanAttack-true and are in the light of sight.
	location loc = getLocation(attacker);
	if (loc == null)
		return null;

	obj_id[] objects = getObjectsInRange(loc, radius);
	resizeable obj_id[] attackable_targets = new obj_id[0];
	for (int i = 0; i < objects.length; i++)
	{
		if (isMob(objects[i]))
		{
			if (pvpCanAttack(attacker, objects[i]))
			{
				if (!isIncapacitated(objects[i]) && !isDead(objects[i]))
				{
					if (isPlayer(objects[i]))
					{
						if (!player_targets)
							continue;
					}

					if (canSee(attacker, objects[i]))
					{
						attackable_targets = utils.addElement(attackable_targets, objects[i]);
					}
				}
			}
		}
		else if ( ai_lib.isTurret(objects[i]))
		{
			if (pvpCanAttack(attacker, objects[i]))
			{

				if (canSee(attacker, objects[i]))
					attackable_targets = utils.addElement(attackable_targets, objects[i]);
			}
		}
	}

	if (attackable_targets.length < 1)
		return null;
	else
		return attackable_targets;
}


obj_id getTrapDroidId(obj_id player)
{
	obj_id dataPad = getPlayerDatapad(player);
	resizeable obj_id[] data = getResizeableContents(dataPad);

	for(int i = 0; i < data.length; i++)
	{
		if(callable.hasCDCallable(data[i]) && hasObjVar(data[i], "module_data.trap_bonus"))
		{
			return data[i];
		}
	}

	return null;

}//end getTrapDroidId

int getTimeLeft(obj_id player, string toCheckFor, int timePenalty)
{

	int currentTime = getGameTime();
	int timeCalled = utils.getIntScriptVar(player, toCheckFor);
	if (timeCalled < 1)
		return -1;

	int timeDone = timeCalled + timePenalty;
	int timeLeft = timeDone - currentTime;

	return timeLeft;

}

int getTimeLeft(obj_id player, string toCheckFor, string modifiedTime)
{

	int currentTime = getGameTime();
	int timeCalled = utils.getIntScriptVar(player, toCheckFor);
	if (timeCalled < 1)
		return -1;

	int timePenalty = utils.getIntScriptVar(player, modifiedTime);
	int timeDone = timeCalled + timePenalty;
	int timeLeft = timeDone - currentTime;

	return timeLeft;

}

boolean isFreeTrial(obj_id player)
{
	return isFreeTrialAccount(player);
}

boolean isFreeTrial(obj_id player, obj_id target)
{
	return isFreeTrialAccount(player);

}



////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////   STOLEN FROM SPACE_UTILS.SCRIPTLIB:  THESE ARE NOT SAFE FOR MULTI-SERVER
////   We're going to have to remove and fix references when space is integrated to Current
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void notifyObject(obj_id objTarget, string strNotificationName, dictionary dctParams)
{
	if(!isIdValid(objTarget))
	{
		debugServerConsoleMsg(null, "Null object id passed into notifyObject, exceptioning");
		Thread.dumpStack();
		throw new InterruptedException();
	}
	if(strNotificationName==null)
	{
		debugServerConsoleMsg(null, "null notification name passed into notifyObject, exceptioning");
		Thread.dumpStack();
		throw new InterruptedException();
	}
	if(strNotificationName=="")
	{
		debugServerConsoleMsg(null, "Empty Notification name passed into notifyObject, exceptioning");
		Thread.dumpStack();
		throw new InterruptedException();
	}

	try
	{
		int intReturn = script_entry.callMessageHandlers(strNotificationName, objTarget, dctParams);
		return;
	}
	catch (Throwable err)
	{
		debugServerConsoleMsg(null, "Unable to call into callMessageHandlers ");
		Thread.dumpStack();
		throw new InterruptedException();
	}
}

void callTrigger(string strTrigger, Object[] params)
{
	try
	{
		script_entry.runScripts(strTrigger, params);
		return;
	}
	catch (Throwable err)
	{
		debugServerConsoleMsg(null, "Unable to call into callMessageHandlers ");
		Thread.dumpStack();
		throw new InterruptedException();
	}
}




////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

string getCellName(obj_id building, obj_id cell) {

	string[] cellNames = getCellNames(building);

	for(int i = 0; i < cellNames.length; i++) {

		string cellName = cellNames[i];
		obj_id thisCell = getCellId(building, cellName);

		if (thisCell == cell) {

			return cellName;
		}
	}

	return "";
}

string getRealPlayerFirstName(obj_id player)
{
	string firstName = getPlayerName(player);

	if(firstName == null)
	{
		return null;
	}

	int idx = firstName.toLowerCase().indexOf("corpse of");
	if(idx >= 0)
	{
		firstName = firstName.substring(idx+1);
	}

	// upper case the first letter in the name
	if(firstName.length() > 0)
	{
		char first = firstName.charAt(0);
		first = Character.toUpperCase(first);
		firstName = first + firstName.substring(1);
	}

	return firstName;
}

void dismountRiderJetpackCheck (obj_id rider)
{
	if(!isIdValid(rider))
	{
		return;
	}

	obj_id mount = getMountId (rider);

	if(!exists(mount))
	{
		return;
	}

	if(isIdValid(mount))
	{
		pet_lib.doDismountNow(rider, false);
		string name = getTemplateName (mount);

		if(vehicle.isJetPackVehicle(mount))
		{
			string_id jetDismount = new string_id ("pet/pet_menu", "jetpack_dismount");
			sendSystemMessage(rider, jetDismount);

			obj_id petControlDevice = callable.getCallableCD(mount);
			vehicle.storeVehicle(petControlDevice, rider);
		}
	}

	return;
}

location getLocationFromTransform(transform trTest)
{
	location locTest = new location();
	vector vctTest = trTest.getPosition_p();
	locTest.x = vctTest.x;
	locTest.y = vctTest.y;
	locTest.z = vctTest.z;
	return locTest;
}

int addClassRequirementAttributes(obj_id player, obj_id item, string[] names, string[] attribs, int firstFree, string prefix)
{
	//sendSystemMessageTestingOnly(obj_id.getObjId(10012897), "1");
	if(hasObjVar(item, prefix + "classRequired"))
	{
		//sendSystemMessageTestingOnly(player, "Class Requirements");
		string requiredClasses = getStringObjVar(item, prefix + "classRequired");
		java.util.StringTokenizer st = new java.util.StringTokenizer(requiredClasses, ",");
		string requiredText = "";
		boolean qualifies = false;

		while(st.hasMoreTokens())
		{
			string classId = st.nextToken();
			string tmp = "@skl_n:class_" + classId + "\0";
			if(st.hasMoreTokens())
			{
				 tmp += "\n\\>117\0";
			}

			requiredText += tmp;
			//sendSystemMessageTestingOnly(player, "Req: " + requiredText);
			if(isProfession(player, stringToInt(classId)))
			{
				qualifies = true;
				break;
			}
		}

		if(!qualifies)
		{
			names[firstFree] = "class_required";
			attribs[firstFree++] = requiredText;
		}
	}

	if(hasObjVar(item, prefix + "levelRequired"))
	{
		int minLevel = getIntObjVar(item, prefix + "levelRequired");
		if(minLevel > getLevel(player))
		{
			names[firstFree] = "levelrequired";
			attribs[firstFree++] = "" + minLevel;
		}
	}

	return firstFree;
}

boolean testItemClassRequirements(obj_id player, string requiredClasses, boolean silent)
{
	java.util.StringTokenizer st = new java.util.StringTokenizer(requiredClasses, ",");
	string requiredText = "";

	while(st.hasMoreTokens())
	{
		string classId = st.nextToken();
		if(isProfession(player, stringToInt(classId)))
		{
			return true;
		}
	}

	if(!silent)
	{
		sendSystemMessage(player, new string_id("spam", "classrequired"));
	}

	return false;
}

boolean testItemClassRequirements(obj_id player, obj_id thing, boolean silent, string prefix)
{
	if(!hasObjVar(thing, prefix + "classRequired"))
	{
		return true;
	}

	string requiredClasses = getStringObjVar(thing, prefix + "classRequired");
	return testItemClassRequirements(player, requiredClasses, silent);
}

boolean testItemLevelRequirements(obj_id player, obj_id thing, boolean silent, string prefix)
{
	if(!hasObjVar(thing, prefix + "levelRequired"))
	{
		return true;
	}

	int minLevel = getIntObjVar(thing, prefix + "levelRequired");
	if(minLevel > getLevel(player))
	{
		if(!silent)
		{
			prose_package pp = prose.getPackage(new string_id("spam", "levelrequired"), "" + minLevel);
			sendSystemMessageProse(player, pp);
		}
		return false;
	}

	return true;
}

boolean testItemAbilityRequirements(obj_id player, obj_id thing, boolean silent, string prefix)
{
	if(!hasObjVar(thing, prefix + "abilityRequired"))
	{
		return true;
	}

	string commandRequired = getStringObjVar(thing, prefix + "abilityRequired");
	if(!hasCommand(player, commandRequired))
	{
		if(!silent)
		{
			prose_package pp = prose.getPackage(new string_id("spam", "abilityrequired"), "@cmd_n:" + toLower(commandRequired));
			sendSystemMessageProse(player, pp);
		}
		return false;
	}

	return true;
}

boolean testItemSkillRequirements(obj_id player, obj_id thing, boolean silent, string prefix)
{
	if(!hasObjVar(thing, prefix + "skillRequired"))
	{
		return true;
	}

	string skillRequired = getStringObjVar(thing, prefix + "skillRequired");
	if(!hasSkill(player, skillRequired))
	{
		if(!silent)
		{
			prose_package pp = prose.getPackage(new string_id("spam", "skill_required"), "@skl_n:" + toLower(skillRequired));
			sendSystemMessageProse(player, pp);
		}
		return false;
	}

	return true;
}

void makeItemNoDrop(obj_id item)
{
	attachScript(item, "item.special.nomove");
	setObjVar(item, "noTrade", 1);
}

boolean isItemNoDrop(obj_id item)
{
	return hasScript(item, "item.special.nomove") || hasObjVar(item, "noTrade");
}

void clearNoDropFromItem(obj_id item)
{
	detachScript(item, "item.special.nomove");
	removeObjVar(item, "noTrade");
}

/**
 * Checks a list of objects to see if one is a notrade item. Will recusively check the contents of containers.
 *
 * @param items			the list of items to check
 * @param testPlayers   flag to check the equipment/inventory of any players in the list
 *
 * @return the id of the 1st notrade item found, or null if there are none
 */
obj_id findNoTradeItem(obj_id[] items, boolean testPlayers)
{
	return findNoTradeItem( items, testPlayers, false );
}

obj_id findNoTradeItem(obj_id[] items, boolean testPlayers, boolean novendor)
{
	if ( items != null )
	{
		for ( int i = 0; i < items.length; ++i )
		{
			if ( isIdValid(items[i]) && (testPlayers || !isPlayer(items[i])) )
			{
				if ( novendor && hasScript( items[i], "terminal.vendor" ) )
					continue;
				if ( !canTrade(items[i]) )
					return items[i];
				else if (utils.isContainer(items[i]))
				{
					obj_id result = findNoTradeItem(getContents(items[i]), testPlayers);
					if ( isIdValid(result) )
						return result;
				}
			}
		}
	}
	return null;
}

obj_id findNoTradeItemNotVendor(obj_id[] items, boolean testPlayers)
{
	return findNoTradeItem( items, testPlayers, true );
}

/**
 * Tests to see if a player has a waypoint with a given name.
 *
 * @param player		the player to test
 * @param name			the waypoint name to look for
 *
 * @return the wapoint with the name, or null if the player has no waypoint
 */
obj_id hasWaypoint(obj_id player, string name)
{
	if ( !isIdValid(player) || name == null )
		return null;

	obj_id[] waypoints = getWaypointsInDatapad(player);
	if ( waypoints == null )
		return null;

	for ( int i = 0; i < waypoints.length; ++i )
	{
		if ( isIdValid(waypoints[i]) )
		{
			string waypointName = getWaypointName(waypoints[i]);
			if ( waypointName != null && waypointName == name)
			{
				return waypoints[i];
			}
		}
	}
	return null;
}

/**
 * Tests to see if a player has a waypoint of the given id.
 *
 * @param player		the player to test
 * @param waypoint		the waypoint id to look for
 *
 * @return true if the waypoint is found, or false if not
 */

boolean waypointExists(obj_id player, obj_id waypoint)
{
	if ( !isIdValid(player) || !isIdValid(waypoint) )
		return false;

	obj_id[] waypoints = getWaypointsInDatapad(player);
	if ( waypoints == null || waypoints.length <= 0 )
		return false;

	for ( int i = 0; i < waypoints.length; ++i )
	{
		if ( isIdValid(waypoints[i]) )
		{
			if ( waypoints[i] == waypoint )
			{
				return true;
			}
		}
	}
	return false;
}

/**
 * Checks a string to see if there are any extended ascii characters in it.
 *
 * @param inString		the incoming string to test
 *
 * @return true or false depending on extended ascii being found.
 */

boolean isExtendedASCII(string inString)
{

	if (inString == null)
	{
		return false;
	}

	for ( int i = 0; i < inString.length(); i++ )
	{
		int ASCIIValue = inString.charAt(i);
		if (ASCIIValue < 0 || ASCIIValue > 255)
		{
			return true;
		}
	}
	return false;
}

// checks to see if the item is antidecay.
// Items that are antidecay will not take damage due to player death or on use (if they are armor or weapons)
boolean isAntiDecay(obj_id item)
{
	if( isIdValid(item) && hasObjVar(item, "antidecay") )
	{
		return true;
	}
	else
	{
		return false;
	}
}

// make an item anti-decay which causes it not to take damage when player dies or it is used (such as armor, weapons and tools)
boolean makeAntiDecay(obj_id item)
{
	if( isIdValid(item) )
	{
		setObjVar(item, "antidecay", 1);
		attachScript(item, "systems.veteran_reward.antidecay_examine");
		// item has been successfully set to be antidecay
		return true;
	}
	// add override code here to prevent specific items to not be anti decay
	else
	{
		// item was not set to be antidecay
		return false;
	}
}

// remove anti-decay from item
boolean removeAntiDecay(obj_id item)
{
	if( isIdValid(item) )
	{
		if ( hasObjVar(item, "antidecay") )
		{
			removeObjVar(item, "antidecay");
		}
		// means item is no longer anti decay (even if it wasn't previously)
		return true;
	}
	// add override code here to not remove anti decay
	else
	{
		return false;
	}
}

// validates if the item can have anti decay applied to it
boolean validItemForAntiDecay(obj_id item)
{
	if( isIdValid(item) )
	{
		// Sorry, Dave
		if (jedi.isLightsaber(item))
			return true;

		// Don't allow PSGs to be flagged anti-decay
		if (isGameObjectTypeOf(item, GOT_armor_psg))
			return false;

		// allow anything that is normally insured as well as weapons to be anti-decay even though weapons don't need insured
		if( cloninglib.isDamagedOnCloneGOT(getGameObjectType(item)) || isGameObjectTypeOf(item, GOT_weapon) )
		{
			return true;
		}
	}
	return false;
}

obj_id[] getLocalGroupMemberIds( obj_id group )
{
	if ( !isIdValid(group) )
		return null;

	obj_id[] groupMemberIds = getGroupMemberIds(group);
	if ( groupMemberIds == null || groupMemberIds.length == 0 )
		return null;

	Vector localMemberIdsVector = new Vector();
	for ( int i =0; i < groupMemberIds.length; ++i )
	{
		if ( isIdValid(groupMemberIds[i]) && exists(groupMemberIds[i]) && isPlayer(groupMemberIds[i]) )
		{
			localMemberIdsVector.addElement(groupMemberIds[i]);
		}
	}

	if ( localMemberIdsVector == null || localMemberIdsVector.size() < 1 )
		return null;

	return ( utils.toStaticObjIdArray(localMemberIdsVector));
}

boolean canSpeakWookiee(obj_id player, obj_id npc)
{
	if(hasSkill(player, "class_smuggler_phase1_novice"))
		return false;

	if(hasSkill(player, "social_language_wookiee_comprehend"))
		return false;

	else
		return true;
}

void emoteWookieeConfusion (obj_id player, obj_id npc)
{
	playClientEffectObj(npc, "clienteffect/voc_wookiee_med_4sec.cef", player, "");
	chat.thinkTo(player, player, new string_id("ep3/sidequests", "wke_convo_failure"));
}


void setObjVarsList(obj_id object, string objVarList)
{
	if ( objVarList == null || objVarList == "" )
		return;

	//get array of strings in the format int:name=value
	string[] pairs = split(objVarList, ',');
	for ( int i = 0; i < pairs.length; i++ )
	{
		//split each pair to get int:name and value
		string[] objVarToSet = split(pairs[i], '=' );
		string objVarValue = objVarToSet[1];
		//split int:name into type (int) and name ("name")
		string[] objVarNameAndType = split(objVarToSet[0], ':');
		string objVarType = objVarNameAndType[0];
		string objVarName = objVarNameAndType[1];

		//Now we have:
		// objVarType	=	string, int, float, boolean
		// objVarName	=	the name of the objvar to set
		// objVarValue	=	the value of the objvar

		if ( objVarType == "string" )
			setObjVar( object, objVarName, objVarValue );
		else if ( objVarType == "int" )
			setObjVar( object, objVarName, utils.stringToInt( objVarValue ) );
		else if ( objVarType == "float" )
			setObjVar( object, objVarName, utils.stringToFloat( objVarValue ) );
		else if ( objVarType == "boolean" || objVarType == "bool" )
			setObjVar( object, objVarName, utils.stringToInt( objVarValue ) );//booleans are stored as int's.
		else
			setObjVar( object, objVarName, objVarValue );//fuck it, must have been a string after all.

	}
}

void setObjVarsListUsingSemiColon(obj_id object, string objVarList)
{
	if ( objVarList == null || objVarList == "" )
		return;

	//get array of strings in the format int:name=value
	string[] pairs = split(objVarList, ',');
	for ( int i = 0; i < pairs.length; i++ )
	{
		//split each pair to get int:name and value
		string[] objVarToSet = split(pairs[i], '=' );
		string objVarValue = objVarToSet[1];
		//split int:name into type (int) and name ("name")
		string[] objVarNameAndType = split(objVarToSet[0], ';');
		string objVarType = objVarNameAndType[0];
		string objVarName = objVarNameAndType[1];

		//Now we have:
		// objVarType	=	string, int, float, boolean
		// objVarName	=	the name of the objvar to set
		// objVarValue	=	the value of the objvar

		if ( objVarType == "string" )
			setObjVar( object, objVarName, objVarValue );
		else if ( objVarType == "int" )
			setObjVar( object, objVarName, utils.stringToInt( objVarValue ) );
		else if ( objVarType == "float" )
			setObjVar( object, objVarName, utils.stringToFloat( objVarValue ) );
		else if ( objVarType == "boolean" || objVarType == "bool" )
			setObjVar( object, objVarName, utils.stringToInt( objVarValue ) );//booleans are stored as int's.
		else
			setObjVar( object, objVarName, objVarValue );//fuck it, must have been a string after all.

	}
}

boolean verifyLocationBasedDestructionAnchor(obj_id subject, float distance)
{
	if (!hasObjVar(subject, "recordLoc"))
	{
		location recordLoc = getLocation(subject);
		setObjVar(subject, "recordLoc", recordLoc);
		return true;
	}

	location verifyLoc = getLocationObjVar(subject, "recordLoc");
	location here = getLocation(getTopMostContainer(subject));
	float distanceDifference = getDistance(verifyLoc, here);
	if (distanceDifference > distance || distanceDifference == -1f)
	{
		destroyObject(subject);
		return false;
	}

	return true;
}

boolean verifyLocationBasedDestructionAnchor(obj_id subject, location recordLoc, float distance)
{
	if (!hasObjVar(subject, "recordLoc"))
	{
		setObjVar(subject, "recordLoc", recordLoc);
		return true;
	}

	location verifyLoc = getLocationObjVar(subject, "recordLoc");
	location here = getLocation(getTopMostContainer(subject));
	float distanceDifference = getDistance(verifyLoc, here);
	if (distanceDifference > distance || distanceDifference == -1f)
	{
		destroyObject(subject);
		return false;
	}

	return true;
}

/***********************************************************************
 * @brief	Converts time from seconds into localized seconds or minutes/seconds or hours/minutes or days/hours  2 significant digits is all anyone really needs
 *			This was setup to use prose packages in the examine window however prose packages couldnt be properly unpacked after using base class packOutOfBandProsePackage
 * @param	int time
 *
 *
 ***********************************************************************/
string assembleTimeRemainToUse(int time)
{
	return assembleTimeRemainToUse(time, true);
}

string assembleTimeRemainToUse(int time, boolean localized)
{
	//check to see if we display seconds
	if(time <= 60)
	{
		string attrib = "";
		if(localized)
			attrib = time + (time != 1 ? " $@spam:seconds$" : " $@spam:second$");
		else
			attrib = time + (time != 1 ? " seconds" : " second");

		return attrib;
	}

	if(time > 60 && time <= 3600 )
	{
		//get minutes
		int minutes = (int)Math.floor(time / 60);
		//get remainder seconds
		int remainder_time = time % 60;

		string attrib = "";
		if(localized)
			attrib = minutes + (minutes != 1 ? " $@spam:minutes$, " : " $@spam:minute$, ") + remainder_time + (remainder_time != 1 ? " $@spam:seconds$" : " $@spam:second$");
		else
			attrib = minutes + (minutes != 1 ? " minutes, " : " minute, ") + remainder_time + (remainder_time != 1 ? " seconds" : " second");
		return attrib;
	}

	if(time  > 3600 && time <= 86400)
	{
		//get hours
		int hours = (int)Math.floor(time / 3600);
		//get remainder minutes
		int remainder_time = (time % 3600) / 60;

		string attrib = "";
		if(localized)
			attrib = hours + (hours != 1 ? " $@spam:hours$, " : " $@spam:hour$, ") + remainder_time + (remainder_time != 1 ? " $@spam:minutes$" : " $@spam:minute$");
		else
			attrib = hours + (hours != 1 ? " hours, " : " hour, ") + remainder_time + (remainder_time != 1 ? " minutes" : " minute");
		return attrib;
	}

	if(time > 86400 && time < Integer.MAX_VALUE)
	{
		//get days
		int days = (int)Math.floor(time / 86400);
		//get remainder hours
		int remainder_hours = (time % 86400) / 3600;
		int remainder_minutes = (time % 3600) / 60;

		string attrib = "";
		if(localized)
		{
			attrib = days + (days != 1 ? " $@spam:days$, " : " $@spam:day$, ") + remainder_hours + (remainder_hours != 1 ? " $@spam:hours$, " : " $@spam:hour$, ") +
			+ remainder_minutes + (remainder_minutes != 1 ? " $@spam:minutes$" : " $@spam:minute$");
		}
		else
		{
			attrib = days + (days != 1 ? " days, " : " day, ") + remainder_hours + (remainder_hours != 1 ? " hours, " : " hour, ") +
			+ remainder_minutes + (remainder_minutes != 1 ? " minutes" : " minute");
		}

		return attrib;
	}

	return null;
}

//helper function to determine if someone is a specific profession
boolean isProfession(obj_id player, int profession)
{
	if (!isIdValid(player))
		return false;

	if (!isPlayer(player))
		return false;

	string classTemplate = getSkillTemplate(player);
	string professionName = "";

	switch(profession)
	{
		case COMMANDO:
			professionName = "commando";
			break;
		case SMUGGLER:
			professionName = "smuggler";
			break;
		case MEDIC:
			professionName = "medic";
			break;
		case OFFICER:
			professionName = "officer";
			break;
		case SPY:
			professionName = "spy";
			break;
		case BOUNTY_HUNTER:
			professionName = "bounty";
			break;
		case FORCE_SENSITIVE:
			professionName = "force";
			break;
		case TRADER:
			professionName = "trader";
			break;
		case ENTERTAINER:
			professionName = "entertainer";
			break;
		default:
			break;
	}

	if ( classTemplate != null && classTemplate.startsWith(professionName))
	{
		return true;
	}
	return false;
}

int getPlayerProfession(obj_id player)
{
	string[] noviceSkillList =
				{
					"class_forcesensitive_phase1_novice",
					"class_bountyhunter_phase1_novice",
					"class_smuggler_phase1_novice",
					"class_commando_phase1_novice",
					"class_officer_phase1_novice",
					"class_spy_phase1_novice",
					"class_medic_phase1_novice",
					"class_entertainer_phase1_novice"
				};

	int[] 	professionList =
				{
					FORCE_SENSITIVE,
					BOUNTY_HUNTER,
					SMUGGLER,
					COMMANDO,
					OFFICER,
					SPY,
					MEDIC,
					ENTERTAINER
				};

	for (int i=0;i<noviceSkillList.length;i++)
	{
		if (hasSkill(player, noviceSkillList[i]))
			return professionList[i];
	}

	return TRADER;
}

//------------------------------------------------------------------------------
// Networking code used to pack objects on Java side. Don't use unless you know
// what you're doing with these
//------------------------------------------------------------------------------

byte[] packObject(Object o)
{
	byte[] ret = null;

	try
	{
		ByteArrayOutputStream byteOutput = new ByteArrayOutputStream();
		ObjectOutputStream objectOutput = new ObjectOutputStream(byteOutput);

		try
		{
			objectOutput.writeObject(o);
			ret = byteOutput.toByteArray();
		}
		catch ( IOException err )
		{
			LOG("utils", "ERROR in Java utils.packObject(): " + err.getMessage());
		}
	}
	catch (java.io.IOException e)
	{
		LOG("utils", "ERROR in initialization of utils.packObject: " + e.getMessage());
	}

	return ret;
}

Object unpackObject(byte[] source)
{
	try
	{
		ByteArrayInputStream byteInput = new ByteArrayInputStream(source);
		ObjectInputStream ois = new ObjectInputStream(byteInput);
		Object result = ois.readObject();

		return result;
	}
	catch (ClassNotFoundException x)
	{
		LOG("utils", "ClassNotFoundException:  "+x.toString());
	}
	catch (IOException x)
	{
		LOG("utils", "IOException:  "+x.toString());
	}

	return null;
}

//Deletes an old snowflake item and replaces with updated snowflake item, handles player equipped
//on floor in houses and containers in houses, in containers in players inventory

boolean replaceSnowflakeItem(obj_id oldItem, string newTemplateName)
{
	obj_id ownerContainer = getContainedBy(oldItem);
	//LOG("replaceSnowflakeItem", "ownerContainer = "+ownerContainer);
	if(!isIdValid(ownerContainer))
		return false;

	//check to see if oldItem is in a bazaar or vendor
	//this is to fix issue with items being converted during the split second it is in the bazzars or vendors inventory
	boolean inVendor = isInVendor(oldItem);
	boolean inBazaar = isInBazaar(oldItem);
	if(inVendor || inBazaar)
	{
		//you are inside a vendor and you will need to delay the change till in players inventory
		//NOTE TO DESIGNERS: if you are going to use this function, you must make the messageHandler on the script on the
		//object. Otherwise nothing will happen. The item wont convert till the player re-loads.
		messageTo(oldItem, "handlerReInitialize", null, 5.0f, false);
		return false;
	}

	obj_id newItem = null;

	//check to see if we are a player
	if (isPlayer(ownerContainer))
	{
		obj_id inventory = utils.getInventoryContainer(ownerContainer);
		//check to see if we are equipped, if so unequip
		if(utils.isEquipped(oldItem))
			putInOverloaded(oldItem, inventory);

		newItem = createObjectOverloaded(newTemplateName, inventory);
		CustomerServiceLog("replaceSnowflakeItem: ", "Old Item (" + oldItem + ")"+ " is contained in player's " + getFirstName(getContainingPlayer(oldItem)) + "(" + getContainingPlayer(oldItem) + ") inventory.");
		CustomerServiceLog("replaceSnowflakeItem: ", "New Item (" + newItem + ")"+ " was created in " + getFirstName(getContainingPlayer(newItem)) + "(" + getContainingPlayer(newItem) + ") inventory.");
	}
	//check to see if we are floating in a house
	else if(getCellName(ownerContainer) != null)
	{
		if(player_structure.isBuilding(getTopMostContainer(ownerContainer)))
		{
			location loc = getLocation(oldItem);
			newItem = createObject(newTemplateName, loc);

			//so for some reason the server creating objects on the floor of a house causes them not to persist
			//so lets we manually do it
			if(isIdValid(newItem))
			{
				if( isObjectPersisted(oldItem) && !isObjectPersisted(newItem) )
					persistObject(newItem);
			}

			CustomerServiceLog("replaceSnowflakeItem: ", "Old Item (" + oldItem + ") is contained in a building (" + getTopMostContainer(ownerContainer) + ")");
			CustomerServiceLog("replaceSnowflakeItem: ", "New Item (" + newItem + ") was created in building (" + getTopMostContainer(ownerContainer) + ")");
			CustomerServiceLog("replaceSnowflakeItem: ", "New Item (" + newItem + ")s location is in a building (" + getTopMostContainer(ownerContainer) + ") is x = " + loc.x + " y = " + loc.y + " z = " + loc.z + "and cell = " + getCellName(getTopMostContainer(ownerContainer), loc.cell));
		}
	}
	else
	{
		newItem = createObjectOverloaded(newTemplateName, ownerContainer);
		CustomerServiceLog("replaceSnowflakeItem: ", "New Item (" + newItem + ")"+ " was created in container (" + ownerContainer + ")");
	}

	//make sure new item is good before destroying old
	if(isIdValid(newItem))
	{
		CustomerServiceLog("replaceSnowflakeItem: ", "New Item (" + newItem + ")"+ " has a valid ID. So Old Item (" + oldItem + ") is to be destroyed");
		destroyObject(oldItem);
	}

	return true;
}

void checkInventoryForSnowflakeItemSwaps(obj_id self)
{
	string[] oldTemplates = dataTableGetStringColumn("datatables/item/snowflake_item_swaps.iff", "OLD_TEMPLATE");
	obj_id objInventory = getInventoryContainer(self);

	if(isIdValid(objInventory) )
	{
		obj_id[] objContents = getContents(objInventory, true);

		if(objContents != null)
		{
			for(int i = 0; i < objContents.length; i++)
			{
				for(int j = 0; j < oldTemplates.length; j++)
				{
					string strItemTemplate = getTemplateName(objContents[i]);
					if(strItemTemplate == oldTemplates[j])
					{
						string newTemplate = dataTableGetString("datatables/item/snowflake_item_swaps.iff", j, "NEW_TEMPLATE");

						if(newTemplate != null || !newTemplate.equals("") )
						{
							replaceSnowflakeItem(objContents[i], newTemplate);
						}
					}
				}
			}
		}
	}


	return;
}

//checks to see if the object is a player vendor
boolean isVendorObject(obj_id object)
{
	if(hasScript(object, VENDOR_SCRIPT))
		return true;
	return false;
}

//checks to see if the object is a bazaar
boolean isBazaarObject(obj_id object)
{
	if(hasScript(object, BAZAAR_SCRIPT))
		return true;
	return false;
}

//Checks to see if an item is in a vendors inventory
// Items will only be in the inventory during the split second it takes to
// move item from wharehouse to players inventory. This function is used in the replaceSnowflakeItem function
boolean isInVendor(obj_id item)
{
	obj_id ownerContainer = getContainedBy(item);
	if(!isIdValid(ownerContainer))
		return false;

	//get the parent ID
	obj_id parentContainer = getContainedBy(ownerContainer);
	//LOG("replaceSnowflakeItem", "parentContainer = "+parentContainer);
	if(hasObjVar(parentContainer, "vendor"))
		return true;
	else
		return false;
}

//Checks to see if an item is in a bazaars inventory
// Items will only be in the inventory during the split second it takes to
// move item from wharehouse to players inventory. This function is used in the replaceSnowflakeItem function
boolean isInBazaar(obj_id item)
{
	obj_id ownerContainer = getContainedBy(item);
	if(!isIdValid(ownerContainer))
		return false;

	if(hasScript(ownerContainer, "terminal.bazaar"))
		return true;
	else
		return false;
}

//checks to see if 2 objects are out of the specified distance of each other
boolean outOfRange(obj_id self, obj_id player, float distance, boolean message)
{
	//gods override range checks
	if(isGod(player))
		return false;

	location a = getLocation(self);
	location b = getLocation(player);
	if (a.cell == b.cell && a.distance(b) < distance)
		return false;

	if (message)
		sendSystemMessage(player, SID_OUT_OF_RANGE);

	return true;
}
//pass in a very long float, round it to the Hundredths place and pass it back
float roundFloatByDecimal(float number)
{
	float tempNumber = number *100;
	int result = (int)Math.round(tempNumber);
	float finalResult = (float)result/100;
	return finalResult;
}

// House packing code
void housePackingDecreaseIncrease (obj_id objPlayer, int change)
{
	// player is earning a point by blowing up a house
	if (change > 0)
	{
		//current points[0]
		//max ever points[1]
		int [] housePacking = new int [utils.HOUSE_MAX];
		//if this is the first house blown up
		if (!hasObjVar (objPlayer, "housePackup"))
			setObjVar (objPlayer, "housePackup", housePacking);

		housePacking = getIntArrayObjVar (objPlayer, "housePackup");
		//validate
		if (housePacking.length != utils.HOUSE_MAX)
			return;
		//increase both counters by 1
		housePacking[0]++;
		housePacking[1]++;
		setObjVar (objPlayer, "housePackup", housePacking);
		//set objvar to make sure that a player can only pack up 10 houses a day
		if (!hasObjVar (objPlayer, "dailyHousePackup"))
		{
			setObjVar (objPlayer, "dailyHousePackup", 1);
			int resetTime = getGameTime() + player_structure.TIME_TO_NEXT_PACKUP; // 24 hours
			setObjVar (objPlayer, "maxHousePackupTimer", resetTime);
		}
		else
		{
			int dailyHousePacking = getIntObjVar (objPlayer, "dailyHousePackup");
			dailyHousePacking++;
			setObjVar (objPlayer, "dailyHousePackup", dailyHousePacking);
		}
		//grant badge after 10 blown up houses
		if (!badge.hasBadge (objPlayer, "house_packup_badge"))
		{
			int[] packupObjVar = getIntArrayObjVar (objPlayer, "housePackup");

			if (packupObjVar != null && packupObjVar.length > 0)
			{
				if (packupObjVar[1] >= player_structure.NUM_NEEDED_PACKUP_FIRST_BADGE)
				{
					badge.grantBadge (objPlayer, "house_packup_badge");
				}
			}
		}
		if (badge.hasBadge (objPlayer, "house_packup_badge"))
		{
			if (!badge.hasBadge (objPlayer, "house_packup_badge_master"))
			{
				int[] packupObjVar = getIntArrayObjVar (objPlayer, "housePackup");

				if (packupObjVar != null && packupObjVar.length > 0)
				{
					if (packupObjVar[1] >= player_structure.NUM_NEEDED_PACKUP_SECOND_BADGE)
					{
						badge.grantBadge (objPlayer, "house_packup_badge_master");
					}
				}
			}
		}
	}
	//decreasing current points because the player is buying something
	else
	{
		//current points[0]
		int [] housePacking = new int [utils.HOUSE_MAX];

		housePacking = getIntArrayObjVar (objPlayer, "housePackup");
		//validate
		if (housePacking.length != utils.HOUSE_MAX)
			return;
		//decrease current points counter by 1
		housePacking[0]--;
		setObjVar (objPlayer, "housePackup", housePacking);
	}
}

//checks to see if we are on the floor of a building and not in a container,player, or other weird place
boolean isInHouseCellSpace(obj_id object)
{
	if(isIdValid(object))
	{
		//are we in a player
		if(isNestedWithinAPlayer(object))
			return false;

		//top object is a building
		obj_id house = getTopMostContainer(object);
		if(isIdValid(house) && !player_structure.isBuilding(house))
			return false;

		obj_id container = getContainedBy(object);
		if(isIdValid(container) && (getContainedBy(container) != house))
			return false;

		//I am not in a cave or public structure
		if(!hasObjVar(house, "player_structure.admin.adminList"))
			return false;

		return true;
	}

	return false;
}

//quick check to see if player has any of the named resource type in inventory
//returns true the first time it finds any of the passed in resource in inventory
boolean hasResourceInInventory(obj_id player, string resource)
{
	if(!isIdValid(player))
		return false;

	if(resource == null || resource == "")
		return false;

	obj_id[] contents = getFilteredPlayerContents(player);
	if ( (contents == null) || (contents.length == 0))
		return false;

	for ( int n = 0; n < contents.length; n++ )
	{
		int got = getGameObjectType(contents[n]);
		if ( isGameObjectTypeOf(got, GOT_resource_container) )
		{
			obj_id resourceCrate = contents[n];
			if ( isIdValid(resourceCrate) )
			{
				obj_id resourceId = getResourceContainerResourceType(resourceCrate);
				if ( isIdValid(resourceId) )
				{
					if ( isResourceDerivedFrom(resourceId, resource) )
						return true;

				}
			}
		}
	}
	return false;
}

obj_id[] validateObjIdArray(obj_id[] source)
{
	resizeable obj_id[] target = new obj_id[0];

	for(int i = 0; i < source.length; i++)
	{
		if(isIdValid(source[i]) && exists(source[i]))
		{
			addElement(target, source[i]);
		}
	}

	source = target;

	return source;
}

obj_id[] getPlayersInBuildoutRow(obj_id player)
{
	location loc = getLocation(player);
	return getPlayersInBuildoutRow(loc.area, locations.getBuildoutAreaRow(player));
}

obj_id[] getPlayersInBuildoutDimensions(string scene, float x1, float x2, float z1, float z2)
{
	float centX = Math.abs((x2 - x1) / 2.0f) + x1;
	float centZ = Math.abs((z2 - z1) / 2.0f) + z1;

	location centerLoc = new location(centX, 0.0f, centZ, scene);
	location lowerLeft = new location(x1, 0.0f, z1, scene);

	float hypotenuse = getDistance(centerLoc, lowerLeft);

	obj_id[] allPlayers = getAllPlayers(centerLoc, hypotenuse * 3.0f);

	resizeable obj_id[] playersInArea = new obj_id[0];

	if(allPlayers == null || allPlayers.length == 0)
	{
		return null;
	}

	for(int i = 0; i < allPlayers.length; i++)
	{
		location loc = getLocation(trial.getTop(allPlayers[i]));

		if(loc.x < x1 || loc.x > x2 || loc.z < z1 || loc.z > z2)
		{
			LOG("doLogging", ""+loc.x+" vs: "+x1+", "+x2+" and "+loc.z+" vs: "+z1+", "+z2);
			continue;
		}

		utils.addElement(playersInArea, allPlayers[i]);
	}

	if(playersInArea == null || playersInArea.length == 0)
		return null;

	return playersInArea;
}

dictionary getCoordinatesInBuildoutRow(string scene, int buildout_row)
{
	string datatable = "datatables/buildout/areas_"+scene+".iff";
	dictionary data = dataTableGetRow(datatable, buildout_row);

	return data;
}

obj_id[] getPlayersInBuildoutRow(string scene, int buildout_row)
{
	string datatable = "datatables/buildout/areas_"+scene+".iff";
	dictionary data = dataTableGetRow(datatable, buildout_row);

	return getPlayersInBuildoutDimensions(scene, data.getFloat("x1"), data.getFloat("x2"), data.getFloat("z1"), data.getFloat("z2"));
}

obj_id[] getPlayersInBuildoutArea(string scene, string buildout_area)
{
	string datatable = "datatables/buildout/areas_"+scene+".iff";
	int rowNum = dataTableSearchColumnForString(buildout_area, 0, datatable);

	if(rowNum == -1)
		return null;

	return getPlayersInBuildoutRow(scene, rowNum);
}

obj_id[] getAllNpcInBuildoutArea(obj_id baseObject)
{
	location loc = getLocation(baseObject);
	int buildout_area = locations.getBuildoutAreaRow(baseObject);

	obj_id[] allObjects =  getAllObjectsInBuildoutArea(loc.area, buildout_area);

	if (allObjects == null || allObjects.length == 0)
		return null;

	resizeable obj_id[] allNpc = new obj_id[0];


	for (int i=0;i<allObjects.length;i++)
	{
		if (!isMob(allObjects[i]))
			continue;

		allNpc.add(allObjects[i]);
	}

	if (allNpc == null || allNpc.length == 0)
		return null;

	allObjects = allNpc;
	return allObjects;
}

obj_id[] getAllObjectsInBuildoutArea(obj_id baseObject)
{
	location loc = getLocation(baseObject);
	int buildout_row = locations.getBuildoutAreaRow(baseObject);

	return getAllObjectsInBuildoutArea(loc.area, buildout_row);
}

obj_id[] getAllObjectsInBuildoutArea(string scene, int buildout_row)
{
	string datatable = "datatables/buildout/areas_"+scene+".iff";
	dictionary data = dataTableGetRow(datatable, buildout_row);

	float x1 = data.getFloat("x1");
	float x2 = data.getFloat("x2");
	float z1 = data.getFloat("z1");
	float z2 = data.getFloat("z2");

	float centX = Math.abs((data.getFloat("x2") - data.getFloat("x1")) / 2.0f) + data.getFloat("x1");
	float centZ = Math.abs((data.getFloat("z2") - data.getFloat("z1")) / 2.0f) + data.getFloat("z1");

	location centerLoc = new location(centX, 0.0f, centZ, scene);
	location lowerLeft = new location(data.getFloat("x1"), 0.0f, data.getFloat("z1"), scene);

	float hypotenuse = getDistance(centerLoc, lowerLeft);

	obj_id[] allObjects = getObjectsInRange(centerLoc, hypotenuse * 3.0f);

	resizeable obj_id[] objectsInArea = new obj_id[0];

	if (allObjects == null || allObjects.length == 0)
		return null;

	for (int i=0;i<allObjects.length;i++)
	{
		location testLoc = getLocation(trial.getTop(allObjects[i]));
		if (testLoc.x < x1 || testLoc.x > x2 || testLoc.z < z1 || testLoc.z > z2)
			continue;

		objectsInArea.add(allObjects[i]);

	}

	if (objectsInArea == null || objectsInArea.length == 0)
		return null;

	return objectsInArea;

}


Vector shuffleArray(Vector list)
{
	Vector newList = new Vector();

	for(int size = list.size();size > 0;size--)
	{

		int i = rand(0, (size - 1));

		newList = utils.addElement(newList, list.get(i));
		list = utils.removeElementAt(list, i);
	}

	if(newList == null || newList.size() == 0)
		return null;

	return newList;

}

//used for granting xmas gifts in past via dropping in players inventories on login
//each year increment the constants if you want to use this, last used 2006
boolean grantGift(obj_id player)
{
	//check character age if they are less than 10 days no joy
	if( (getCurrentBirthDate() - getPlayerBirthDate(player))  < 10 )
		return false;

	// Check to see if the player has already gotten presents
	if ( hasObjVar(player, XMAS_RECEIVED_VI1))
		return false;

	if (!isIdValid(player))
		return false;

	string config = getConfigSetting("GameServer", "grantGift");
	if (config != null)
	{
		if (config.equals("false"))
			return false;
	}

	if	(isInTutorialArea(player))
	{
		setObjVar(player, XMAS_NOT_RECEIVED_TUTORIAL, 1);
		CustomerServiceLog("grantGift", getFirstName(player) + "(" + player + ") did not receive Christmas '06 gift because they logged in on the tutorial planet.");
		return false;
	}

	//you are no longer in tutorial give them presents when they leave
	removeObjVar(player, XMAS_NOT_RECEIVED_TUTORIAL);

	obj_id inv = utils.getInventoryContainer(player);
	if (!isIdValid(inv))
	{
		CustomerServiceLog("grantGift", getFirstName(player) + "(" + player + ") did not have an inventory container. Didn't receive Christmas '06 gift, but not blocked from future attempt.");
		return false;
	}

	obj_id giftSelf= static_item.createNewItemFunction( "item_lifeday_gift_self_01_02", inv);

	obj_id giftOther= static_item.createNewItemFunction( "item_lifeday_gift_other_01_02", inv);
	setObjVar(giftOther, LIFEDAY_OWNER, player);

	// Mark the player has having gotten the item
	utils.sendMail(GIFT_GRANTED_SUB, GIFT_GRANTED, player, "System");
	setObjVar(player, XMAS_RECEIVED_VI1, 1);
	CustomerServiceLog("grantGift", getFirstName(player) + "(" + player + ") has received his Christmas '06 gift.");

	return true;
}

void fullExpertiseReset(obj_id player, boolean storeBeast)
{
	//need to store beasts
	if(storeBeast)
	{
		if(beast_lib.isBeastMaster(player))
			beast_lib.storeBeasts(player);
	}
	//drop the stance/focus buff if we are a jedi
	if(utils.isProfession(player, utils.FORCE_SENSITIVE))
	{
		if(buff.isInStance(player))
			buff.removeBuff(player, jedi.JEDI_STANCE);

		if(buff.isInFocus(player))
			buff.removeBuff(player, jedi.JEDI_FOCUS);
	}
	//set the version number
	respec.setRespecVersion(player);

	//clear buffs
	buff.removeAllBuffs(player, false, true);

	//reset the expertise
	resetExpertises(player);
}

//Used to get all the passengers in all the slots of vehicles
//this will not get the riderId, it only checks for passengers
obj_id[] getAllRidersInVehicle(obj_id player, obj_id vehicle)
{
	//validate our data
	if(!isIdValid(player) || !isIdValid(vehicle))
		return null;
	if(!exists(player) || !exists(vehicle))
		return null;

	//create our temporary array for holding data
	 resizeable obj_id[] resizeList = new obj_id[0];

	//we are going to assume that we dont have more than 25 passengers
	for(int i = 1; i <= 25; ++i)
	{
		//lets attempt to get the obj_id of rider in this slot
		obj_id tempRider = getObjectInSlot(vehicle, "rider"+i);

		//if it is an invalid Id we need to keep going
		if(!isIdValid(tempRider) || !exists(tempRider))
			continue;

		//if the id is valid, lets add it to the list.
		resizeList = addElement(resizeList, tempRider);
	}

	//lets return our list of passengers. This list could be zero length, if we had no passengers
	//so be sure to check for null or 0 length where you are calling this function
	return resizeList;
}

/*
retroactively fix up CTS stuff
*/
void updateCTSObjVars(obj_id player)
{
	if (!isIdValid(player) || !exists(player))
		return;

	boolean retrievedCtsOjbvars = false;
	dictionary[] ctsOjbvars = null;

	//check to see if they have already done this update
	string updateObjvar = utils.CTS_OBJVAR_HISTORY + ".1";
	if (!hasObjVar(player, updateObjvar))
	{
		if ((ctsOjbvars == null) && !retrievedCtsOjbvars)
		{
			ctsOjbvars = getCharacterRetroactiveCtsObjvars(player);
			retrievedCtsOjbvars = true;
		}

		if ((ctsOjbvars != null) && (ctsOjbvars.length > 0))
		{
			utils.updateRespecCTSObjvars(player, ctsOjbvars);
			utils.updateBeastMasterCTSObjvars(player, ctsOjbvars);
		}

		setObjVar(player, updateObjvar, 1);
	}

	//check to see if they have already done this update
	updateObjvar = utils.CTS_OBJVAR_HISTORY + ".2";
	if (!hasObjVar(player, updateObjvar))
	{
		if ((ctsOjbvars == null) && !retrievedCtsOjbvars)
		{
			ctsOjbvars = getCharacterRetroactiveCtsObjvars(player);
			retrievedCtsOjbvars = true;
		}

		if ((ctsOjbvars != null) && (ctsOjbvars.length > 0))
		{
			utils.updateHousePackupCTSObjvars(player, ctsOjbvars);
		}

		setObjVar(player, updateObjvar, 1);
	}

/* template for for future CTS objvar migrations
	//check to see if they have already done this update
	updateObjvar = utils.CTS_OBJVAR_HISTORY + ".3";
	if (!hasObjVar(player, updateObjvar))
	{
		if ((ctsOjbvars == null) && !retrievedCtsOjbvars)
		{
			ctsOjbvars = getCharacterRetroactiveCtsObjvars(player);
			retrievedCtsOjbvars = true;
		}

		if ((ctsOjbvars != null) && (ctsOjbvars.length > 0))
		{
			utils.updateXXXXXCTSObjvars(player, ctsOjbvars);
			utils.updateYYYYYCTSObjvars(player, ctsOjbvars);
			utils.updateZZZZZCTSObjvars(player, ctsOjbvars);
		}

		setObjVar(player, updateObjvar, 1);
	}
*/
}

/*
retroactively fix up CTS stuff relating to the respec objvars
*/
void updateRespecCTSObjvars(obj_id player, dictionary[] ctsOjbvars)
{
	if (!isIdValid(player) || !exists(player))
		return;

	if ((ctsOjbvars == null) || (ctsOjbvars.length <= 0))
		return;

	// use the higher of respecsBought objvar from the most recent
	// tranfer or the current respecsBought objvar on the character
	const int indexMostRecentTransfer = ctsOjbvars.length - 1;
	if ((ctsOjbvars[indexMostRecentTransfer] != null) && ctsOjbvars[indexMostRecentTransfer].containsKey("respecsBought") && ctsOjbvars[indexMostRecentTransfer].isInt("respecsBought"))
	{
		const int respecsBoughtFromTransfer = ctsOjbvars[indexMostRecentTransfer].getInt("respecsBought");
		int respecsBoughtCurrentValue = 0;
		if (hasObjVar(player, "respecsBought"))
			respecsBoughtCurrentValue = getIntObjVar(player, "respecsBought");

		if (respecsBoughtFromTransfer > respecsBoughtCurrentValue)
		{
			CustomerServiceLog("CharacterTransferRetroactiveHistory", "changing respecsBought objvar for " + player + " from " + respecsBoughtCurrentValue + " to " + respecsBoughtFromTransfer);
			setObjVar(player, "respecsBought", respecsBoughtFromTransfer);
		}
	}

	// for each of the value of the playerRespec.levelArrayComEntCra objvar,
	// use the higher value from the highest value from all the transfers
	// or the current value on the character
	int[] recpecLevelsFromTransfer = {-1, -1, -1};
	for (int i = 0; i < ctsOjbvars.length; ++i)
	{
		if ((ctsOjbvars[i] != null) && ctsOjbvars[i].containsKey(respec.PROF_LEVEL_ARRAY) && ctsOjbvars[i].isIntArray(respec.PROF_LEVEL_ARRAY))
		{
			int[] levelArray = ctsOjbvars[i].getIntArray(respec.PROF_LEVEL_ARRAY);
			if ((levelArray != null) && (levelArray.length == 3))
			{
				if (levelArray[0] > recpecLevelsFromTransfer[0])
					recpecLevelsFromTransfer[0] = levelArray[0];

				if (levelArray[1] > recpecLevelsFromTransfer[1])
					recpecLevelsFromTransfer[1] = levelArray[1];

				if (levelArray[2] > recpecLevelsFromTransfer[2])
					recpecLevelsFromTransfer[2] = levelArray[2];
			}
		}
	}

	if ((recpecLevelsFromTransfer[0] > -1) || (recpecLevelsFromTransfer[1] > -1) || (recpecLevelsFromTransfer[2] > -1))
	{
		int[] recpecLevelsCurrentValue = {-1, -1, -1};
		if (hasObjVar(player, respec.PROF_LEVEL_ARRAY))
			recpecLevelsCurrentValue = getIntArrayObjVar(player, respec.PROF_LEVEL_ARRAY);

		if ((recpecLevelsCurrentValue != null) && (recpecLevelsCurrentValue.length == 3))
		{
			int[] recpecLevelsNewValue = {-1, -1, -1};
			recpecLevelsNewValue[0] = Math.max(recpecLevelsCurrentValue[0], recpecLevelsFromTransfer[0]);
			recpecLevelsNewValue[1] = Math.max(recpecLevelsCurrentValue[1], recpecLevelsFromTransfer[1]);
			recpecLevelsNewValue[2] = Math.max(recpecLevelsCurrentValue[2], recpecLevelsFromTransfer[2]);

			if ((recpecLevelsNewValue[0] != recpecLevelsCurrentValue[0]) || (recpecLevelsNewValue[1] != recpecLevelsCurrentValue[1]) || (recpecLevelsNewValue[2] != recpecLevelsCurrentValue[2]))
			{
				CustomerServiceLog("CharacterTransferRetroactiveHistory", "changing " + respec.PROF_LEVEL_ARRAY + " objvar for " + player + " from (" + recpecLevelsCurrentValue[0] + "," + recpecLevelsCurrentValue[1] + "," + recpecLevelsCurrentValue[2] + ") to (" + recpecLevelsNewValue[0] + "," + recpecLevelsNewValue[1] + "," + recpecLevelsNewValue[2] + ")");
				setObjVar(player, respec.PROF_LEVEL_ARRAY, recpecLevelsNewValue);
			}
		}
	}

	//lets make sure that our current template is the right level
	if (hasObjVar(player, respec.PROF_LEVEL_ARRAY))
	{
		//get the current tempalte of the player
		string skillTemplate = getSkillTemplate(player);
		//get the respec history values
		int[] recpecLevelsValue = getIntArrayObjVar(player, respec.PROF_LEVEL_ARRAY);

		if ((skillTemplate != null) && (skillTemplate.length() > 0) && (recpecLevelsValue != null) && (recpecLevelsValue.length == 3))
		{
			//get the current level
			int currentLevel = getLevel(player);

			//if you are not an entertainer or trader, you are a combat toon
			if (!skillTemplate.startsWith("entertainer") && !skillTemplate.startsWith("trader"))
			{
				//get respec history combat level
				int combatLevel = recpecLevelsValue[respec.PROF_LEVEL_COMBAT];
				//if current level is lower than respec history combat level
				//we need to level the player up to the historical level
				if(currentLevel < combatLevel)
					respec.autoLevelPlayer(player, combatLevel, true);
			}
			//are you an entertainer?
			else if (skillTemplate.startsWith("entertainer"))
			{
				//get respec history entertainer level
				int entLevel = recpecLevelsValue[respec.PROF_LEVEL_ENT];

				//if current level is lower than respec history entertainer level
				//we need to level the player up to the historical level
				if(currentLevel < entLevel)
					respec.autoLevelPlayer(player, entLevel, true);
			}
			//are you an trader?
			else if (skillTemplate.startsWith("trader"))
			{
				//get respec history trader level
				int traderLevel = recpecLevelsValue[respec.PROF_LEVEL_TRADER];

				//if current level is lower than respec history trader level
				//we need to level the player up to the historical level
				if(currentLevel < traderLevel)
					respec.autoLevelPlayer(player, traderLevel, true);
			}
		}
	}
}

/*
retroactively fix up CTS stuff relating to the beast master ability objvar
*/
void updateBeastMasterCTSObjvars(obj_id player, dictionary[] ctsOjbvars)
{
	if (!isIdValid(player) || !exists(player))
		return;

	if ((ctsOjbvars == null) || (ctsOjbvars.length <= 0))
		return;

	// merge the values of the beast_master.known_skills objvars
	// from all the previous transfers with the current values
	HashSet abilities = new HashSet();

	// compile the list of abilities frm all previous transfers
	for (int i = 0; i < ctsOjbvars.length; ++i)
	{
		if (ctsOjbvars[i] != null)
		{
			int j = 0;
			while (true)
			{
				const String objVarName = beast_lib.PLAYER_KNOWN_SKILLS_LIST + "." + j;
				if (ctsOjbvars[i].containsKey(objVarName) && ctsOjbvars[i].isIntArray(objVarName))
				{
					const int[] objVarValue = ctsOjbvars[i].getIntArray(objVarName);
					if ((objVarValue != null) && (objVarValue.length > 0))
					{
						for (int k = 0; k < objVarValue.length; ++k)
						{
							abilities.add(new Integer(objVarValue[k]));
						}
					}

					++j;
				}
				else
				{
					break;
				}
			}
		}
	}

	if (!abilities.isEmpty())
	{
		// get current abilities
		resizeable int[] abilitiesCurrent = utils.getResizeableIntBatchObjVar(player, beast_lib.PLAYER_KNOWN_SKILLS_LIST);

		boolean updateRequired = false;
		if ((abilitiesCurrent == null) || (abilitiesCurrent.length <= 0))
		{
			updateRequired = true;
		}
		else
		{
			// make sure there are no dupes in the current abilities
			HashSet abilitiesCurrentNoDupes = new HashSet();
			for (int i = 0; i < abilitiesCurrent.length; ++i)
			{
				abilitiesCurrentNoDupes.add(new Integer(abilitiesCurrent[i]));
			}

			// merge current abilities with those from previous transfers
			Iterator abilitiesIterator = abilitiesCurrentNoDupes.iterator();
			while (abilitiesIterator.hasNext())
			{
				Integer ability = (Integer)abilitiesIterator.next();
				abilities.add(ability);
			}

			// if there is at least one ability from all the previous transfers
			// that the player currently doesn't have, we need to update the
			// player's current abilities to include the missing abilities
			if (abilities.size() != abilitiesCurrentNoDupes.size())
			{
				updateRequired = true;
			}
		}

		if (updateRequired)
		{
			int[] abilitiesNew = new int[abilities.size()];
			Iterator abilitiesIterator = abilities.iterator();
			string strAbilitiesNew = new string();
			int i = 0;
			while (abilitiesIterator.hasNext() && (i < abilitiesNew.length))
			{
				Integer ability = (Integer)abilitiesIterator.next();
				abilitiesNew[i] = ability.intValue();
				strAbilitiesNew += "" + abilitiesNew[i] + ", ";

				++i;
			}

			string strAbilitiesCurrent = new string();
			if ((abilitiesCurrent != null) && (abilitiesCurrent.length > 0))
			{
				for (int j = 0; j < abilitiesCurrent.length; ++j)
				{
					strAbilitiesCurrent += "" + abilitiesCurrent[j] + ", ";
				}
			}

			CustomerServiceLog("CharacterTransferRetroactiveHistory", "changing " + beast_lib.PLAYER_KNOWN_SKILLS_LIST + " objvar for " + player + " from (" + strAbilitiesCurrent + ") to (" + strAbilitiesNew + ")");

			utils.setBatchObjVar(player, beast_lib.PLAYER_KNOWN_SKILLS_LIST, abilitiesNew);
		}
	}
}

/*
retroactively fix up CTS stuff relating to the house packup objvars
*/
void updateHousePackupCTSObjvars(obj_id player, dictionary[] ctsOjbvars)
{
	if (!isIdValid(player) || !exists(player))
		return;

	if ((ctsOjbvars == null) || (ctsOjbvars.length <= 0))
		return;

	// add all the values of the housePackup objvars from all the
	// previous transfers to the current values on the character
	int[] housePackupNewValues = {0, 0};
	for (int i = 0; i < ctsOjbvars.length; ++i)
	{
		if ((ctsOjbvars[i] != null) && ctsOjbvars[i].containsKey(player_structure.HOUSE_PACKUP_ARRAY_OBJVAR) && ctsOjbvars[i].isIntArray(player_structure.HOUSE_PACKUP_ARRAY_OBJVAR))
		{
			int[] housePackupCTSValues = ctsOjbvars[i].getIntArray(player_structure.HOUSE_PACKUP_ARRAY_OBJVAR);
			if ((housePackupCTSValues != null) && (housePackupCTSValues.length == 2))
			{
				if (housePackupCTSValues[0] > 0)
					housePackupNewValues[0] += housePackupCTSValues[0];

				if (housePackupCTSValues[1] > 0)
					housePackupNewValues[1] += housePackupCTSValues[1];
			}
		}
	}

	if ((housePackupNewValues[0] > 0) || (housePackupNewValues[1] > 0))
	{
		int[] housePackupCurrentValues = {0, 0};
		if (hasObjVar(player, player_structure.HOUSE_PACKUP_ARRAY_OBJVAR))
			housePackupCurrentValues = getIntArrayObjVar(player, player_structure.HOUSE_PACKUP_ARRAY_OBJVAR);

		if ((housePackupCurrentValues != null) && (housePackupCurrentValues.length == 2))
		{
			housePackupNewValues[0] += housePackupCurrentValues[0];
			housePackupNewValues[1] += housePackupCurrentValues[1];

			CustomerServiceLog("CharacterTransferRetroactiveHistory", "changing " + player_structure.HOUSE_PACKUP_ARRAY_OBJVAR + " objvar for " + player + " from (" + housePackupCurrentValues[0] + ", " + housePackupCurrentValues[1] + ") to (" + housePackupNewValues[0] + ", " + housePackupNewValues[1] + ")");
			setObjVar(player, player_structure.HOUSE_PACKUP_ARRAY_OBJVAR, housePackupNewValues);
		}
	}
}
//Will return the status of a player in the following formats:
//If the player is online it will display: "Online <PlanetName>: <RegionName>, <CityName>
//If the player is offline it will display: "Offline <days>:<hours>:<minutes>:<seconds>
//If the obj_id is not a player it will return "Deleted"
string getOnlineOfflineStatus(obj_id player)
{
	string returnData = "";

	if(!isPlayer(player))
	{
		    returnData = "Deleted";
	}
	else if(!isPlayerConnected(player))
	{
		int lastLoginTime = getPlayerLastLoginTime(player);

		if(lastLoginTime > 0)
		{
			int timeDifference = getCalendarTime() - lastLoginTime;

			if(timeDifference > 0)
			{
				returnData = "Offline " + utils.padTimeDHMS(timeDifference);
			}
			else
			{
				returnData = "Offline ????d:??h:??m:??s";
			}
		}
		else
		{
			returnData = "Unknown";
		}
	}
	else
	{
		string locText = "Unknown";
		dictionary playerLoc = getConnectedPlayerLocation(player);

		//failed base call - bail
		if(playerLoc == null)
		{
			return locText;
		}

		string planet = playerLoc.getString("planet");

		if(planet != null && planet.length() > 0)
		{
			locText = localize(new string_id("planet_n", planet));
		}

		string region = playerLoc.getString("region");

		if(region != null && region.length() > 0)
		{
			locText += ": " + localize(new string_id(region.substring(1, region.indexOf(":")), region.substring(region.indexOf(":") + 1, region.length())));
		}

		string city = playerLoc.getString("playerCity");

		if(city != null && city.length() > 0)
		{
			locText += ", " + city;
		}

		returnData = "Online " + locText;
	}
	return returnData;
}

string localizeSIDString(string text)
{
	if(text == null || text.length() < 1)
	{
		return null;
	}

	int left = 0;

	if(text.startsWith("@"))
	{
		left = 1;
	}

	if(text.indexOf(":") < 0)
	{
		return text;
	}

	return localize(new string_id(text.substring(left, text.indexOf(":")), text.substring(text.indexOf(":") + 1, text.length())));
}

//function to set the color on an object. Usually called from trigger OnCustomizeFinished
//the trigger fires on the player who uses the UI generated from openCustomizationWindow
boolean colorizeItemFromWidget(obj_id player, obj_id item, string params)
{

	if(!isValidId(player) || !exists(player))
	{
		return false;
	}
	if(!isValidId(item) || !exists(item))
	{
		utils.removeScriptVar(player, "veteranRewardItemColor.color_setting");
		return false;
	}

	if(params == null || params.equals(""))
	{
		utils.removeScriptVar(player, "veteranRewardItemColor.color_setting");
		return false;
	}

	string[] colorArray = split(params, ' ');
	if(colorArray == null || colorArray.length <= 0)
	{
		utils.removeScriptVar(player, "veteranRewardItemColor.color_setting");
		return false;
	}

	for(int i = 0; i < colorArray.length; i+=2)
	{
		if(colorArray[i] == null || colorArray[i].equals(""))
			break;//if a blank entry is found bail out.
		hue.setColor(item, colorArray[i], utils.stringToInt(colorArray[i+1]));
	}
	utils.removeScriptVar(player, "veteranRewardItemColor.color_setting");
	return true;
}

/*
* Validates number of skills on an item
* Validates the stat ranges on an item
*
*
*
*
*/
boolean validateSkillModsAttached(obj_id item)
{
	return true;
}

int getNumCreaturesForSpawnLimit()
{
	// the following formula is also duplicated in GameServerMetricsData.cpp::updateData()
	const int intNumCreatures = getNumAI() - (getNumHibernatingAI() / 2);
	if (intNumCreatures <= 0)
		return 0;

	return intNumCreatures;
}