nwnx_creature.nss

Go to the documentation of this file.

#include "nwnx"
 
const string NWNX_Creature = "NWNX_Creature"; 
 
const int NWNX_CREATURE_MOVEMENT_RATE_PC        = 0;
const int NWNX_CREATURE_MOVEMENT_RATE_IMMOBILE  = 1;
const int NWNX_CREATURE_MOVEMENT_RATE_VERY_SLOW = 2;
const int NWNX_CREATURE_MOVEMENT_RATE_SLOW      = 3;
const int NWNX_CREATURE_MOVEMENT_RATE_NORMAL    = 4;
const int NWNX_CREATURE_MOVEMENT_RATE_FAST      = 5;
const int NWNX_CREATURE_MOVEMENT_RATE_VERY_FAST = 6;
const int NWNX_CREATURE_MOVEMENT_RATE_DEFAULT   = 7;
const int NWNX_CREATURE_MOVEMENT_RATE_DM_FAST   = 8;
 
const int NWNX_CREATURE_MOVEMENT_TYPE_STATIONARY      = 0;
const int NWNX_CREATURE_MOVEMENT_TYPE_WALK            = 1;
const int NWNX_CREATURE_MOVEMENT_TYPE_RUN             = 2;
const int NWNX_CREATURE_MOVEMENT_TYPE_SIDESTEP        = 3;
const int NWNX_CREATURE_MOVEMENT_TYPE_WALK_BACKWARDS  = 4;
 
const int NWNX_CREATURE_BONUS_TYPE_ATTACK        = 1;
const int NWNX_CREATURE_BONUS_TYPE_DAMAGE        = 2;
const int NWNX_CREATURE_BONUS_TYPE_SAVING_THROW  = 3;
const int NWNX_CREATURE_BONUS_TYPE_ABILITY       = 4;
const int NWNX_CREATURE_BONUS_TYPE_SKILL         = 5;
const int NWNX_CREATURE_BONUS_TYPE_TOUCH_ATTACK  = 6;
 
const int NWNX_CREATURE_PROJECTILE_VFX_NONE         = 0; 
const int NWNX_CREATURE_PROJECTILE_VFX_ACID         = 1;
const int NWNX_CREATURE_PROJECTILE_VFX_COLD         = 2;
const int NWNX_CREATURE_PROJECTILE_VFX_ELECTRICAL   = 3;
const int NWNX_CREATURE_PROJECTILE_VFX_FIRE         = 4;
const int NWNX_CREATURE_PROJECTILE_VFX_SONIC        = 5;
const int NWNX_CREATURE_PROJECTILE_VFX_RANDOM       = 6; 
 
const int NWNX_CREATURE_ABILITY_NONE = 6;
 
struct NWNX_Creature_SpecialAbility
{
    int id; 
    int ready; 
    int level; 
};
 
void NWNX_Creature_AddFeat(object creature, int feat);
 
void NWNX_Creature_AddFeatByLevel(object creature, int feat, int level);
 
void NWNX_Creature_RemoveFeat(object creature, int feat);
 
void NWNX_Creature_RemoveFeatByLevel(object creature, int feat, int level);
 
int NWNX_Creature_GetKnowsFeat(object creature, int feat);
 
int NWNX_Creature_GetFeatCountByLevel(object creature, int level);
 
int NWNX_Creature_GetFeatByLevel(object creature, int level, int index);
 
int NWNX_Creature_GetFeatGrantLevel(object creature, int feat);
 
int NWNX_Creature_GetFeatCount(object creature);
 
int NWNX_Creature_GetFeatByIndex(object creature, int index);
 
int NWNX_Creature_GetMeetsFeatRequirements(object creature, int feat);
 
int NWNX_Creature_GetSpecialAbilityCount(object creature);
 
struct NWNX_Creature_SpecialAbility NWNX_Creature_GetSpecialAbility(object creature, int index);
 
void NWNX_Creature_AddSpecialAbility(object creature, struct NWNX_Creature_SpecialAbility ability);
 
void NWNX_Creature_RemoveSpecialAbility(object creature, int index);
 
void NWNX_Creature_SetSpecialAbility(object creature, int index, struct NWNX_Creature_SpecialAbility ability);
 
int NWNX_Creature_GetClassByLevel(object creature, int level);
 
void NWNX_Creature_SetBaseAC(object creature, int ac);
 
int NWNX_Creature_GetBaseAC(object creature);
 
void NWNX_Creature_SetRawAbilityScore(object creature, int ability, int value);
 
int NWNX_Creature_GetRawAbilityScore(object creature, int ability);
 
void NWNX_Creature_ModifyRawAbilityScore(object creature, int ability, int modifier);
 
int NWNX_Creature_GetPrePolymorphAbilityScore(object creature, int ability);
 
int NWNX_Creature_GetRemainingSpellSlots(object creature, int class, int level);
 
void NWNX_Creature_SetRemainingSpellSlots(object creature, int class, int level, int slots);
 
int NWNX_Creature_GetMaxSpellSlots(object creature, int class, int level);
 
void NWNX_Creature_AddKnownSpell(object creature, int class, int level, int spellId);
 
void NWNX_Creature_RemoveKnownSpell(object creature, int class, int level, int spellId);
 
int NWNX_Creature_GetMaxHitPointsByLevel(object creature, int level);
 
void NWNX_Creature_SetMaxHitPointsByLevel(object creature, int level, int value);
 
void NWNX_Creature_SetMovementRate(object creature, int rate);
 
float NWNX_Creature_GetMovementRateFactor(object creature);
 
void NWNX_Creature_SetMovementRateFactor(object creature, float rate);
 
float NWNX_Creature_GetMovementRateFactorCap(object creature);
 
void NWNX_Creature_SetMovementRateFactorCap(object creature, float cap);
 
int NWNX_Creature_GetMovementType(object creature);
 
void NWNX_Creature_SetWalkRateCap(object creature, float fWalkRate = 2000.0f);
 
void NWNX_Creature_SetAlignmentGoodEvil(object creature, int value);
 
void NWNX_Creature_SetAlignmentLawChaos(object creature, int value);
 
void NWNX_Creature_SetSkillRank(object creature, int skill, int rank);
 
int NWNX_Creature_GetSkillRankByLevel(object creature, int skill, int level);
 
void NWNX_Creature_SetSkillRankByLevel(object creature, int skill, int rank, int level);
 
void NWNX_Creature_SetClassByPosition(object creature, int position, int classID, int bUpdateLevels = TRUE);
 
void NWNX_Creature_SetLevelByPosition(object creature, int position, int level);
 
void NWNX_Creature_SetBaseAttackBonus(object creature, int bab);
 
