[KorTeX]

Bijour tout le monde


Désolé j'ai pas eu le temps de le mettre avant ce soir.. bon après le patch 1.06, on a pu créer des pièges. Donc je me suis dit que ce serait pas mal de faire des pièges aléatoires dans les donjons


Donc voilà je me suis rendu compte de plusieurs petites choses

- SetTrapActive ne fonctionne pas super... je voulais mettre des pièges non actif prédéfinis sur les objet, et le fait qu'ils ne soient pas actif empêche l'ouverture des placeables.... Donc si on peut pas ouvrir ça limite son intérêt

- je suis une quiche je n'arrive pas à trouver un moyen simple et efficace pour séparer les waypoint des objets (y'a la fonction GetWaypointByTag mais les WP sont pris aussi avec GetObjectByTag donc j'y arrive pas) du coup j'ai séparer en deux...




Le principe :

mettre un trigger (en fait 2 du coup, un pour les objets et l'autre pour les placeables) avec pour tag TAG_TRIGGER. Ensuite placer des waypoints OU des objets / portes avec pour tag TAG_TRIGGER1, TAG_TRIGGER2, TAG_TRIGGER3, TAG_TRIGGER4 etc... jusqu'à 9 (amplement suffisant à mon goût)

Sur la zone on peut mettre un variable "trap_chance" qui définie la chance par défaut de voir un piège apparaître (cette variable est la variable générale, on peut la modifier en particulier sur chaque placeable / waypoint / porte)



Ensuite dans le détail :


Si les objets placés sont des WP, un piège au sol apparaîtra comme un carré de 3x3 ... on peut le changer mais moi ça m'a paru correct (en fait j'en sais rien )

Sur les objets de pièges que l'on place (WP - porte - placeables) on met plusieurs variables :
- TRAP_TYPE : de 0 à 3, qui correspond à la puissance du piège (de mineur à épique). Les pièges seront pris de façon aléatoire ensuite
- Aucun piège n'est à déclenchement unique, mais on peut le faire en mettant sur les objets à pièges (WP, placeables, portes) la variable OneShot à TRUE
- Detect : le DD de détection.
- Disarm : le DD de désarmement


LES DD :
si vous mettez les variables à -1, le piège sera indetectable / non désarmable (oué je sais ça doit pas exister dans le dico ... )
Si vous ne mettez rien le DD par défaut du piège sera pris.


