//::///////////////////////////////////////////////
//:: Name re_rndenc
//:: FileName re_rndenc.nss
//:: Copyright (c) 2002 Raymond Miller
//:://////////////////////////////////////////////
/*
This script creates functions called RandomEncounter(),
CleanHouse(), and SetRndEncProperties() for use in the NWN
scripting language. This script is meant to be used as an #include
and is part of the BESIE Random Encounter package by Ray Miller
*/
//:://////////////////////////////////////////////
//:: Created By: Ray Miller
//:: Created On: 7/6/2002
//:://////////////////////////////////////////////
// Encounter Type Constants
int ENCOUNTER_TYPE_AREA = 0;
int ENCOUNTER_TYPE_PARTY = 1;
int ENCOUNTER_TYPE_IND = 2;
// PRIVATE FUNCTION DECLARATIONS
// Sets properties for random encounters that are likely to seldom change
// - iDifficulty 1 to 10
// - bConsiderCR: If true takes CR of creature into consideration when
// choosing an encounter.
// - sCreatureTable: "re_***" - where *** is a string of letter and/or numbers to indicate to the function what type
// of creatures to spawn. They are as follows:
// a - animals
// c - construct
// d - dragon
// e - elemental
// g - giant
// h - humanoid
// i - insect
// m - miscellaneous
// p - planar
// u - undead
// b - bandit
// 0 through 9 - These are for custom encounter tables (see Custom Encounter Tables, later in this section.)
// - iLifeTime: Time in seconds before unengaged encounters decay.
// - Mph: Should equal the Minutes Per Hour setting of the Module.
// - iEncountertype:
// ENCOUNTER_TYPE_PARTY (default) - Takes into consideration the average level of the entire party of the PC who is to
// receive the encounter when choosing an encounter of appropriate difficulty level.
// ENCOUNTER_TYPE_AREA - Takes into consideration the levels off all PCs and henchmen within a 20m radius of the PC
// who is to receive the encounter.
// ENCOUNTER_TYPE_IND - Takes into consideration only the levels of the individual PC who is to receive the encounter.
// - bLOSCheck: Dependant upon a broken scripting function. (future use!)
// Note: This function is best called by the OnModuleLoad or OnAreaLoad handler.
void SetRndEncProperties(int iDifficulty = 4, int bConsiderCR = TRUE, string sCreatureTable = "re_ceghimpub", int iLifeTime = 180, int iMph = 2, int iEncounterType = 1, int bLOSCheck = FALSE);
// Generates the likelihood of a random encounter.
// - fChanceOfEncounter: Odds of encounter spawning when funciton is called. Accurate to two
// decimal places. .01 to 100.00 percent chance.
// - oEncounterObject: The object about which the encounter will spawn, whose levels, party
// or area is considered when determining an appropriate creature.
// - sTemplate: When used as the sCreatureTable parameter in the SetRndEncProperties()
// function this parameter has higher priority. It can also be set to the tag of a
// specific creature, or to "random" to use the default table set by SetRndEncProperties()
// - iMinNumberOfCreatures: If > 1, a random number of creatures between this and iMaxNumberOfCreatures
// will spawn. If set to 0, then exactly the number of creatures set by iMaxNumberOfCreatures will
// spawn.
// - iMaxNumberOfCreatures: If this and iMinNumberOfCreatures is set to 0 then the number of Creatures
// spawned will be determined by the CR of the creature spawned compared to the levels of the player(s).
// - iMinEncounterDistance: If set to 0, encounter distance will always be at the number set by iMaxEncounterDistance.
// - iMaxEncounterDistance: Farthest distance the encounter can be from oEncounterObject.
// - iOrientation: 0 to 360. Counterclockwise representing the angle from facing where the encounter will spawn.
// a value of 0 will spawn the encounter directly in front of oEncounterObject. 360 will generate a random angle.
// - iTolerance: The number of degrees by which the angle can randomly be off from iOrientation.
// - iLevelOverride: Use this to force the function to base the encounter on a character level other than that
// determined by oEncounterObject.
// - iDifficulty: Overrides the difficulty setting determined by the SetRndEncProperties() function.
object RandomEncounter(float fChanceOfEncounter = 100.0, object oEncounterObject = OBJECT_SELF, string sTemplate = "random", int iMinNumberOfCreatures = 0, int iMaxNumberOfCreatures = 0, int iMinEncounterDistance = 1, int iMaxEncounterDistance = 15, int iOrientation = 360, int iTolerance = 0, int iLevelOverride = 0, int iDifficulty = 0);
// Used to "clean up" an area that has become littered by random encounters.
// - bDestroyPlotItems - Tells the function whether or not to destroy items with their plot flags set. If set to TRUE,
// plot items will be destroyed just like any other item.
// - oArea - The area to clean up.
// - iSpawnOverride - Overrides the default (set by the SetRndEncProperties() function) time to destroy random encounter
// creatures who are not engaged by PCs.
// - iItemOverride - Overrides the default time of 30 minutes after which to destroy items dropped by PCs
// Note: Only works if the "re_moditemdrop" script included with the BESIE Random Encounter package
// is placed in the module OnItemUnacquire handler.
// - iBodyBagOverride - Overrides the default time of 5 minutes after which to destroy loot that was dropped by creatures
// who were killed.
// NOTE: If there is bDestroyPlotItems is FALSE and there is a plot item or items inside a container or body bag, the container
// and all non-plot items will decay but the plot item(s) will be left.
// NOTE: A value of zero assigned to the override parameters will cause the function to use the default value for that parameter.
void CleanHouse(int bDestroyPlotItems = FALSE, object oArea = OBJECT_SELF, int iSpawnOverride = 0, int iItemOverride = 0, int iBodyBagOverride = 0);
void SetRndEncProperties(int iDifficulty = 4, int bConsiderCR = TRUE, string sCreatureTable = "re_ceghimpub", int iLifeTime = 180, int iMph = 2, int iEncounterType = 1, int bLOSCheck = FALSE)
{
// INITIALIZE SOME GLOBAL VARIABLES
object oMod = GetModule();
object oPC;
if(GetIsObjectValid(oMod))
{
SetLocalInt(oMod, "bInitialized", TRUE);
SetLocalInt(oMod, "bConsiderCR", bConsiderCR);
SetLocalInt(oMod, "iMph", iMph);
SetLocalInt(oMod, "iLifeTime", iLifeTime);
SetLocalInt(oMod, "bLOSCheck", bLOSCheck);
SetLocalInt(oMod, "iDifficulty", iDifficulty);
SetLocalInt(oMod, "iEncounterType", iEncounterType);
SetLocalString(oMod, "sCreatureTable", sCreatureTable);
SetLocalInt(oMod, "iMinNumberOfCreatures", 0);
SetLocalInt(oMod, "iMaxNumberOfCreatures", 0);
}
}
#include "re_table"
object RandomEncounter(float fChanceOfEncounter = 100.0, object oEncounterObject = OBJECT_SELF, string sTemplate = "random", int iMinNumberOfCreatures = 0, int iMaxNumberOfCreatures = 0, int iMinEncounterDistance = 1, int iMaxEncounterDistance = 15, int iOrientation = 360, int iTolerance = 0, int iLevelOverride = 0, int iDifficulty = 0)
{
// IF PROPERTIES ARE NOT SET THEN SET THEM WITH DEFAULTS
if(!GetLocalInt(GetModule(), "bInitialized"))
{
SetRndEncProperties();
}
// DETERMINE IF ENCOUNTER HAPPENS
// The following two lines allow for a chance of encounter with a precision of up to
// two decimal places. ie. 100.00. An encounter can have as little as a 0.01 chance
// of occuring.
int iHappens = Random(10000)+1;
int iChanceOfEncounter = FloatToInt(fChanceOfEncounter * 100);
if(iChanceOfEncounter < iHappens)
{
return OBJECT_INVALID;
}
// DECLARE AND INITIALIZE VARIABLES
object oMod = GetModule();
int iLifeTime = GetLocalInt(oMod, "iLifeTime");
int bLOSCheck = GetLocalInt(oMod, "bLOSCheck");
if(!iDifficulty) iDifficulty = GetLocalInt(oMod, "iDifficulty") * 2;
int iEncounterType = GetLocalInt(oMod, "iEncounterType");
int iCounter1 = 1; // Used to count the creatures when spawning them.
int iCounter2 = 1; // Used in loop to set difficulty level.
int iCounter3 = 1; // Used in loop to check line of sight float fEncounterDistance (future use!);
int iCounter4;
int iNumberOfCreatures;
int iEncounterDistance;
int iFacingSameWay;
int iLevels;
int bNumberByLevel = FALSE;
int bNoEncounter = FALSE;
int bComplete1 = FALSE;
int bComplete2 = FALSE;
int iMph;
float fMinCR;
float fMaxCR;
float fEncounterDistance;
float fNewEncounterDistance;
float fCreatureFacing;
float fEncounterAngle;
float fEncounterVector;
float fAngleOffset;
float fLevels;
float fDifficulty = 0.167;
vector vEncounterVector;
vector vVectorOffset;
vector vCreatureVector;
object oAmIAPC;
object oCreature;
object oArea;
if(oEncounterObject == GetModule())
{
oAmIAPC = GetFirstPC();
while(GetIsObjectValid(oAmIAPC))
{
SetLocalObject(oMod, "oEncounterObject" + IntToString(iCounter4), oAmIAPC);
iCounter4++;
oAmIAPC = GetNextPC();
}
oEncounterObject = GetLocalObject(oMod, "oEncounterObject" + IntToString(Random(iCounter4)));
}
else if(GetObjectType(oEncounterObject) == 0 && oEncounterObject != GetModule())
{
oArea = oEncounterObject;
oAmIAPC = GetFirstObjectInArea(oArea);
while(GetIsObjectValid(oAmIAPC))
{
if(GetIsPC(oAmIAPC))
{
SetLocalObject(oArea, "oEncounterObject" + IntToString(iCounter4), oAmIAPC);
iCounter4++;
}
oAmIAPC = GetNextObjectInArea(oArea);
}
oEncounterObject = GetLocalObject(oArea, "oEncounterObject" + IntToString(Random(iCounter4)));
}
else
{
oArea = GetArea(oEncounterObject);
}
if(!GetIsPC(oEncounterObject))
iEncounterType = ENCOUNTER_TYPE_AREA;
location lCreatureLocation;
vector vEncounterObjectVector = GetPosition(oEncounterObject);
if(!GetLocalInt(GetModule(), "iMph"))
{
iMph = 2;
}
else
{
iMph = GetLocalInt(GetModule(), "iMph");
}
int iMin = 60;
int iHr = iMin * iMph;
int iDay = iHr * 24;
int iMth = iDay * 28;
int iYr = iMth * 12;
if(iDifficulty > 10)
{
iDifficulty = 10;
}
if(iDifficulty == 0)
{
iDifficulty = GetGameDifficulty() * 2;
}
while(iCounter2 <= iDifficulty)
{
fDifficulty = fDifficulty * 1.5;
iCounter2++;
}
// FURTHER CHECKS TO DETERMINE IF ENCOUNTER HAPPENS
oAmIAPC = GetFirstObjectInShape(SHAPE_SPHERE, 35.0, GetLocation(oEncounterObject), FALSE, OBJECT_TYPE_CREATURE);
if(GetIsObjectValid(oAmIAPC))
{
while(GetIsObjectValid(oAmIAPC))
{
if(GetIsPC(oAmIAPC))
{
if(IsInConversation(oAmIAPC))
{
return OBJECT_INVALID;
}
}
oAmIAPC = GetNextObjectInShape(SHAPE_SPHERE, 25.0, GetLocation(oEncounterObject), FALSE, OBJECT_TYPE_CREATURE);
}
}
// ERROR CORRECTION
if(iMaxNumberOfCreatures < iMinNumberOfCreatures)
{
iMaxNumberOfCreatures = iMinNumberOfCreatures;
}
if(iMaxEncounterDistance < iMinEncounterDistance)
{
iMaxEncounterDistance = iMinEncounterDistance;
}
if(!GetIsPC(oEncounterObject))
{
iEncounterType = ENCOUNTER_TYPE_AREA;
}
// DETERMINE THE ANGLE OFFSET OF THE SPAWN
if(iOrientation == 360)
{
fEncounterAngle = IntToFloat(Random(360));
}
else
{
fEncounterAngle = GetFacingFromLocation(GetLocation(oEncounterObject)) + IntToFloat(iOrientation);
fEncounterAngle = (fEncounterAngle + (IntToFloat(iTolerance) * 0.5)) - (IntToFloat(Random(iTolerance)));
}
// DETERMINE THE DISTANCE FROM THE SPAWNING OBJECT
if(iMinEncounterDistance == 0)
{
iMinEncounterDistance = iMaxEncounterDistance;
fEncounterDistance = IntToFloat(iMaxEncounterDistance);
}
else
{
fEncounterDistance = IntToFloat(iMinEncounterDistance + Random((iMaxEncounterDistance - iMinEncounterDistance) + 1));
}
iEncounterDistance = FloatToInt(fEncounterDistance);
// DETERMINE THE FACING OF THE SPAWN
fCreatureFacing = IntToFloat(Random(360));
iFacingSameWay = Random(2); // Note: If there is more than one creature there is a 50% chance they will all be facing the same direction
// DETERMINE TOTAL CHARACTER LEVELS TO CONSIDER WHEN CHOOSING A CREATURE
// AND/OR DETERMINING THE NUMBER OF CREATURES TO SPAWN.
// If the variable iEncounterType is AREA, this routine
// determines the total character levels
// based upon the character levels of all PCs
// in a 20 meter radius around the object that spawned
// the encounter.
// Later on the total character levels will be compared to
// the challenge rating of the creature spawned, and a number
// of creatures will be determined from that comparison.
if(iEncounterType == ENCOUNTER_TYPE_AREA)
{
oAmIAPC = GetFirstObjectInShape(SHAPE_SPHERE, 20.0, GetLocation(oEncounterObject), FALSE, OBJECT_TYPE_CREATURE);
while(GetIsObjectValid(oAmIAPC))
{
if(GetIsPC(oAmIAPC))
{
iLevels = iLevels + GetLevelByPosition(1, oAmIAPC) + GetLevelByPosition(2, oAmIAPC) + GetLevelByPosition(3, oAmIAPC);
if(GetIsObjectValid(GetHenchman(oAmIAPC)))
{
iLevels = iLevels + GetLevelByPosition(1, GetHenchman(oAmIAPC)) + GetLevelByPosition(2, GetHenchman(oAmIAPC)) + GetLevelByPosition(3, GetHenchman(oAmIAPC));
}
}
oAmIAPC = GetNextObjectInShape(SHAPE_SPHERE, 20.0, GetLocation(oEncounterObject), FALSE, OBJECT_TYPE_CREATURE);
}
}
else if(iEncounterType == ENCOUNTER_TYPE_PARTY)
{
iLevels = GetFactionAverageLevel(oEncounterObject);
}
else
{
// If the variable iEncounterType is set to IND, this
// routine determines the total character levels based upon the
// character level of the object that spawned the encounter.
// if the object that spawned the encounter is NOT a PC then
// the number of creatures spawned will be one. This shouldn't
// happen since the the encounter type sets itself to AREA if
// the encounter object is a placeable.
if(GetIsPC(oEncounterObject))
{
iLevels = GetLevelByPosition(1, oEncounterObject) + GetLevelByPosition(2, oEncounterObject) + GetLevelByPosition(3, oEncounterObject);
}
}
// Modify the float representing the total levels by the difficulty level.
if(iLevelOverride)
{
iLevels = iLevelOverride;
}
fLevels = IntToFloat(iLevels) * fDifficulty;
// CHOOSE A CREATURE TO SPAWN
if(GetStringLowerCase(sTemplate) == "random" || GetStringLowerCase(GetStringLeft(sTemplate, 3)) == "re_")
{
if(GetStringLowerCase(GetStringLeft(sTemplate, 3)) == "re_")
{
sTemplate = GetStringRight(sTemplate, GetStringLength(sTemplate) - 3);
}
if(fLevels < 0.25)
{
fMaxCR = 0.25;
}
else
{
fMaxCR = fLevels;
}
fMinCR = IntToFloat(FloatToInt(fMaxCR * 0.2));
//If there is a definative number of creatures to spawn passed to
//the RandomEncounter function when it is called, then do not
//allow as much play in the low end, and a little more in the
// high end challange ratings.
if(iMinNumberOfCreatures == 0 && iMaxNumberOfCreatures > 1)
{
fMinCR = IntToFloat(FloatToInt(fMaxCR * 0.4));
fMaxCR = fMaxCR * 1.2;
}
if(iMinNumberOfCreatures == 0 && iMaxNumberOfCreatures == 1)
{
fMinCR = IntToFloat(FloatToInt(fMaxCR * 0.6));
fMaxCR = fMinCR * 1.2;
}
if(GetLocalInt(oMod, "bConsiderCR") == FALSE)
{
fMaxCR = 9999.0;
fMinCR = 0.0;
}
sTemplate = GetRndEncCreature(fMinCR, fMaxCR, sTemplate);
}
// DETERMINE LOCATION AND SPAWN ONE CREATURE
// NOTE: Line Of Sight checks have a bug. Bioware says they are looking
// into the bug. I have spent an ungodly amount of hours trying to come
// up with an acceptable work-around to the Line Of Sight functionality
// of Get**ObjectInShape(). Unless somebody else can come up with a working
// LOS check, I have no choice but to disregard LOS checks until they are
// fixed.
//
// if(LOSCheck = TRUE)
// {
// <LOS code goes here>
// }
//
// note: one creature is spawned in now so its challange rating can be
// used to determine if more are needed. (if that option is set)
vEncounterVector = AngleToVector(fEncounterAngle);
vVectorOffset = vEncounterVector * fEncounterDistance;
vCreatureVector = vEncounterObjectVector + vVectorOffset;
lCreatureLocation = Location(oArea, vCreatureVector, fCreatureFacing);
oCreature = CreateObject(OBJECT_TYPE_CREATURE, sTemplate, lCreatureLocation, TRUE);
// DETERMINE THE NUMBER OF ADDITIONAL CREATURES TO SPAWN.
// If the min and max number of creatures in the function call are zero
// then get the min and max number from the local variables in the module
// object.
if(iMinNumberOfCreatures == 0 && iMaxNumberOfCreatures == 0)
{
iMinNumberOfCreatures = GetLocalInt(oMod, "iMinNumberOfCreatures");
iMaxNumberOfCreatures = GetLocalInt(oMod, "iMaxNumberOfCreatures");
}
// Now that we are done with these local integers, we need to clean reset
// them to their defaults so we don't accidentally use old numbers later.
SetLocalInt(oMod, "iMinNumberOfCreatures", 0);
SetLocalInt(oMod, "iMaxNumberOfCreatures", 0);
if(iMinNumberOfCreatures == 0 && iMaxNumberOfCreatures != 0)
{
iNumberOfCreatures = iMaxNumberOfCreatures;
}
if(iMinNumberOfCreatures != 0 && iMaxNumberOfCreatures != 0)
{
iNumberOfCreatures = iMinNumberOfCreatures + Random((iMaxNumberOfCreatures - iMinNumberOfCreatures) + 1);
}
if(iMinNumberOfCreatures == 0 && iMaxNumberOfCreatures == 0)
{
// This is the routine that sets the number of creatures to spawn
// based on their challenge rating and the total character levels.
// It chooses a random number between one half (truncated) and 125
// percent (1 for every 4) of the number of creatures ideal for the
// difficulty level set.
iMaxNumberOfCreatures = FloatToInt(fLevels / GetChallengeRating(oCreature));
iMinNumberOfCreatures = FloatToInt(IntToFloat(iMaxNumberOfCreatures) * 0.75);
iMaxNumberOfCreatures = FloatToInt(IntToFloat(iMaxNumberOfCreatures) * 1.25);
iNumberOfCreatures = iMinNumberOfCreatures + Random((iMaxNumberOfCreatures - iMinNumberOfCreatures) + 1);
if((iNumberOfCreatures < 1) && (iLevels > 0))
{
iNumberOfCreatures = 1;
}
}
// SPAWN THOSE SUCKERS!
while(iCounter1 <= iNumberOfCreatures)
{
// Stick some labels on the creature for record keeping and reference (future use!)
SetLocalInt(oCreature, "bRandomEncounter", TRUE);
SetLocalObject(oCreature, "oRandomEncounterSpawner", oEncounterObject);
SetLocalInt(oCreature, "iRandomEncounterCounter", 1);
SetLocalInt(oCreature, "iRandomEncounterSpawnTime", (GetCalendarYear() * iYr) + (GetCalendarMonth() * iMth) + (GetCalendarDay()* iDay) + (GetTimeHour()* iHr) + (GetTimeMinute() * iMin) + GetTimeSecond());
SetLocalInt(oCreature, "iRandomEncounterLifeTime", iLifeTime);
if(iCounter1 < iNumberOfCreatures)
{
oCreature = CreateObject(OBJECT_TYPE_CREATURE, sTemplate, lCreatureLocation, TRUE);
}
iCounter1++;
// Determine the facing of the next creature
if(iFacingSameWay == FALSE)
{
fCreatureFacing = IntToFloat(Random(360));
lCreatureLocation = Location(oArea, vCreatureVector, fCreatureFacing);
}
}
// Stick a lable on the spawning object for record keeping and reference (future use?)
SetLocalString(oEncounterObject, "sLastRandomEncounterSpawned", GetTag(oCreature));
return oCreature;
}
void CleanHouse(int bDestroyPlotItems = FALSE, object oArea = OBJECT_SELF, int iSpawnOverride = 0, int iItemOverride = 0, int iBodyBagOverride = 0)
{
// IF NOT INITIALIZED THEN DO SO
if(!GetLocalInt(GetModule(), "bInitialized"))
{
SetRndEncProperties();
}
int iMph;
if(!GetLocalInt(GetModule(), "iMph"))
{
iMph = 2;
}
else
{
iMph = GetLocalInt(GetModule(), "iMph");
}
// DECLARE AND INTIALIZE VARIABLES
int iMin = 60;
int iHr = iMin * iMph;
int iDay = iHr * 24;
int iMth = iDay * 28;
int iYr = iMth * 12;
int bShouldIKillHim = TRUE;
int iLifeTime;
int iItemLifeTime;
int iBodyBagLifeTime;
int iPresentTime = (GetCalendarYear() * iYr) + (GetCalendarMonth() * iMth) + (GetCalendarDay() * iDay) + (GetTimeHour() * iHr) + (GetTimeMinute() * iMin) + GetTimeSecond();
object oObject;
// GET EACH OBJECT IN THE AREA AND TEST FOR VALIDITY
object oAmIASpawn = GetFirstObjectInArea();
while(GetIsObjectValid(oAmIASpawn))
{
// IS IT A BODY BAG?
if(GetTag(oAmIASpawn) == "Body Bag" && !GetLocalInt(oAmIASpawn, "bDroppedItem"))
{
SetLocalInt(oAmIASpawn, "bDroppedItem", TRUE);
SetLocalInt(oAmIASpawn, "iDropTime", iPresentTime);
}
// IS IT A DROPPED ITEM?
if(GetLocalInt(oAmIASpawn, "bDroppedItem"))
{
// HAS IT BEEN AROUND TOO LONG?
if(iItemOverride)
{
iItemLifeTime = iItemOverride;
}
else
{
iItemLifeTime = 1800;
}
if(iBodyBagOverride)
{
iBodyBagLifeTime = iBodyBagOverride;
}
else
{
iBodyBagLifeTime = 300;
}
if((iPresentTime - GetLocalInt(oAmIASpawn, "iDropTime") > iItemLifeTime && GetTag(oAmIASpawn) != "Body Bag") || (iPresentTime - GetLocalInt(oAmIASpawn, "iDropTime") > iBodyBagLifeTime && GetTag(oAmIASpawn) == "Body Bag"))// && !GetPlotFlag(oAmIASpawn))
{
if(GetHasInventory(oAmIASpawn))
{
oObject = GetFirstItemInInventory(oAmIASpawn);
while(GetIsObjectValid(oObject))
{
if(!GetPlotFlag(oObject) || bDestroyPlotItems)
{
DestroyObject(oObject, 0.0);
}
oObject = GetNextItemInInventory(oAmIASpawn);
}
}
if(!GetPlotFlag(oAmIASpawn) || bDestroyPlotItems)
{
DestroyObject(oAmIASpawn, 0.0);
}
}
}
// IS HE IS A RANDOM ENCOUNTER?
if(GetLocalInt(oAmIASpawn, "bRandomEncounter"))
{
// HAS HE BEEN AROUND TOO LONG?
if(iSpawnOverride)
{
iLifeTime = iSpawnOverride;
}
else
{
iLifeTime = GetLocalInt(oAmIASpawn, "iRandomEncounterLifeTime");
}
if(iPresentTime - GetLocalInt(oAmIASpawn, "iRandomEncounterSpawnTime") > iLifeTime)
{
// IS HE IN COMBAT?
if(!GetIsInCombat(oAmIASpawn))
{
// GET EACH PC AND TEST IF THE CREATURE SEES HIM
// Note: this is because the creature might be charmed
// or influenced not to attack the PCs by other means.
object oPC = GetFirstPC();
if(GetIsObjectValid(oPC))
{
while(GetIsObjectValid(oPC))
{
if(GetObjectSeen(oPC, oAmIASpawn))
{
bShouldIKillHim = FALSE;
}
oPC = GetNextPC();
}
}
// IF THE CREATURE HAS PASSED ALL OF THESE CHECKS, DESTROY HIM.
if(bShouldIKillHim)
{
DestroyObject(oAmIASpawn, 0.0);
}
}
}
}
oAmIASpawn = GetNextObjectInArea();
}
}