[Deyonara]

ATTENTION : Pour des raisons de compatibilité, précisées juste ICI, ce post a été édité.


Je passais quelques temps à contempler ce système un peu bancal mais ô combien pratique, que l'on nomme TagBased Scripts, quand soudain... Une lueur... Je me suis souvenue que quelqu'un avait parlé d'une autre manière d'utiliser ce système. (il me semble que c'est Garrath, je ne sais plus trop)

J'ai donc décidé de modifier ce système à ma convenance, en utilisant non plus le module comme support, mais le principal intéressé : Le possesseur de l'item. Les modifications ne sont pas énormes, et je n'ai pas eu autant de travail que la longueur du post pourrait laisser prétendre.


J'ai donc écrit une nouvelle bibliothèque, que je nommerai ici "inc_tagbased", déterminant les nouvelles fonctions ainsi que les constantes :

Code PHP:

const int EVENT_ACTIVATE_ITEM     = 0;
const int EVENT_EQUIP_ITEM        = 1;
const int EVENT_UNEQUIP_ITEM      = 2;
const int EVENT_ONHITCAST_ITEM    = 3;
const int EVENT_ACQUIRE_ITEM      = 4;
const int EVENT_UNACQUIRE_ITEM    = 5;
const int EVENT_SPELLCAST_AT_ITEM = 6;

const int EXECUTE_SCRIPT_CONTINUE = 0;
const int EXECUTE_SCRIPT_END      = 1; 

Je me suis basée sur quelques fonctions déjà existantes, comme "ExecuteScriptAndReturnInt()", puis ai arrangé la sauce selon mes besoin :

Code PHP:

// Cette fonction au nom barbare est désormais
// la seule dont je me sers pour activer l'évènement concerné.
int FireItemEventAndReturnValue(int nEvent, object oItem, object oTarget);

// L'original est à peine modifié pour pouvoir l'utiliser sur tout objet.
int GetUserDefinedEventType(object oTarget=OBJECT_SELF);

// Absolument pas nécessaire du tout, cette fonction me permet de faire
// un script lisible, en retrouvant l'Item concerné par l'évènement.
object GetUserDefinedEventItem(object oTarget=OBJECT_SELF);

// L'original est à peine modifié pour pouvoir l'utiliser sur tout objet.
void SetExecutedScriptReturnInt(object oTarget=OBJECT_SELF, int nValue=EXECUTE_SCRIPT_END); 

Concernant la construction des fonctions je ne commenterai que peu celles qui ont été à peine modifiées.


- int FireItemEventAndReturnValue(int nEvent, object oItem, object oTarget) :

Cette fonction est une copie quasi-conforme de la fonction "ExecuteScriptAndReturnInt()".

- Elle me permet d'inscrire sur la cible la variable "int" correspondant à la constante "EVEN_####_ITEM" (l'évènement personnalisé "déclenché"), ainsi que la variable "object" correspondant à l'item concerné. Le reste de la fonction s'occupe de lancer le script portant comme nom le tag de l'item.

- Il est possible de rajouter un préfixe pour que chaque nom de script corresponde à "[préfixe]+[tag_de_l'item]. La taille d'un nom de script ne pouvant pas dépasser 16 caractères, il vaut mieux faire au plus simple. Ici j'ai rajouté le préfixe "item_". Si cela n'est pas d'une importance capitale, ce préfixe me permet d'avoir une liste de scripts propre et organisée :

Code PHP:

int FireItemEventAndReturnValue(int nEvent, object oItem, object oTarget)
{
    // Le type d'évènement ainsi que l'objet sont mis en variable
    // sur la cible. Attention à ne pas se tromper de noms de variable
    // quand il faudra les récupérer car c'est ici qu'ils sont déterminés.
    // Si le nom change, il faudra modifier les scripts en dépendant.
    SetLocalInt(oTarget,"LAST_EVENT_TYPE",nEvent);
    SetLocalObject(oTarget,"EVENT_TYPE_ITEM",oItem);

    // on définit ci dessous le préfixe permettant de reconnaître les scripts
    // relatifs aux items. Dans ce cas, tous mes scripts devront commencer
    // par "item_", vous pouver supprimer, ou bien changer ce préfixe.
    ExecuteScript("item_" + GetTag(oItem),oTarget);

    // Le script lancé, il va rendre une valeur que l'on récupére ici.
    // Cette valeur sera déterminée dans le script de l'item.
    // Elle nous permet de savoir, tout comme "ExecuteScriptAndReturnInt()",
    // si le script de l'évènement de base devra continuer après avoir utilisé
    // ce système personnalisé. 
    int nRet = GetLocalInt(oTarget,"SCRIPT_LAST_RETVAR");

    // La valeur récupérée, on efface la variable de la cible,
    // afin d'éviter les éventuels problèmes relatifs aux scripts
    // se lançant quasiment en même temps.
    DeleteLocalInt(oTarget,"SCRIPT_LAST_RETVAR");

    // On retourne la valeur récupérée.
    return nRet;
} 

- int GetUserDefinedEventType(object oTarget=OBJECT_SELF)
- object GetUserDefinedEventItem(object oTarget=OBJECT_SELF)

Ces deux fonctions sont peu utiles. Utilisées dans mon script d'item, elles me permettent juste d'avoir un code plus lisible, ainsi qu'une gestion un peu plus propre des variables.

Code PHP:

int GetUserDefinedEventType(object oTarget=OBJECT_SELF)
{
    // On récupère ici la valeur de la variable nommée et définie
    // dans la fonction "FireItemEventAndReturnValue()", représentant
    // l'évènement concerné.
    int nReturn = GetLocalInt(oTarget,"LAST_EVENT_TYPE");

    // On éfface cette variable pour les même raisons que précédemment.
    DeleteLocalInt(oTarget,"LAST_EVENT_TYPE");

    // On retourne la valeur récupérée.
    return nReturn;
}

object GetUserDefinedEventItem(object oTarget=OBJECT_SELF)
{
    // Le principe est identique, sauf qu'ici on récupère l'item concerné par l'évènement.
    object oReturn = GetLocalObject(oTarget,"EVENT_TYPE_ITEM");

    DeleteLocalObject(oTarget,"EVENT_TYPE_ITEM");

    return oReturn;
} 

- void SetExecutedScriptReturnInt(object oTarget=OBJECT_SELF, int nValue=EXECUTE_SCRIPT_END)

Cette fonction est quasiment la même que l'originale. Elle permet de répondre à la première fonction, en précisant si le script de l'évènement de base doit se poursuivre ou stopper.

Code PHP:

void SetExecutedScriptReturnInt(object oTarget=OBJECT_SELF, int nValue=EXECUTE_SCRIPT_END)
{
    // La variable de retour est ici nommée et inscrite sur la cible.
    // Attention à ne pas se tromper de nom de variable quand il
    // faudra la récupérer, car c'est ici qu'il est déterminé.
    // Si le nom change, les scripts en dépendant devront aussi
    // avoir le nom modifié.
    SetLocalInt(oTarget,"SCRIPT_LAST_RETVAR",nValue);
} 

Au final, je prends ici pour exemple l'évènement OnAcquireItem et OnEquipItem :

Ma bibliothèque (appelée ici "inc_tagbased") :

Code PHP:

const int EVENT_ACTIVATE_ITEM     = 0;
const int EVENT_EQUIP_ITEM        = 1;
const int EVENT_UNEQUIP_ITEM      = 2;
const int EVENT_ONHITCAST_ITEM    = 3;
const int EVENT_ACQUIRE_ITEM      = 4;
const int EVENT_UNACQUIRE_ITEM    = 5;
const int EVENT_SPELLCAST_AT_ITEM = 6;

const int EXECUTE_SCRIPT_CONTINUE = 0;
const int EXECUTE_SCRIPT_END      = 1;