Faut mettre les triggers à des passages obligés.
Pendant 15 secondes après le premier passage, le trigger est inactif (ça permet au groupe de passer sans problème

Quand un piège est désamorcé


euh... voilà je pense que c'est tout pour les explications
mais n'hésitez pas pour des améliorations ou autres questions

Code PHP:

 /* mettre la variable "trap_chance" 
Elle définie le pourcentage de chance de voir apparaître un piège
 
sur la zone elle est prise pour tous les objets / waypoints en général
Sur les objets, waypoints pour un pourcentage particulier
Si rien n'est mis par défaut 60% de chance qu'un piège n'apparaisse
 
sur le trigger il faut placer une variable WP integer à 1 pour les waypoint.
ne rien mettre pour les placeables
 
*/
 
 
// script à mettre sur le déclencheur
 
// nom de la bibliothèque. A changer selon les besoins
#include "ktx_trap_inc" 
 
void main()
{
if (GetLocalInt (OBJECT_SELF, "ACTIVE") == TRUE) return;
if (!GetIsPC (GetEnteringObject())) return;
else 
    {
    SetLocalInt (OBJECT_SELF, "ACTIVE", TRUE);
    SetLocalInt (GetArea(OBJECT_SELF), GetTag(OBJECT_SELF), TRUE);
    string sTag = GetTag (OBJECT_SELF);
    int i=1;
    int iPourcent = GetLocalInt (GetArea(OBJECT_SELF), "trap_chance");
    // pourcentage par défaut à modifier selon les besoins
    if (iPourcent == 0) iPourcent = 60;
    int iChanceObject;
    int iTrap;
    int iActiveWP;
    int iJet;
    int iTrapType;
    int iObjectType;
    object oTrap;
 
 
 
    int iWP = GetLocalInt (OBJECT_SELF, "WP");
 
 
 
    if (iWP == 1)
        {
        oTrap = GetWaypointByTag (sTag + IntToString (i));
        while (oTrap != OBJECT_INVALID)
            {
            iChanceObject = GetLocalInt (oTrap, "trap_chance");
            if (iChanceObject != 0) iPourcent = iChanceObject;
            //KTXDebug (GetTag (oTrap) + " : pourcentage : " + IntToString (iPourcent));
            iActiveWP = GetLocalInt (oTrap, "ACTIVE");
            //if (iActiveWP==TRUE) KTXDebug (GetTag (oTrap) + " : déjà activée -- return");
            if (iActiveWP==FALSE) // ne peut pas mettre de piège là où il y en a déjà un
                {
                iJet = d100();
                //KTXDebug ("Jet : " + IntToString (iJet));
                if (iJet< iPourcent)    
                    {
                    //KTXDebug (GetTag (oTrap) + " : ACTIVE");
                    iTrapType = GetLocalInt (oTrap, "TRAP_TYPE");
                    iTrap = SetRandomTrapType (iTrapType);
                    KTX_CreateTrapLoc (iTrap, oTrap, TAILLE_PIEGE,(sTag + IntToString (i)) , STANDARD_FACTION_HOSTILE);
                    }
                }
            i++;
 
            oTrap = GetWaypointByTag (sTag + IntToString (i));
            }
        }
 
    else
        {            
        i=1;    
        oTrap = GetObjectByTag (sTag + IntToString (i));
        while (oTrap != OBJECT_INVALID)
            {
            iChanceObject = GetLocalInt (oTrap, "trap_chance");
            if (iChanceObject != 0) iPourcent = iChanceObject;
            //KTXDebug (GetTag (oTrap) + " (plac) : pourcentage : " + IntToString (iPourcent));
            iActiveWP = GetLocalInt (oTrap, "ACTIVE");
            //if (iActiveWP==TRUE) KTXDebug (GetTag (oTrap) + " (plac) : déjà activée -- return");
            if (iActiveWP==FALSE) // ne peut pas mettre de piège là où il y en a déjà un
                {
                iJet = d100();
                //KTXDebug ("Jet : " + IntToString (iJet));
                if (iJet< iPourcent)    
                    {
                    //KTXDebug (GetTag (oTrap) + " (plac) : ACTIVE");
                    iTrapType = GetLocalInt (oTrap, "TRAP_TYPE");
                    iTrap = SetRandomTrapType (iTrapType);
                    KTX_CreateTrapObject (iTrap, oTrap, STANDARD_FACTION_HOSTILE);
                    }
                }
            i++;
            oTrap = GetObjectByTag (sTag + IntToString (i));
            }
        }
    DelayCommand (15.0f, SetLocalInt (OBJECT_SELF, "ACTIVE", FALSE));
    }
} 

Code PHP:

const string sScript = "ktx_trap_rearm"; // script à mettre sur le OnDisarm
const float TAILLE_PIEGE = 3.0f ;// changer pour la taille des pièges au sol
 
// fonction inutile
//void SauvegardePiege (object oPiege, object oWP);
 
 
// cette fonction permet de mettre à jour les propriétés de la trap
// mettre sur les waypoints 2 variables INTEGER : Disarm et Detect
// si Detect est à 0, il est impossible de détecter le piège
// si Disarm est à 0, il est impossible de Désarmer le piège
// optionnel : mettre OneShot à 1 pour que le piège soit à déclenchement unique
void SetPiege(object oPiege, object oWP);
 
// crée un piège sur un placeabe ou une porte
void KTX_CreateTrapObject (int iTrap, object oObject, int iFaction);
 
// créer un piège  à l'endroit du waypoint
void KTX_CreateTrapLoc (int iTrap, object oWP, float fsize, string sTag, int iFaction);
 
 
 
// fonction de débuggage
// du coup elle sert plus :)
//void KTXDebug (string stxt);
 
// mettre sur le WP la variable int TRAP_TYPE
// 0 : piège léger
// 1 : piège moyen
// 2 : piège difficile
// 1 : piège épique
int SetRandomTrapType (int average);
 
 
 
/* 
// fonction non utilisée.. je voulais sauvegarder le piège par cession de reboot 
// du serveur et les remettre mais bon c'est pas si intéressant que ça au final
 
void SauvegardePiege (object oPiege, object oWP)
{
int iTrap = GetTrapBaseType(oPiege);
int iCanDetect = GetTrapDetectable (oPiege);
int iDetectDC = GetTrapDetectDC (oPiege);
int iCanDisarm = GetTrapDisarmable (oPiege);
int iDisarmDC = GetTrapDisarmDC (oPiege);
int iOneShot = GetTrapOneShot(oPiege);
 
SetLocalInt (oWP, "TrapType",iTrap);
SetLocalInt (oWP, "CanDetect",iCanDetect);
SetLocalInt (oWP, "DetectDC",iDetectDC);
SetLocalInt (oWP, "CanDisarm",iCanDisarm);
SetLocalInt (oWP, "DisarmDC",iDisarmDC);
SetLocalInt (oWP, "OneShot",iOneShot);
}
*/
 
 
 
void SetPiege(object oPiege, object oWP)
{
int iDetectDC = GetLocalInt (oWP, "Detect");
int iDisarmDC = GetLocalInt (oWP, "Disarm");
int iOneShot = GetLocalInt (oWP, "OneShot");
 
if (iDetectDC != -1)
    {
    SetTrapDetectable (oPiege, TRUE);
    if (iDetectDC != 0)SetTrapDetectDC (oPiege, iDetectDC);
    }
else SetTrapDetectable (oPiege, FALSE);
//KTXDebug (GetTag(oPiege) + " DetectDC : " + IntToString (iDetectDC));
 
if (iDisarmDC != -1)
    {
    SetTrapDisarmable (oPiege, TRUE);
    if (iDisarmDC != 0) SetTrapDisarmDC (oPiege, iDisarmDC);
    //KTXDebug ("DisarmDC = " + IntToString (GetTrapDisarmDC (oPiege)));
    }
else SetTrapDisarmDC (oPiege, FALSE);
 
SetTrapOneShot (oPiege, iOneShot);
 
}
 
void KTX_CreateTrapObject (int iTrap, object oObject, int iFaction)
{
CreateTrapOnObject (iTrap, oObject , iFaction, sScript);
SetPiege (oObject, oObject);
SetTrapActive (oObject, TRUE);
}
 
void KTX_CreateTrapLoc (int iTrap, object oWP, float fsize, string sTag, int iFaction)
{
location lLoc = GetLocation (oWP);
object oTrapCreate = CreateTrapAtLocation (iTrap, lLoc, fsize, sTag, iFaction, sScript);
SetPiege (oTrapCreate, oWP);
}
 
 
/*
void KTXDebug (string stxt)
{
SendMessageToPC (GetFirstPC(), stxt);
}
*/
 
int SetRandomTrapType (int iType)
{
int iRandom;
int iTrap;
if (iType == 0)
    {
    iRandom = Random (11);
    switch (iRandom)
        {
        case 0 : iTrap = TRAP_BASE_TYPE_MINOR_ACID; break;
        case 1 : iTrap = TRAP_BASE_TYPE_MINOR_ACID_SPLASH; break;
        case 2 : iTrap = TRAP_BASE_TYPE_MINOR_ELECTRICAL; break;
        case 3 : iTrap = TRAP_BASE_TYPE_MINOR_FIRE; break;
        case 4 : iTrap = TRAP_BASE_TYPE_MINOR_FROST; break;
        case 5 : iTrap = TRAP_BASE_TYPE_MINOR_GAS; break;
        case 6 : iTrap = TRAP_BASE_TYPE_MINOR_HOLY; break;
        case 7 : iTrap = TRAP_BASE_TYPE_MINOR_NEGATIVE; break;
        case 8 : iTrap = TRAP_BASE_TYPE_MINOR_SONIC; break;
        case 9 : iTrap = TRAP_BASE_TYPE_MINOR_SPIKE; break;
        case 10 : iTrap = TRAP_BASE_TYPE_MINOR_TANGLE; break;
        }
 
    }
else if (iType == 1)    
    {iRandom = Random (11);
    switch (iRandom)
        {
        case 0 : iTrap = TRAP_BASE_TYPE_AVERAGE_ACID; break;
        case 1 : iTrap = TRAP_BASE_TYPE_AVERAGE_ACID_SPLASH; break;
        case 2 : iTrap = TRAP_BASE_TYPE_AVERAGE_ELECTRICAL; break;
        case 3 : iTrap = TRAP_BASE_TYPE_AVERAGE_FIRE; break;
        case 4 : iTrap = TRAP_BASE_TYPE_AVERAGE_FROST; break;
        case 5 : iTrap = TRAP_BASE_TYPE_AVERAGE_GAS; break;
        case 6 : iTrap = TRAP_BASE_TYPE_AVERAGE_HOLY; break;
        case 7 : iTrap = TRAP_BASE_TYPE_AVERAGE_NEGATIVE; break;
        case 8 : iTrap = TRAP_BASE_TYPE_AVERAGE_SONIC; break;
        case 9 : iTrap = TRAP_BASE_TYPE_AVERAGE_SPIKE; break;
        case 10 : iTrap = TRAP_BASE_TYPE_AVERAGE_TANGLE; break;
        }
    }
else if (iType == 2)    
    {
    iRandom = Random (11);
    switch (iRandom)
        {
        case 0 : iTrap = TRAP_BASE_TYPE_STRONG_ACID; break;
        case 1 : iTrap = TRAP_BASE_TYPE_STRONG_ACID_SPLASH; break;
        case 2 : iTrap = TRAP_BASE_TYPE_STRONG_ELECTRICAL; break;
        case 3 : iTrap = TRAP_BASE_TYPE_STRONG_FIRE; break;
        case 4 : iTrap = TRAP_BASE_TYPE_STRONG_FROST; break;
        case 5 : iTrap = TRAP_BASE_TYPE_STRONG_GAS; break;
        case 6 : iTrap = TRAP_BASE_TYPE_STRONG_HOLY; break;
        case 7 : iTrap = TRAP_BASE_TYPE_STRONG_NEGATIVE; break;
        case 8 : iTrap = TRAP_BASE_TYPE_STRONG_SONIC; break;
        case 9 : iTrap = TRAP_BASE_TYPE_STRONG_SPIKE; break;
        case 10 : iTrap = TRAP_BASE_TYPE_STRONG_TANGLE; break;
        }
    }
else if (iType == 3)    
    {
    iRandom = Random (11);
    switch (iRandom)
        {
        case 0 : iTrap = TRAP_BASE_TYPE_DEADLY_ACID; break;
        case 1 : iTrap = TRAP_BASE_TYPE_DEADLY_ACID_SPLASH; break;
        case 2 : iTrap = TRAP_BASE_TYPE_DEADLY_ELECTRICAL; break;
        case 3 : iTrap = TRAP_BASE_TYPE_DEADLY_FIRE; break;
        case 4 : iTrap = TRAP_BASE_TYPE_DEADLY_FROST; break;
        case 5 : iTrap = TRAP_BASE_TYPE_DEADLY_GAS; break;
        case 6 : iTrap = TRAP_BASE_TYPE_DEADLY_HOLY; break;
        case 7 : iTrap = TRAP_BASE_TYPE_DEADLY_NEGATIVE; break;
        case 8 : iTrap = TRAP_BASE_TYPE_DEADLY_SONIC; break;
        case 9 : iTrap = TRAP_BASE_TYPE_DEADLY_SPIKE; break;
        case 10 : iTrap = TRAP_BASE_TYPE_DEADLY_TANGLE; break;
        }
    }
else if (iType == 4)    
    {
    iRandom = Random (4);
    switch (iRandom)
        {
        case 0 : iTrap = TRAP_BASE_TYPE_EPIC_ELECTRICAL; break;
        case 1 : iTrap = TRAP_BASE_TYPE_EPIC_FIRE; break;
        case 2 : iTrap = TRAP_BASE_TYPE_EPIC_FROST; break;
        case 3 : iTrap = TRAP_BASE_TYPE_EPIC_SONIC; break;
        }
    }
return iTrap;
} 

Code PHP:

// ce script sert à "réarmer" la zone. Elle a été touchée donc les pièges pourront
// être remis
 
 
#include "ktx_trap_inc"
void main ()
{
string sTag=GetTag(OBJECT_SELF);
object oWP = GetWaypointByTag (sTag);
//SauvegardePiege (OBJECT_SELF, oWP);
SetLocalInt (oWP, "ACTIVE", FALSE);
string sTagBase = GetStringLeft (GetTag(OBJECT_SELF), (GetStringLength(GetTag(OBJECT_SELF))-1));
SetLocalInt (GetArea(OBJECT_SELF), sTagBase, FALSE);
} 

[Deyonara]

J'ai pu remarquer un détail pour ça :

Code PHP:

int SetRandomTrapType (int iType)
{
int iRandom;
int iTrap;
if (iType == 0)
    {
    iRandom = Random (11);
    switch (iRandom)
        {
        case 0 : iTrap = TRAP_BASE_TYPE_MINOR_ACID;
        case 1 : iTrap = TRAP_BASE_TYPE_MINOR_ACID_SPLASH;
        case 2 : iTrap = TRAP_BASE_TYPE_MINOR_ELECTRICAL;
        case 3 : iTrap = TRAP_BASE_TYPE_MINOR_FIRE;
        case 4 : iTrap = TRAP_BASE_TYPE_MINOR_FROST;
        case 5 : iTrap = TRAP_BASE_TYPE_MINOR_GAS;
        case 6 : iTrap = TRAP_BASE_TYPE_MINOR_HOLY;
        case 7 : iTrap = TRAP_BASE_TYPE_MINOR_NEGATIVE;
        case 8 : iTrap = TRAP_BASE_TYPE_MINOR_SONIC;
        case 9 : iTrap = TRAP_BASE_TYPE_MINOR_SPIKE;
        case 10 : iTrap = TRAP_BASE_TYPE_MINOR_TANGLE;
        }
    
    }
else if (iType == 1)    
    {iRandom = Random (11);
    switch (iRandom)
        {
        case 0 : iTrap = TRAP_BASE_TYPE_AVERAGE_ACID;
        case 1 : iTrap = TRAP_BASE_TYPE_AVERAGE_ACID_SPLASH;
        case 2 : iTrap = TRAP_BASE_TYPE_AVERAGE_ELECTRICAL;
        case 3 : iTrap = TRAP_BASE_TYPE_AVERAGE_FIRE;
        case 4 : iTrap = TRAP_BASE_TYPE_AVERAGE_FROST;
        case 5 : iTrap = TRAP_BASE_TYPE_AVERAGE_GAS;
        case 6 : iTrap = TRAP_BASE_TYPE_AVERAGE_HOLY;
        case 7 : iTrap = TRAP_BASE_TYPE_AVERAGE_NEGATIVE;
        case 8 : iTrap = TRAP_BASE_TYPE_AVERAGE_SONIC;
        case 9 : iTrap = TRAP_BASE_TYPE_AVERAGE_SPIKE;
        case 10 : iTrap = TRAP_BASE_TYPE_AVERAGE_TANGLE;
        }
    }
else if (iType == 2)    
    {
    iRandom = Random (11);
    switch (iRandom)
        {
        case 0 : iTrap = TRAP_BASE_TYPE_STRONG_ACID;
        case 1 : iTrap = TRAP_BASE_TYPE_STRONG_ACID_SPLASH;
        case 2 : iTrap = TRAP_BASE_TYPE_STRONG_ELECTRICAL;
        case 3 : iTrap = TRAP_BASE_TYPE_STRONG_FIRE;
        case 4 : iTrap = TRAP_BASE_TYPE_STRONG_FROST;
        case 5 : iTrap = TRAP_BASE_TYPE_STRONG_GAS;
        case 6 : iTrap = TRAP_BASE_TYPE_STRONG_HOLY;
        case 7 : iTrap = TRAP_BASE_TYPE_STRONG_NEGATIVE;
        case 8 : iTrap = TRAP_BASE_TYPE_STRONG_SONIC;
        case 9 : iTrap = TRAP_BASE_TYPE_STRONG_SPIKE;
        case 10 : iTrap = TRAP_BASE_TYPE_STRONG_TANGLE;
        }
    }
else if (iType == 3)    
    {
    iRandom = Random (11);
    switch (iRandom)
        {
        case 0 : iTrap = TRAP_BASE_TYPE_DEADLY_ACID;
        case 1 : iTrap = TRAP_BASE_TYPE_DEADLY_ACID_SPLASH;
        case 2 : iTrap = TRAP_BASE_TYPE_DEADLY_ELECTRICAL;
        case 3 : iTrap = TRAP_BASE_TYPE_DEADLY_FIRE;
        case 4 : iTrap = TRAP_BASE_TYPE_DEADLY_FROST;
        case 5 : iTrap = TRAP_BASE_TYPE_DEADLY_GAS;
        case 6 : iTrap = TRAP_BASE_TYPE_DEADLY_HOLY;
        case 7 : iTrap = TRAP_BASE_TYPE_DEADLY_NEGATIVE;
        case 8 : iTrap = TRAP_BASE_TYPE_DEADLY_SONIC;
        case 9 : iTrap = TRAP_BASE_TYPE_DEADLY_SPIKE;
        case 10 : iTrap = TRAP_BASE_TYPE_DEADLY_TANGLE;
        }
    }
else if (iType == 4)    
    {
    iRandom = Random (4);
    switch (iRandom)
        {
        case 0 : iTrap = TRAP_BASE_TYPE_EPIC_ELECTRICAL;
        case 1 : iTrap = TRAP_BASE_TYPE_EPIC_FIRE;
        case 2 : iTrap = TRAP_BASE_TYPE_EPIC_FROST;
        case 3 : iTrap = TRAP_BASE_TYPE_EPIC_SONIC;
        }
    }
return iTrap;
} 

Alors les constantes sont bien faites et sont groupées par 4. Excepté pour les pièges épiques, bien sûr, il fallait bien que quelque chose soit lourd à programmer...

Quoi qu'il en soit, en prenant juste les deux premiers pièges, on se retrouve avec des constantes qui ont les valeurs suivantes :

Code:

TRAP_BASE_TYPE_MINOR_SPIKE   = 0
TRAP_BASE_TYPE_AVERAGE_SPIKE = 1
TRAP_BASE_TYPE_STRONG_SPIKE  = 2
TRAP_BASE_TYPE_DEADLY_SPIKE  = 3

TRAP_BASE_TYPE_MINOR_HOLY    = 4
TRAP_BASE_TYPE_AVERAGE_HOLY  = 5
TRAP_BASE_TYPE_STRONG_HOLY   = 6
TRAP_BASE_TYPE_DEADLY_HOLY   = 7

// etc...

Tu coup, tu peux toi-même créer tes constantes "repères" de 0 à 4 pour définir si un piège est mineur, moyen, puissant, mortel, ou épique. Puis utiliser ta fonction "SetRandomTrapType(...)" comme suit :

Code PHP:

const int TRAP_DIFFICULTY_MINOR   = 0
const int TRAP_DIFFICULTY_AVERAGE = 1
const int TRAP_DIFFICULTY_STRONG  = 2
const int TRAP_DIFFICULTY_DEADLY  = 3
const int TRAP_DIFFICULTY_EPIC    = 4

// mettre sur le WP la variable int TRAP_TYPE
// 0 : piège mineur
// 1 : piège moyen
// 2 : piège difficile
// 3 : piège mortel
// 4 : piège épique
int SetRandomTrapType(int nDifficulty);

int SetRandomTrapType(int nDifficulty)
{
    int nReturn;

    // les pièges épiques vont de 44 à 47
    // Je fais juste une vérification, et je
    // calcule tout ça à part :
    if(nPower==TRAP_DIFFICULTY_EPIC)
        nReturn = Random(4)+44;

    // Sinon pour les autres pièges, je calcule
    // un Random(11)*4 pour avoir le type de
    // piège, et je rajoute la difficulté. Ce qui
    // me donne à coup sûr un piège valide :
    else
        nReturn = (Random(11)*4)+nDifficulty;

    return nReturn;
} 

Voila voila. Ca fait la même chose en un peu moins compréhensible, mais ça prend beaucoup moins de place. ^^

Bon c'est sûr on peut aller plus loin, en écrivant directement ça :

Code PHP:

int SetRandomTrapType(int nDifficulty)
{
    if(nPower==4)
        return (Random(4)+44);

    return ((Random(11)*4)+nDifficulty);
} 

[Laban]

Moi qui adore la randomisation, j'en pleure de joie

Et dites, concernant les gains d'xp sur ces pièges, vous en pensez quoi ?

ça redonnerait pas mal de valeur à nos roublards, sachant que les points sont sucrés en général pour empêcher la pose et l'enlèvement par deux joueurs de leurs pièges respectifs... Mais là, sur les pièges aléatoires... Et seulement ceux là..

Un Cap de XP par jour sinon ?

[KorTeX]

Pour donner de l'xp on peut mettre un truc du genre

Code PHP:

object oPC = GetLastDisarmed ();
int ibase = GetTrapbaseType (OBJECT_SELF);
int iXp;
if (iBase >= 44) iXp = 150000; // nbre d'xp donnés pour un piège épique

else 
   {
   iXp = ibase%11; 
// j'ai bien appris mes leçons :p % renvoie le reste de la division de ibase par 11
   if (iXp == 0) iXp = 2500; // là si ça renvoie 0 c'est que le piège est mineur
   else iXp = iXp * 150000000; // on multiplie la base 1-2-3-4 (moyen fort mortel etc) par un multiplicateur
   }


GiveXPToCreature (oPC, iXp); 

Je ne l'ai pas testé mais l'idée y est
à mettre dans le script de réarmement

[Deyonara]

Pour retrouver la difficulté du piège, il faut regarder si ça n'est pas un piège épique, puis récupérer le reste d'une division par 4. Je t'en fais une fonction :

Code PHP:

// La fonction renverra la difficulté du piège
// en allant de 0 (mineur) à 4 (épique) :
int GetTrapDifficulty(object oObject=OBJECT_SELF)
{
    int nTrap = GetTrapBaseType(oObject);
    if(nTrap>43)
        return 4;

    return (nTrap%4);
}

void main()
{
    object oPlayer = GetLastDisarmed();

    // Pour avoir un calcul d'XP correct, j'ajoute 1 à la
    // valeur que me renvoie "GetTrapDifficulty(...)".
    // Puis je multiplie cette valeur par... disons 50.
    // Ca fera 50 XP pour un piège mineur, et 250 XP
    // pour un piège épique.
    int nXP = 50 * (GetTrapDifficulty()+1);

    SetXP(oPlayer, GetXP(oPlayer)+nXP);
} 

A mettre dans le script de Désarmement. ^^

[Laban]

Héhé... pas mal du tout ça

Mais je pense qu'il faudrait faire une échelle plus correspondante aux niveaux (de 10 à 1000 disons).

En tout cas ça le fait bien tout ça

[maero]

Citation :

SetTrapActive ne fonctionne pas super... je voulais mettre des pièges non actif prédéfinis sur les objet, et le fait qu'ils ne soient pas actif empêche l'ouverture des placeables.... Donc si on peut pas ouvrir ça limite son intérêt

Mes donjons se "réactivent" sur le OnEnter de la première zone, je remet les monstres, les trésors, verrouille les portes les coffres, etc ...

Je voulais remettre les pièges, mais a l'époque le SetTrapActive n'existait pas, j'avais donc laissé un marqueur dans mon code, je viens d'y implémenter ce dernier et la surprise: même problème que Kortex. Les joueurs ne peuvent plus interagir avec le plaçable, alors même que le piège est défini actif au départ, conclusion c'est vraiment buggué ou alors y'a une astuce sacrément filoute.

Bizarement en tant que Dm, je n'ai pas le problème.

[Ariok]

A noter que les fonctions sur les pieges ne sont pas dans le patch note, et qu elles etaient prevues pour integrer le patch 1.07. Il est donc possible que certaines ne soient pas completement finalisées.

[KorTeX]

mise à jour sur une fonction : j'avais oublié de mettre break; à la fin dans les switch (ça fait très technique quand on écrit ça )


post modifié pour la fonction SetRandomTrapType (int iType)

Code PHP:

int SetRandomTrapType (int iType)
{
int iRandom;
int iTrap;
if (iType == 0)
    {
    iRandom = Random (11);
    switch (iRandom)
        {
        case 0 : iTrap = TRAP_BASE_TYPE_MINOR_ACID; break;
        case 1 : iTrap = TRAP_BASE_TYPE_MINOR_ACID_SPLASH; break;
        case 2 : iTrap = TRAP_BASE_TYPE_MINOR_ELECTRICAL; break;
        case 3 : iTrap = TRAP_BASE_TYPE_MINOR_FIRE; break;
        case 4 : iTrap = TRAP_BASE_TYPE_MINOR_FROST; break;
        case 5 : iTrap = TRAP_BASE_TYPE_MINOR_GAS; break;
        case 6 : iTrap = TRAP_BASE_TYPE_MINOR_HOLY; break;
        case 7 : iTrap = TRAP_BASE_TYPE_MINOR_NEGATIVE; break;
        case 8 : iTrap = TRAP_BASE_TYPE_MINOR_SONIC; break;
        case 9 : iTrap = TRAP_BASE_TYPE_MINOR_SPIKE; break;
        case 10 : iTrap = TRAP_BASE_TYPE_MINOR_TANGLE; break;
        }
 
    }
else if (iType == 1)    
    {iRandom = Random (11);
    switch (iRandom)
        {
        case 0 : iTrap = TRAP_BASE_TYPE_AVERAGE_ACID; break;
        case 1 : iTrap = TRAP_BASE_TYPE_AVERAGE_ACID_SPLASH; break;
        case 2 : iTrap = TRAP_BASE_TYPE_AVERAGE_ELECTRICAL; break;
        case 3 : iTrap = TRAP_BASE_TYPE_AVERAGE_FIRE; break;
        case 4 : iTrap = TRAP_BASE_TYPE_AVERAGE_FROST; break;
        case 5 : iTrap = TRAP_BASE_TYPE_AVERAGE_GAS; break;
        case 6 : iTrap = TRAP_BASE_TYPE_AVERAGE_HOLY; break;
        case 7 : iTrap = TRAP_BASE_TYPE_AVERAGE_NEGATIVE; break;
        case 8 : iTrap = TRAP_BASE_TYPE_AVERAGE_SONIC; break;
        case 9 : iTrap = TRAP_BASE_TYPE_AVERAGE_SPIKE; break;
        case 10 : iTrap = TRAP_BASE_TYPE_AVERAGE_TANGLE; break;
        }
    }
else if (iType == 2)    
    {
    iRandom = Random (11);
    switch (iRandom)
        {
        case 0 : iTrap = TRAP_BASE_TYPE_STRONG_ACID; break;
        case 1 : iTrap = TRAP_BASE_TYPE_STRONG_ACID_SPLASH; break;
        case 2 : iTrap = TRAP_BASE_TYPE_STRONG_ELECTRICAL; break;
        case 3 : iTrap = TRAP_BASE_TYPE_STRONG_FIRE; break;
        case 4 : iTrap = TRAP_BASE_TYPE_STRONG_FROST; break;
        case 5 : iTrap = TRAP_BASE_TYPE_STRONG_GAS; break;
        case 6 : iTrap = TRAP_BASE_TYPE_STRONG_HOLY; break;
        case 7 : iTrap = TRAP_BASE_TYPE_STRONG_NEGATIVE; break;
        case 8 : iTrap = TRAP_BASE_TYPE_STRONG_SONIC; break;
        case 9 : iTrap = TRAP_BASE_TYPE_STRONG_SPIKE; break;
        case 10 : iTrap = TRAP_BASE_TYPE_STRONG_TANGLE; break;
        }
    }
else if (iType == 3)    
    {
    iRandom = Random (11);
    switch (iRandom)
        {
        case 0 : iTrap = TRAP_BASE_TYPE_DEADLY_ACID; break;
        case 1 : iTrap = TRAP_BASE_TYPE_DEADLY_ACID_SPLASH; break;
        case 2 : iTrap = TRAP_BASE_TYPE_DEADLY_ELECTRICAL; break;
        case 3 : iTrap = TRAP_BASE_TYPE_DEADLY_FIRE; break;
        case 4 : iTrap = TRAP_BASE_TYPE_DEADLY_FROST; break;
        case 5 : iTrap = TRAP_BASE_TYPE_DEADLY_GAS; break;
        case 6 : iTrap = TRAP_BASE_TYPE_DEADLY_HOLY; break;
        case 7 : iTrap = TRAP_BASE_TYPE_DEADLY_NEGATIVE; break;
        case 8 : iTrap = TRAP_BASE_TYPE_DEADLY_SONIC; break;
        case 9 : iTrap = TRAP_BASE_TYPE_DEADLY_SPIKE; break;
        case 10 : iTrap = TRAP_BASE_TYPE_DEADLY_TANGLE; break;
        }
    }
else if (iType == 4)    
    {
    iRandom = Random (4);
    switch (iRandom)
        {
        case 0 : iTrap = TRAP_BASE_TYPE_EPIC_ELECTRICAL; break;
        case 1 : iTrap = TRAP_BASE_TYPE_EPIC_FIRE; break;
        case 2 : iTrap = TRAP_BASE_TYPE_EPIC_FROST; break;
        case 3 : iTrap = TRAP_BASE_TYPE_EPIC_SONIC; break;
        }
    }
return iTrap;
}