int NWNX_Creature_GetAttacksPerRound(object creature, int bBaseAPR = FALSE);
 
void NWNX_Creature_RestoreFeats(object creature);
 
void NWNX_Creature_RestoreSpecialAbilities(object creature);
 
void NWNX_Creature_RestoreItems(object creature);
 
void NWNX_Creature_SetSize(object creature, int size);
 
int NWNX_Creature_GetSkillPointsRemaining(object creature);
 
void NWNX_Creature_SetSkillPointsRemaining(object creature, int skillpoints);
 
int NWNX_Creature_GetSkillPointsRemainingByLevel(object creature, int level);
 
void NWNX_Creature_SetSkillPointsRemainingByLevel(object creature, int level, int value);
 
void NWNX_Creature_SetRacialType(object creature, int racialtype);
 
void NWNX_Creature_SetGold(object creature, int gold);
 
void NWNX_Creature_SetCorpseDecayTime(object creature, int nDecayTime);
 
int NWNX_Creature_GetBaseSavingThrow(object creature, int which);
 
void NWNX_Creature_SetBaseSavingThrow(object creature, int which, int value);
 
void NWNX_Creature_LevelUp(object creature, int class, int count = 1, int package = PACKAGE_INVALID);
 
void NWNX_Creature_LevelDown(object creature, int count=1);
 
void NWNX_Creature_SetChallengeRating(object creature, float fCR);
 
int NWNX_Creature_GetAttackBonus(object creature, int isMelee = -1, int isTouchAttack = FALSE, int isOffhand = FALSE, int includeBaseAttackBonus = TRUE);
 
int NWNX_Creature_GetHighestLevelOfFeat(object creature, int feat);
 
int NWNX_Creature_GetFeatRemainingUses(object creature, int feat);
 
int NWNX_Creature_GetFeatTotalUses(object creature, int feat);
 
void NWNX_Creature_SetFeatRemainingUses(object creature, int feat, int uses);
 
int NWNX_Creature_GetTotalEffectBonus(object creature, int bonusType=NWNX_CREATURE_BONUS_TYPE_ATTACK, object target=OBJECT_INVALID, int isElemental=0, int isForceMax=0, int savetype=-1, int saveSpecificType=-1, int skill=-1, int abilityScore=-1, int isOffhand=FALSE);
 
void NWNX_Creature_SetOriginalName(object creature, string name, int isLastName);
 
string NWNX_Creature_GetOriginalName(object creature, int isLastName);
 
void NWNX_Creature_SetSpellResistance(object creature, int sr);
 
void NWNX_Creature_SetAnimalCompanionCreatureType(object creature, int type);
 
void NWNX_Creature_SetFamiliarCreatureType(object creature, int type);
 
void NWNX_Creature_SetAnimalCompanionName(object creature, string name);
 
void NWNX_Creature_SetFamiliarName(object creature, string name);
 
int NWNX_Creature_GetDisarmable(object creature);
 
void NWNX_Creature_SetDisarmable(object creature, int disarmable);
 
void NWNX_Creature_SetDomain(object creature, int class, int index, int domain);
 
void NWNX_Creature_SetSpecialization(object creature, int class, int school);
 
void NWNX_Creature_SetFaction(object oCreature, int nFactionId);
 
int NWNX_Creature_GetFaction(object oCreature);
 
int NWNX_Creature_GetFlatFooted(object oCreature);
 
string NWNX_Creature_SerializeQuickbar(object oCreature);
 
int NWNX_Creature_DeserializeQuickbar(object oCreature, string sSerializedQuickbar);
 
void NWNX_Creature_SetCasterLevelModifier(object oCreature, int nClass, int nModifier, int bPersist = FALSE);
 
int NWNX_Creature_GetCasterLevelModifier(object oCreature, int nClass);
 
void NWNX_Creature_SetCasterLevelOverride(object oCreature, int nClass, int nCasterLevel, int bPersist = FALSE);
 
int NWNX_Creature_GetCasterLevelOverride(object oCreature, int nClass);
 
void NWNX_Creature_JumpToLimbo(object oCreature);
 
void NWNX_Creature_SetCriticalMultiplierModifier(object oCreature, int nModifier, int nHand = 0, int bPersist = FALSE, int nBaseItem = -1);
 
int NWNX_Creature_GetCriticalMultiplierModifier(object oCreature, int nHand = 0, int nBaseItem = -1);
 
void NWNX_Creature_SetCriticalMultiplierOverride(object oCreature, int nOverride, int nHand = 0, int bPersist = FALSE, int nBaseItem = -1);
 
int NWNX_Creature_GetCriticalMultiplierOverride(object oCreature, int nHand = 0, int nBaseItem = -1);
 
void NWNX_Creature_SetCriticalRangeModifier(object oCreature, int nModifier, int nHand = 0, int bPersist = FALSE, int nBaseItem = -1);
 
int NWNX_Creature_GetCriticalRangeModifier(object oCreature, int nHand = 0, int nBaseItem = -1);
 
void NWNX_Creature_SetCriticalRangeOverride(object oCreature, int nOverride, int nHand = 0, int bPersist = FALSE, int nBaseItem = -1);
 
int NWNX_Creature_GetCriticalRangeOverride(object oCreature, int nHand = 0, int nBaseItem = -1);
 
void NWNX_Creature_AddAssociate(object oCreature, object oAssociate, int nAssociateType);
 
void NWNX_Creature_OverrideDamageLevel(object oCreature, int nDamageLevel);
 
void NWNX_Creature_SetEncounter(object oCreature, object oEncounter);
 
object NWNX_Creature_GetEncounter(object oCreature);
 
int NWNX_Creature_GetIsBartering(object oCreature);
 
void NWNX_Creature_SetLastItemCasterLevel(object oCreature, int nCasterLvl);
 
int NWNX_Creature_GetLastItemCasterLevel(object oCreature);
 
int NWNX_Creature_GetArmorClassVersus(object oAttacked, object oVersus, int nTouch=FALSE);
 
int NWNX_Creature_GetWalkAnimation(object oCreature);
 
void NWNX_Creature_SetWalkAnimation(object oCreature, int nAnimation);
 
void NWNX_Creature_SetAttackRollOverride(object oCreature, int nRoll, int nModifier);
 
void NWNX_Creature_SetParryAllAttacks(object oCreature, int bParry);
 
int NWNX_Creature_GetNoPermanentDeath(object oCreature);
 
void NWNX_Creature_SetNoPermanentDeath(object oCreature, int bNoPermanentDeath);
 
vector NWNX_Creature_ComputeSafeLocation(object oCreature, vector vPosition, float fRadius = 20.0f, int bWalkStraightLineRequired = TRUE);
 