int FireItemEventAndReturnValue(int nEvent, object oItem, object oTarget)
{
    SetLocalInt(oTarget,"LAST_EVENT_TYPE",nEvent);
    SetLocalObject(oTarget,"EVENT_TYPE_ITEM",oItem);

    ExecuteScript("item_" + GetTag(oItem),oTarget);
    int nRet = GetLocalInt(oTarget,"SCRIPT_LAST_RETVAR");
    DeleteLocalInt(oTarget,"SCRIPT_LAST_RETVAR");

    return nRet;
}

int GetUserDefinedEventType(object oTarget=OBJECT_SELF)
{
    int nReturn = GetLocalInt(oTarget,"LAST_EVENT_TYPE");
    DeleteLocalInt(oTarget,"LAST_EVENT_TYPE");

    return nReturn;
}

object GetUserDefinedEventItem(object oTarget=OBJECT_SELF)
{
    object oReturn = GetLocalObject(oTarget,"EVENT_TYPE_ITEM");
    DeleteLocalObject(oTarget,"EVENT_TYPE_ITEM");

    return oReturn;
}

void SetExecutedScriptReturnInt(object oTarget=OBJECT_SELF, int nValue=EXECUTE_SCRIPT_END)
{
    SetLocalInt(oTarget,"SCRIPT_LAST_RETVAR",nValue);
} 

OnAcquireItem :

Code PHP:

#include "inc_tagbased"

void main()
{
    oItem = GetModuleItemAcquired();
    oTarget = GetModuleItemAcquiredBy();

    // TagBased Script : Debut //
    int nValue = FireItemEventAndReturnValue(EVENT_ACQUIRE_ITEM,oItem,oTarget);
    if(nValue==EXECUTE_SCRIPT_END)
    {
        return;
    }
    // TagBased Script : Fin   //
} 

OnEquipItem :

Code PHP:

#include "inc_tagbased"

void main()
{
    object oItem = GetPCItemLastEquipped();
    object oTarget = GetPCItemLastEquippedBy();

    // TagBased Script : Debut //
    int nValue = FireItemEventAndReturnValue(EVENT_EQUIP_ITEM,oItem,oTarget);
    if(nValue==EXECUTE_SCRIPT_END)
    {
        return;
    }
    // TagBased Script : Fin   //
} 

Mon script d'item sera simple. Si mon item porte le tag "epee_mag01", le script se nommera de la même manière, sauf si j'ai défini un préfixe. Dans le cas où le préfixe est "item_", mon script se nommera "item_epee_mag01" :

Code PHP:

#include "inc_tagbased"

void main()
{
    object oPossessor = OBJECT_SELF;

    int nEvent = GetUserDefinedEventType(oPossessor);

    if(nEvent==EVENT_ACQUIRE_ITEM)
    {
        object oItem = GetUserDefinedEventItem(oPossessor);

        // j'inscrit ici mon code concernant l'évènement OnAcquireItem

        // Ci-dessous, je décide que le script du OnAcquireItem devra se poursuivre.
        SetExecutedScriptReturnInt(oPossessor,EXECUTE_SCRIPT_CONTINUE);
    }

    else if(nEvent==EVENT_EQUIP_ITEM)
    {
        object oItem = GetUserDefinedEventItem(oPossessor);

        // j'inscrit ici mon code concernant l'évènement OnEquipItem

        // Ci-dessous, je décide que le script du OnEquipItem ne devra pas se poursuivre.
        SetExecutedScriptReturnInt(oPossessor,EXECUTE_SCRIPT_END);
    }
} 

Pour finir, il faudra très certainement modifier le script "x2_inc_spellhook" pour bénéficier pleinement de ce système. Car ce dernier script permet de définir l'évènement "OnSpellCastAt" sur un item.


Voili voila... Si j'ai oublié quoi que ce soit n'hésitez pas.

[Garrath]

euh non je crois pas... c'est le seul evenement qui est de base portee par le PJ

