[NWScript] Liste des fonctions prédéfinies

Par Daynos le 27/5/2002 à 22:20:52 (#1539316)

Extrati du script "nwscript.nss", script inclue par défaut dans les scripts NWScript


string sLanguage = "nwscript";

int Random(int nMaxInteger);

void PrintString(string sString);

void PrintFloat(float fFloat, int nWidth=18, int nDecimals=9);
string FloatToString(float fFloat, int nWidth=18, int nDecimals=9);
void PrintInteger(int nInteger);
void PrintObject(object oObject);
void AssignCommand(object oTarget,action aActionToAssign);
void DelayCommand(float fSeconds, action aActionToDelay);
void ExecuteScript(string sScript, object oTarget);
void ClearAllActions();
void SetFacing(float fDirection);

void SetCalendar(int nYear,int nMonth, int nDay);

void SetTime(int nHour,int nMinute,int nSecond,int nMillisecond);

int GetCalendarYear();
int GetCalendarMonth();
int GetCalendarDay();
int GetTimeHour();
int GetTimeMinute();
int GetTimeSecond();
int GetTimeMillisecond();
void ActionRandomWalk();
void ActionMoveToLocation(location lDestination, int bRun=FALSE);
void ActionMoveToObject(object oMoveTo, int bRun=FALSE, float fRange = 1.0f);
void ActionMoveAwayFromObject(object oFleeFrom, int bRun=FALSE, float fMoveAwayRange = 40.0f);
object GetArea(object oTarget);
object GetEnteringObject();
object GetExitingObject();
vector GetPosition(object oTarget);
float GetFacing(object oTarget);

object GetItemPossessor(object oItem);

object GetItemPossessedBy(object oCreature, string sItemTag);

object CreateItemOnObject(string sItemTemplate, object oTarget = OBJECT_SELF, int nStackSize = 1);

void ActionEquipItem(object oItem, int nInventorySlot);

void ActionUnequipItem(object oItem);

void ActionPickUpItem(object oItem);

void ActionPutDownItem(object oItem);

object GetLastAttacker(object oAttackee=OBJECT_SELF);

void ActionAttack(object oAttackee, int bPassive = FALSE);

object GetNearestCreature(int nFirstCreatureType, int nFirstParameter, object oTarget=OBJECT_SELF, int nNth=1, int nSecondCreatureType = -1, int nSecondParameter = -1, int nThirdCreatureType = -1, int nThirdParameter = -1 );

void ActionSpeakString(string sStringToSpeak, int nTalkVolume=TALKVOLUME_TALK);
void ActionPlayAnimation(int nAnimation, float fSpeed=1.0, float fSeconds=0.0);
float GetDistanceToObject(object oObject);
int GetIsObjectValid(object oObject);

void ActionOpenDoor(object oDoor);
void ActionCloseDoor(object oDoor);

void SetCameraFacing(float fDirection);
void PlaySound(string sSoundName);
object GetSpellTargetObject();

void ActionCastSpellAtObject(int nSpellID, object oTarget, int nMetaMagic = METAMAGIC_ANY, int bCheat = FALSE, int nDomainLevel = 0, int nProjectilePathType = PROJECTILE_PATH_TYPE_DEFAULT, int bInstantSpell = FALSE);

int GetCurrentHitPoints(object oObject = OBJECT_SELF);
int GetMaxHitPoints(object oObject = OBJECT_SELF);

int GetLocalInt(object oObject, string sVarName);
float GetLocalFloat(object oObject, string sVarName);
string GetLocalString(object oObject, string sVarName);
object GetLocalObject(object oObject, string sVarName);
void SetLocalInt(object oObject, string sVarName, int nValue);
void SetLocalFloat(object oObject, string sVarName, float fValue);
void SetLocalString(object oObject, string sVarName, string sValue);
void SetLocalObject(object oObject, string sVarName, object oValue);

int GetStringLength(string sString);
string GetStringUpperCase(string sString);
string GetStringLowerCase(string sString);
string GetStringRight(string sString, int nCount);
string GetStringLeft(string sString, int nCount);
string InsertString(string sDestination, string sString, int nPosition);
string GetSubString(string sString, int nStart, int nCount);
int FindSubString(string sString, string sSubString);

float fabs(float fValue);
float cos(float fValue);
float sin(float fValue);
float tan(float fValue);
float acos(float fValue);
float asin(float fValue);
float atan(float fValue);
float log(float fValue);
float pow(float fValue, float fExponent);
float sqrt(float fValue);
int abs(int nValue);

effect EffectHeal(int nDamage);
effect EffectDamage(int nDamage, int nDamageType=DAMAGE_TYPE_MAGICAL, int nDamagePower=DAMAGE_POWER_NORMAL);
effect EffectAbilityIncrease(int nAttribute, int nModifyBy);

effect EffectDamageResistance(int nDamageType, int nAmount, int nLimit=0);
effect EffectResurrection();

effect EffectSummonCreature(string sResref, int nVisualEffectId = VFX_NONE, float fDelay=0.0f);

int GetCasterLevel(object oCreature);

effect GetFirstEffect(object oCreature);
effect GetNextEffect(object oCreature);
void RemoveEffect(object oCreature, effect eEffect);
int GetIsEffectValid(effect eEffect);
int GetEffectDurationType(effect eEffect);
int GetEffectSubType(effect eEffect);
object GetEffectCreator(effect eEffect);

string IntToString(int nInteger);

object GetFirstObjectInArea(object oArea = OBJECT_INVALID);

object GetNextObjectInArea(object oArea = OBJECT_INVALID);

int d2(int nDice=1);
int d3(int nDice=1);
int d4(int nDice=1);
int d6(int nDice=1);
int d8(int nDice=1);
int d10(int nDice=1);
int d12(int nDice=1);
int d20(int nDice=1);
int d100(int nDice=1);

float VectorMagnitude(vector vVector);

int GetMetaMagicFeat();

int GetObjectType(object oTarget);

int GetRacialType(object oCreature);

int FortitudeSave(object oCreature, int nDC, int nSaveType=SAVING_THROW_TYPE_NONE, object oSaveVersus=OBJECT_SELF);

int ReflexSave(object oCreature, int nDC, int nSaveType=SAVING_THROW_TYPE_NONE, object oSaveVersus=OBJECT_SELF);

int WillSave(object oCreature, int nDC, int nSaveType=SAVING_THROW_TYPE_NONE, object oSaveVersus=OBJECT_SELF);
int GetSpellSaveDC();

effect MagicalEffect(effect e);
effect SupernaturalEffect(effect e);
effect ExtraordinaryEffect(effect e);

effect EffectACIncrease(int nValue, int nModifyType=AC_DODGE_BONUS);
int GetAC(object oidObject, int nVersusType=RACIAL_TYPE_ALL);

effect EffectSavingThrowIncrease(int nSave, int nValue, int nSaveType=SAVING_THROW_TYPE_ALL);
effect EffectAttackIncrease(int nBonus, int nModifierType=ATTACK_BONUS_MISC);

effect EffectDamageReduction(int nAmount, int nDamagePower, int nLimit=0);

effect EffectDamageIncrease(int nValue, int nDamageType=DAMAGE_TYPE_MAGICAL);

float RoundsToSeconds(int nRounds);
float HoursToSeconds(int nHours);
float TurnsToSeconds(int nTurns);

int GetLawChaosValue(object oCreature);
int GetGoodEvilValue(object oCreature);
int GetAlignmentLawChaos(object oCreature);
int GetAlignmentGoodEvil(object oCreature);

object GetFirstObjectInShape(int nShape, float fSize, location lTarget, int bLineOfSight=FALSE, int nObjectFilter=OBJECT_TYPE_CREATURE, vector vOrigin=[0.0,0.0,0.0]);
object GetNextObjectInShape(int nShape, float fSize, location lTarget, int bLineOfSight=FALSE, int nObjectFilter=OBJECT_TYPE_CREATURE, vector vOrigin=[0.0,0.0,0.0]);

effect EffectEntangle();

void SignalEvent(object oObject, event evToRun);
event EventUserDefined(int nUserDefinedEventNumber);

effect EffectDeath( int nSpectacularDeath = FALSE, int nDisplayFeedback = TRUE );

effect EffectKnockdown();

void ActionGiveItem(object oItem, object oGiveTo);

void ActionTakeItem(object oItem, object oTakeFrom);

vector VectorNormalize(vector vVector);

effect EffectCurse(int nStrMod=1, int nDexMod=1, int nConMod=1, int nIntMod=1, int nWisMod=1, int nChaMod=1);

int GetAbilityScore(object oCreature, int nAbility);

int GetIsDead(object oCreature);
void PrintVector(vector vVector);
vector Vector(float x=0.0f, float y=0.0f, float z=0.0f);

void SetFacingPoint(vector vTarget);
vector AngleToVector(float fAngle);
float VectorToAngle(vector vVector);

int TouchAttackMelee(object oTarget, int bDisplayFeedback = TRUE);

int TouchAttackRanged(object oTarget, int bDisplayFeedback = TRUE);

effect EffectParalyze();

effect EffectSpellImmunity( int nSpellLevel = -1, int nSpellSchool = SPELL_SCHOOL_GENERAL, int nSpell = -1 );

effect EffectDeaf();

float GetDistanceBetween(object oObjectA, object oObjectB);

void SetLocalLocation(object oObject, string sVarName, location lValue);
location GetLocalLocation(object oObject, string sVarName);

effect EffectSleep();

object GetItemInSlot(int nInventorySlot, object oCreature = OBJECT_SELF);

effect EffectCharmed();
effect EffectConfused();
effect EffectFrightened();
effect EffectDominated();
effect EffectDazed();
effect EffectStunned();

void SetCommandable(int bCommandable, object oTarget = OBJECT_SELF);
int GetCommandable(object oTarget = OBJECT_SELF);

effect EffectRegenerate(int nAmount, float fInterval);
effect EffectMovementSpeedIncrease(int nPercentChange);
int GetHitDice(object oCreature);

void ActionForceFollowObject(object oFollow, float fFollowDistance=0.0f);

string GetTag(object oObject);

int ResistSpell(object oCaster, object oTarget);

int GetEffectType(effect e);

effect EffectAreaOfEffect(int nAreaEffectId, string sOnEnterScript=", string sHeartbeatScript=", string sOnExitScript=");

int GetFactionEqual(object oFirstObject, object oSecondObject = OBJECT_SELF);

void ChangeFaction(object oObjectToChangeFaction, object oMemberOfFactionToJoin);

int GetIsListening(object oObject);

void SetListening(object oObject, int bValue);

void SetListenPattern(object oObject, string sPattern, int nNumber = 0);

int TestStringAgainstPattern(string sPattern, string sStringToTest);

string GetMatchedSubstring(int nString);

int GetMatchedSubstringsCount();

effect EffectVisualEffect(int nVisualEffectId, int nMissEffect = FALSE);

object GetFactionWeakestMember(object oFactionMember=OBJECT_SELF, int bMustBeVisible=TRUE);

object GetFactionStrongestMember(object oFactionMember=OBJECT_SELF, int bMustBeVisible=TRUE);

object GetFactionMostDamagedMember(object oFactionMember=OBJECT_SELF, int bMustBeVisible=TRUE);

object GetFactionLeastDamagedMember(object oFactionMember=OBJECT_SELF, int bMustBeVisible=TRUE);

int GetFactionGold(object oFactionMember);

int GetFactionAverageReputation(object oSource, object oTarget);

int GetFactionAverageGoodEvilAlignment(object oFactionMember);

int GetFactionAverageLawChaosAlignment(object oFactionMember);

int GetFactionAverageLevel(object oFactionMember);

int GetFactionAverageXP(object oFactionMember);

int GetFactionMostFrequentClass(object oFactionMember);

object GetFactionWorstAC(object oFactionMember=OBJECT_SELF, int bMustBeVisible=TRUE);

object GetFactionBestAC(object oFactionMember=OBJECT_SELF, int bMustBeVisible=TRUE);

void ActionSit( object oChair );

int GetListenPatternNumber();

void ActionJumpToObject(object oToJumpTo, int nWalkStraightLineToPoint=1);

object GetWaypointByTag(string sWaypointTag);

object GetTransitionTarget(object oTransition);

effect EffectLinkEffects(effect eLinkThis, effect eToThis );

object GetObjectByTag(string sTag, int nNth=0);

void AdjustAlignment(object oSubject, int nAlignment, int nShift);

void ActionWait(float fSeconds);

void SetAreaTransitionBMP(int nAreaTransition, string sCustomBMP = ");

void ActionStartConversation(object oObjectToConverse, string sDialogResRef = ", int bPrivateConversation = FALSE);

void ActionPauseConversation();

void ActionResumeConversation();

effect EffectBeam(int nBeamVisualEffect, object oEffector, int nBodyPart, int nMissEffect = FALSE);

int GetReputation(object oSource, object oTarget);

void AdjustReputation(object oTargetCreature, object oMemberOfSourceFaction, int nAdjustment);

object GetSittingCreature( object oObject );

object GetGoingToBeAttackedBy( object oTarget );

effect EffectSpellResistanceIncrease(int nValue);

location GetLocation(object oObject);

void ActionJumpToLocation(location lLoc);

location Location(object oArea, vector vPosition, float fOrientation);

void ApplyEffectAtLocation(int nDurationType, effect e, location l, float fDuration = 0.0f);

int GetIsPC(object oCreature);

float FeetToMeters(float fFeet);

float YardsToMeters(float fYards);

void ApplyEffectToObject(int nDurationType, effect e, object oTarget, float fDuration = 0.0f);

void SpeakString(string sStringToSpeak, int nTalkVolume=TALKVOLUME_TALK);

location GetSpellTargetLocation();

vector GetPositionFromLocation(location l);

object GetAreaFromLocation(location l);

float GetFacingFromLocation(location l);

object GetNearestCreatureToLocation(int nFirstCreatureType, int nFirstParameter, location l, int nNth=1, int nSecondCreatureType = -1, int nSecondParameter = -1, int nThirdCreatureType = -1, int nThirdParameter = -1 );

object GetNearestObject(int nObjectType=OBJECT_TYPE_ALL, object oTarget=OBJECT_SELF, int nNth=1);
object GetNearestObjectToLocation(int nObjectType, location l, int nNth=1);
object GetNearestObjectByTag(string sTag, object oTarget=OBJECT_SELF, int nNth=1);

float IntToFloat(int nInteger);

int FloatToInt(float fFloat);
int StringToInt(string sNumber);
float StringToFloat(string sNumber);

void ActionCastSpellAtLocation(int nSpellID, location lTarget, int nMetaMagic = METAMAGIC_ANY, int bCheat = FALSE, int nProjectilePathType = PROJECTILE_PATH_TYPE_DEFAULT, int bInstantSpell = FALSE);

int GetIsEnemy(object oTarget, object oSource=OBJECT_SELF);

int GetIsFriend(object oTarget, object oSource=OBJECT_SELF);

int GetIsNeutral(object oTarget, object oSource=OBJECT_SELF);

object GetPCSpeaker();

string GetStringByStrRef(int nStrRef);

void ActionSpeakStringByStrRef(int nStrRef, int nTalkVolume=TALKVOLUME_TALK);

void DestroyObject(object oDestroy, float fDelay=0.0f);

object GetModule();

object CreateObject(int nObjectType, string sTemplate, location lLoc, int bUseAppearAnimation = FALSE);

event EventSpellCastAt(object oCaster, int nSpellId, int bHarmful=TRUE);

object GetLastSpellCaster();

int GetLastSpell();

int GetUserDefinedEventNumber();

int GetSpellId();

string RandomName();

effect EffectPoison(int nPoisonType);

effect EffectDisease(int nDiseaseType);

effect EffectSilence();

string GetName(object oObject);

object GetLastSpeaker();

int BeginConversation(string sResRef=", object oObjectToDialog=OBJECT_INVALID);

object GetLastPerceived();

int GetLastPerceptionHeard();

int GetLastPerceptionInaudible();

int GetLastPerceptionSeen();

void E3PlaySound(string sFileName, location lSoundLocation, float fGain, float fRefDistance, float fRollOffFactor);

int GetLastPerceptionVanished();

object GetFirstInPersistentObject(object oPersistentObject = OBJECT_SELF, int nResidentObjectType = OBJECT_TYPE_CREATURE, int nPersistentZone = PERSISTENT_ZONE_ACTIVE);

object GetNextInPersistentObject(object oPersistentObject = OBJECT_SELF, int nResidentObjectType = OBJECT_TYPE_CREATURE, int nPersistentZone = PERSISTENT_ZONE_ACTIVE);

object GetAreaOfEffectCreator(object oAreaOfEffectObject = OBJECT_SELF);

void DeleteLocalInt(object oObject, string sVarName);
void DeleteLocalFloat(object oObject, string sVarName);
void DeleteLocalString(object oObject, string sVarName);
void DeleteLocalObject(object oObject, string sVarName);
void DeleteLocalLocation(object oObject, string sVarName);

effect EffectHaste();
effect EffectSlow();

string ObjectToString(object oObject);

effect EffectImmunity(int nImmunityType);
int GetIsImmune(object oCreature, int nImmunityType, object oVersus = OBJECT_INVALID);

effect EffectDamageImmunityIncrease(int nDamageType, int nPercentImmunity);

int GetEncounterActive(object oEncounter = OBJECT_SELF);

void SetEncounterActive(int nNewValue, object oEncounter = OBJECT_SELF);

int GetEncounterSpawnsMax(object oEncounter = OBJECT_SELF);

void SetEncounterSpawnsMax(int nNewValue, object oEncounter = OBJECT_SELF);

int GetEncounterSpawnsCurrent(object oEncounter = OBJECT_SELF);

void SetEncounterSpawnsCurrent(int nNewValue, object oEncounter = OBJECT_SELF);

object GetModuleItemAcquired();

object GetModuleItemAcquiredFrom();

void SetCustomToken(int nCustomTokenNumber, string sTokenValue);

int GetHasFeat(int nFeat, object oCreature = OBJECT_SELF);

int GetHasSkill(int nSkill, object oCreature = OBJECT_SELF);

void ActionUseFeat(int nFeat, object oTarget);

void ActionUseSkill(int nSkill, object oTarget);

int GetObjectSeen(object oTarget, object oSource = OBJECT_SELF);

int GetObjectHeard(object oTarget, object oSource = OBJECT_SELF);

object GetLastPlayerDied();

object GetModuleItemLost();

object GetModuleItemLostBy();

void ActionDoCommand(action aActionToDo);

event EventConversation();

void SetEncounterDifficulty(int nEncounterDifficulty, object oEncounter = OBJECT_SELF);

int GetEncounterDifficulty(object oEncounter = OBJECT_SELF);

float GetDistanceBetweenLocations(location lLocationA, location lLocationB);

int GetReflexAdjustedDamage(int nDamage, object oCreature, int nDC, int nSaveType=SAVING_THROW_TYPE_NONE, object oSaveVersus=OBJECT_SELF);

void PlayAnimation(int nAnimation, float fSpeed=1.0, float fSeconds=0.0);

talent TalentSpell(int nSpellID);

talent TalentFeat(int nFeatID);

talent TalentSkill(int nSkillID);

int GetHasSpellEffect(int nSpellId, object oObject=OBJECT_SELF);

int GetEffectSpellId(effect eSpellEffect);

int GetCreatureHasTalent(talent tTalent, object oCreature=OBJECT_SELF);

talent GetCreatureTalentRandom(int nCategory, object oCreature=OBJECT_SELF);

talent GetCreatureTalentBest(int nCategory, int nCRMax, object oCreature=OBJECT_SELF);

void ActionUseTalentOnObject(talent tChosenTalent, object oTarget);

void ActionUseTalentAtLocation(talent tChosenTalent, location lTarget);

int GetGoldPieceValue(object oItem);

int GetIsPlayableRacialType(object oCreature);

void JumpToLocation(location lDestination);

effect EffectTemporaryHitpoints(int nHitPoints);

int GetSkillRank(int nSkill, object oTarget=OBJECT_SELF);

object GetAttackTarget(object oTarget=OBJECT_SELF);

int GetLastAttackType(object oTarget=OBJECT_SELF);

int GetLastAttackMode(object oTarget=OBJECT_SELF);

object GetMaster(object oAssociate=OBJECT_SELF);

int GetIsInCombat(object oCreature=OBJECT_SELF);

int GetLastAssociateCommand(object oAssociate=OBJECT_SELF);

void GiveGoldToCreature(object oCreature, int nGP);

void SetIsDestroyable( int bDestroyable, int bRaiseable = TRUE, int bSelectableWhenDead = FALSE );

void SetLocked(object oTarget, int bLocked);

int GetLocked(object oTarget);

object GetClickingObject();

void SetAssociateListenPatterns(object oTarget=OBJECT_SELF);

object GetLastWeaponUsed(object oCreature);

void ActionInteractObject(object oPlaceable);

object GetLastUsedBy();

int GetAbilityModifier(int nAbility, object oCreature=OBJECT_SELF);

int GetIdentified(object oItem);

void SetIdentified(object oItem, int bIdentified);

void SummonAnimalCompanion(object oMaster=OBJECT_SELF);

void SummonFamiliar(object oMaster=OBJECT_SELF);

object GetBlockingDoor();

int GetIsDoorActionPossible(object oTargetDoor, int nDoorAction);

void DoDoorAction(object oTargetDoor, int nDoorAction);

object GetFirstItemInInventory(object oTarget = OBJECT_SELF);

object GetNextItemInInventory(object oTarget = OBJECT_SELF);

int GetClassByPosition(int nClassPosition, object oCreature = OBJECT_SELF);

int GetLevelByPosition(int nClassPosition, object oCreature = OBJECT_SELF);

int GetLevelByClass(int nClassType, object oCreature = OBJECT_SELF);

int GetDamageDealtByType(int nDamageType);

int GetTotalDamageDealt();

object GetLastDamager();

object GetLastDisarmed();

object GetLastDisturbed();

object GetLastLocked();

object GetLastUnlocked();

effect EffectSkillIncrease(int nSkill, int nValue);

int GetInventoryDisturbType();

object GetInventoryDisturbItem();

object GetHenchman(object oMaster = OBJECT_SELF);

effect VersusAlignmentEffect(effect eEffect, int nLawChaos = ALIGNMENT_ALL, int nGoodEvil = ALIGNMENT_ALL);
effect VersusRacialTypeEffect(effect eEffect, int nRacialType);
effect VersusTrapEffect(effect eEffect);

int GetGender(object oCreature);

int GetIsTalentValid(talent tTalent);

void ActionMoveAwayFromLocation(location lMoveAwayFrom, int bRun=FALSE, float fMoveAwayRange = 40.0f);

object GetAttemptedAttackTarget();

int GetTypeFromTalent(talent tTalent);

int GetIdFromTalent(talent tTalent);

object GetAssociate(int nAssociateType, object oMaster=OBJECT_SELF);

void AddHenchman(object oMaster, object oHenchman=OBJECT_SELF);

void RemoveHenchman(object oMaster, object oHenchman=OBJECT_SELF);

void AddJournalQuestEntry(string szPlotID, int nState, object oObject, int bAllPartyMemebers=TRUE, int bAllPlayers=FALSE, int bAllowOverrideHigher=FALSE);

void RemoveJournalQuestEntry(string szPlotID, object oObject, int bAllPartyMemebers=TRUE, int bAllPlayers=FALSE);

void SetJournalQuestEntryPicture(string szPlotID, object oObject, int nPictureIndex, int bAllPartyMemebers=TRUE, int bAllPlayers=FALSE);

void AddJournalWorldEntry( int nIndex, string szEntry, string szTitle = "World Entry" );

void AddJournalWorldEntryStrref ( int strref, int strrefTitle );

void DeleteJournalWorldEntry( int nIndex );

void DeleteJournalWorldEntryStrref( int strref );

void DeleteJournalWorldAllEntries();

object GetAttemptedSpellTarget();

object GetLastOpenedBy();

int GetHasSpell(int nSpellId, object oCreature=OBJECT_SELF);

void OpenStore(object oStore, object oPC, int nBonusMarkUp=0, int nBonusMarkDown=0);

effect EffectTurned();

object GetFirstFactionMember(object oMemberOfFaction, int bPCOnly = TRUE);

object GetNextFactionMember(object oMemberOfFaction, int bPCOnly = TRUE);

void ActionForceMoveToLocation(location lDestination, int bRun=FALSE, float fTimeout=30.0f);

void ActionForceMoveToObject(object oMoveTo, int bRun=FALSE, float fRange = 1.0f, float fTimeout=30.0f);

int GetJournalQuestExperience(string szPlotID);

void JumpToObject(object oToJumpTo, int nWalkStraightLineToPoint=1);

void SetMapPinEnabled( object oMapPin, int nEnabled );

effect EffectHitPointChangeWhenDying(float fHitPointChangePerRound);

void PopUpGUIPanel(object oPC, int nGUIPanel);

void ClearPersonalReputation(object oTarget, object oSource=OBJECT_SELF);

void SetIsTemporaryFriend(object oTarget, object oSource=OBJECT_SELF, int bDecays=FALSE, float fDurationInSeconds=180.0f);

void SetIsTemporaryEnemy(object oTarget, object oSource=OBJECT_SELF, int bDecays=FALSE, float fDurationInSeconds=180.0f);

void SetIsTemporaryNeutral(object oTarget, object oSource=OBJECT_SELF, int bDecays=FALSE, float fDurationInSeconds=180.0f);

void GiveXPToCreature( object oCreature, int nXpAmount );

void SetXP( object oTarget, int nXpAmount );

int GetXP( object oTarget );

string IntToHexString( int nInteger );

int GetBaseItemType( object oItem );

int GetItemHasItemProperty( object oItem, int nProperty );

void ActionEquipMostDamagingMelee( object oVersus = OBJECT_INVALID, int bOffHand = FALSE );

void ActionEquipMostDamagingRanged( object oVersus = OBJECT_INVALID );

int GetItemACValue( object oItem );

void ActionRest();

void ExploreAreaForPlayer( object oArea, object oPlayer );

void ActionEquipMostEffectiveArmor();

int GetIsDay();

int GetIsNight();

int GetIsDawn();

int GetIsDusk();

int GetIsEncounterCreature(object oCreature=OBJECT_SELF);

object GetLastPlayerDying();

location GetStartingLocation();

void ChangeToStandardFaction(object oCreatureToChange, int nStandardFaction);

void SoundObjectPlay( object oSound );
void SoundObjectStop( object oSound );
void SoundObjectSetVolume( object oSound, int nVolume );
void SoundObjectSetPosition( object oSound, vector vPosition );

void SpeakOneLinerConversation(string sDialogResRef = ", object oTokenTarget = OBJECT_TYPE_INVALID);

int GetGold( object oTarget = OBJECT_SELF );

object GetLastRespawnButtonPresser();

int GetIsDM(object oCreature);

void PlayVoiceChat( int nVoiceChatID, object oTarget = OBJECT_SELF );

void GetIsWeaponEffective( object oVersus = OBJECT_INVALID, int bOffHand = FALSE );

int GetLastSpellHarmful();

event EventActivateItem(object oItem, location lTarget, object oTarget=OBJECT_INVALID);

Par Daynos le 27/5/2002 à 22:23:30 (#1539332)

void MusicBackgroundPlay( object oArea );
void MusicBackgroundStop( object oArea );
void MusicBackgroundSetDelay( object oArea, int nDelay );
void MusicBackgroundChangeDay( object oArea, int nTrack );
void MusicBackgroundChangeNight( object oArea, int nTrack );

void MusicBattlePlay( object oArea );
void MusicBattleStop( object oArea );
void MusicBattleChange( object oArea, int nTrack );

void AmbientSoundPlay( object oArea );
void AmbientSoundStop( object oArea );
void AmbientSoundChangeDay( object oArea, int nTrack );
void AmbientSoundChangeNight( object oArea, int nTrack );

object GetLastKiller();

object GetSpellCastItem();

object GetItemActivated();

object GetItemActivator();

location GetItemActivatedTargetLocation();

object GetItemActivatedTarget();

int GetIsOpen(object oObject);

void TakeGoldFromCreature( int nAmount, object oCreatureToTakeFrom, int bDestroy = FALSE );

int IsInConversation( object oObject );

effect EffectAbilityDecrease(int nAttribute, int nModifyBy);

effect EffectAttackDecrease(int nBonus, int nModifierType=ATTACK_BONUS_MISC);
effect EffectDamageDecrease(int nBonus, int nDamageType = DAMAGE_TYPE_MAGICAL);
effect EffectDamageImmunityDecrease(int nDamageType, int nPercentImmunity);
effect EffectACDecrease(int nValue, int nModifyType=AC_DODGE_BONUS);
effect EffectMovementSpeedDecrease(int nPercentChange);
effect EffectSavingThrowDecrease(int nSave, int nValue, int nSaveType=SAVING_THROW_TYPE_ALL);
effect EffectSkillDecrease(int nSkill, int nValue);

effect EffectSpellResistanceDecrease(int nValue);

int GetPlotFlag(object oTarget=OBJECT_SELF);
void SetPlotFlag(object oTarget, int nPlotFlag);

effect EffectInvisibility( int nInvisibilityType );

effect EffectConcealment( int nPercentage );

effect EffectDarkness();

effect EffectDispelMagicAll(int nCasterLevel);

effect EffectUltravision();

effect EffectNegativeLevel( int nNumLevels );

effect EffectPolymorph(int nPolymorphSelection);

effect EffectSanctuary( int nDifficultyClass );

effect EffectTrueSeeing();

effect EffectSeeInvisible();

effect EffectTimeStop( );

effect EffectBlindness();

int GetIsReactionTypeFriendly(object oTarget, object oSource=OBJECT_SELF);

int GetIsReactionTypeNeutral(object oTarget, object oSource=OBJECT_SELF);

int GetIsReactionTypeHostile(object oTarget, object oSource=OBJECT_SELF);

effect EffectSpellLevelAbsorption(int nMaxSpellLevelAbsorbed, int nTotalSpellLevelsAbsorbed = 0, int nSpellSchool = SPELL_SCHOOL_GENERAL );

effect EffectDispelMagicBest(int nCasterLevel);

void ActivatePortal(object oTarget, string sIPaddress=", string sPassword=", string sWaypointTag=", int bSeemless=FALSE);

int GetNumStackedItems( object oItem );

void SurrenderToEnemies();

effect EffectMissChance( int nPercentage );

int GetTurnResistanceHD(object oUndead=OBJECT_SELF);

int GetCreatureSize( object oCreature );

effect EffectDisappearAppear( location lLocation );

effect EffectDisappear();

effect EffectAppear();

void ActionUnlockObject( object oTarget );

void ActionLockObject( object oTarget );

effect EffectModifyAttacks( int nAttacks );

object GetLastTrapDetected( object oTarget = OBJECT_SELF );

effect EffectDamageShield( int nDamageAmount, int nRandomAmount, int nDamageType );

object GetNearestTrapToObject( object oTarget = OBJECT_SELF, int nTrapDetected = TRUE );

string GetDeity( object oTarget );

string GetSubRace( object oTarget );

int GetFortitudeSavingThrow( object oTarget );

int GetWillSavingThrow( object oTarget );

int GetReflexSavingThrow( object oTarget );

float GetChallengeRating( object oTarget );

int GetAge( object oTarget );

int GetMovementRate( object oTarget );

int GetAnimalCompanionCreatureType( object oTarget );

int GetFamiliarCreatureType( object oTarget );

string GetAnimalCompanionName( object oTarget );

string GetFamiliarName( object oTarget );

void ActionCastFakeSpellAtObject( int nSpellID, object oTarget, int nProjectilePathType = PROJECTILE_PATH_TYPE_DEFAULT );

void ActionCastFakeSpellAtLocation( int nSpellID, location lTarget, int nProjectilePathType = PROJECTILE_PATH_TYPE_DEFAULT );

void RemoveSummonedAssociate(object oMaster, object oAssociate=OBJECT_SELF);

void SetCameraMode( object oPlayer, int nCameraMode );

int GetIsResting(object oCreature=OBJECT_SELF);

object GetLastPCRested();

void SetWeather(object oTarget, int nWeather);

int GetLastRestEventType();

void StartNewModule(string sModuleName);

effect EffectSwarm(int nLooping, string sTemplate1, string sTemplate2=", string sTemplate3=", string sTemplate4=");

int GetWeaponRanged( object oItem );

void DoSinglePlayerAutoSave();

int GetGameDifficulty();

void SetTileMainLightColor( location lTile, int nMainLight1Color, int nMainLight2Color );

void SetTileSourceLightColor( location lTile, int nSourceLight1Color, int nSourceLight2Color );

void RecomputeStaticLighting( object oArea );

int GetTileMainLight1Color( location lTile );

int GetTileMainLight2Color( location lTile );

int GetTileSourceLight1Color( location lTile );

int GetTileSourceLight2Color( location lTile );

void SetPanelButtonFlash( object oPlayer, int nButton, int nEnableFlash );

int GetCurrentAction(object = OBJECT_SELF);

void SetStandardFactionReputation(int nStandardFactionId, int nNewReputation, object oCreature=OBJECT_SELF);

int GetStandardFactionReputation(int nStandardFactionId, object oCreatures=OBJECT_SELF);

void FloatingTextStrRefOnCreature( int nStrRefToFloat, object oCreatureToFloatAbove, int bBroadcastToFaction = TRUE );

void FloatingTextStringOnCreature( string sStringToFloat, object oCreatureToFloatAbove, int bBroadcastToFaction = TRUE );

int GetTrapDisarmable( object oTrapObject );

int GetTrapDetectable( object oTrapObject );

int GetTrapDetectedBy( object oTrapObject, object oCreature );

int GetTrapFlagged( object oTrapObject );

int GetTrapBaseType( object oTrapObject );

int GetTrapOneShot( object oTrapObject );

object GetTrapCreator( object oTrapObject );

string GetTrapKeyTag( object oTrapObject );

int GetTrapDisarmDC( object oTrapObject );

int GetTrapDetectDC( object oTrapObject );

int GetLockKeyRequired( object oObject );

int GetLockKeyTag( object oObject );

int GetLockLockable( object oObject );

int GetLockUnlockDC( object oObject );

int GetLockLockDC( object oObject );

object GetPCLevellingUp();

int GetHasFeatEffect(int FeatId, object oObject=OBJECT_SELF);

void SetPlaceableIllumination( object oPlaceable = OBJECT_SELF, int bIlluminate = TRUE );

int GetPlaceableIllumination( object oPlaceable = OBJECT_SELF );

int GetIsPlaceableObjectActionPossible(object oTargetObject, int nPlaceableAction);

void DoPlaceableObjectAction(object oTargetObject, int nPlaceableAction);

object GetFirstPC();

object GetNextPC();

int SetTrapDetectedBy( object oTrap, object oDetector );

int GetIsTrapped( object oTrap );

effect EffectTurnResistanceDecrease(int nHitDice);

effect EffectTurnResistanceIncrease(int nHitDice);

void PopUpDeathGUIPanel(object oPC, int bRespawnButtonEnabled = TRUE, int bWaitForHelpButtonEnabled = TRUE, int nHelpStringReference = 0, string sHelpString = ");

void SetTrapDisabled( object oTrap );

object GetLastHostileActor(object oVictim=OBJECT_SELF);

void ExportAllCharacters();

Par Daynos le 27/5/2002 à 22:27:38 (#1539355)

//::///////////////////////////////////////////////
//:: Generic Scripting Include
//:: NW_I0_GENERIC
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
********************************************
WARNING THIS SCRIPT IS CHANGED AT YOUR PERIL
********************************************

This is the master generic script and currently
handles all combat and some plot behavior
within NWN. If this script is tampered
with their is a chance of introducing game
breaking bugs. But other than that enjoy.
*/
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Sept 20, 2001
//:://////////////////////////////////////////////

//GENERIC STRUCTURES

struct sEnemies
{
int FIGHTERS;
int FIGHTER_LEVELS;
int CLERICS;
int CLERIC_LEVELS;
int MAGES;
int MAGE_LEVELS;
int MONSTERS;
int MONTERS_LEVELS;
int TOTAL;
int TOTAL_LEVELS;
};

struct sSpellSelect
{
int RANGED;
int MELEE;
object GROUP_TARGET;
object MOB_TARGET;
object MELEE_TOUGHEST;
object TOUGHEST_TARGET;
int ENEMY_HD;
int ALLIED_HD;
};

//Flee and move constants
int NW_GENERIC_FLEE_EXIT_FLEE = 0;
int NW_GENERIC_FLEE_EXIT_RETURN = 1;
int NW_GENERIC_FLEE_TELEPORT_FLEE = 2;
int NW_GENERIC_FLEE_TELEPORT_RETURN = 3;

//Shout constants
int NW_GENERIC_SHOUT_I_WAS_ATTACKED = 1; // NOT USED
int NW_GENERIC_SHOUT_I_AM_DEAD = 12; //IN OnDeath Script
int NW_GENERIC_SHOUT_BACK_UP_NEEDED = 13; //IN TalentMeleeAttacked
int NW_GENERIC_SHOUT_BLOCKER = 2;

//Master Constants
int NW_FLAG_SPECIAL_CONVERSATION = 0x00000001;
int NW_FLAG_SHOUT_ATTACK_MY_TARGET = 0x00000002; //Failed
int NW_FLAG_STEALTH = 0x00000004;
int NW_FLAG_SEARCH = 0x00000008;
int NW_FLAG_SET_WARNINGS = 0x00000010;
int NW_FLAG_ESCAPE_RETURN = 0x00000020; //Failed
int NW_FLAG_ESCAPE_LEAVE = 0x00000040;
int NW_FLAG_TELEPORT_RETURN = 0x00000080; //Failed
int NW_FLAG_TELEPORT_LEAVE = 0x00000100;
int NW_FLAG_PERCIEVE_EVENT = 0x00000200;
int NW_FLAG_ATTACK_EVENT = 0x00000400;
int NW_FLAG_DAMAGED_EVENT = 0x00000800;
int NW_FLAG_SPELL_CAST_AT_EVENT = 0x00001000;
int NW_FLAG_DISTURBED_EVENT = 0x00002000;
int NW_FLAG_END_COMBAT_ROUND_EVENT = 0x00004000;
int NW_FLAG_ON_DIALOGUE_EVENT = 0x00008000;
int NW_FLAG_RESTED_EVENT = 0x00010000;
int NW_FLAG_DEATH_EVENT = 0x00020000;
int NW_FLAG_SPECIAL_COMBAT_CONVERSATION = 0x00040000;
int NW_FLAG_AMBIENT_ANIMATIONS = 0x00080000;
int NW_FLAG_HEARTBEAT_EVENT = 0x00100000;
int NW_FLAG_IMMOBILE_AMBIENT_ANIMATIONS = 0x00200000;
int NW_FLAG_DAY_NIGHT_POSTING = 0x00400000;
int NW_FLAG_AMBIENT_ANIMATIONS_AVIAN = 0x00800000;
int NW_FLAG_APPEAR_SPAWN_IN_ANIMATION = 0x01000000;
int NW_FLAG_SLEEPING_AT_NIGHT = 0x02000000;
int NW_FLAG_FAST_BUFF_ENEMY = 0x04000000;

//Behavior Constants
int NW_FLAG_BEHAVIOR_SPECIAL = 0x00000001;
int NW_FLAG_BEHAVIOR_CARNIVORE = 0x00000002; //Will always attack regardless of faction
int NW_FLAG_BEHAVIOR_OMNIVORE = 0x00000004; //Will only attack if approached
int NW_FLAG_BEHAVIOR_HERBIVORE = 0x00000008; //Will never attack. Will alway flee.

//Talent Type Constants
int NW_TALENT_PROTECT = 1;
int NW_TALENT_ENHANCE = 2;

//PRIVATE FUNCTION DECLARATIONS
int GetHasEffect(int nEffectType, object oTarget = OBJECT_SELF);
int GetCharacterLevel(object oTarget);
int GetIsLocationValid(location lLocal); //HACKY Should be removed
int CheckFriendlyFireOnTarget(object oTarget, float fDistance = 5.0);
int CheckEnemyGroupingOnTarget(object oTarget, float fDistance = 5.0);
int CheckCastRadiusDanger(object oTarget, float fDistance);
object FindSingleRangedTarget();
int GetNumberOfMeleeAttackers();
int GetNumberOfRangedAttackers();
float GetPercentageHPLoss(object oWounded);
int GetHealingCR(object oWounded);
int GetRacialTypeCount(int nRacial_Type);
object GetNearestSeenOrHeardEnemy();
void PlaySingleBattleCry();
void SetLastGenericSpellCast(int nSpell);
int GetLastGenericSpellCast();
int CompareLastSpellCast(int nSpell);
void RemoveAmbientSleep();
int GetIsFighting(object oFighting);
object GetLockedObject(object oMaster);
void EquipAppropriateWeapons(object oTarget);
void ResetHenchmenState();
int AssociateCheck(object oCheck);

//DETERMINE COMBAT ROUND SUB FUNCTIONS
int BashDoorCheck(object oIntruder = OBJECT_INVALID);
int DetermineClassToUse();
struct sEnemies DetermineEnemies();
string GetMostDangeriousClass(struct sEnemies sCount);
int GetMatchCompatibility(talent tUse, string sClass, int nType);
int MatchCombatProtections(talent tUse);
int MatchSpellProtections(talent tUse);
int MatchElementalProtections(talent tUse);
talent StartProtectionLoop();
int GetAttackCompatibility(talent tUse, int nClass);
int MatchReflexAttacks(talent tUse);
int MatchFortAttacks(talent tUse);
object GetRangedAttackGroup(int bAllowFriendlyFire = FALSE);
object GetToughestMeleeAttacker();
object GetToughestAttacker();
struct sSpellSelect AnalyzeCombatSituation();
int GetAlliedHD();
int GetEnemyHD();
talent StartAttackLoop();
int VerifyDisarm(talent tUse, object oTarget);
int UniversalSpellMatch(talent tUse);

//CURRENT TALENT FUNCTIONS
int TalentUseProtectionOnSelf();
int TalentUseProtectionOthers();
int TalentEnhanceOthers();
int TalentUseEnhancementOnSelf();
int TalentMeleeAttacked(object oIntruder = OBJECT_INVALID);
int TalentRangedAttackers(object oIntruder = OBJECT_INVALID);
int TalentRangedEnemies(object oIntruder = OBJECT_INVALID);
int TalentSummonAllies();
int TalentHealingSelf(); //Use spells and potions
int TalentHeal(); //User spells only
int TalentMeleeAttack(object oIntruder = OBJECT_INVALID);
int TalentSneakAttack();
int TalentFlee(object oIntruder = OBJECT_INVALID);
int TalentUseTurning();
int TalentPersistantAbilities();
int TalentAdvancedBuff(float fDistance);
int TalentBuffSelf(); //Used for Potions of Enhancement and Protection
int TalentSeeInvisible();
int TalentCureCondition();
int TalentDragonCombat(object oIntruder = OBJECT_INVALID);
int TalentBardSong();
int TalentAdvancedProtectSelf();
int TalentAdvancedSpellAttack(object oIntruder = OBJECT_INVALID);

//CORE AI FUNCTIONS
void DetermineCombatRound(object oIntruder = OBJECT_INVALID, int nAI_Difficulty = 10);
void SetListeningPatterns();
void RespondToShout(object oShouter, int nShoutIndex, object oIntruder = OBJECT_INVALID);
void RunCircuit(int nTens, int nNum, int nRun = FALSE, float fPause = 1.0);
void WalkWayPoints(int nRun = FALSE, float fPause = 1.0);
void RunNextCircuit(int nRun = FALSE, float fPause = 1.0);
int CheckWayPoints(object oWalker = OBJECT_SELF);

//PLOT FUNCTIONS
void SetNPCWarningStatus(int nStatus = TRUE);
int GetNPCWarningStatus();
void SetSummonHelpIfAttacked();
void CreateSignPostNPC(string sTag, location lLocal);
void ActivateFleeToExit();
int GetFleeToExit();

//MASTER LOCAL FUNCTIONS
void SetSpawnInCondition(int nCondition, int bValid = TRUE);
int GetSpawnInCondition(int nCondition);
void SetSpawnInLocals(int nCondition);

//ASSOCIATE MASTER VARIABLE FUNCTIONS
void SetAssociateState(int nCondition, int bValid = TRUE);
int GetAssociateState(int nCondition);

//ASSOCIATE FUNCTIONS
int GetAssociateCRMax();
int GetAssociateHealMaster();
float GetFollowDistance();
void CheckIsUnlocked(object oLastObject);
void SetAssociateStartLocation();
location GetAssociateStartLocation();

//AMBIENT ANIMATION COMMANDS
void PlayMobileAmbientAnimations();
void PlayImmobileAmbientAnimations();

//BEHAVIOR LOCAL FUNCTIONS
void SetBehaviorState(int nCondition, int bValid = TRUE);
int GetBehaviorState(int nCondition);
void DetermineSpecialBehavior(object oIntruder = OBJECT_INVALID);

Par Daynos le 27/5/2002 à 22:29:03 (#1539361)

//::///////////////////////////////////////////////
//:: Master Local Get and Set
//:: FileName
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
All On Spawn in conditions in the game are now
being stored within one local. The get and set
changed or checks the condition of this one
Hex local. The NW_FLAG_XXX variables above
allow for the user of these functions throughout
the generic scripts.
*/
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Nov 14, 2001
//:://////////////////////////////////////////////

void SetSpawnInCondition(int nCondition, int bValid = TRUE)
{
int nPlot = GetLocalInt(OBJECT_SELF, "NW_GENERIC_MASTER");
if(bValid == TRUE)
{
nPlot = nPlot | nCondition;
SetSpawnInLocals(nCondition);
SetLocalInt(OBJECT_SELF, "NW_GENERIC_MASTER", nPlot);
}
else if (bValid == FALSE)
{
nPlot = nPlot & ~nCondition;
SetLocalInt(OBJECT_SELF, "NW_GENERIC_MASTER", nPlot);
}
}

int GetSpawnInCondition(int nCondition)
{
int nPlot = GetLocalInt(OBJECT_SELF, "NW_GENERIC_MASTER");
if(nPlot & nCondition)
{
return TRUE;
}
return FALSE;
}

void SetSpawnInLocals(int nCondition)
{
if(nCondition == NW_FLAG_SHOUT_ATTACK_MY_TARGET)
{
SetListenPattern(OBJECT_SELF, "NW_ATTACK_MY_TARGET", 5);
}
else if(nCondition == NW_FLAG_ESCAPE_RETURN)
{
SetLocalLocation(OBJECT_SELF, "NW_GENERIC_START_POINT", GetLocation(OBJECT_SELF));
}
else if(nCondition == NW_FLAG_TELEPORT_LEAVE)
{
SetLocalLocation(OBJECT_SELF, "NW_GENERIC_START_POINT", GetLocation(OBJECT_SELF));
}
}

//::///////////////////////////////////////////////
//:: DetermineCombatRound
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
This function is the master function for the
generic include and is called from the main
script. This function is used in lieu of
any actual scripting.
*/
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Oct 16, 2001
//:://////////////////////////////////////////////

void DetermineCombatRound(object oIntruder = OBJECT_INVALID, int nAI_Difficulty = 10)
{
if(GetAssociateState(NW_ASC_IS_BUSY))
{
return;
}
if(BashDoorCheck(oIntruder)) {return;}
int nClass = DetermineClassToUse();

//This check is to see if the master is being attacked and in need of help

if(GetAssociateState(NW_ASC_HAVE_MASTER))
{
if(GetAssociateState(NW_ASC_MODE_DEFEND_MASTER))
{
oIntruder = GetLastAttacker(GetMaster());
if(!GetIsObjectValid(oIntruder))
{
oIntruder = GetGoingToBeAttackedBy(GetMaster());
if(!GetIsObjectValid(oIntruder))
{
oIntruder = GetLastAttacker();
if(!GetIsObjectValid(oIntruder))
{
return;
}
else if(!GetIsEnemy(oIntruder))
{
oIntruder = OBJECT_INVALID;
}
}
}
}
}
if(GetIsObjectValid(GetMaster()))
{
if(GetDistanceToObject(GetMaster()) > 15.0)
{
if(GetCurrentAction(GetMaster()) != ACTION_FOLLOW)
{
ClearAllActions();
//ActionAttack(OBJECT_INVALID);
ActionForceFollowObject(GetMaster(), GetFollowDistance());
//ActionForceMoveToObject(GetMaster(), TRUE, GetFollowDistance(), 5.0);
return;
}
}
}

int nOffense = d100();

if(GetIsObjectValid(oIntruder) ||
GetIsObjectValid(GetNearestCreature(CREATURE_TYPE_REPUTATION, REPUTATION_TYPE_ENEMY, OBJECT_SELF, 1, CREATURE_TYPE_PERCEPTION, PERCEPTION_SEEN)) ||
(GetIsObjectValid(oIntruder) && GetIsObjectValid(GetMaster())))
{
int nAlignment = GetAlignmentGoodEvil(OBJECT_SELF);
//AM I AN ARCANE SPELLCASTER?
if(nClass == CLASS_TYPE_WIZARD || nClass == CLASS_TYPE_SORCERER || nClass == CLASS_TYPE_BARD)
{
if(TalentAdvancedProtectSelf()){return;} //******************************************//

if(nClass == CLASS_TYPE_BARD)
{
if(TalentBardSong()) {return;}
}
//Use healing potions to not die
if(TalentHealingSelf()) {return;}

//Use a defensive talent fire then offensive if that fails
if(nOffense > 75)
{
//Use protections on Self
if(TalentUseProtectionOnSelf()) {return;}
//Use protection on allies
if(TalentUseProtectionOthers()) {return;}
//Check if the character can enhance themselves
if(TalentUseEnhancementOnSelf()) {return;}
//Use Enhancements on the part
if(TalentEnhanceOthers()) {return;}
//Use advanced spell search
if(TalentAdvancedSpellAttack()){return;} //******************************************//
//Check for Personal Attackers
if(TalentMeleeAttacked(oIntruder)) {return;}
//Check for Ranged Attackers
if(TalentRangedAttackers(oIntruder)) {return;}
//Check for Ranged Enemies
if(TalentRangedEnemies(oIntruder)) {return;}
//Check for Allies
if(TalentSummonAllies()) {return;}
//Attack if out of spells
if(TalentMeleeAttack(oIntruder)) {return;}
}
else //Use a offensive talent only
{
if(TalentAdvancedSpellAttack()){return;} //******************************************//
//Check for Personal Attackers
if(TalentMeleeAttacked(oIntruder)) {return;}
//Check for Ranged Attackers
if(TalentRangedAttackers(oIntruder)) {return;}
//Check for Ranged Enemies
if(TalentRangedEnemies(oIntruder)) {return;}
//Summon Allies
if(TalentSummonAllies()) {return;}
//Attack if out of spells
if(TalentMeleeAttack(oIntruder)) {return;}
}
return;
}
else if(nClass == CLASS_TYPE_CLERIC || nClass == CLASS_TYPE_DRUID)
{
//Cast spells specific to the main enemy I am facing.
if(TalentAdvancedProtectSelf()) {return;} //******************************************//
//Remove negative effects from allies
if(TalentCureCondition()) {return;}
//Turning check
if(TalentUseTurning()) {return;}
//Check if allies or self are injured
if(TalentHeal()) {return;}
//Use healing potions to not die
if(TalentHealingSelf()) {return;}

if(nOffense > 75)
{
if(GetPercentageHPLoss(OBJECT_SELF) 1)
{
if(TalentAdvancedSpellAttack()){return;} //******************************************//
if(TalentMeleeAttacked(oIntruder)) {return;}
if(TalentMeleeAttack(oIntruder)) {return;}
}
else if(GetNumberOfMeleeAttackers() == 1)
{

if(TalentMeleeAttack(oIntruder)) {return;}
}
else
{
//Check if the character can enhance themselves
if(TalentUseEnhancementOnSelf()) {return;}
// Check for enhancements on party
if(TalentEnhanceOthers()) {return;}
//Cast general protection on self
if(TalentUseProtectionOnSelf()) {return;}
//Check for Allies
if(TalentUseProtectionOthers()) {return;}
//Check for Allies
if(TalentSummonAllies()) {return;}
//Check for Personal Attackers
if(Random(101) > 75)
{
if(TalentAdvancedSpellAttack()){return;} //******************************************//
if(TalentMeleeAttacked(oIntruder)) {return;}
}
//Check for Ranged Attackers
if(TalentRangedAttackers(oIntruder)) {return;}
//Check for Ranged Enemies
if(TalentRangedEnemies(oIntruder)) {return;}
//Attack if out of spells
if(TalentMeleeAttack(oIntruder)) {return;}
}
}
else
{
//Cast Summon Spells
if(TalentSummonAllies()) {return;}
//Check for Personal Attackers
if(TalentMeleeAttacked(oIntruder)) {return;}
//Check for Ranged Attackers
if(TalentRangedAttackers(oIntruder)) {return;}
//Check for Ranged Enemies
if(TalentRangedEnemies(oIntruder)) {return;}
//Attack if out of spells
if(TalentMeleeAttack(oIntruder)) {return;}
}
return;
}
else if(nClass == CLASS_TYPE_FIGHTER ||
nClass == CLASS_TYPE_ROGUE ||
nClass == CLASS_TYPE_PALADIN ||
nClass == CLASS_TYPE_RANGER ||
nClass == CLASS_TYPE_MONK ||
nClass == CLASS_TYPE_BARBARIAN)
{
//Use healing potions to not die
if(TalentHealingSelf()) {return;}
//Use potions of enhancement and protection
if(TalentBuffSelf()) {return;}
//Check if the character can enhance themselves
if(TalentUseEnhancementOnSelf()) {return;}
//Check for Paladins who can turn undead
if(TalentUseTurning()) {return;}
//Sneak Attack Flanking attack
if(TalentSneakAttack()) {return;}
//Use melee skills and feats
if(TalentMeleeAttack(oIntruder)) {return;}
return;
}
else if(nClass == CLASS_TYPE_COMMONER)
{
if(TalentFlee(oIntruder)) {return;}
return;
}
else if(nClass == CLASS_TYPE_UNDEAD)
{
//SpeakString("Determining Combat Round Undead");
if(TalentPersistantAbilities()) {return;}
if(nOffense > 75)
{
//Check if the character can enhance themselves
if(TalentUseEnhancementOnSelf()) {return;}
// Check for enhancements on party
if(TalentEnhanceOthers()) {return;}
//Use protections on Self
if(TalentUseProtectionOnSelf()) {return;}
//Check for Allies
if(TalentUseProtectionOthers()) {return;}
//Check for Allies
if(TalentSummonAllies()) {return;}
//Check for Personal Attackers
if(TalentMeleeAttacked(oIntruder)) {return;}
//Check for Ranged Attackers
if(TalentRangedAttackers(oIntruder)) {return;}
//Check for Ranged Enemies
if(TalentRangedEnemies(oIntruder)) {return;}
//Attack if out of spells
if(TalentMeleeAttack(oIntruder)) {return;}
}
else
{
if(TalentSummonAllies()) {return;}
//Check for Personal Attackers
if(TalentMeleeAttacked(oIntruder)) {return;}
//Check for Ranged Attackers
if(TalentRangedAttackers(oIntruder)) {return;}
//Check for Ranged Enemies
if(TalentRangedEnemies(oIntruder)) {return;}
//Attack if out of spells
if(TalentMeleeAttack(oIntruder)) {return;}
}
return;
}
else if(nClass == CLASS_TYPE_DRAGON)
{
//Use healing potions to not die
if(TalentHealingSelf()) {return;}
if(d100() 75)
{
if(TalentAdvancedProtectSelf()){return;}
//Check if the character can enhance themselves
if(TalentUseEnhancementOnSelf()) {return;}
// Check for enhancements on party
if(TalentEnhanceOthers()) {return;}
//Use protections on Self
if(TalentUseProtectionOnSelf()) {return;}
//Check for Allies
if(TalentUseProtectionOthers()) {return;}
//Check for Allies
if(TalentSummonAllies()) {return;}
//Check for Personal Attackers
if(TalentMeleeAttacked(oIntruder)) {return;}
//Check for Ranged Attackers
if(TalentRangedAttackers(oIntruder)) {return;}
//Check for Ranged Enemies
if(TalentRangedEnemies(oIntruder)) {return;}
//Attack if out of spells
if(TalentMeleeAttack(oIntruder)) {return;}
}
else
{
if(TalentAdvancedSpellAttack()){return;} //******************************************//
if(TalentSummonAllies()) {return;}
//Check for Personal Attackers
if(TalentMeleeAttacked(oIntruder)) {return;}
//Check for Ranged Attackers
if(TalentRangedAttackers(oIntruder)) {return;}
//Check for Ranged Enemies
if(TalentRangedEnemies(oIntruder)) {return;}
//Attack if out of spells
if(TalentMeleeAttack(oIntruder)) {return;}
}
return;
}
}
//This check is to make sure that people do not drop out of combat before they are supposed to.
object oTarget = GetNearestCreature(CREATURE_TYPE_REPUTATION, REPUTATION_TYPE_ENEMY, OBJECT_SELF, 1, CREATURE_TYPE_PERCEPTION, PERCEPTION_SEEN);
if(GetIsObjectValid(oTarget))
{
SpeakString("Danger Will Robinson Danger");
DetermineCombatRound(oTarget);
return;
}
//This is a call to the function which determines which way point to go back to.
ClearAllActions();
WalkWayPoints();
}

Par Daynos le 27/5/2002 à 22:30:39 (#1539373)

//::///////////////////////////////////////////////
//:: SetListeningPatterns
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
Sets the correct listen checks on the NPC by
determining what talents they possess or what
class they use.

This is also a good place to set up all of
the sleep and appear disappear animations for
various models.
*/
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Oct 24, 2001
//:://////////////////////////////////////////////

void SetListeningPatterns()
{
//There is a 70% chance to make someone sleep if it is night.
//If they have no way points to walk.
if(GetIsNight() && !CheckWayPoints())
{
if(GetSpawnInCondition(NW_FLAG_SLEEPING_AT_NIGHT))
{
if(d10() 0)
{
SetListenPattern(OBJECT_SELF, "NW_MOB_ATTACK", 2);
}
SetListenPattern(OBJECT_SELF, "NW_I_AM_DEAD", 3);

//Set a custom listening pattern for the creature so that placables with
//"NW_BLOCKER" + Blocker NPC Tag will correctly call to their blockers.
string sBlocker = "NW_BLOCKER_BLK_" + GetTag(OBJECT_SELF);
SetListenPattern(OBJECT_SELF, sBlocker, 4);
SetListenPattern(OBJECT_SELF, "NW_CALL_TO_ARMS", 6);
}

//::///////////////////////////////////////////////
//:: Respond To Shouts
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
Allows the listener to react in a manner
consistant with the given shout but only to one
combat shout per round
*/
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Oct 25, 2001
//:://////////////////////////////////////////////

//NOTE ABOUT COMMONERS
/*
Commoners are universal cowards. If you attack anyone they will flee for 4 seconds away from the attacker.
However to make the commoners into a mob, make a single commoner at least 10th level of the same faction.
If that higher level commoner is attacked or killed then the commoners will attack the attacker. They will disperse again
after some of them are killed. Should NOT make multi-class creatures using commoners.
*/
//NOTE ABOUT BLOCKERS
/*
It should be noted that the Generic Script for On Dialogue attempts to get a local set on the shouter by itself.
This object represents the LastOpenedBy object. It is this object that becomes the oIntruder within this function.
*/

//NOTE ABOUT INTRUDERS
/*
The intruder object is for cases where a placable needs to pass a LastOpenedBy Object or a AttackMyAttacker
needs to make his attacker the enemy of everyone.
*/

void RespondToShout(object oShouter, int nShoutIndex, object oIntruder = OBJECT_INVALID)
{
switch (nShoutIndex)
{
case 1://NW_GENERIC_SHOUT_I_WAS_ATTACKED:
{
object oTarget = oIntruder;
if(!GetIsObjectValid(oTarget))
{
oTarget = GetLastAttacker(oShouter);
}
if(!GetBehaviorState(NW_FLAG_BEHAVIOR_SPECIAL))
{
if(!GetLevelByClass(CLASS_TYPE_COMMONER))
{
if(!GetIsObjectValid(GetAttemptedAttackTarget()) && !GetIsObjectValid(GetAttemptedSpellTarget()))
{
if(GetIsObjectValid(oTarget))
{
if(!GetIsFriend(oTarget) && GetIsFriend(oShouter))
{
RemoveAmbientSleep();
DetermineCombatRound(oTarget);
}
}
/*
if(GetIsObjectValid(GetLastAttacker(oShouter)))
{
if(!GetIsFriend(GetLastAttacker(oShouter)) && GetIsFriend(oShouter))
{
RemoveAmbientSleep();
DetermineCombatRound(GetLastAttacker(oShouter));
}
}
*/
}
}
else if (GetLevelByClass(CLASS_TYPE_COMMONER, oShouter) >= 10)
{
ActionAttack(GetLastAttacker(oShouter));
}
else
{
DetermineCombatRound(oIntruder);
}
}
else
{
DetermineSpecialBehavior();
}
}
break;

case 2://NW_GENERIC_SHOUT_MOB_ATTACK:
{
if(!GetBehaviorState(NW_FLAG_BEHAVIOR_SPECIAL))
{

//Is friendly check to make sure that only like minded commoners attack.
if(GetIsFriend(oShouter))
{
ActionAttack(GetLastAttacker(oShouter));
}
//if(TalentMeleeAttack()) {return;}
}
else
{
DetermineSpecialBehavior();
}
}
break;

case 3://NW_GENERIC_SHOUT_I_AM_DEAD:
{
if(!GetBehaviorState(NW_FLAG_BEHAVIOR_SPECIAL))
{
//Use I was attacked script above
if(!GetLevelByClass(CLASS_TYPE_COMMONER))
{
if(!GetIsObjectValid(GetAttemptedAttackTarget()) && !GetIsObjectValid(GetAttemptedSpellTarget()))
{
if(GetIsObjectValid(GetLastAttacker(oShouter)))
{
if(!GetIsFriend(GetLastAttacker(oShouter)) && GetIsFriend(oShouter))
{
DetermineCombatRound(GetLastAttacker(oShouter));
}
}
}
}
else if (GetLevelByClass(CLASS_TYPE_COMMONER, oShouter) >= 10)
{
ActionAttack(GetLastAttacker(oShouter));
}
else
{
DetermineCombatRound();
}

}
else
{
DetermineSpecialBehavior();
}
}
break;
//For this shout to work the object must shout the following
//string sHelp = "NW_BLOCKER_BLK_" + GetTag(OBJECT_SELF);
case 4: //BLOCKER OBJECT HAS BEEN DISTURBED
{
if(!GetLevelByClass(CLASS_TYPE_COMMONER))
{
if(!GetIsObjectValid(GetAttemptedAttackTarget()) && !GetIsObjectValid(GetAttemptedSpellTarget()))
{
if(GetIsObjectValid(oIntruder))
{
SetIsTemporaryEnemy(oIntruder);
DetermineCombatRound(oIntruder);
}
}
}
else if (GetLevelByClass(CLASS_TYPE_COMMONER, oShouter) >= 10)
{
ActionAttack(oIntruder);
}
else
{
DetermineCombatRound();
}
}
break;

case 5: //ATTACK MY TARGET
{
AdjustReputation(oIntruder, OBJECT_SELF, -100);
if(GetIsFriend(oShouter))
{
SetIsTemporaryEnemy(oIntruder);
ClearAllActions();
DetermineCombatRound(oIntruder);
}
}
break;

case 6: //CALL_TO_ARMS
{
//This was once commented out.
DetermineCombatRound();
}
break;

//ASSOCIATE SHOUT RESPONSES ******************************************************************************

case ASSOCIATE_COMMAND_ATTACKNEAREST: //Used to de-activate AGGRESSIVE DEFEND MODE
{
ResetHenchmenState();
SetAssociateState(NW_ASC_MODE_DEFEND_MASTER, FALSE);
SetAssociateState(NW_ASC_MODE_STAND_GROUND, FALSE);
PlaySingleBattleCry();
DetermineCombatRound();
}
break;

case ASSOCIATE_COMMAND_FOLLOWMASTER: //Only used to retreat, or break free from Stand Ground Mode
{
ResetHenchmenState();
SetAssociateState(NW_ASC_MODE_STAND_GROUND, FALSE);
PlayVoiceChat(VOICE_CHAT_CANDO);

if(GetAssociateState(NW_ASC_AGGRESSIVE_STEALTH))
{
ActionUseSkill(SKILL_HIDE, OBJECT_SELF);
//ActionUseSkill(SKILL_MOVE_SILENTLY,OBJECT_SELF);
}
if(GetAssociateState(NW_ASC_AGGRESSIVE_SEARCH))
{
ActionUseSkill(SKILL_SEARCH, OBJECT_SELF);
}
ActionForceFollowObject(GetMaster(), GetFollowDistance());
SetAssociateState(NW_ASC_IS_BUSY);
DelayCommand(5.0, SetAssociateState(NW_ASC_IS_BUSY, FALSE));
//SetCommandable(FALSE);
//DelayCommand(5.0, SetCommandable(TRUE));
}
break;

case ASSOCIATE_COMMAND_GUARDMASTER: //Used to activate AGGRESSIVE DEFEND MODE
{
ResetHenchmenState();
//Companions will only attack the Masters Last Attacker
SetAssociateState(NW_ASC_MODE_DEFEND_MASTER);
SetAssociateState(NW_ASC_MODE_STAND_GROUND, FALSE);
PlayVoiceChat(VOICE_CHAT_CANDO);
DetermineCombatRound(GetLastAttacker(GetMaster()));
}
break;

case ASSOCIATE_COMMAND_HEALMASTER: //Ignore current healing settings and heal me now
{
ResetHenchmenState();
//SetCommandable(TRUE);
if(TalentCureCondition()) {PlayVoiceChat(VOICE_CHAT_CANDO); return;}
if(TalentHeal()) {PlayVoiceChat(VOICE_CHAT_CANDO); return;}
PlayVoiceChat(VOICE_CHAT_CANTDO);
}
break;

case ASSOCIATE_COMMAND_MASTERFAILEDLOCKPICK: //Check local for Re-try locked doors and
{
if(!GetAssociateState(NW_ASC_MODE_STAND_GROUND))
{
if(GetAssociateState(NW_ASC_RETRY_OPEN_LOCKS))
{
int bValid = TRUE;
object oLastObject = GetLockedObject(GetMaster());
//SpeakString(IntToString(GetIsObjectValid(oLastObject)));
if(GetIsObjectValid(oLastObject))
{
//int nLockDC = GetLockUnlockDC(oLastObject);
//int nSkill = GetSkillRank(SKILL_OPEN_LOCK) - GetAbilityModifier(ABILITY_DEXTERITY);

if(GetIsDoorActionPossible(oLastObject, DOOR_ACTION_KNOCK) || GetIsPlaceableObjectActionPossible(oLastObject, PLACEABLE_ACTION_KNOCK))
{
ClearAllActions();
ActionCastSpellAtObject(SPELL_KNOCK, oLastObject);
ActionWait(1.0);
bValid = FALSE;
}
/*((nSkill + 20) > nLockDC) &&*/
else if (GetIsDoorActionPossible(oLastObject, DOOR_ACTION_UNLOCK)|| GetIsPlaceableObjectActionPossible(oLastObject, PLACEABLE_ACTION_UNLOCK))
{
ClearAllActions();
ActionWait(1.0);
ActionUseSkill(SKILL_OPEN_LOCK,oLastObject);
bValid = FALSE;

}
else if(GetAbilityScore(OBJECT_SELF, ABILITY_STRENGTH) >= 16)
{
if(GetIsDoorActionPossible(oLastObject, DOOR_ACTION_BASH) || GetIsPlaceableObjectActionPossible(oLastObject, PLACEABLE_ACTION_BASH))
{
//SpeakString(IntToString(GetIsDoorActionPossible(oLastObject, DOOR_ACTION_BASH)));
//SpeakString(IntToString(GetIsDoorActionPossible(oLastObject, PLACEABLE_ACTION_BASH)));
ClearAllActions();
ActionEquipMostDamagingMelee(oLastObject);
ActionAttack(oLastObject);
SetLocalObject(OBJECT_SELF, "NW_GENERIC_DOOR_TO_BASH", oLastObject);
bValid = FALSE;
}
}
}
if(bValid == TRUE)
{
PlayVoiceChat(VOICE_CHAT_CANTDO);
}
else
{
ActionDoCommand(CheckIsUnlocked(oLastObject));
}
}
}
}
break;

case ASSOCIATE_COMMAND_MASTERUNDERATTACK: //Check whether the master has you in AGGRESSIVE DEFEND MORE
{
if(!GetAssociateState(NW_ASC_MODE_STAND_GROUND))
{
if(!GetIsFighting(OBJECT_SELF))
{
if(GetAssociateState(NW_ASC_MODE_DEFEND_MASTER))
{
PlayVoiceChat(VOICE_CHAT_CANDO);
DetermineCombatRound(GetLastAttacker(GetMaster()));
}
else
{
PlayVoiceChat(VOICE_CHAT_CANDO);
DetermineCombatRound();
}
}
}
}
break;

case ASSOCIATE_COMMAND_STANDGROUND: //No longer follow the master or guard him
{
SetAssociateState(NW_ASC_MODE_STAND_GROUND);
SetAssociateState(NW_ASC_MODE_DEFEND_MASTER, FALSE);
PlayVoiceChat(VOICE_CHAT_CANDO);
ActionAttack(OBJECT_INVALID);
ClearAllActions();
}
break;

case ASSOCIATE_COMMAND_MASTERSAWTRAP:
{
if(!GetAssociateState(NW_ASC_MODE_STAND_GROUND))
{
object oTrap = GetLastTrapDetected();
if(GetIsObjectValid(oTrap))
{
int nTrapDC = GetTrapDisarmDC(oTrap);
int nSkill = GetSkillRank(SKILL_DISABLE_TRAP);
nSkill = nSkill + 20 - nTrapDC;

if(GetCurrentAction(OBJECT_SELF) != ACTION_DISABLETRAP && nSkill > 0)
{
PlayVoiceChat(VOICE_CHAT_STOP);
if(GetHasSkill(SKILL_DISABLE_TRAP, OBJECT_SELF))
{
ClearAllActions();
ActionUseSkill(SKILL_DISABLE_TRAP, oTrap);
SetCommandable(FALSE);
ActionDoCommand(SetCommandable(TRUE));
PlayVoiceChat(VOICE_CHAT_TASKCOMPLETE);
}
}
}
}
}
break;

case ASSOCIATE_COMMAND_MASTERATTACKEDOTHER:
{
if(!GetAssociateState(NW_ASC_MODE_STAND_GROUND))
{
if(!GetAssociateState(NW_ASC_MODE_DEFEND_MASTER))
{
if(!GetIsFighting(OBJECT_SELF))
{
PlayVoiceChat(VOICE_CHAT_ENEMIES);
object oAttack = GetAttackTarget(GetMaster());
if(GetIsObjectValid(oAttack))
{
ClearAllActions();
DetermineCombatRound(oAttack);
}
}
}
}
}
break;

case ASSOCIATE_COMMAND_MASTERGOINGTOBEATTACKED:
{
if(!GetAssociateState(NW_ASC_MODE_STAND_GROUND))
{
if(!GetIsFighting(OBJECT_SELF))
{
object oAttacker = GetGoingToBeAttackedBy(GetMaster());
if(GetIsObjectValid(oAttacker))
{
ClearAllActions();
PlayVoiceChat(VOICE_CHAT_ENEMIES);
DetermineCombatRound(oAttacker);
}
}
}
}
break;

case ASSOCIATE_COMMAND_LEAVEPARTY:
{
object oMaster = GetMaster();
if(GetIsObjectValid(oMaster))
{
ClearAllActions();
if(GetAssociate(ASSOCIATE_TYPE_HENCHMAN, GetMaster()) == OBJECT_SELF)
{
AddJournalQuestEntry("Henchman",50,GetMaster(),FALSE,FALSE,TRUE);
}
SetLocalObject(OBJECT_SELF,"NW_L_FORMERMASTER", oMaster);
RemoveHenchman(oMaster, OBJECT_SELF);
}
}
break;
}
}

Par Daynos le 27/5/2002 à 22:33:48 (#1539394)

Mouef... Ca prend beaucoup plus de place que prévu... (j'en suis à peine au quart...)

J'étais en train de mettre tout ça dans le but de décoder les fonctions de base, afin de mieux comprendre leur fonctionnement et ainsi la façon de les utiliser mais je crois qu'il ne va pas être pratique de tout faire ici... Va falloir s'organiser différemment je suppose...

Par ß®|Tñamp;ÿ le 28/5/2002 à 13:11:21 (#1542463)

C'est très interessant... Une page sur le site? :)

Par Daynos le 28/5/2002 à 14:32:46 (#1542874)

Provient du message de ß®|Tñ&ÿ :
C'est très interessant... Une page sur le site? :)

Je crois que je me limiterai au fichier en DL. Ceci dit, il se trouve avec l'éditeur. Il n'y a qu'à utiliser un petit utilitaire pour décompresser les ".bif" et hop, ça s'ouvre dans un éditeur de texte...

PS : il se prononce comment ton pseudo ? :confus:

Par Estheral le 28/5/2002 à 14:48:43 (#1542970)

Je comprends po tout. Au début ca ressemble a un listing des fonctions de l'éditeur, et apres c'est des exemples, ou tous les progs utiles au jeu?
Un peu d'explications supplémentaires auraient étés les bienvenues.....
Merci, et escusez mes ignorances (2eme année IUT GEII, et po tres bon en prog)

Explications

Par KulzZer le 28/5/2002 à 18:37:04 (#1544323)

Heu j'aimerais savoir si il y a un site, qu'il soit français ou anglais, je m'en fous, qui explique à quoi servent toutes ces fonctions (et si possible les constantes). :confus:

Par ß®|Tñamp;ÿ le 28/5/2002 à 19:00:40 (#1544482)

Provient du message de Daynos :
Je crois que je me limiterai au fichier en DL. Ceci dit, il se trouve avec l'éditeur. Il n'y a qu'à utiliser un petit utilitaire pour décompresser les ".bif" et hop, ça s'ouvre dans un éditeur de texte...

Ah voui je viens de le trouver :)

Provient du message de Daynos :
PS : il se prononce comment ton pseudo ? :confus:

Ca se prononce Kray-qui-a-perdu-un-pari-à-la-con :)

Provient du message de Estheral :
Je comprends po tout. Au début ca ressemble a un listing des fonctions de l'éditeur, et apres c'est des exemples, ou tous les progs utiles au jeu?

Faut avoir quelques bases en C++ quand même... Le "listing" comme tu dis, c'est la déclaration des fonctions, et ensuite, c'est le remplissage des fonctions... ;)

Provient du message de Estheral :
(2eme année IUT GEII, et po tres bon en prog)

C'est juste une histoire d'interet... Lit des bouquins, visite des sites, entraine-toi, c'est pas une histoire de cours la programmation! :p

Provient du message de KulzZer :
Heu j'aimerais savoir si il y a un site, qu'il soit français ou anglais, je m'en fous, qui explique à quoi servent toutes ces fonctions (et si possible les constantes).

Je crois pas que ca existe déjà... M'enfin si tu trouves ca m'interesse aussi :D.

Par KulzZer le 28/5/2002 à 19:21:40 (#1544655)

wé ça serait cool:D