Parser XML pour NWN

Par Gargantuel le 8/8/2002 à 23:32:07 (#1936991)

Je sais pas si je vais pas passer pour un taré mais je le dis quand meme.
N'ayant pas trouvé de petit parser pour NWN j'ai fini par faire le mien et ayant décidé de faire les choses bien, j'ai respecté le standard XML (niveau très basic). Heuuu, arretez de me regarder comme si l'etait un extra-terrestre, je vous assure que c'est tres utile ! Non, je ne suis pas fou ! Non pas la camisole ! Haaaa ...

A quoi ca sert me direz vous ?
A plein de choses : stocker des données complexes, gerer une petite base de données en mémoire, exporter des informations via la log (génération de statistiques par exemple) etc ...
Personnellement je m'en sers pour sauvegarder/restaurer la persistance d'un module semi-persistant. :)

Limitation : Le nombre d'instruction a été limité par bioware au niveau d'un script :enerve: .
Il vous sera peut etre nécessaire de spliter vos executions complexes (genre restauration complete du module) en plusieurs ExecuteScript() :(

Voila la bete a mettre en include tout simplement :

///////////////////////////////
// FileName xml_parser //
///////////////////////////////
// Created By: Gargantuel //
// Created On: 8/8/2002 //
///////////////////////////////
// Constantes
string XML_START = ";
string XML_EQUAL = "=";
string XML_SEPARATOR = " ";
string XML_SLASH = "/";
string XML_STRING_START = "'";
string XML_STRING_END = "'";
string XML_INVALID_PARAMETER = "XML_INVALID_PARAMETER";
string XML_INVALID_VALUE = "XML_INVALID_VALUE";
string XML_INVALID_TAG = "XML_INVALID_TAG";

// Construit un parametre d'un tag XML
// renvoi = param="value" ou XML_INVALID_PARAMETER ou XML_INVALID_VALUE
string BuildXMLParameter(string sParam, string sValue);

// renvoi le nom du tag
// ou INVALID_TAG
string GetXMLName(string sTag);

// renvoi la 1ere valeur du parametre dans le string
// ou INVALID_PARAMETER
string GetXMLParameterValue(string sTag, string sParameter);

// Supprime un parametre d'un tag
// renvoi le nouveau tag ou le tag existant
string RemoveXMLParameter(string sTag, string sParameterName);

// Change ou ajoute un parametre d'un tag
// renvoi le nouveau tag ou INVALID_PARAMETER ou INVALID_TAG ou INVALID_VALUE
string SetXMLParameter(string sTag, string sParameter, string sValue);

// Renvoi la section gauche du tag (exemple )
// ou INVALID_TAG
string GetXMLStartTag(string sTag);

// Renvoi la section droite du tag (exemple )
// ou INVALID_TAG
string GetXMLEndTag(string sTag);

// renvoi la valeur d'un tag XML
// ou INVALID_TAG
string GetXMLValue(string sTag);

// Affecte la valeur d'un tag XML
// renvoi le nouveau tag XML ou INVALID_TAG ou INVALID_VALUE
string SetXMLValue(string sTag, string sValue);

// Construit un tag XML
// renvoi un nouveau tag XML ou INVALID_TAG
string BuildXMLTag(string sTagName, string sValue=");

// Renvoi le curseur du 1er tag trouvé dans la chaine de caractere à
// partir du curseur ou -1
int MoveFirstXMLTag(string sData, string sTagName=", int iCursor=0);

// Deplace le curseur sur le tag suivant trouvé dans la chaine de caractere à
// partir du curseur ou -1
int MoveNextXMLTag(string sData, string sTagName=", int iCursor=0);

// Renvoi le curseur du 1er precedent tag trouvé dans la chaine de caractere
// à partir du curseur ou -1
int MovePreviousXMLTag(string sData, string sTagName=", int iCursor=0);

// Renvoi le premier tag trouvé dans la chaine de caractere à partir du
// caractere ou INVALID_TAG
string GetXMLTag(string sData, string sTagName=", int iCursor=0);

// Renvoi le champs données avec le tag supprimé à partir du curseur
// ou INVALID_TAG
string RemoveXMLTag(string sData, string sTagName=", int iCursor=0);

// Renvoi le champs données avec le tag ajouté ou modifié à partir du curseur
// ou INVALID_TAG
string SetXMLTag(string sData, string sTag, int iCursor=0, int iAdd=0);

// Construit un parametre d'un tag XML
// renvoi = param="value" ou XML_INVALID_PARAMETER ou XML_INVALID_VALUE
string BuildXMLParameter(string sParam, string sValue)
{
if (sParam == " ||
FindSubString(sParam, XML_STRING_START) != -1 ||
FindSubString(sParam, XML_STRING_END) != -1)
return XML_INVALID_PARAMETER;

if (FindSubString(sValue, XML_STRING_START) != -1 ||
FindSubString(sValue, XML_STRING_END) != -1)
return XML_INVALID_VALUE;

return (sParam + XML_EQUAL + XML_STRING_START + sValue + XML_STRING_END);
}

// renvoi le nom du tag
// ou XML_INVALID_TAG
string GetXMLName(string sTag)
{
int iCursorStart = FindSubString(sTag, XML_START);
if (iCursorStart == -1)
return XML_INVALID_TAG;
iCursorStart += GetStringLength(XML_START);
int iCursorEnd = FindSubString(GetSubString(sTag, iCursorStart, -1), XML_SEPARATOR);;
int iTemp = FindSubString(GetSubString(sTag, iCursorStart, -1), XML_END);
if (iCursorEnd == -1 && iTemp == -1)
return XML_INVALID_TAG;
if (iCursorEnd == -1 || (iCursorEnd > iTemp && iTemp != -1))
iCursorEnd = iTemp;
return GetSubString(sTag, iCursorStart, (iCursorEnd-iCursorStart+1));
}

// renvoi la 1ere valeur du parametre dans le string
// ou INVALID_PARAMETER
string GetXMLParameterValue(string sTag, string sParameter)
{
// Recherche du parametre
string sSearch = sParameter + XML_EQUAL + XML_STRING_START;
int iCursorStart = FindSubString(sTag, sSearch);
if (iCursorStart == -1)
return XML_INVALID_PARAMETER;
iCursorStart += GetStringLength(sSearch);

// Recherche de la fin du parametre
int iCursorEnd = FindSubString(GetSubString(sTag, iCursorStart, -1), XML_STRING_END);;
if (iCursorEnd == -1)
return XML_INVALID_PARAMETER;

// Retourne la valeur
return GetSubString(sTag, iCursorStart, iCursorEnd);
}

// Supprime un parametre d'un tag
// renvoi le nouveau tag ou le tag existant
string RemoveXMLParameter(string sTag, string sParameterName)
{
// Construction du parametre
string sParameterValue = GetXMLParameterValue(sTag, sParameterName);
if (sParameterValue == XML_INVALID_PARAMETER)
return sTag;
string sSearch = sParameterName + XML_EQUAL + XML_STRING_START + sParameterValue + XML_STRING_END;
int iCursorStart = FindSubString(sTag, sSearch);
if (iCursorStart == -1)
return sTag;
int iCursorEnd = iCursorStart + GetStringLength(sSearch);
// Si un espace suit, on l'enleve aussi
if (GetSubString(sTag, iCursorEnd, GetStringLength(XML_SEPARATOR)) == XML_SEPARATOR)
iCursorEnd++;

// Retourne le tag sans le parametre
return (GetSubString(sTag, 0, (iCursorStart-1))+GetSubString(sTag, iCursorEnd, -1));
}

// Change ou ajoute un parametre d'un tag
// renvoi le nouveau tag ou INVALID_PARAMETER ou INVALID_TAG ou INVALID_VALUE
string SetXMLParameter(string sTag, string sParameter, string sValue)
{
// Recupere le nom du tag
string sTagName = GetXMLName(sTag);
if (sTagName==XML_INVALID_TAG)
return XML_INVALID_TAG;

// Verifie que la valeur ne comporte pas de caractere incorrect
if (FindSubString(sValue, XML_STRING_START) != -1 ||
FindSubString(sValue, XML_STRING_END) != -1)
return XML_INVALID_VALUE;

// Verifie que le parametre ne comporte pas de caractere incorrect
if (FindSubString(sParameter, XML_STRING_START) != -1 ||
FindSubString(sParameter, XML_STRING_END) != -1 ||
FindSubString(sParameter, XML_EQUAL) != -1 ||
FindSubString(sParameter, XML_SEPARATOR) != -1 ||
FindSubString(sParameter, XML_START) != -1 ||
FindSubString(sParameter, XML_END) != -1 ||
FindSubString(sParameter, XML_SLASH) != -1)
return XML_INVALID_PARAMETER;

// Construction du nouveau parametre
string sNewParam = XML_SEPARATOR + sParameter + XML_EQUAL + XML_STRING_START + sValue + XML_STRING_END;

// recherche de la position ou inserer le parametre
string sStart = XML_START + sTagName;
int iCursorStart = FindSubString(sTag, sStart);
if (iCursorStart == -1)
return XML_INVALID_TAG;
iCursorStart += GetStringLength(sStart);
// Suppression de l'ancien parametre
sTag = RemoveXMLParameter(sTag, sParameter);
// Renvoi le nouveau tag
return (GetSubString(sTag, 0, (iCursorStart)) +
sNewParam +
GetSubString(sTag, iCursorStart, -1));
}

// Renvoi la section gauche du tag (exemple )
// ou INVALID_TAG
string GetXMLStartTag(string sTag)
{
string sTagName = GetXMLName(sTag);
if (sTagName==XML_INVALID_TAG)
return XML_INVALID_TAG;

// recherche de la position ou inserer le parametre
string sStart = XML_START + sTagName;
int iXMLLeftTagStart = FindSubString(sTag, sStart);
if (iXMLLeftTagStart == -1)
return XML_INVALID_TAG;
int iCursor = iXMLLeftTagStart + GetStringLength(sStart);

// Recherche d'un XML_END qui ne soit pas dans un parameter value
int iXMLLeftTagEnd = 0;
int iFound = FALSE;
while (iFound == FALSE)
{
iXMLLeftTagEnd = FindSubString(GetSubString(sTag, iCursor, -1), XML_END);
if (iXMLLeftTagEnd == -1)
return XML_INVALID_TAG;

int iStringPair = 0;
int i=0;
for(i=iCursor; i<(iCursor+iXMLLeftTagEnd); i++)
{
string sChar = GetSubString(sTag, i, 1);
if (sChar == XML_STRING_START && iStringPair == 0)
iStringPair = 1;
else if (sChar == XML_STRING_END && iStringPair == 1)
iStringPair = 0;
}
if (iStringPair == 0)
iFound = TRUE;
iCursor += iXMLLeftTagEnd;
}
return GetSubString(sTag, iXMLLeftTagStart, (iCursor+1));
}

// Renvoi la section droite du tag (exemple )
// ou INVALID_TAG
string GetXMLEndTag(string sTag)
{
string sTagName = GetXMLName(sTag);
if (sTagName==XML_INVALID_TAG)
return XML_INVALID_TAG;

string sXMLStart = GetXMLStartTag(sTag);
if (sXMLStart == XML_INVALID_TAG)
return XML_INVALID_TAG;

int iXMLValueStart = FindSubString(sTag, sXMLStart) + GetStringLength(sXMLStart);

string sXMLEnd = XML_START + XML_SLASH + sTagName + XML_END;
int iXMLValueEnd = FindSubString(GetSubString(sTag, iXMLValueStart, -1), sXMLEnd);
if (iXMLValueEnd == -1)
return XML_INVALID_TAG;

return sXMLEnd;
}


// renvoi la valeur d'un tag XML
// ou INVALID_TAG
string GetXMLValue(string sTag)
{
// Recuperation du debut du tag
string sXMLStart = GetXMLStartTag(sTag);
if (sXMLStart == XML_INVALID_TAG)
return XML_INVALID_TAG;

// Recuperation de la fin du tag
string sXMLEnd = GetXMLEndTag(sTag);
if (sXMLEnd == XML_INVALID_TAG)
return XML_INVALID_TAG;

// Recherche de la fin de la valeur
int iXMLValueStart = FindSubString(sTag, sXMLStart) + GetStringLength(sXMLStart);
int iXMLValueEnd = FindSubString(GetSubString(sTag, iXMLValueStart, -1), sXMLEnd);

return GetSubString(sTag, iXMLValueStart, iXMLValueEnd);
}

// Affecte la valeur d'un tag XML
// renvoi le nouveau tag XML ou XML_INVALID_TAG ou XML_INVALID_VALUE
string SetXMLValue(string sTag, string sValue)
{
// Recuperation du debut du tag
string sXMLStart = GetXMLStartTag(sTag);
if (sXMLStart == XML_INVALID_TAG)
return XML_INVALID_TAG;

// Recuperation de la fin du tag
string sXMLEnd = GetXMLEndTag(sTag);
if (sXMLEnd == XML_INVALID_TAG)
return XML_INVALID_TAG;

// Vérifie que la fin du tag n'est pas présente dans la valeur
if (FindSubString(sValue, sXMLEnd) != -1)
return XML_INVALID_VALUE;

return (sXMLStart + sValue + sXMLEnd);
}

// Construit un tag XML
// renvoi un nouveau tag XML ou XML_INVALID_TAG ou XML_INVALID_VALUE
string BuildXMLTag(string sTagName, string sValue=")
{
// Verifie que le nom du tag ne comporte pas de caractere incorrect
if (FindSubString(sTagName, XML_STRING_START) != -1 ||
FindSubString(sTagName, XML_STRING_END) != -1 ||
FindSubString(sTagName, XML_EQUAL) != -1 ||
FindSubString(sTagName, XML_SEPARATOR) != -1 ||
FindSubString(sTagName, XML_START) != -1 ||
FindSubString(sTagName, XML_END) != -1 ||
FindSubString(sTagName, XML_SLASH) != -1)
return XML_INVALID_TAG;

string sXMLStart = XML_START + sTagName + XML_END;
string sXMLEnd = XML_START + XML_SLASH + sTagName + XML_END;

// Vérifie que la fin du tag n'est pas présente dans la valeur
if (FindSubString(sValue, sXMLEnd) != -1)
return XML_INVALID_VALUE;

return (sXMLStart + sValue + sXMLEnd);
}

// Renvoi le curseur du tag suivant trouvé dans la chaine de caractere à
// partir du curseur ou -1
int MoveFirstXMLTag(string sData, string sTagName=", int iCursor=0)
{
int iFound = FALSE;
int iCursorStart = 0;
string sDataWork = ";
while (iFound == FALSE)
{
sDataWork = GetSubString(sData, iCursor, -1);
// recherche d'un debut de tag
iCursorStart = FindSubString(sDataWork, XML_START);
if (iCursorStart == -1)
return -1;
int iTagNameLength = FindSubString(GetSubString(sDataWork, iCursorStart, -1), XML_SEPARATOR);
int iTemp = FindSubString(GetSubString(sDataWork, iCursorStart, -1), XML_END);
if (iTagNameLength == -1 && iTemp == -1)
return -1;
if (iTagNameLength == -1 || (iTagNameLength > iTemp && iTemp != -1))
iTagNameLength = iTemp;
string sTagFound = GetSubString(sDataWork, (iCursorStart+1), (iTagNameLength-1));
if (sTagName == " || sTagName == sTagFound)
{
// recherche de la fin de ce tag
string sXMLEnd = XML_START + XML_SLASH + sTagFound + XML_END;
// Vérifie que la fin du tag est présente
if (FindSubString(GetSubString(sDataWork, (iCursorStart+1), -1), sXMLEnd) != -1)
iFound = TRUE;
}
if ( iFound == FALSE)
iCursor += iCursorStart + 1;
}
return (iCursor + iCursorStart);
}

// Deplace le curseur sur le tag suivant trouvé dans la chaine de caractere à
// partir du curseur ou -1
int MoveNextXMLTag(string sData, string sTagName=", int iCursor=0)
{
iCursor = MoveFirstXMLTag(sData, sTagName, iCursor);
if (iCursor == -1)
return -1;
iCursor++;
return MoveFirstXMLTag(sData, sTagName, iCursor);
}


// Renvoi le curseur du 1er precedent tag trouvé dans la chaine de caractere
// à partir du curseur ou -1
// int MovePreviousXMLTag(string sData, string sTagName=", int iCursor=0);
// To be implemented later ... (tired :p )

// Renvoi le premier tag trouvé dans la chaine de caractere à partir du
// caractere ou INVALID_TAG
string GetXMLTag(string sData, string sTagName=", int iCursor=0)
{
iCursor = MoveFirstXMLTag(sData, sTagName, iCursor);
if (iCursor == -1)
return XML_INVALID_TAG;
string sDataWork = GetSubString(sData, iCursor, -1);
string sXMLTagLeft = GetXMLStartTag(sDataWork);
if (sXMLTagLeft == XML_INVALID_TAG)
return XML_INVALID_TAG;
string sXMLTagRight = GetXMLEndTag(sDataWork);
if (sXMLTagRight == XML_INVALID_TAG)
return XML_INVALID_TAG;
int iTagLength = FindSubString(sDataWork, sXMLTagRight) + GetStringLength(sXMLTagRight);
return GetSubString(sDataWork, 0, iTagLength);
}
// Renvoi le champs données avec le tag supprimé à partir du curseur
// ou le champs tel quel
string RemoveXMLTag(string sData, string sTagName=", int iCursor=0)
{
int iCursorStart = MoveFirstXMLTag(sData, sTagName, iCursor);
if (iCursorStart == -1)
return XML_INVALID_TAG;
string sTag = GetXMLTag(sData, sTagName, iCursorStart);
if (sTag == XML_INVALID_TAG)
return XML_INVALID_TAG;
int iCursorEnd = iCursorStart + GetStringLength(sTag);
return (GetSubString(sData, 0, (iCursorStart)) + GetSubString(sData, iCursorEnd, -1));
}

// Renvoi le champs données avec le tag ajouté ou modifié à partir du curseur
// ou INVALID_TAG
// Note : iCursor à -1 veut dire que le tag doit etre ajouté systématiquement
string SetXMLTag(string sData, string sTag, int iCursor=0, int iAdd=0)
{
string sTagName = GetXMLName(sTag);
if (sTagName == XML_INVALID_TAG)
return XML_INVALID_TAG;
if (iAdd != 1)
iCursor = MoveFirstXMLTag(sData, sTagName, iCursor);
if (iCursor == -1 || iAdd == 1)
return (sData + sTag);

sData = RemoveXMLTag(sData, sTagName, iCursor);
if (sData == XML_INVALID_TAG)
return XML_INVALID_TAG;
return (GetSubString(sData, 0, (iCursor)) + sTag + GetSubString(sData, (iCursor), -1));
}

Par yenal le 9/8/2002 à 1:48:48 (#1937445)

C MONSTRUEUX J'Y COMPREND RIEN !!
vala comme ca je crois que g bien resumé la cituation....
:D

Par Alendril le 9/8/2002 à 2:13:53 (#1937506)

Un grand merci à toi, encore une fois Gargantuel !

Par znog32 le 9/8/2002 à 2:38:58 (#1937556)

*impressionné, quoiqu'il n'y pige que kouick*

comme d'hab je te conseille de poster ca au moins sur le forum Bioware approprié, voire dans d'autres bibliothèques de scripts, comme celle de nw connections : http://neverwinterconnections.com/scripts/index.cfm/fuseaction/scripts.htm

Par Amaranthe le 9/8/2002 à 9:57:57 (#1938267)

Alors là !

Chapeau !

Par Daeron le 9/8/2002 à 11:27:33 (#1938602)

aïe aïe aïe là je me revois dans mes cours de Java l'année dernière avec des progs énormes à construire que je galérais comme un vrai galérien :mdr:
Impressionant en tout cas...

Par Gargantuel le 9/8/2002 à 15:46:33 (#1939925)

Provient du message de znog32
comme d'hab je te conseille de poster ca au moins sur le forum Bioware approprié, voire dans d'autres bibliothèques de scripts, comme celle de nw connections : http://neverwinterconnections.com/scripts/index.cfm/fuseaction/scripts.htm

C'est fait :
http://nwn.bioware.com/forums/viewtopic.html?topic=120704&forum=47&sp=0#1043805

Par Kemay le 11/8/2002 à 15:18:16 (#1946502)

Comme je vois que tu t'es déjà bien penché sur les logs et le "parsing", j'en profite pour poser deux questions rapides :

1) Est-ce que tu as repéré une taille maximum pour les logs ?
2) Tu parles d'un nombre de limite d'instructions par script, une idée du nombre ou une approximation ?

Merci d'avance! :)

Par tonton le grognon le 12/8/2002 à 8:01:47 (#1949282)

heu... la je suis impressionné... et largué... quelqu'un me fait une explication "pour les quiches" de comment on se sert de ce truc..?

Par Baltord Vlad Mortem le 12/8/2002 à 9:50:35 (#1949516)

C'est du Grec ancien ? Une recette de cuisine Lituanienne ? Une chanson de Nana Mouskouri ?

:bouffon:

Par Styx31 le 12/8/2002 à 12:03:31 (#1950045)

Excellent, du grand art Gargantuel :)

J'ai de la chance, je fais parti des rares à qui ca doit parler un peu sans explications supplémentaires...

Alors je vais me lancer dans quelques explications pour les intéressés. Excusez mes termes barbares, mais je suis au taf, je rentre de 15 jours de congés et le boulot me tente pas trop.

Donc l'XML est en fait est un format que l'on a adopté pour avoir une "méthode-que-tout-le-monde-il-va-utiliser-la-même" de manière à ce que n'importe qui soit capable de lire/ecrire des données de manière compréhensible.

En gros, ils se sont mis d'accord (oui, les "ils", ceux du dessus là), ils ont dit "quand vous voudrez stocker des informations, vous le ferez comme ca, point-barre."

Et donc voilà.

A noter tout de même que l'XML sert à stocker des données. Donc, pour ceux qui ne le savent pas, un simili de base de donnée.

Pour ceux à qui ce terme ne parle pas, imaginez une table excel rudimentaire, avec des colonnes nommées (nom, adresse, etc.) et où chaque ligne correspond à un enregistrement (une liste d'adhérents par exemple).

A quoi ça ressemble ? Voici un exemple bête :

Tartampion
Luc
0512345678

Voici donc une fiche, délimitée par un représentant le début, et le représentant la fin.

A l'intérieur de cette fiche, on a plusieurs "champs" (ou plutôt "balises") (nom, prenom et telephone) qui sont renseignés.

Donc, si l'on voulait stocker une serie de fiches, on procèderai ainsi :

Tartampion
Luc
0512345678


Pioupiou
Jean
0287654321


Yoga
Chantal
0145671223

Et voilà.

Notez que l'on est obligé de respecter le schéma :

données

où les données peuvent être d'autres balises...

données
données

Et voici le genre d'erreur classique :

coucou

Grosse faute : les balises se "croisent", on ne sait plus où se trouvent les données.
L'intérêt de l'XML, c'est que ca peut tout de même aller assez loin.

Par exemple, on peut imbriquer indéfiniement les balises (les ), par exemple pour une fiche plus élaborée :

Tartampion
Luc
Homme



1, rue des tulipes
Perduville
12345
France


2, route des pins
Trouville
23456


Très gentil, brave toutou
Penser à lui donner sa patée à 16h tous les jours
Assez susceptible
A rappeller

Alors quelques explications sur les différences :

Tartampion
...

Voilà ce en quoi consiste l'imbrication.
Déjà, à partir de là, on oublie la ressemblance avec Excel, l'XML est déjà allé plus loin. On peut donc avoir des sortes de "sous-tables". Par exemple, dans un ligne excel avec votre fiche, en cliquant sur une cellule, vous tomberiez sur une nouvelle table contenant les infos de civilité de la personne.
Dans cet exemple précis, cela n'est d'aucune utilité puisqu'il n'y a qu'une ligne pour la civilité. Mais pour les adresses par exemple, on aura ainsi toutes les adresses de la fiche.

L'autre fonctionnalité est la possibilité de gérer les paramètres :

Cela sert à rajouter des informations sur la balise (l'exemple donné est assez explicite je pense). Notez qu'il peut y avoir plusieurs paramètres pour une adresse.

Notez aussi qu'entre deux balises et il peut y avoir plusieurs lignes de données pour la valeur... Comme dans l'exemple :

Très gentil, brave toutou
Penser à lui donner sa patée à 16h tous les jours
Assez susceptible
A rappeller

Notez que vous devez absolument trouver un moyen pour éviter d'utiliser les caractères " entre les balises. Je ne pense pas (où bien j'ai mal lu) que le parser de Gargantuel permette ce genre de manipulation. De même dans les paramètre, évitez les guillemets (") ;)

Pour les plus curieux, vous aurez remarqué que dans la seconde adresse, je n'ai pas renseigné le pays. En effet, il n'y a rien d'obligatoire en XML. Vous pouvez créer une balise adresse qui possède certains champs, puis la réutiliser plus tard avec d'autres champs. Donc c'est à vous, au moment ou vous lisez/écrivez vos données XML qu'il vous faut définir vos règles ("ce champ je ne le remplirai peut-être pas à chaque fois, donc il faudra que je le contrôle avant"). Sachez qu'en XML "évolué", il existe des fichiers qui permettent de donner des "règles" de structure à l'XML, empêchant ainsi que l'on fasse un fichier un peu n'importe comment.

Bon, voilà, si vous cherchez de la doc, je vous conseille ce site : commentcamarche, un excellent site sur la vulgarisation informatique.

Et si vous avez des question, PM ou bien quotez la partie qui vous embête et je tâcherai d'y répondre.

Et bon courage à tous ceux qui s'y mettent, et merci à Gargantuel !

PS : QQ questions à l'intéressé tt de même et aux autres : Comment faire en sorte que les données soient enregistrés dans le module, puis lues lors du chargement suivant (une sauvegarde serveur en sorte) ? Et cela est-il possible alors que l'on continue à faire évoluer le module dans Aurora ?

Par Styx31 le 12/8/2002 à 12:12:08 (#1950093)

En me relisant je m'aperçois que ça n'est pas très compréhensible pour celui qui ne connait vraiment pas...

donc je m'efforcerai d'améliorer les explications et de répondre aux questions :rolleyes: :D

Par Kemay le 12/8/2002 à 12:19:12 (#1950136)

Le principe de "sauvegarde de serveur" est de sortir des logs ayant une forme la plus proche possible d'un script NWN et contenant les variables que tu veux sauver juste avant de fermer le serveur. Avant de relancer ton seveur tu modifies le log pour qu'il ait exactement la syntaxe d'un script (en gros il s'agit surtout de remettre les guillemets " ) ainsi que l'extension .txt en .nss et tu attaches ce nouveau script à l'event onModuleLoading du module

Par Styx31 le 12/8/2002 à 12:22:10 (#1950154)

Okay, bidouille en force donc ;)

Par Caepolla le 12/8/2002 à 12:23:14 (#1950158)

Je ne pense pas que cela puisse me servir dans l'immédiat, mais en tout cas : bravo ! :)

Par Kemay le 12/8/2002 à 12:25:04 (#1950173)

Le toolset lui même ne semble qu'être une grosse bidouille, la moitié des fonctions et des events ne fonctionnent pas de la manière décrite pas Bioware (quand ils fonctionnent tout court)... Helas oui, tout ce qu'on peut faire avec NWN c'est de la bidouille et du contournement de bug :(

Par Baltord Vlad Mortem le 12/8/2002 à 13:37:04 (#1950507)

Bien que je connaisse le principe de l'XML et que je ne sois pas trop une quiche en NWN script j'avoue être totalement incapable de savoir l'utilité de ce script à partir du code de Gargantuel, c'est vraiment du gros boulot, impressionant :amour:

Gargantuel épouses moi :rolleyes: :mdr:

Par Styx31 le 12/8/2002 à 13:51:53 (#1950580)

J'ai presque l'impression qu'il faudrait une autre couche pour pouvoir se servir de ces scripts... Déjà préformatées pour certains utilisations. Genre une librairie "save_concours" pour sauvegarder des resultats, ou autre chose.

Par tonton le grognon le 12/8/2002 à 16:51:16 (#1951649)

moi, je veux un exemple de comment on peut se servir de l'infame machin de gargantu ;) surtout pour faire : "Personnellement je m'en sers pour sauvegarder/restaurer la persistance d'un module semi-persistant"

Par Agone OCN le 13/8/2002 à 19:03:35 (#1957647)

*soutien Tonton*

Oui il a raison !! c'est dommage un truc qui a l'air d'avoir demandé tant d'effort pour qu'au finale on ne voit que partiellement ce qu'on peut en faire si on est pas une quiche.

Apparement seul ceux qui s'y connaissent vraiment on compris a quoi ça sert, le probleme c'est justement que cela auraient, avec le meme courage que Gargantuel, pu arriver a ce resultat.

Pensez aux quiches comme moi je vous en pris :sanglote: c'est assez frustrant de ce dire qu'on a un magnifique outils a porté de main sans savoir/pouvoir s'en servir :(

En tout cas Bravo et merci a Gargantuel :hardos: :hardos: :hardos: :hardos:

Par Azrael07 le 14/8/2002 à 10:10:39 (#1960148)

Ben moi je connais un peu l'XML(mais un tout petit peu...), mais je suis pas convaincu de l'utilité de ce truc

Bon ca doit effectivement etre utile pour stocker un gd nombre de donner tout en gardant un truc pas trop bordélique, mais je ne suis pas sure qu'on soit obligé de passer par un truc de cette compexité

pourquoi ne pas compresser les données dans une local string ?

bon ok ce ki a au dessu c achement plus joli...

Enfinbon, si l'auteur de se script c fait chier cme ca c surement qu'il doit s'en servir...

Par BlackWings le 26/8/2002 à 23:32:58 (#2034001)

éteint ton module et relance le: fini ton string

Parse (lit) ton fichier log et crée un petit fichier en dur (sur disque dur).

Rallume ton serveur et parse ton fichier en dur et tu récupère tes variables...

Je penses que là, le "Franc est tombé"

:D

Par Gargantuel le 26/8/2002 à 23:47:19 (#2034109)

Provient du message de Styx31
QQ questions à l'intéressé tt de même et aux autres : Comment faire en sorte que les données soient enregistrés dans le module, puis lues lors du chargement suivant (une sauvegarde serveur en sorte) ? Et cela est-il possible alors que l'on continue à faire évoluer le module dans Aurora ?

J'ai couplé le parser avec le systeme PWUM.

PWUM est franchement basique car il stocke tout sur un seul objet.
Couplé au parser ca ma permis de sauvegarder l'etat des factions, la localisation des objets uniques et d'autres trucs du genre.

Pour info PWUM prends une variable string et te la colles dans ta log. Puis converti ta log en fichier include qui sera executé au démarrage de ton serveur.
Je m'en sers donc pour stocker mes messages XML.

Ce parser n'est qu'un moyen de stocker de l'information. C'est à chacun de programmer l'usage qu'il fera de ces informations.

Je pense aussi m'en servir pour qu'une page PHP lise la log en temps réelle et affiche des informations sur l'état du module, des joueurs, des quetes, etc ...

Par Skanzo Sylan le 27/8/2002 à 0:31:10 (#2034458)

C'est vraiment fantastique! :)

Moi-même j'ai rien pigé mais je sais que grâce à ça je pourrai récupérer la date et heure du serveur et l'utiliser dans mes scripts.

Gargantuel, si tu pouvais m'aider ne serait-ce qu'un petit peu... Wouah!! :D

Par Louis Kharn le 27/8/2002 à 9:02:16 (#2035918)

quand tu sort la version "compréhensible par les NOOOOOOOB" tu me la faxe ok?:rolleyes: :hardos: