Détournement de Binaire pour définir des constantes

Répondre
Partager Rechercher
Bon, à la demande de RAT, je vais vous faire profiter d'une de mes petites magouilles pour stocker des constantes.
J'ai utilisé ce système pour gérer entre autre les alignements dans mon système de Déité.
Concrètement, j'ai 105 dieux à gérer, chacun autorisant de 3 à 9 alignements possibles pour leur disciples. Il me fallait un système simple et rapide pour vérifier que l'alignement du joueur est bien compatible avec les alignement possible d'un dieu. Je me voyais mal enchainer les tests d'alignement standard pour arriver à mes fins et cela pour 105 dieux.
Et c'est là que m'est venu une petite idée en regardant le système d'azrael et Jedaï pour utiliser le binaire pour stocker des variables.
Pourquoi ne pas utiliser une chaine de 1 ou 0 comme une rampe d'interrupteurs. Ouais ça à pas l'air clair comme ça donc je vais donner un petit exemple.
J'ai besoin dans ce cas là de 9 valeurs d'alignement, du loyal bon au chaotique mauvais auquel je fait correspondre 9 caratères (0 ou 1).
Code PHP:

 LB LN LM NB NN NM CB CN CM                              
 0  0  0  0  0  0  0  0  0 
donc pour avoir une déïté qui autorise les alignements LN, NM et CN, la chaîne de caractère sera
Code PHP:

010001010 