void NWNX_Creature_DoPerceptionUpdateOnCreature(object oCreature, object oTargetCreature);
 
float NWNX_Creature_GetPersonalSpace(object oCreature);
 
void NWNX_Creature_SetPersonalSpace(object oCreature, float fPerspace);
 
float NWNX_Creature_GetCreaturePersonalSpace(object oCreature);
 
void NWNX_Creature_SetCreaturePersonalSpace(object oCreature, float fCrePerspace);
 
float NWNX_Creature_GetHeight(object oCreature);
 
void NWNX_Creature_SetHeight(object oCreature, float fHeight);
 
float NWNX_Creature_GetHitDistance(object oCreature);
 
void NWNX_Creature_SetHitDistance(object oCreature, float fHitDist);
 
float NWNX_Creature_GetPreferredAttackDistance(object oCreature);
 
void NWNX_Creature_SetPreferredAttackDistance(object oCreature, float fPrefAtckDist);
 
int NWNX_Creature_GetArmorCheckPenalty(object oCreature);
 
int NWNX_Creature_GetShieldCheckPenalty(object oCreature);
 
void NWNX_Creature_SetBypassEffectImmunity(object oCreature, int nImmunityType, int nChance = 100, int bPersist = FALSE);
 
int NWNX_Creature_GetBypassEffectImmunity(object oCreature, int nImmunityType);
 
void NWNX_Creature_SetLastKiller(object oCreature, object oKiller);
 
void NWNX_Creature_DoItemCastSpell(object oCreature, object oTarget, location locTarget, int nSpellID, int nCasterLevel, float fProjectileTime, int nProjectilePathType = PROJECTILE_PATH_TYPE_DEFAULT, int nProjectileSpellID = -1, object oItem = OBJECT_INVALID, string sImpactScript = "");
 
int NWNX_Creature_RunEquip(object oCreature, object oItem, int nInventorySlot);
 
int NWNX_Creature_RunUnequip(object oCreature, object oItem);
 
void NWNX_Creature_OverrideRangedProjectileVFX(object oCreature, int nProjectileVFX, int bPersist = FALSE);
 
void NWNX_Creature_SetInitiativeModifier(object oCreature, int nMod, int bPersist = FALSE);
 
int NWNX_Creature_GetInitiativeModifier(object oCreature);
 
object NWNX_Creature_GetBodyBag(object oCreature);
 
int NWNX_Creature_AddCastSpellActions(object oCreature, object oTarget, vector vTargetLocation, int nSpellID, int nMultiClass, int nMetaMagic = METAMAGIC_NONE, int nDomainLevel = 0, int nProjectilePathType = PROJECTILE_PATH_TYPE_DEFAULT, int bInstant = FALSE, int bClearActions = FALSE, int bAddToFront = FALSE);
 
int NWNX_Creature_GetIsFlanking(object oCreature, object oTargetCreature);
 
void NWNX_Creature_DecrementRemainingSpellSlots(object oCreature, int nClass, int nSpellLevel);
 
void NWNX_Creature_IncrementRemainingSpellSlots(object oCreature, int nClass, int nSpellLevel);
 
int NWNX_Creature_GetMaximumBonusAttacks(object oCreature);
 
void NWNX_Creature_SetMaximumBonusAttacks(object oCreature, int nMaxBonusAttacks, int bPersist = FALSE);
 
void NWNX_Creature_DoCleaveAttack(object oCreature);
 
object NWNX_Creature_GetLockOrientationToObject(object oCreature);
 
void NWNX_Creature_SetLockOrientationToObject(object oCreature, object oTarget);
 
void NWNX_Creature_BroadcastAttackOfOpportunity(object oCreature, object oSingleCreature = OBJECT_INVALID, int bMovement = FALSE);
 
int NWNX_Creature_GetMaxSellToStorePriceOverride(object oCreature, object oStore);
 
void NWNX_Creature_SetMaxSellToStorePriceOverride(object oCreature, object oStore, int nMaxSellToPrice);
 
int NWNX_Creature_GetAbilityIncreaseByLevel(object oCreature, int nLevel);
 
void NWNX_Creature_SetAbilityIncreaseByLevel(object oCreature, int nLevel, int nAbility);
 
float NWNX_Creature_GetMaxAttackRange(object oCreature, object oTarget);
 
int NWNX_Creature_GetMulticlassLimit(object oCreature);
 