C'est d'ailleurs un truc que je ne comprends pas... remarques j'ai pas cherche a aller plus loin non plus...

[Deyonara]

ATTENTION : Pour des raisons de compatibilité, le post précédent a été modifié. J'ai renommé la fonction "SetExecutedScriptReturnValue()" en SetExecutedScriptReturnInt()", vu que cette fonction est déjà présente dans les bibliothèques Bioware.


J'en profite pour enrichir un autre point, concernant le script "x2_inc_spellhook", et l'évènement "OnSpellCastAt". On peut aisément y rajouter la nouvelle bibliothèque créée. Voici les modifications que j'ai apportées.

Je rajoute au script l'include "inc_tagbased", tel qu'il a été conçu, à part la modification précisée précédemment. il ne peut pas entrer en conflit avec l'include déjà en place :

Code PHP:

16 |//:://////////////////////////////////////////////
17 |//:: Created By: Georg Zoeller
18 |//:: Created On: 2003-06-04
19 |//:: Updated On: 2003-10-25
20 |//:://////////////////////////////////////////////
21 |
22 |//#include "x2_inc_itemprop" - Inherited from x2_inc_craft
23 |#include "x2_inc_craft"
24 |
25 |// Je rajoute ci-dessous le script concerné :
26 |#include "inc_tagbased" 

Situées plus bas ces lignes concernent le système TagBased Script actuel. Il suffit de remplacer :

Code PHP:

304|         //-----------------------------------------------------------------------
305|         // * Execute item OnSpellCast At routing script if activated
306|         //-----------------------------------------------------------------------
307|         if(GetModuleSwitchValue(MODULE_SWITCH_ENABLE_TAGBASED_SCRIPTS) == TRUE)
308|         {
309|             SetUserDefinedItemEventNumber(X2_ITEM_EVENT_SPELLCAST_AT);
310|             int nRet = ExecuteScriptAndReturnInt(GetUserDefinedItemEventScriptName(oTarget),OBJECT_SELF);
311|             if(nRet==X2_EXECUTE_SCRIPT_END)
312|             {
313|                 return FALSE;
314|             }
315|         } 

par :

Code PHP:

// TagBased Script : Debut //

// Dans le SpellHook, l'item est déjà défini par oTarget
// Il ne nous reste plus qu'à retrouver son possesseur.
object oPossessor = GetItemPossessor(oTarget);

int nValue = FireItemEventAndReturnValue(EVENT_SPELLCAST_AT_ITEM,oTarget,oPossessor);
if(nValue==EXECUTE_SCRIPT_END)
{
    // Autre petite modification relative au SpellHook
    // qui doit lui-même rendre une valeur si le script
    // lui faisant appel doit s'interrompre.
    return FALSE;
}
// TagBased Script : Fin   // 

Voili voila...

Je poursuis actuellement mes recherches concernant l'évènement "OnHitCast", dont le pouvoir peut être rajouté à une arme et/ou une armure

[Deyonara]

J'ai fini mes modifications concernant la partie "OnHitCast".


Il s'agit cette fois-ci d'ouvrir le script "x2_s3_onhitcast" et de tout remplacer par :

Code PHP:

#include "inc_tagbased"

void main()
{
    // Cette propriété d'objet est considérée comme un sort.
    // Le script sera donc lancé de base sur le possesseur
    // de l'item, soit "OBJECT_SELF"
    object oTarget = OBJECT_SELF;
    object oItem   = GetSpellCastItem();

    // Bioware a rajouté cette vérification. Si elle s'avère inutile
    // autant la supprimer, mais si elle est là c'est qu'il y a
    // peut-être une raison... Obscur, tout ça...
    if(GetIsObjectValid(oItem))
    {
        int nValue = FireItemEventAndReturnValue(EVENT_ONHITCAST_ITEM,oItem,oTarget);
        if(nValue == EXECUTE_SCRIPT_END)
        {
           return;
        }
    }
} 