Je dis bien chaîne de caractère car contrairement aux valeurs binaires qui ne peuvent contenir que 32bits, un SetLocalString peu contenir une valeur de string 500 et quelques caractères (d'après les tests de RAT sur le sujet) quoique l'on en ai jamais besoin d'autan.
Donc on stock ça comme ça:
Code PHP:

SetLocalString(oMod,"STR_GOD_ALIGN_ABBATHOR",   "001001001"); 

Ensuite il ne nous reste plus qu'a décoder la chaîne de caractères pour qu'elle nous renvoi les valeurs d'alignement du dieu, la comparer a l'alignement du joueur et nous dire si l'alignement du joueur est valide.
Code PHP:

/***********************************************/
/* Fonction : GetAlignement                    */
/*            Par Mirandiel                    */
/*            Copyrith Althea                  */
/***********************************************/
string GetAlignement(object oPC)
{
  
string alphabeta;
  switch (
GetAlignmentLawChaos(oPC))
  {
    case 
ALIGNMENT_LAWFULalpha "L"; break;
    case 
ALIGNMENT_NEUTRALalpha "N"; break;
    case 
ALIGNMENT_CHAOTICalpha "C"; break;
  }
  switch (
GetAlignmentGoodEvil(oPC))
  {
    case 
ALIGNMENT_GOODbeta "G"; break;
    case 
ALIGNMENT_NEUTRALbeta ="N"; break;
    case 
ALIGNMENT_EVILbeta "E"; break;
  }
  return 
alpha+beta;
}

/***********************************************/
/* Fonction : GetIsValidAlignement             */
/*            Par Jaha Effect                  */
/*            le 27/03/2003                    */
/***********************************************/
int GetIsValidAlignement (object oPC)
{
    
string sGodID;
    
string sPCAlign GetAlignement(oPC);
    
string sAlignValue GetLocalString(oMod"STR_GOD_ALIGN_"+sGodID);//sGodID correspond au nom
                                                                       // du dieu mais on s'en fout pour l'exemple
    
string sReturnAlign;
    
int nGodAlign;
    
int nReturn 0;
    
int i 0;

      if (
oPC != OBJECT_INVALID)
        {
        while( 
<= )
            {
            
nGodAlign StringToInt(GetSubString(sAlignValuei1));
                     if (
i==&& nGodAlign == 1)
                        {
                        
sReturnAlign "LB";
                        
SpeakString(sReturnAlign);
                            if ( 
sPCAlign == sReturnAlign)
                                
nReturn 1;
                        }
                else if (
i==&& nGodAlign == 1)
                        {
                        
sReturnAlign "LN";
                        
SpeakString(sReturnAlign);
                            if ( 
sPCAlign == sReturnAlign)
                                
nReturn 1;
                        }
                else if (
i==&& nGodAlign == 1)
                        {
                        
sReturnAlign "LM";
                        
SpeakString(sReturnAlign);
                            if ( 
sPCAlign == sReturnAlign)
                                
nReturn 1;
                        }
                else if (
i==&& nGodAlign == 1)
                        {
                        
sReturnAlign "NB";
                        
SpeakString(sReturnAlign);
                            if ( 
sPCAlign == sReturnAlign)
                                
nReturn 1;
                        }
                else if (
i==&& nGodAlign == 1)
                        {
                        
sReturnAlign "NN";
                        
SpeakString(sReturnAlign);
                            if ( 
sPCAlign == sReturnAlign)
                                
nReturn 1;
                        }
                else if (
i==&& nGodAlign == 1)
                        {
                        
sReturnAlign "NM";
                        
SpeakString(sReturnAlign);
                            if ( 
sPCAlign == sReturnAlign)
                                
nReturn 1;
                        }
                else if (
i==&& nGodAlign == 1)
                        {
                        
sReturnAlign "CB";
                        
SpeakString(sReturnAlign);
                            if ( 
sPCAlign == sReturnAlign)
                                
nReturn 1;
                        }
                else if (
i==&& nGodAlign == 1)
                        {
                        
sReturnAlign "CN";
                        
SpeakString(sReturnAlign);
                            if ( 
sPCAlign == sReturnAlign)
                                
nReturn 1;
                        }
                else if (
i==&& nGodAlign == 1)
                        {
                        
sReturnAlign "LM";
                        
SpeakString(sReturnAlign);
                            if ( 
sPCAlign == sReturnAlign)
                                
nReturn 1;
                        }
            
i++;
            }
        }
        return 
nReturn;
}

void main()
{
object oPC GetPCSpeaker (); //ou quelque autre facon de recuperer le pc suivant le cas
int nCheck GetIsValidAlignement (oPC);

    if (
nCheck != 1)
       
SpeakString("Votre alignement ne vous permet pas de garder votre divinit tutlaire");

Voilà, j'espère que celà vous donnera des idées

Jaha Effect
Heuuu comment dire ... ba tout simplement... Génial .... comme j'ai pu te le dire quand tu me l'as expliqué l'autre fois, je trouve que c'est une super idée, et que cela va en faciliter plus d'un.
Donc bravo, l'explication est clair, à mettre dans les persistants

Encore bravo

PS Pour la limitation des strings:
Ba rare sont les personnes qui auront besoin de connaître la limite d'un string pour le script. Moi j'en ai eu besoin pour concaténer tous mes resrefs , et les stack items sur une seule chaine et quand cela dépassait les 510 alors je créé une autre variable et ainsi de suite .
Ah oui j'oubliais, compte tenu du fait que la manipulation de 0 ou de 1 peut être un peu fastidieuse, je me suis fait une petite feuille exel pour me faciliter le boulot, c'est pas grand chose mais terriblement pratique.
Feuille de calcul exel

Jaha Effect

PS: à noter que la chaine n'est pas obligatoirement une suite de 0 ou de 1
Le lien marche passsssss

Tu as essayé une autre solution ?

Tu pourrai retourner l alignement du joueur de la facon suivant : ( dsl, je repompe le corps principal pour allez plus vite )

Code PHP:

/***********************************************/
/* Fonction : GetAlignement                    */
/*            Par Mirandiel                    */
/*            Copyrith Althea                  */
/***********************************************/
string GetAlignement(object oPC)
{
  
string alphabeta;
  switch (
GetAlignmentLawChaos(oPC))
  {
    case 
ALIGNMENT_LAWFULalpha 0;break;
    case 
ALIGNMENT_NEUTRALalpha break;
    case 
ALIGNMENT_CHAOTICalpha break;
  }
  switch (
GetAlignmentGoodEvil(oPC))
  {
    case 
ALIGNMENT_GOODbeta break;
    case 
ALIGNMENT_NEUTRALbeta =break;
    case 
ALIGNMENT_EVILbeta break;
  }
  return 
alpha+beta;

pour ensuite t en servir comme ca :

Code PHP:

/***********************************************/
/* Fonction : GetIsValidAlignement             */
/*            Par Jaha Effect                  */
/*            le 27/03/2003                    */
/***********************************************/
int GetIsValidAlignement (object oPC)
{
    
string sGodID;
    
string sAlignValue GetLocalString(oMod"STR_GOD_ALIGN_"+sGodID);//sGodID correspond au nom
                                                                       // du dieu mais on s'en fout pour l'exemple
    
int nPCAlign GetAlignement(oPC);
    
int nPCAlignVsGod;
    
int nReturn 0;

      if (
oPC != OBJECT_INVALID)
        {
            
nPCAlignVsGod StringToInt(GetSubString(sAlignValuenPCAlign1));
                  if (
nPCAlignVsGod == 1)
                     {
                             
nReturn 1;
                     }
        }
        return 
nReturn;

et ca marche ( je pense ........ )
L'inconvenient, c'est qu il n y pas le retour sur l alignement du joueur. :/

PS : Quand meme, j allucine tout le temp sur le travail que vous fournissez ( les scripteur, modeleur et autres ) !! Merci a tous
bien en fait, je m'excuse, mais je ne vois pas trop l'interet la

Peut être que je me trompe, mais comme tu utilise une chaine, la compression binaire n'a pas vraiment d'interet, autant laisser ca en caractères :
ainsi tu laisse ta chaine donnant l'alignement sous cette forme :
"LB", ou "CN", "NN", etc... et tu n'as plus qu'a faire :
Code PHP:

sChar GetSubString(sAlignValue11);
if(
sChar == LnAlignLC ALIGNEMENT_LOYAL;
if(
sChar == LnAlignLC ALIGNEMENT_NEUTRE;
if(
sChar == LnAlignLC ALIGNEMENT_CHAOTIC;

sChar GetSubString(sAlignValue21);
if(
sChar == LnAlignLC ALIGNEMENT_GOOD;
if(
sChar == LnAlignLC ALIGNEMENT_NEUTRAL;
if(
sChar == LnAlignLC ALIGNEMENT_EVIL
bon, peut être que j'ai rien compris au principe, mais j'ai l'impression que tu fais beaucoup d'effort pour arriver à un resultat bien moins interessant

EDIT : oui je viens de regarder la seconde solution, c'est déjà plus optimisé (plus interessant que ma solution).

Bon, après si vous voulez, je peux vous faire rentrer ca sur un seul caractère
Citation :
Provient du message de Azrael07
bien en fait, je m'excuse, mais je ne vois pas trop l'interet la
Ben le problème c'est que tu te cantonne à l'exemple et au moyen de l'optimiser, or on s'en fout complètement ce n'est qu'un exemple.
L'interet est dans le stockage des constante, leur récupération en a moins puisqu'on peut faire à peut près se qu'on veux après.
Dans mon cas, dans un seul local string je stock pour un même dieu la totalité des alignements que peut prendre un fidèle (9charactères), les feats qu'il autorise (19 caractères développe sur le fichier exel) et le resref de l'objet créature qui est utilisé pour stocker la déité (3 caractères)
Ca nous donnera une string du genre sous forme:resref+alignement+feat

Code PHP:

SetLocalString(oMod,"STR_GOD_ID_ABBATHOR""abb0010010010000010000000000100"); 

Le binaire ne sert qu'a simplifier l'écriture, on pourrait tout aussi bien utiliser O ou N. De plus, cette methode devient interressante quand on a une grande quantité de constante a gérer.

Jaha Effect
Le soucie c'est que vous essayez de trop voir le résultat du script de Jaha. Alors que ce n'est pas du tout le but , son script n'est là que pour vous faire comprendre et faire office de tutorial avec toutes ses explications .
D'un point de vue simplifier, imaginez que c'est une autre manière d'utiliser un tableau.

Je trouve ça méthode tout à fait réussi.
Même si par définition, ce n'est pas du vrai binaire, et que nous pourrions tout à fait utiliser plusieurs chiffres.
Mais comme le binaire, il permet d'activer ou de désactiver un don, une compétence, etc...
Avec une chaine composé de X 0 et de X 1 . Chaque 0 et 1 sont reliés à une constante, la valeur changeant juste pour dire que telle compétence est activé oui ou non .

Voilà, je ne sais pas si j'ai bien expliqué, mais l'idée est là .

Moi je peux juste vous dire, qu'avec ça, cela va me donner plein d'idée pour optimiser certains de mes scripts dans l'avenir, si j'ai beaucoup de constante.

Voilouuu
Regardez les tous les 2 ! Bientot, ca va devenir cochon

Sinon, sympa ta petite feuille ( ca marche au boulot ), ca permet de pas se planter en oubliant un 0.

Il est vrai que je n avais vu que l exemple, et c'est vrai qu il y a un grand interet a stocker sous cette forme les valeurs, le tout etant de bien se souvenir quelle partie est quoi.

Ca me fait penser que ma methode pour stocker alignement peut servir a plein de chose et surtout d eviter d appeler les fonctions GetAlignmentxxxxx(oPC) a tout bout de champ ............ reste a appliquer ........

Bonne journée a vous
Ah ok, je n'avais pas compris que ce n'était qu'un exemple ^_^

disons que c'est un peu con de faire ca si on a que des 1 et 0, c'est lourd alors qu'on peut le faire rentrer bien plus vite. S

inon dans les autres cas..... bien moi aussi j'utilise souvent ce système, c'est vachement pratique pour définir les propriétés d'un objet, item ou autre simplement avec son tag (ca évite les SetLocalMachin dans le OnSpawn, puis c'est moins lourd )
Dans mon cas je préfère le SetLocalString car l'objet qui gère ça est appelé a disparaitre avec la persistance de Bioware pour me libérer le slot carmour.
Si tu connais un moyen de stocker toute les infos plus vite je suis preneur.

Jaha Effect
Citation :
Si tu connais un moyen de stocker toute les infos plus vite je suis preneur.
le problème, c'est que le cas est télement différent selon les exemple qu'il est difficile de faire un cas général.

Enfin je suis loin de critiquer ta méthode, comme je l'ai dit je l'utilise dans certains cas
@Caarheim sur une petite correction sur ton script

Code PHP:

int GetAlignement(object oPC)
{
  
int alphabeta;
  switch (
GetAlignmentLawChaos(oPC))
  {
    case 
ALIGNMENT_LAWFULalpha 0;break;
    case 
ALIGNMENT_NEUTRALalpha 3; break;
    case 
ALIGNMENT_CHAOTICalpha 6; break;
  }
  switch (
GetAlignmentGoodEvil(oPC))
  {
    case 
ALIGNMENT_GOODbeta 0; break;
    case 
ALIGNMENT_NEUTRALbeta =1; break;
    case 
ALIGNMENT_EVILbeta 2; break;
  }
  return 
alpha+beta;

J'ai juste rajouté quelques ; qui manquaient et passé les valeur de retour en int.

Jaha Effect
Répondre

Connectés sur ce fil

 
1 connecté (0 membre et 1 invité) Afficher la liste détaillée des connectés