void NWNX_Creature_SetMulticlassLimit(object oCreature, int nLimit, int bPersist = FALSE);
 
 
void NWNX_Creature_AddFeat(object creature, int feat)
{
    string sFunc = "AddFeat";
    NWNX_PushArgumentInt(feat);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_AddFeatByLevel(object creature, int feat, int level)
{
    string sFunc = "AddFeatByLevel";
 
    NWNX_PushArgumentInt(level);
    NWNX_PushArgumentInt(feat);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_RemoveFeat(object creature, int feat)
{
    string sFunc = "RemoveFeat";
    NWNX_PushArgumentInt(feat);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_RemoveFeatByLevel(object creature, int feat, int level)
{
    string sFunc = "RemoveFeatByLevel";
 
    NWNX_PushArgumentInt(level);
    NWNX_PushArgumentInt(feat);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetKnowsFeat(object creature, int feat)
{
    string sFunc = "GetKnowsFeat";
 
    NWNX_PushArgumentInt(feat);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
int NWNX_Creature_GetFeatCountByLevel(object creature, int level)
{
    string sFunc = "GetFeatCountByLevel";
 
    NWNX_PushArgumentInt(level);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
int NWNX_Creature_GetFeatByLevel(object creature, int level, int index)
{
    string sFunc = "GetFeatByLevel";
 
    NWNX_PushArgumentInt(index);
    NWNX_PushArgumentInt(level);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
int NWNX_Creature_GetFeatCount(object creature)
{
    string sFunc = "GetFeatCount";
 
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
int NWNX_Creature_GetFeatGrantLevel(object creature, int feat)
{
    string sFunc = "GetFeatGrantLevel";
 
    NWNX_PushArgumentInt(feat);
    NWNX_PushArgumentObject(creature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
int NWNX_Creature_GetFeatByIndex(object creature, int index)
{
    string sFunc = "GetFeatByIndex";
 
    NWNX_PushArgumentInt(index);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
int NWNX_Creature_GetMeetsFeatRequirements(object creature, int feat)
{
    string sFunc = "GetMeetsFeatRequirements";
 
    NWNX_PushArgumentInt(feat);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
struct NWNX_Creature_SpecialAbility NWNX_Creature_GetSpecialAbility(object creature, int index)
{
    string sFunc = "GetSpecialAbility";
 
    struct NWNX_Creature_SpecialAbility ability;
 
    NWNX_PushArgumentInt(index);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    ability.level  = NWNX_GetReturnValueInt();
    ability.ready  = NWNX_GetReturnValueInt();
    ability.id     = NWNX_GetReturnValueInt();
 
    return ability;
}
 
int NWNX_Creature_GetSpecialAbilityCount(object creature)
{
    string sFunc = "GetSpecialAbilityCount";
 
    NWNX_PushArgumentObject(creature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_AddSpecialAbility(object creature, struct NWNX_Creature_SpecialAbility ability)
{
    string sFunc = "AddSpecialAbility";
 
    NWNX_PushArgumentInt(ability.id);
    NWNX_PushArgumentInt(ability.ready);
    NWNX_PushArgumentInt(ability.level);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_RemoveSpecialAbility(object creature, int index)
{
    string sFunc = "RemoveSpecialAbility";
 
    NWNX_PushArgumentInt(index);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetSpecialAbility(object creature, int index, struct NWNX_Creature_SpecialAbility ability)
{
    string sFunc = "SetSpecialAbility";
 
    NWNX_PushArgumentInt(ability.id);
    NWNX_PushArgumentInt(ability.ready);
    NWNX_PushArgumentInt(ability.level);
    NWNX_PushArgumentInt(index);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetClassByLevel(object creature, int level)
{
    string sFunc = "GetClassByLevel";
 
    NWNX_PushArgumentInt(level);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetBaseAC(object creature, int ac)
{
    string sFunc = "SetBaseAC";
 
    NWNX_PushArgumentInt(ac);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetBaseAC(object creature)
{
    string sFunc = "GetBaseAC";
 
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetRawAbilityScore(object creature, int ability, int value)
{
    string sFunc = "SetRawAbilityScore";
 
    NWNX_PushArgumentInt(value);
    NWNX_PushArgumentInt(ability);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetRawAbilityScore(object creature, int ability)
{
    string sFunc = "GetRawAbilityScore";
 
    NWNX_PushArgumentInt(ability);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_ModifyRawAbilityScore(object creature, int ability, int modifier)
{
    string sFunc = "ModifyRawAbilityScore";
 
    NWNX_PushArgumentInt(modifier);
    NWNX_PushArgumentInt(ability);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetPrePolymorphAbilityScore(object creature, int ability)
{
    string sFunc = "GetPrePolymorphAbilityScore";
 
    NWNX_PushArgumentInt(ability);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
int NWNX_Creature_GetRemainingSpellSlots(object creature, int class, int level)
{
    string sFunc = "GetRemainingSpellSlots";
 
    NWNX_PushArgumentInt(level);
    NWNX_PushArgumentInt(class);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetRemainingSpellSlots(object creature, int class, int level, int slots)
{
    string sFunc = "SetRemainingSpellSlots";
 
    NWNX_PushArgumentInt(slots);
    NWNX_PushArgumentInt(level);
    NWNX_PushArgumentInt(class);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_RemoveKnownSpell(object creature, int class, int level, int spellId)
{
    string sFunc = "RemoveKnownSpell";
 
    NWNX_PushArgumentInt(spellId);
    NWNX_PushArgumentInt(level);
    NWNX_PushArgumentInt(class);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_AddKnownSpell(object creature, int class, int level, int spellId)
{
    string sFunc = "AddKnownSpell";
 
    NWNX_PushArgumentInt(spellId);
    NWNX_PushArgumentInt(level);
    NWNX_PushArgumentInt(class);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetMaxSpellSlots(object creature, int class, int level)
{
    string sFunc = "GetMaxSpellSlots";
 
    NWNX_PushArgumentInt(level);
    NWNX_PushArgumentInt(class);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
 
int NWNX_Creature_GetMaxHitPointsByLevel(object creature, int level)
{
    string sFunc = "GetMaxHitPointsByLevel";
 
    NWNX_PushArgumentInt(level);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetMaxHitPointsByLevel(object creature, int level, int value)
{
    string sFunc = "SetMaxHitPointsByLevel";
 
    NWNX_PushArgumentInt(value);
    NWNX_PushArgumentInt(level);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetMovementRate(object creature, int rate)
{
    string sFunc = "SetMovementRate";
 
    NWNX_PushArgumentInt(rate);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
float NWNX_Creature_GetMovementRateFactor(object creature)
{
    string sFunc = "GetMovementRateFactor";
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueFloat();
}
 
void NWNX_Creature_SetMovementRateFactor(object creature, float factor)
{
    string sFunc = "SetMovementRateFactor";
 
    NWNX_PushArgumentFloat(factor);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
float NWNX_Creature_GetMovementRateFactorCap(object creature)
{
    string sFunc = "GetMovementRateFactorCap";
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueFloat();
}
 
void NWNX_Creature_SetMovementRateFactorCap(object creature, float cap)
{
    string sFunc = "SetMovementRateFactorCap";
 
    NWNX_PushArgumentFloat(cap);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetAlignmentGoodEvil(object creature, int value)
{
    string sFunc = "SetAlignmentGoodEvil";
 
    NWNX_PushArgumentInt(value);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetAlignmentLawChaos(object creature, int value)
{
    string sFunc = "SetAlignmentLawChaos";
 
    NWNX_PushArgumentInt(value);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetSkillRank(object creature, int skill, int rank)
{
    string sFunc = "SetSkillRank";
    NWNX_PushArgumentInt(rank);
    NWNX_PushArgumentInt(skill);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetSkillRankByLevel(object creature, int skill, int level)
{
    string sFunc = "GetSkillRankByLevel";
 
    NWNX_PushArgumentInt(level);
    NWNX_PushArgumentInt(skill);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetSkillRankByLevel(object creature, int skill, int rank, int level)
{
    string sFunc = "SetSkillRankByLevel";
 
    NWNX_PushArgumentInt(level);
    NWNX_PushArgumentInt(rank);
    NWNX_PushArgumentInt(skill);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetClassByPosition(object creature, int position, int classID, int bUpdateLevels = TRUE)
{
    string sFunc = "SetClassByPosition";
    NWNX_PushArgumentInt(bUpdateLevels);
    NWNX_PushArgumentInt(classID);
    NWNX_PushArgumentInt(position);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetLevelByPosition(object creature, int position, int level)
{
    string sFunc = "SetLevelByPosition";
    NWNX_PushArgumentInt(level);
    NWNX_PushArgumentInt(position);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetBaseAttackBonus(object creature, int bab)
{
    string sFunc = "SetBaseAttackBonus";
    NWNX_PushArgumentInt(bab);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetAttacksPerRound(object creature, int bBaseAPR = FALSE)
{
    string sFunc = "GetAttacksPerRound";
    NWNX_PushArgumentInt(bBaseAPR);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_RestoreFeats(object creature)
{
    string sFunc = "RestoreFeats";
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_RestoreSpecialAbilities(object creature)
{
    string sFunc = "RestoreSpecialAbilities";
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_RestoreItems(object creature)
{
    string sFunc = "RestoreItems";
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetSize(object creature, int size)
{
    string sFunc = "SetSize";
    NWNX_PushArgumentInt(size);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetSkillPointsRemaining(object creature)
{
    string sFunc = "GetSkillPointsRemaining";
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
 
void NWNX_Creature_SetSkillPointsRemaining(object creature, int skillpoints)
{
    string sFunc = "SetSkillPointsRemaining";
    NWNX_PushArgumentInt(skillpoints);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetSkillPointsRemainingByLevel(object creature, int level)
{
    string sFunc = "GetSkillPointsRemainingByLevel";
 
    NWNX_PushArgumentInt(level);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetSkillPointsRemainingByLevel(object creature, int level, int value)
{
    string sFunc = "SetSkillPointsRemainingByLevel";
 
    NWNX_PushArgumentInt(value);
    NWNX_PushArgumentInt(level);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetRacialType(object creature, int racialtype)
{
    string sFunc = "SetRacialType";
    NWNX_PushArgumentInt(racialtype);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetMovementType(object creature)
{
    string sFunc = "GetMovementType";
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetWalkRateCap(object creature, float fWalkRate = 2000.0f)
{
    string sFunc = "SetWalkRateCap";
    NWNX_PushArgumentFloat(fWalkRate);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetGold(object creature, int gold)
{
    string sFunc = "SetGold";
    NWNX_PushArgumentInt(gold);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetCorpseDecayTime(object creature, int nDecayTime)
{
    string sFunc = "SetCorpseDecayTime";
    NWNX_PushArgumentInt(nDecayTime);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
 
int NWNX_Creature_GetBaseSavingThrow(object creature, int which)
{
    string sFunc = "GetBaseSavingThrow";
    NWNX_PushArgumentInt(which);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetBaseSavingThrow(object creature, int which, int value)
{
    string sFunc = "SetBaseSavingThrow";
    NWNX_PushArgumentInt(value);
    NWNX_PushArgumentInt(which);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_LevelUp(object creature, int class, int count = 1, int package = PACKAGE_INVALID)
{
    string sFunc = "LevelUp";
    NWNX_PushArgumentInt(package);
    NWNX_PushArgumentInt(count);
    NWNX_PushArgumentInt(class);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_LevelDown(object creature, int count=1)
{
    string sFunc = "LevelDown";
    NWNX_PushArgumentInt(count);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetChallengeRating(object creature, float fCR)
{
    string sFunc = "SetChallengeRating";
    NWNX_PushArgumentFloat(fCR);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetAttackBonus(object creature, int isMelee = -1, int isTouchAttack = FALSE, int isOffhand = FALSE, int includeBaseAttackBonus = TRUE)
{
    string sFunc = "GetAttackBonus";
 
    if (isMelee == -1)
    {
        object oWeapon = GetItemInSlot(INVENTORY_SLOT_RIGHTHAND, creature);
 
        if (GetIsObjectValid(oWeapon))
        {
            isMelee = !GetWeaponRanged(oWeapon);
        }
        else
        {// Default to melee for unarmed
            isMelee = TRUE;
        }
    }
 
    NWNX_PushArgumentInt(includeBaseAttackBonus);
    NWNX_PushArgumentInt(isOffhand);
    NWNX_PushArgumentInt(isTouchAttack);
    NWNX_PushArgumentInt(isMelee);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
int NWNX_Creature_GetHighestLevelOfFeat(object creature, int feat)
{
    string sFunc = "GetHighestLevelOfFeat";
 
    NWNX_PushArgumentInt(feat);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
int NWNX_Creature_GetFeatRemainingUses(object creature, int feat)
{
    string sFunc = "GetFeatRemainingUses";
 
    NWNX_PushArgumentInt(feat);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
int NWNX_Creature_GetFeatTotalUses(object creature, int feat)
{
    string sFunc = "GetFeatTotalUses";
 
    NWNX_PushArgumentInt(feat);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetFeatRemainingUses(object creature, int feat, int uses)
{
    string sFunc = "SetFeatRemainingUses";
 
    NWNX_PushArgumentInt(uses);
    NWNX_PushArgumentInt(feat);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetTotalEffectBonus(object creature, int bonusType=NWNX_CREATURE_BONUS_TYPE_ATTACK, object target=OBJECT_INVALID, int isElemental=0, int isForceMax=0, int savetype=-1, int saveSpecificType=-1, int skill=-1, int abilityScore=-1, int isOffhand=FALSE)
{
    string sFunc = "GetTotalEffectBonus";
 
    NWNX_PushArgumentInt(isOffhand);
    NWNX_PushArgumentInt(abilityScore);
    NWNX_PushArgumentInt(skill);
    NWNX_PushArgumentInt(saveSpecificType);
    NWNX_PushArgumentInt(savetype);
    NWNX_PushArgumentInt(isForceMax);
    NWNX_PushArgumentInt(isElemental);
    NWNX_PushArgumentObject(target);
    NWNX_PushArgumentInt(bonusType);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetOriginalName(object creature, string name, int isLastName)
{
    string sFunc = "SetOriginalName";
 
    NWNX_PushArgumentInt(isLastName);
    NWNX_PushArgumentString(name);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
string NWNX_Creature_GetOriginalName(object creature, int isLastName)
{
    string sFunc = "GetOriginalName";
 
    NWNX_PushArgumentInt(isLastName);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueString();
}
 
void NWNX_Creature_SetSpellResistance(object creature, int sr)
{
    string sFunc = "SetSpellResistance";
 
    NWNX_PushArgumentInt(sr);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetAnimalCompanionCreatureType(object creature, int type)
{
    string sFunc = "SetAnimalCompanionCreatureType";
 
    NWNX_PushArgumentInt(type);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetFamiliarCreatureType(object creature, int type)
{
    string sFunc = "SetFamiliarCreatureType";
 
    NWNX_PushArgumentInt(type);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetAnimalCompanionName(object creature, string name)
{
    string sFunc = "SetAnimalCompanionName";
 
    NWNX_PushArgumentString(name);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetFamiliarName(object creature, string name)
{
    string sFunc = "SetFamiliarName";
 
    NWNX_PushArgumentString(name);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetDisarmable(object creature)
{
    string sFunc = "GetDisarmable";
 
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetDisarmable(object creature, int disarmable)
{
    string sFunc = "SetDisarmable";
 
    NWNX_PushArgumentInt(disarmable);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetDomain(object creature, int class, int index, int domain)
{
    string sFunc = "SetDomain";
 
    NWNX_PushArgumentInt(domain);
    NWNX_PushArgumentInt(index);
    NWNX_PushArgumentInt(class);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetSpecialization(object creature, int class, int school)
{
    string sFunc = "SetSpecialization";
 
    NWNX_PushArgumentInt(school);
    NWNX_PushArgumentInt(class);
    NWNX_PushArgumentObject(creature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetFaction(object oCreature, int nFactionId)
{
    string sFunc = "SetFaction";
    NWNX_PushArgumentInt(nFactionId);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetFaction(object oCreature)
{
    string sFunc = "GetFaction";
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
int NWNX_Creature_GetFlatFooted(object oCreature)
{
    string sFunc = "GetFlatFooted";
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
string NWNX_Creature_SerializeQuickbar(object oCreature)
{
    string sFunc = "SerializeQuickbar";
 
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueString();
}
 
int NWNX_Creature_DeserializeQuickbar(object oCreature, string sSerializedQuickbar)
{
    string sFunc = "DeserializeQuickbar";
 
    NWNX_PushArgumentString(sSerializedQuickbar);
    NWNX_PushArgumentObject(oCreature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetCasterLevelModifier(object oCreature, int nClass, int nModifier, int bPersist = FALSE)
{
    string sFunc = "SetCasterLevelModifier";
 
    NWNX_PushArgumentInt(bPersist);
    NWNX_PushArgumentInt(nModifier);
    NWNX_PushArgumentInt(nClass);
    NWNX_PushArgumentObject(oCreature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetCasterLevelModifier(object oCreature, int nClass)
{
    string sFunc = "GetCasterLevelModifier";
 
    NWNX_PushArgumentInt(nClass);
    NWNX_PushArgumentObject(oCreature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetCasterLevelOverride(object oCreature, int nClass, int nCasterLevel, int bPersist = FALSE)
{
    string sFunc = "SetCasterLevelOverride";
 
    NWNX_PushArgumentInt(bPersist);
    NWNX_PushArgumentInt(nCasterLevel);
    NWNX_PushArgumentInt(nClass);
    NWNX_PushArgumentObject(oCreature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetCasterLevelOverride(object oCreature, int nClass)
{
    string sFunc = "GetCasterLevelOverride";
 
    NWNX_PushArgumentInt(nClass);
    NWNX_PushArgumentObject(oCreature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_JumpToLimbo(object oCreature)
{
    string sFunc = "JumpToLimbo";
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetCriticalMultiplierModifier(object oCreature, int nModifier, int nHand = 0, int bPersist = FALSE, int nBaseItem = -1)
{
    string sFunc = "SetCriticalMultiplierModifier";
 
    NWNX_PushArgumentInt(nBaseItem);
    NWNX_PushArgumentInt(bPersist);
    NWNX_PushArgumentInt(nHand);
    NWNX_PushArgumentInt(nModifier);
    NWNX_PushArgumentObject(oCreature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetCriticalMultiplierModifier(object oCreature, int nHand = 0, int nBaseItem = -1)
{
    string sFunc = "GetCriticalMultiplierModifier";
 
    NWNX_PushArgumentInt(nBaseItem);
    NWNX_PushArgumentInt(nHand);
    NWNX_PushArgumentObject(oCreature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetCriticalMultiplierOverride(object oCreature, int nOverride, int nHand = 0, int bPersist = FALSE, int nBaseItem = -1)
{
    string sFunc = "SetCriticalMultiplierOverride";
 
    NWNX_PushArgumentInt(nBaseItem);
    NWNX_PushArgumentInt(bPersist);
    NWNX_PushArgumentInt(nHand);
    NWNX_PushArgumentInt(nOverride);
    NWNX_PushArgumentObject(oCreature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetCriticalMultiplierOverride(object oCreature, int nHand = 0, int nBaseItem = -1)
{
    string sFunc = "GetCriticalMultiplierOverride";
 
    NWNX_PushArgumentInt(nBaseItem);
    NWNX_PushArgumentInt(nHand);
    NWNX_PushArgumentObject(oCreature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetCriticalRangeModifier(object oCreature, int nModifier, int nHand = 0, int bPersist = FALSE, int nBaseItem = -1)
{
    string sFunc = "SetCriticalRangeModifier";
 
    NWNX_PushArgumentInt(nBaseItem);
    NWNX_PushArgumentInt(bPersist);
    NWNX_PushArgumentInt(nHand);
    NWNX_PushArgumentInt(nModifier);
    NWNX_PushArgumentObject(oCreature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetCriticalRangeModifier(object oCreature, int nHand = 0, int nBaseItem = -1)
{
    string sFunc = "GetCriticalRangeModifier";
 
    NWNX_PushArgumentInt(nBaseItem);
    NWNX_PushArgumentInt(nHand);
    NWNX_PushArgumentObject(oCreature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetCriticalRangeOverride(object oCreature, int nOverride, int nHand = 0, int bPersist = FALSE, int nBaseItem = -1)
{
    string sFunc = "SetCriticalRangeOverride";
 
    NWNX_PushArgumentInt(nBaseItem);
    NWNX_PushArgumentInt(bPersist);
    NWNX_PushArgumentInt(nHand);
    NWNX_PushArgumentInt(nOverride);
    NWNX_PushArgumentObject(oCreature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetCriticalRangeOverride(object oCreature, int nHand = 0, int nBaseItem = -1)
{
    string sFunc = "GetCriticalRangeOverride";
 
    NWNX_PushArgumentInt(nBaseItem);
    NWNX_PushArgumentInt(nHand);
    NWNX_PushArgumentObject(oCreature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_AddAssociate(object oCreature, object oAssociate, int nAssociateType)
{
    string sFunc = "AddAssociate";
 
    NWNX_PushArgumentInt(nAssociateType);
    NWNX_PushArgumentObject(oAssociate);
    NWNX_PushArgumentObject(oCreature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_OverrideDamageLevel(object oCreature, int nDamageLevel)
{
    string sFunc = "OverrideDamageLevel";
 
    NWNX_PushArgumentInt(nDamageLevel);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetEncounter(object oCreature, object oEncounter)
{
    string sFunc = "SetEncounter";
 
    NWNX_PushArgumentObject(oEncounter);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
object NWNX_Creature_GetEncounter(object oCreature)
{
    string sFunc = "GetEncounter";
 
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueObject();
}
 
int NWNX_Creature_GetIsBartering(object oCreature)
{
    string sFunc = "GetIsBartering";
 
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetLastItemCasterLevel(object oCreature, int nCasterLvl)
{
    string sFunc = "SetLastItemCasterLevel";
    NWNX_PushArgumentInt(nCasterLvl);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
 
int NWNX_Creature_GetLastItemCasterLevel(object oCreature)
{
    string sFunc = "GetLastItemCasterLevel";
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueInt();
}
 
int NWNX_Creature_GetArmorClassVersus(object oAttacked, object oVersus, int nTouch=FALSE)
{
    string sFunc = "GetArmorClassVersus";
    NWNX_PushArgumentInt(nTouch);
    NWNX_PushArgumentObject(oVersus);
    NWNX_PushArgumentObject(oAttacked);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueInt();
}
 
int NWNX_Creature_GetWalkAnimation(object oCreature)
{
    string sFunc = "GetWalkAnimation";
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetWalkAnimation(object oCreature, int nAnimation)
{
    string sFunc = "SetWalkAnimation";
    NWNX_PushArgumentInt(nAnimation);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetAttackRollOverride(object oCreature, int nRoll, int nModifier)
{
    string sFunc = "SetAttackRollOverride";
    NWNX_PushArgumentInt(nModifier);
    NWNX_PushArgumentInt(nRoll);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetParryAllAttacks(object oCreature, int bParry)
{
    string sFunc = "SetParryAllAttacks";
    NWNX_PushArgumentInt(bParry);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetNoPermanentDeath(object oCreature)
{
    string sFunc = "GetNoPermanentDeath";
 
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetNoPermanentDeath(object oCreature, int bNoPermanentDeath)
{
    string sFunc = "SetNoPermanentDeath";
 
    NWNX_PushArgumentInt(bNoPermanentDeath);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
vector NWNX_Creature_ComputeSafeLocation(object oCreature, vector vPosition, float fRadius = 20.0f, int bWalkStraightLineRequired = TRUE)
{
    string sFunc = "ComputeSafeLocation";
 
    NWNX_PushArgumentInt(bWalkStraightLineRequired);
    NWNX_PushArgumentFloat(fRadius);
    NWNX_PushArgumentFloat(vPosition.x);
    NWNX_PushArgumentFloat(vPosition.y);
    NWNX_PushArgumentFloat(vPosition.z);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    vector v;
    v.z = NWNX_GetReturnValueFloat();
    v.y = NWNX_GetReturnValueFloat();
    v.x = NWNX_GetReturnValueFloat();
 
    return v;
}
 
void NWNX_Creature_DoPerceptionUpdateOnCreature(object oCreature, object oTargetCreature)
{
    string sFunc = "DoPerceptionUpdateOnCreature";
 
    NWNX_PushArgumentObject(oTargetCreature);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
float NWNX_Creature_GetPersonalSpace(object oCreature)
{
    string sFunc = "GetPersonalSpace";
 
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueFloat();
}
 
void NWNX_Creature_SetPersonalSpace(object oCreature, float fPerspace)
{
    string sFunc = "SetPersonalSpace";
 
    NWNX_PushArgumentFloat(fPerspace);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
float NWNX_Creature_GetCreaturePersonalSpace(object oCreature)
{
    string sFunc = "GetCreaturePersonalSpace";
 
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueFloat();
}
 
void NWNX_Creature_SetCreaturePersonalSpace(object oCreature, float fCrePerspace)
{
    string sFunc = "SetCreaturePersonalSpace";
 
    NWNX_PushArgumentFloat(fCrePerspace);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
float NWNX_Creature_GetHeight(object oCreature)
{
    string sFunc = "GetHeight";
 
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueFloat();
}
 
void NWNX_Creature_SetHeight(object oCreature, float fHeight)
{
    string sFunc = "SetHeight";
 
    NWNX_PushArgumentFloat(fHeight);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
float NWNX_Creature_GetHitDistance(object oCreature)
{
    string sFunc = "GetHitDistance";
 
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueFloat();
}
 
void NWNX_Creature_SetHitDistance(object oCreature, float fHitDist)
{
    string sFunc = "SetHitDistance";
 
    NWNX_PushArgumentFloat(fHitDist);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
float NWNX_Creature_GetPreferredAttackDistance(object oCreature)
{
    string sFunc = "GetPreferredAttackDistance";
 
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueFloat();
}
 
void NWNX_Creature_SetPreferredAttackDistance(object oCreature, float fPrefAtckDist)
{
    string sFunc = "SetPreferredAttackDistance";
 
    NWNX_PushArgumentFloat(fPrefAtckDist);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetArmorCheckPenalty(object oCreature)
{
    string sFunc = "GetArmorCheckPenalty";
 
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
int NWNX_Creature_GetShieldCheckPenalty(object oCreature)
{
    string sFunc = "GetShieldCheckPenalty";
 
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetBypassEffectImmunity(object oCreature, int nImmunityType, int nChance = 100, int bPersist = FALSE)
{
    string sFunc = "SetBypassEffectImmunity";
 
    NWNX_PushArgumentInt(bPersist);
    NWNX_PushArgumentInt(nChance);
    NWNX_PushArgumentInt(nImmunityType);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetBypassEffectImmunity(object oCreature, int nImmunityType)
{
    string sFunc = "GetBypassEffectImmunity";
 
    NWNX_PushArgumentInt(nImmunityType);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetLastKiller(object oCreature, object oKiller)
{
    string sFunc = "SetLastKiller";
 
    NWNX_PushArgumentObject(oKiller);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_DoItemCastSpell(object oCreature, object oTarget, location locTarget, int nSpellID, int nCasterLevel, float fProjectileTime, int nProjectilePathType = PROJECTILE_PATH_TYPE_DEFAULT, int nProjectileSpellID = -1, object oItem = OBJECT_INVALID, string sImpactScript = "")
{
    string sFunc = "DoItemCastSpell";
 
    object oArea = GetAreaFromLocation(locTarget);
    vector vPosition = GetPositionFromLocation(locTarget);
 
    NWNX_PushArgumentString(sImpactScript);
    NWNX_PushArgumentObject(oItem);
    NWNX_PushArgumentInt(nProjectileSpellID);
    NWNX_PushArgumentInt(nProjectilePathType);
    NWNX_PushArgumentFloat(fProjectileTime);
    NWNX_PushArgumentInt(nCasterLevel);
    NWNX_PushArgumentInt(nSpellID);
    NWNX_PushArgumentFloat(vPosition.z);
    NWNX_PushArgumentFloat(vPosition.y);
    NWNX_PushArgumentFloat(vPosition.x);
    NWNX_PushArgumentObject(oArea);
    NWNX_PushArgumentObject(oTarget);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_RunEquip(object oCreature, object oItem, int nInventorySlot)
{
    string sFunc = "RunEquip";
 
    NWNX_PushArgumentInt(nInventorySlot);
    NWNX_PushArgumentObject(oItem);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueInt();
}
 
int NWNX_Creature_RunUnequip(object oCreature, object oItem)
{
    string sFunc = "RunUnequip";
 
    NWNX_PushArgumentObject(oItem);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_OverrideRangedProjectileVFX(object oCreature, int nProjectileVFX, int bPersist = FALSE)
{
    string sFunc = "OverrideRangedProjectileVFX";
 
    NWNX_PushArgumentInt(bPersist);
    NWNX_PushArgumentInt(nProjectileVFX);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_SetInitiativeModifier(object oCreature, int nMod, int bPersist = FALSE)
{
    string sFunc = "SetInitiativeModifier";
 
    NWNX_PushArgumentInt(bPersist);
    NWNX_PushArgumentInt(nMod);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetInitiativeModifier(object oCreature)
{
    string sFunc = "GetInitiativeModifier";
 
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
object NWNX_Creature_GetBodyBag(object oCreature)
{
    string sFunc = "GetBodyBag";
 
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueObject();
}
 
int NWNX_Creature_AddCastSpellActions(object oCreature, object oTarget, vector vTargetLocation, int nSpellID, int nMultiClass, int nMetaMagic = METAMAGIC_NONE, int nDomainLevel = 0, int nProjectilePathType = PROJECTILE_PATH_TYPE_DEFAULT, int bInstant = FALSE, int bClearActions = FALSE, int bAddToFront = FALSE)
{
    string sFunc = "AddCastSpellActions";
 
    NWNX_PushArgumentInt(bAddToFront);
    NWNX_PushArgumentInt(bClearActions);
    NWNX_PushArgumentInt(bInstant);
    NWNX_PushArgumentInt(nProjectilePathType);
    NWNX_PushArgumentInt(nDomainLevel);
    NWNX_PushArgumentInt(nMetaMagic);
    NWNX_PushArgumentInt(nMultiClass);
    NWNX_PushArgumentInt(nSpellID);
    NWNX_PushArgumentFloat(vTargetLocation.z);
    NWNX_PushArgumentFloat(vTargetLocation.y);
    NWNX_PushArgumentFloat(vTargetLocation.x);
    NWNX_PushArgumentObject(oTarget);
    NWNX_PushArgumentObject(oCreature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
int NWNX_Creature_GetIsFlanking(object oCreature, object oTargetCreature)
{
    string sFunc = "GetIsFlanking";
 
    NWNX_PushArgumentObject(oTargetCreature);
    NWNX_PushArgumentObject(oCreature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_DecrementRemainingSpellSlots(object oCreature, int nClass, int nSpellLevel)
{
    string sFunc = "DecrementRemainingSpellSlots";
 
    NWNX_PushArgumentInt(nSpellLevel);
    NWNX_PushArgumentInt(nClass);
    NWNX_PushArgumentObject(oCreature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_IncrementRemainingSpellSlots(object oCreature, int nClass, int nSpellLevel)
{
    string sFunc = "IncrementRemainingSpellSlots";
 
    NWNX_PushArgumentInt(nSpellLevel);
    NWNX_PushArgumentInt(nClass);
    NWNX_PushArgumentObject(oCreature);
 
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetMaximumBonusAttacks(object oCreature)
{
    string sFunc = "GetMaximumBonusAttacks";
 
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetMaximumBonusAttacks(object oCreature, int nMaxBonusAttacks, int bPersist = FALSE)
{
    string sFunc = "SetMaximumBonusAttacks";
 
    NWNX_PushArgumentInt(bPersist);
    NWNX_PushArgumentInt(nMaxBonusAttacks);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_DoCleaveAttack(object oCreature)
{
    string sFunc = "DoCleaveAttack";
 
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
object NWNX_Creature_GetLockOrientationToObject(object oCreature)
{
    string sFunc = "GetLockOrientationToObject";
 
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueObject();
}
 
void NWNX_Creature_SetLockOrientationToObject(object oCreature, object oTarget)
{
    string sFunc = "SetLockOrientationToObject";
 
    NWNX_PushArgumentObject(oTarget);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
void NWNX_Creature_BroadcastAttackOfOpportunity(object oCreature, object oSingleCreature = OBJECT_INVALID, int bMovement = FALSE)
{
    string sFunc = "BroadcastAttackOfOpportunity";
 
    NWNX_PushArgumentInt(bMovement);
    NWNX_PushArgumentObject(oSingleCreature);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetMaxSellToStorePriceOverride(object oCreature, object oStore)
{
    string sFunc = "GetMaxSellToStorePriceOverride";
 
    NWNX_PushArgumentObject(oStore);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetMaxSellToStorePriceOverride(object oCreature, object oStore, int nMaxSellToPrice)
{
    string sFunc = "SetMaxSellToStorePriceOverride";
 
    NWNX_PushArgumentInt(nMaxSellToPrice);
    NWNX_PushArgumentObject(oStore);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
int NWNX_Creature_GetAbilityIncreaseByLevel(object oCreature, int nLevel)
{
    string sFunc = "GetAbilityIncreaseByLevel";
 
    NWNX_PushArgumentInt(nLevel);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueInt();
}
 
void NWNX_Creature_SetAbilityIncreaseByLevel(object oCreature, int nLevel, int nAbility)
{
    string sFunc = "SetAbilityIncreaseByLevel";
 
    NWNX_PushArgumentInt(nAbility);
    NWNX_PushArgumentInt(nLevel);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}
 
float NWNX_Creature_GetMaxAttackRange(object oCreature, object oTarget)
{
    string sFunc = "GetMaxAttackRange";
 
    NWNX_PushArgumentObject(oTarget);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueFloat();
}
 
int NWNX_Creature_GetMulticlassLimit(object oCreature)
{
    string sFunc = "GetMulticlassLimit";
 
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
 
    return NWNX_GetReturnValueInt();
}
 
 
void NWNX_Creature_SetMulticlassLimit(object oCreature, int nLimit, int bPersist = FALSE)
{
    string sFunc = "SetMulticlassLimit";
 
    NWNX_PushArgumentInt(bPersist);
    NWNX_PushArgumentInt(nLimit);
    NWNX_PushArgumentObject(oCreature);
    NWNX_CallFunction(NWNX_Creature, sFunc);
}