nwnx_creature.nss

Go to the documentation of this file.

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