Et voici un système TagBased script complet. ^^


Je récapitule ci-dessous les divers évènement que le script d'un item entièrement paramètré pourra interpréter grace à ce système.

Pour plus de lisibilité, le possesseur de l'item sera nommé "oActor" (c'est lui le support des script), l'item concerné "oItem". Les paramètres propres à chaque évènement seront indiqués directement dans la partie leur correspondant.

Chaque évènement sera ponctué par la fonction "SetExecutedScriptReturnInt()", déterminant si le script de l'évènement originel doit se poursuivre ou non :

Code PHP:

#include "inc_tagbased"

void main()
{
    object oActor = OBJECT_SELF;
    object oItem = GetUserDefinedEventItem(oActor);

    int nEvent = GetUserDefinedEventType(oActor);

    // Evènement "OnAcquireItem"
    if(nEvent==EVENT_ACQUIRE_ITEM)
    {
        // Si l'objet passe de main en main, on peut identifier
        // l'ancien porteur comme indiqué ci-dessous.
        object oTier = GetModuleItemAcquiredFrom();

        SetExecutedScriptReturnInt(oActor /* , EXECUTE_SRIPT_# */);
    }

    // Evènement "OnActivateItem"
    else if(nEvent==EVENT_ACTIVATE_ITEM)
    {
        // Si l'objet est activé sur une tierce personne,
        // on l'identifie comme indiqué ci-dessous.
        object oTier = GetItemActivatedTarget();

        SetExecutedScriptReturnInt(oActor /* , EXECUTE_SRIPT_# */);
    }

    // Evènement "OnEquipItem"
    else if(nEvent==EVENT_EQUIP_ITEM)
    {

        SetExecutedScriptReturnInt(oActor /* , EXECUTE_SRIPT_# */);
    }

    // Evènement "OnUnacquireItem"
    else if(nEvent==EVENT_UNACQUIRE_ITEM)
    {

        SetExecutedScriptReturnInt(oActor /* , EXECUTE_SRIPT_# */);
    }

    // Evènement "OnUnequipItem"
    else if(nEvent==EVENT_UNEQUIP_ITEM)
    {

        SetExecutedScriptReturnInt(oActor /* , EXECUTE_SRIPT_# */);
    }

    // Evènement "OnHitCast" (cf. Propriétés de l'item)
    else if(nEvent==EVENT_ONHITCAST_ITEM)
    {
        // On récupère ici la cible si l'item est une arme.
        // Si l'item est une armure on saura qui a attaqué
        // le porteur de l'item.
        object oTier = GetSpellTargetObject();

        SetExecutedScriptReturnInt(oActor /* , EXECUTE_SRIPT_# */);
    }

    // Evènement "OnSpellCastAt"
    else if(nEvent==EVENT_SPELLCAST_AT_ITEM)
    {
        // Il se peut que le lanceur du sort ne soit pas
        // le possesseur de l'item. Je pense aux sorts
        // tels que "Arme de feu" ou "Affûtage".
        // On récupère donc ci-dessous le lanceur du sort.
        object oTier = GetLastSpellCaster();

        // On peut ci-dessous identifier le sort lancé sur l'item
        int nSpell = GetLastSpell();

        SetExecutedScriptReturnInt(oActor /* , EXECUTE_SRIPT_# */);
    }
} 

[Reyan]

Sympatouille tous ca, j'aime bien les fonctions, qui modifient un peu l'organisation du TagBased, et groupe le posage de variable

mais, quelle est l'utilité de changer l'objet sur lequel sont stockées les variables ? Ca "réduit" la probabilité que deux scripts soient lancés en même temps sur l'objet où elles sont stockées et que les variables se téléscopent, mais elle est sensée être nulle

Cela dit, je trouve cela plus "propre" dans l'idée, et celon les modules et la facon de scripter, il peut y avoir bcp de variables sur le module ou sur les PJs/PNJs, il vaut mieux répartir il parait, même si ca tient plus de l'intégrisme que de l'optimisation je crois
Enfin, je n'ai aucune idée du fonctionnement de cela une fois les scripts lancés, cmt sont gérées les variables, l'exécution de scripts sur les objets, tout ca . . .

Dans l'idée, il aurait pu être interessant de rajouter des fonctions ajoutant divers paramètres, entiers, strings, etc. passés en variables sur l'objet "stockeur" et réutilisable dans le script. C'est vrai quoi, il est bien "sec" ce ExecuteScript, on peut pas lui passer bcp de paramètres
Dans le même genre, pousser le boucher un peu (loin ?) en permettant le coup des "préfixe" posés sur les objets : pouvoir modifier le fonctionnement de toute une gamme de scripts (en fait, changer de d'ensemble de scripts) pour un joueur par exemple, en changeant simplement une variable posée dessus.
La variable retour peut être utilisée pour savoir si un script a été lancé ou pas, et déclencher un script générique sinon. Mais je m'emballe, je veux toujours en faire *trop*

Alors là le coup de passer par l'objet sur lequel le script est lancé pour stocker les variable "temporelle" prendrait un interêt tout autre

[Deyonara]

J'y ai pensé, oui, mais j'ai préféré le faire de manière simple, pour que tout le monde puisse utiliser tout ça sans trop de problèmes d'intégration.

Je propose une base saine, que tout le monde pourra modifier à sa sauce.

[Deyonara]

Vu que Reyan a parlé de choses plutôt utiles :

*te montre du doigt et pis s'en moque même si c'est pas poli*

Oui oui.. Toi, Reyan...

Citation :

Publié par Reyan

mais, quelle est l'utilité de changer l'objet sur lequel sont stockées les variables ? Ca "réduit" la probabilité que deux scripts soient lancés en même temps sur l'objet où elles sont stockées et que les variables se téléscopent, mais elle est sensée être nulle

C'est valable jusqu'à un certain point, celui de la fonction "ExecuteScriptAndReturnInt()". Le système de base utilisant 7 évènements, la même variable, et le même support, il faut au moins multiplier les risques par 7 pendant le temps où cette fonction exécute le script, inscrit les variables sur le module, et retourne la valeur. Je ne compte pas la variation du nombre de joueurs manipulant des items en même temps. Dans le cas où le joueur est le support, il est quasiment impossible de "télescoper" ces variables. Je dis "quasiment" car il reste un seul risque, celui où le joueur ayant mis deux armes en raccourci (ou une arme et un bouclier) utilise ledit raccourci, ce qui "pourrait" déclencher deux scripts en même temps (dans le cas où les deux items sont concernés par le système. Après, il est strictement impossible de cliquer à deux endroits différents en même temps. On peut donc qualifier le risque de "nul", à part peut être dans le cas d'un lag, et d'un joueur activant, équippant, et toutes ces sortes de choses qui exécuteraient ces actions après "dissipation" dudit lag. Ceci dit, je pars sur mes estimations personnelles, je peux me tromper, mais au final je suis assez optimiste et j'ai bien plus confiance en ce système modifié qu'en celui de Bioware.

Citation :

Publié par Reyan

Dans l'idée, il aurait pu être interessant de rajouter des fonctions ajoutant divers paramètres, entiers, strings, etc. passés en variables sur l'objet "stockeur" et réutilisable dans le script. C'est vrai quoi, il est bien "sec" ce ExecuteScript, on peut pas lui passer bcp de paramètres

J'ai fait ceci, notamment en modifiant la fonction de cette manière :

- int FireItemEventAndReturnValue(int nEvent, object oItem, object oTarget, object oTarget=OBJECT_INVALID, int nValue=FALSE)

Ce qui me permet entre autre de mettre en variable "object" la cible d'un item activé, le lanceur d'un sort, ou encore la créature ciblée par la propriété "OnHitCast". On peut encore plus le paramétrer. Seul problème je n'ai pas pu rajouter un paramètre "location" dans le cas où je laisse cette fonction telle qu'elle. Il me faut la passer en void et utiliser "ExecuteScriptAndReturnInt()". j'ai quand même contourné le problème en rajoutant "manuellement" la variable "location" sur le support pour les évènements susceptibles de demander une telle valeur.

Citation :

Publié par Reyan

Dans le même genre, pousser le boucher un peu (loin ?) en permettant le coup des "préfixe" posés sur les objets : pouvoir modifier le fonctionnement de toute une gamme de scripts (en fait, changer de d'ensemble de scripts) pour un joueur par exemple, en changeant simplement une variable posée dessus.
La variable retour peut être utilisée pour savoir si un script a été lancé ou pas, et déclencher un script générique sinon. Mais je m'emballe, je veux toujours en faire *trop*

Non non, tu ne pousses pas le bouchon trop loin, il suffit d'inscrire le type de préfixe désiré sur l'item, via l'éditeur. Tu pourrait même faire changer de catégorie un item en préparant les scripts à l'avance. Comme j'aime faire propre, et que je suis un peu maniaque, voici une manière dont je pourrais procéder, en numérotant mes catégories de 0 à plus :

Code PHP:

string sTag = GetTag(oItem);
string sCat = "item";

int nCat = GetLocalInt(oItem,"ITEM_EVENT_CATEGORY");
if(nCat>9)
    sCat += IntToString(nCat)+"_";
else
    sCat += "0"+IntToString(nCat)+"_";

ExecuteScript(sCat+sTag,oTarget); 

On peut aussi inscrire le préfixe entier sur l'item :

Code PHP:

string sTag = GetTag(oItem);
string sCat = GetLocalString(oItem,"ITEM_EVENT_PREFIX");

ExecuteScript(sCat+sTag,oTarget); 

[Camelia d'Oriel]

Alors question ...

Ce système remplacerait ou accompagnerait le système que je nomme familièrement le "x2_it_trucmuche" sauf que les variables seraient enregistrées sur le perso et non sur l'item qu'il porte ? (j'ai compris ou pas ?)
Ca donnerait :
le pnj Paulo est équipé d'un casque bleu et d'une armure rouge donc il peut faire une lumière bleue et un dragon rouge ?

[Deyonara]

Là, je dois avouer que tes questions ne sont pas claires du tout, ou alors c'est juste moi qui n'ai rien compris...

[Camelia d'Oriel]

Je me demandais simplement si je pourrais adapter ton système au système de Georg Zoeller qui utilisent des peaux qui donnent une apparence. Ces peaux étant associées elle même à des scripts ...

(*se demande si la clarté est avec elle aujourd'hui...*)

[Deyonara]

Je regarderai à l'occasion, je n'ai pas l'éditeur sous les yeux... à la limite, dis moi si ça utilise l'évènement "OnEquip", et au pire si tu as un script de peau à me mettre sous les yeux, là.

[Camelia d'Oriel]

Oui ça utilise tout ça !

le OnEquiped :

Code PHP:

#include "x2_inc_switches"
#include "x2_inc_intweapon"
void main()
{

    object oItem = GetPCItemLastEquipped();
    object oPC   = GetPCItemLastEquippedBy();
    // -------------------------------------------------------------------------
    // Intelligent Weapon System
    // -------------------------------------------------------------------------
    if (IPGetIsIntelligentWeapon(oItem))
    {
        IWSetIntelligentWeaponEquipped(oPC,oItem);
        // prevent players from reequipping their weapon in
        if (IWGetIsInIntelligentWeaponConversation(oPC))
        {
                object oConv =   GetLocalObject(oPC,"X2_O_INTWEAPON_SPIRIT");
                IWEndIntelligentWeaponConversation(oConv, oPC);
        }
        else
        {
            //------------------------------------------------------------------
            // Trigger Drain Health Event
            //------------------------------------------------------------------
            if (GetLocalInt(oPC,"X2_L_ENSERRIC_ASKED_Q3")==1)
            {
                ExecuteScript ("x2_ens_dodrain",oPC);
            }
            else
            {
                IWPlayRandomEquipComment(oPC,oItem);
            }
        }
    }


     // -------------------------------------------------------------------------
     // Generic Item Script Execution Code
     // If MODULE_SWITCH_EXECUTE_TAGBASED_SCRIPTS is set to TRUE on the module,
     // it will execute a script that has the same name as the item's tag
     // inside this script you can manage scripts for all events by checking against
     // GetUserDefinedItemEventNumber(). See x2_it_example.nss
     // -------------------------------------------------------------------------
     if (GetModuleSwitchValue(MODULE_SWITCH_ENABLE_TAGBASED_SCRIPTS) == TRUE)
     {
        SetUserDefinedItemEventNumber(X2_ITEM_EVENT_EQUIP);
        int nRet =   ExecuteScriptAndReturnInt(GetUserDefinedItemEventScriptName(oItem),OBJECT_SELF);
        if (nRet == X2_EXECUTE_SCRIPT_END)
        {
           return;
        }
     }

} 

et le script de ma peau :

Code PHP:

#include "x2_inc_switches"

void main()
{
    int nEvent =GetUserDefinedItemEventNumber();
    object oPC;
    object oItem;

   SendMessageToPC(GetFirstPC(),IntToString(nEvent));

    // * This code runs when the item has the OnHitCastSpell: Unique power property
    // * and it hits a target(weapon) or is being hit (armor)
    // * Note that this event fires for non PC creatures as well.
    if (nEvent ==X2_ITEM_EVENT_ONHITCAST)
    {
        oItem  =  GetSpellCastItem();                  // The item casting triggering this spellscript
        object oSpellOrigin = OBJECT_SELF ;
        object oSpellTarget = GetSpellTargetObject();
        oPC = OBJECT_SELF;

    }

    // * This code runs when the Unique Power property of the item is used
    // * Note that this event fires PCs only
    else if (nEvent ==  X2_ITEM_EVENT_ACTIVATE)
    {

        oPC   = GetItemActivator();
        oItem = GetItemActivated();

    }

    // * This code runs when the item is equipped
    // * Note that this event fires PCs only
    else if (nEvent ==X2_ITEM_EVENT_EQUIP)
    {

        oPC = GetPCItemLastEquippedBy();
        oItem = GetPCItemLastEquipped();


    }

    // * This code runs when the item is unequipped
    // * Note that this event fires PCs only
    else if (nEvent ==X2_ITEM_EVENT_UNEQUIP)
    {

        oPC    = GetPCItemLastUnequippedBy();
        oItem  = GetPCItemLastUnequipped();

    }
    // * This code runs when the item is acquired
    // * Note that this event fires PCs only
    else if (nEvent == X2_ITEM_EVENT_ACQUIRE)
    {

        oPC = GetModuleItemAcquiredBy();
        oItem  = GetModuleItemAcquired();
        SetCreatureAppearanceType(oPC, 305);

    }

    // * This code runs when the item is unaquire d
    // * Note that this event fires PCs only
    else if (nEvent == X2_ITEM_EVENT_UNACQUIRE)
    {

        oPC = GetModuleItemLostBy();
        oItem  = GetModuleItemLost();
    }

    //* This code runs when a PC or DM casts a spell from one of the
    //* standard spellbooks on the item
    else if (nEvent == X2_ITEM_EVENT_SPELLCAST_AT)
    {

        oPC = GetModuleItemLostBy();
        oItem  = GetModuleItemLost();
    }


} 

[Deyonara]

Il faudra donc modifier les tags et les scripts des peaux pour qu'ils concordent avec ma version. J'ai mis en deuxième partie de CE POST un exemple d'un item basique prêt à être modifié.

[Camelia d'Oriel]

Oki merci !
Je vais m'y pencher et je reviendrai avec mes questions idiotes !