Bienvenue sur JeuxOnLine - MMO, MMORPG et MOBA !
Les sites de JeuxOnLine...
 

Panneau de contr√īle

Recherche | Retour aux forums

JOL Archives

les sauvegardes de modules online

Par Obierwan le 2/10/2002 à 19:53:09 (#2271905)

J'ai un problème pour créer un script qui pourrait me permettre de faire une sauvegarde des objets sur le module en faisant une mise à jour.

J'avais l'idée de créer une banque ou chaque joueur, moyennant finance, pourrait avoir un coffre personnel dans lequel il pourrait mettre des objets auquel il tient.

Mais le problème se pose de la conservation des ces objets lors d'une mise à jour du module. En fait ce serait un script pour sauvegarder le contenu des coffres de la banque et les sauvegardes des pj lorsque l'on retouche au module. Car les PJ seront sauvegardés sur le serveur.

Merci d'avance :)

Par Gargantuel le 3/10/2002 à 18:13:51 (#2276745)

Est ce que votre monde persistant s'appuie déjà sur un système de sauvegarde ? (PWUM, PWDB, Itemizer, ...)

En ce qui me concerne j'avais une idée assez précise sur ca avec PWUM mais je ne l'ai pas encore réalisé.

Si tu veux en parler => ICQ ou MP

Par Tyn' le 3/10/2002 à 18:59:22 (#2277072)

J'ai fais un système d'émulation de tableaux de tags/quantités exactement au même sujet. Voilà la chose :
En OnOpen:

//::///////////////////////////////////////////////
//:: Ouverture d'un coffre a objets
//:: at_schest_open.nss
//:: Copyright (c) Althea 2002
//:://////////////////////////////////////////////
/*
Genere le contenu du coffre en fonction du
joueur qui l'ouvre.
*/
//:://////////////////////////////////////////////
//:: Créé par : Tynril
//:: Créé le : 16/09/2002
//:://////////////////////////////////////////////
#include "at_include"

void main()
{
object oPC = GetLastOpenedBy();
object oSelf = OBJECT_SELF;

string sInventory = GetFlagString(oPC,"CHEST_CONTENT");
string sItem = ";
string sTemp = sInventory;
int nLen = GetStringLength(sInventory);
int nSPos,nNumItem;
string sBuffer, sNum;
while(nLen > 0)
{
nSPos = FindSubString(sTemp,"#!!#");
sBuffer = GetStringLeft(sTemp,nSPos);
sItem = StrBefore(sBuffer,"#!#");
sNum = StrAfter(sBuffer,"#!#");
nNumItem = StringToInt(sNum);
Debug(oPC,"Item a invoquer : "+sItem+" x"+sNum);
CreateItemOnObject(sItem,oSelf,nNumItem);
sTemp = StrReplace(sTemp,sBuffer+"#!!#",");
nLen = nLen - GetStringLength(sBuffer+"#!!#");
}
}
En OnClose:
//::///////////////////////////////////////////////
//:: Fermeture d'un coffre a objets
//:: at_schest_close
//:: Copyright (c) Althea 2002
//:://////////////////////////////////////////////
/*
Sauvegarde le contenu du coffre a objet et le vide.
*/
//:://////////////////////////////////////////////
//:: Créé par : Tynril
//:: Créé le : 16/09/2002
//:://////////////////////////////////////////////
#include "at_include"

void main()
{
object oPC = GetLastClosedBy();
object oSelf = OBJECT_SELF;
string sContent;
object oItemInventory = GetFirstItemInInventory(oSelf);
while(GetIsObjectValid(oItemInventory))
{
DestroyObject(oItemInventory);
sContent = sContent+GetTag(oItemInventory)+"#!#"+IntToString(GetNumStackedItems(oItemInventory))+"#!!#";
oItemInventory = GetNextItemInInventory(oSelf);
}
SetFlagString(oPC,"CHEST_CONTENT",sContent);
}
Ces scripts s'appuye sur deux bibliothèques :
Gestion des strings:
//::///////////////////////////////////////////////
//:: Gestion avancee des chaines de caracteres
//:: at_strings.nss
//:: Copyright (c) Althea 2002
//:://////////////////////////////////////////////
/*
Bibliotheques de fonction de traitement
avance des chaines de caracteres.
*/
//:://////////////////////////////////////////////
//:: Créé par : Tynril
//:: Créé le : 21/09/2002
//:://////////////////////////////////////////////


//----------------------------------------------------------------------------
// CONSTANTES

// Succes de l'operation sur le Tokenizer.
int StrTOKENIZER_SUCCESS = 0;

// Erreur retournee si l'on essaye d'initialise un Tokenizer existant.
int StrTOKENIZER_EXISTS = -1;

// Erreur retournee si l'on essaye d'utiliser un Tokenizer non-initialise.
int StrTOKENIZER_NOTINITIALIZED = -2;

// Erreur retournee si l'on essaye d'utiliser un Tokenizer avec un Token vide.
int StrTOKENIZER_EMPTYTOKEN = -3;

// Erreur retournee si l'on essaye d'utiliser un Tokenizer avec une chaine vide.
int StrTOKENIZER_EMPTYSTRING = -4;



//----------------------------------------------------------------------------
// PROTOTYPES DE FONCTIONS ET DECLARATIONS

// Retourne les caracteres se trouvant avant sPattern.
// Exemple : StrBefore("Un chien"," ") -> "Un"
// Si sPattern n'est pas trouve dans la chaine, celle-ci est retournee entiere.
string StrBefore(string sSource, string sPattern);

// Retourne les caracteres se trouvant apres sPattern.
// Exemple : StrAfter("Un chien"," ") -> "chien"
// Si sPattern n'est pas trouve dans la chaine, celle-ci est retournee entiere.
string StrAfter(string sSource, string sPattern);

// Initialize the string tokenizer with a given string and token. Optionally,
// takes a tokenizer session, in case you need to run more than one tokenizer
// at a time. The tokenized string can be walked with the function
// StrTokenizerNext, and freed with StrTokenizerFree.
//
int StrTokenizerInitialize(string sStringToTokenize, string sToken, int iTokenizerSession = 0);

// Returns the next token-delimited string from a given initialized tokenizer,
// or " if the tokenizer is not initialized or empty of tokens. A tokenizer
// needs to be allocated with Strtokenizer_initialize and freed with
// Strtokenizer_free.
string StrTokenizerNext(int iTokenizerSession = 0);

// Frees an initialized tokenizer.
int StrTokenizerFree(int iTokenizerSession = 0);

// Turns a given string uppercase
string StrUpperCase(string sSource);

// Turns a given string lowercase
string StrLowerCase(string sSource);

// Replaces all instances of sReplaceMe in sSource with sNewText, and return
// the altered string. If sReplaceMe is empty, then sSource is immediately
// returned unaltered.
string StrReplace(string sSource, string sReplaceMe, string sNewText);

// Capitalize the first letter of a string. Useful for turning
// 'mister' into 'Mister', for example, in generating conversation or
// other text.
//
string StrCapStr(string sSource);

// Pads a string on the left with the pattern given.
string StrPadLeft(string sOriginal, int iPadTo, string sPadWith);

// Pads a string on the right with the pattern given.
string StrPadRight(string sOriginal, int iPadTo, string sPadWith);

// Returns the member position of the token in the string, beginning with 0,
// or -1 if the given token is not a member of the string list. Token must
// be a complete one.
//
int StrMember(string sList, string sToken, string sDelimit = " ", int iTokenizer = 969);

// Returns the number of tokens in a delimited list string, or -1 on error.
int StrMemberCount(string sList, string sDelimit = " ", int iTokenizer = 969);


//----------------------------------------------------------------------------
// ACTUAL FUNCTION SOURCES

// FUNCTION: StrBefore
//
// Returns the portion of sSource which is before the first occurance of
// sPattern. For example, Strbefore("Foo bar"," ") -> "Foo"
//
// If the pattern does not exist in the string, the entire string is returned.
string StrBefore(string sSource, string sPattern)
{
int iMarker;
string sResult;

// Sanity check!
if ((sPattern == ") || (sSource == "))
return sSource;

iMarker = FindSubString(sSource,sPattern);

if (iMarker >= 0) {
sResult = GetSubString(sSource,0,iMarker);
}
else {
sResult = sSource;
}

return sResult;
}

// FUNCTION: StrAfter
//
// Returns the portion of sSource which is after the first occurance of
// sPattern. For example, Strbefore("Foo bar"," ") -> "bar"
//
// If the pattern does not exist in the string, an empty string is returned.
string StrAfter(string sSource, string sPattern)
{
int iMarker, iMarkerLength;
string sResult;

// Sanity check!
if ((sPattern == ") || (sSource == "))
return ";

iMarkerLength = GetStringLength(sPattern);
iMarker = FindSubString(sSource,sPattern);

if (iMarker >= 0) {
sResult = GetSubString(sSource,iMarker + iMarkerLength,
GetStringLength(sSource) - (iMarker + iMarkerLength));
}
else {
sResult = ";
}

return sResult;
}

// FUNCTION: StrTokenizerInitialize
//
// Initialize the string tokenizer with a given string and token. Optionally,
// takes a tokenizer session, in case you need to run more than one tokenizer
// at a time. The tokenized string can be walked with the function
// Strtokenizer_next, and freed with Strtokenizer_free.
//
int StrTokenizerInitialize(string sStringToTokenize, string sToken,
int iTokenizerSession = 0)
{
// Sanity check to make sure we're not clobbering an existing token.
if (GetLocalString(OBJECT_SELF,"tokenizer_" + IntToString(iTokenizerSession) + "_token") != ") {
return StrTOKENIZER_EXISTS;
}

// Sanity check that we have a token.
if (sToken == ")
return StrTOKENIZER_EMPTYTOKEN;

// Sanity check that we have a string to tokenize!
if (sStringToTokenize == ")
return StrTOKENIZER_EMPTYSTRING;

// Set up our data for later.
SetLocalString(OBJECT_SELF,
"tokenizer_" + IntToString(iTokenizerSession) + "_token",
sToken);

SetLocalString(OBJECT_SELF,
"tokenizer_" + IntToString(iTokenizerSession) + "_stringbuf",
sStringToTokenize);

return StrTOKENIZER_SUCCESS;
}

// FUNCTION: StrTokenizerNext
//
// Returns the next token-delimited string from a given initialized tokenizer,
// or " if the tokenizer is not initialized or empty of tokens. A tokenizer
// needs to be allocated with Strtokenizer_initialize and freed with
// Strtokenizer_free.
//
string StrTokenizerNext(int iTokenizerSession = 0)
{
string sCurBuffer, sNewBuffer, sToken;

sToken = GetLocalString(OBJECT_SELF, "tokenizer_" +
IntToString(iTokenizerSession) + "_token");
sCurBuffer = GetLocalString(OBJECT_SELF, "tokenizer_" +
IntToString(iTokenizerSession) + "_stringbuf");

// Sanity check to make sure we have an initialized tokenizer
if (sToken == ")
return ";

sNewBuffer = StrBefore(sCurBuffer, sToken);
sCurBuffer = StrAfter(sCurBuffer, sToken);

SetLocalString(OBJECT_SELF, "tokenizer_" +
IntToString(iTokenizerSession) + "_stringbuf", sCurBuffer);

return sNewBuffer;
}

// FUNCTION: StrTokenizerFree
//
// Frees an initialized tokenizer.
//
int StrTokenizerFree(int iTokenizerSession = 0)
{
if (GetLocalString(OBJECT_SELF, "tokenizer_" +
IntToString(iTokenizerSession) + "_token") == ")
return StrTOKENIZER_NOTINITIALIZED;

DeleteLocalString(OBJECT_SELF, "tokenizer_" +
IntToString(iTokenizerSession) + "_token");
DeleteLocalString(OBJECT_SELF, "tokenizer_" +
IntToString(iTokenizerSession) + "_stringbuf");

return StrTOKENIZER_SUCCESS;
}

// FUNCTION: StrUpperCase
//
// Turns a given string uppercase
//
string StrUpperCase(string sSource)
{
string sResult;
string UppercaseLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string LowercaseLetters = "abcdefghijklmnopqrstuvwxyz";
int loop, marker;

// Sanity check!
if (sSource == ")
return ";

// Walk the string...
for (loop = 0; loop = 0) {
// If so, replace with a matching UppercaseLetter.
sChar = GetSubString(UppercaseLetters, marker, 1);
}

// Append the current character to the result.
sResult = sResult + sChar;
}

return sResult;
}

// FUNCTION: StrLowerCase
//
// Turns a given string lowercase
//
string StrLowerCase(string sSource)
{
string sResult;
string UppercaseLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string LowercaseLetters = "abcdefghijklmnopqrstuvwxyz";
int loop, marker;

// Sanity check!
if (sSource == ")
return ";

// Walk the string...
for (loop = 0; loop = 0) {
// If so, replace with a matching LowercaseLetter.
sChar = GetSubString(LowercaseLetters, marker, 1);
}

// Append the current character to the result.
sResult = sResult + sChar;
}

return sResult;
}

// FUNCTION: StrReplace
//
// Replaces all instances of sReplaceMe in sSource with sNewText, and return
// the altered string. If sReplaceMe is empty, then sSource is immediately
// returned unaltered.
//
string StrReplace(string sSource, string sReplaceMe, string sNewText)
{
string sResult;
int marker;

// Sanity check!
if (sSource == ")
return ";

// Sanity check!
if (sReplaceMe == ")
return sSource;

sResult = sSource;

// As long as an instance of our replace-string exists, keep walking
// the string and altering it.
while ((marker = FindSubString(sResult, sReplaceMe)) >= 0) {

// Isn't it nice to be able to reuse your own library functions?
sResult =
StrBefore(sResult, sReplaceMe) +
sNewText +
StrAfter(sResult, sReplaceMe);

}

return sResult;
}

// FUNCTION: StrCapStr
//
// Capitalize the first letter of a string. Useful for turning
// 'mister' into 'Mister', for example, in generating conversation or
// other text.
//
string StrCapStr(string sSource)
{
string sResult;
string UppercaseLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string LowercaseLetters = "abcdefghijklmnopqrstuvwxyz";
string sChar;
int iPos;

sChar = GetSubString(sSource, 0, 1);
iPos = FindSubString(LowercaseLetters, sChar);

if (iPos != -1) {
sChar = GetSubString(UppercaseLetters,iPos,1);
}

sResult = sChar + GetSubString(sSource,1,GetStringLength(sSource) - 1);

return sResult;
}

// FUNCTION: StrPadLeft
//
// Pads a string on the left with the pattern given.
string StrPadLeft(string sOriginal, int iPadTo, string sPadWith)
{
string sNew;

sNew = sOriginal;
while (GetStringLength(sNew) iPadTo) {
sNew = GetStringRight(sNew, iPadTo);
}

return sNew;
}

// FUNCTION: StrPadRight
//
// Pads a string on the right with the pattern given.
string StrPadRight(string sOriginal, int iPadTo, string sPadWith)
{
string sNew;

sNew = sOriginal;
while (GetStringLength(sNew) iPadTo) {
sNew = GetStringLeft(sNew, iPadTo);
}

return sNew;
}

// FUNCTION: StrMember
//
// Returns the member position of the token in the string, beginning with 0,
// or -1 if the given token is not a member of the string list. Token must
// be a complete one.
//
int StrMember(string sList, string sToken, string sDelimit = " ", int iTokenizer = 969)
{
string sTempKey;
int iCounter, iFound;

iCounter = 0;
iFound = -1;

if (StrTokenizerInitialize(sList, sDelimit, iTokenizer) != StrTOKENIZER_SUCCESS) {
return -1;
}

while (((sTempKey = StrTokenizerNext(iTokenizer)) != ") && (iFound == -1)) {
if (sTempKey == sToken) {
iFound = iCounter;
}
iCounter++;
}

StrTokenizerFree(iTokenizer);

return iFound;
}

// FUNCTION: StrMemberCount
//
// Returns the number of tokens in a delimited list string, or -1 on error.
//
int StrMemberCount(string sList, string sDelimit = " ", int iTokenizer = 969)
{
string sTempKey;
int iCounter;

iCounter = 0;

if (sList == ")
return 0;

if (FindSubString(sList, sDelimit) == -1)
return 0;

if (StrTokenizerInitialize(sList, sDelimit, iTokenizer) != StrTOKENIZER_SUCCESS) {
return -1;
}

while ((sTempKey = StrTokenizerNext(iTokenizer)) != ") {
iCounter++;
}

StrTokenizerFree(iTokenizer);

return iCounter;
}
Gestion des flags en parallèle avec PWUM:
//:: Definition des fonctions
// Fonction Althea
// Recupere le nom d'une variable flaguee sur un joueur
string GetFlagName(object oPlayer, string sFlag);
// Fonction Althea
// Defini le flag sFlag sur le joueur oPlayer a la valeur nValue
void SetFlagInt(object oPlayer, string sFlag, int nValue);
// Fonction Althea
// Defini le flag sFlag sur le joueur oPlayer a la valeur fValue
void SetFlagFloat(object oPlayer, string sFlag, float fValue);
// Fonction Althea
// Defini le flag sFlag sur le joueur oPlayer a la valeur sValue
void SetFlagString(object oPlayer, string sFlag, string sValue);
// Fonction Althea
// Defini le flag sFlag sur le joueur oPlayer a la valeur lValue
void SetFlagLocation(object oPlayer, string sFlag, location lValue);
// Fonction Althea
// Recupere le flag sFlag sur le joueur oPlayer
int GetFlagInt(object oPlayer, string sFlag);
// Fonction Althea
// Recupere le flag sFlag sur le joueur oPlayer
float GetFlagFloat(object oPlayer, string sFlag);
// Fonction Althea
// Recupere le flag sFlag sur le joueur oPlayer
string GetFlagString(object oPlayer, string sFlag);
// Fonction Althea
// Recupere le flag sFlag sur le joueur oPlayer
location GetFlagLocation(object oPlayer, string sFlag);

string GetFlagName(object oPlayer, string sFlag)
{
//Verification des informations fournies
string sReturn;
if(GetIsPC(oPlayer) && sFlag != ")
{ //Execution du script
//Recuperation des informations du joueur
string sPlayerName = GetPCPlayerName(oPlayer);
string sName = GetName(oPlayer);
string sPublicKey = GetPCPublicCDKey(oPlayer);
//Definition de la valeur
sReturn = sPlayerName+sPublicKey+sName+sFlag;
}else{ //Retour d'une erreur
//Definition de la valeur
sReturn = "ERREUR DANS L'APPEL DE LA FONCTION GetFlagName";
}
//Renvoit de la valeur
return sReturn;
}

void SetFlagInt(object oPlayer, string sFlag, int nValue)
{
Debug(oPlayer,"Flag "+sFlag+" du personnage "+GetName(oPlayer)+" defini a "+IntToString(nValue));
SetPWUMInt(GetFlagName(oPlayer,sFlag),nValue); //Enregistrement de la variable
}

void SetFlagFloat(object oPlayer, string sFlag, float fValue)
{
Debug(oPlayer,"Flag "+sFlag+" du personnage "+GetName(oPlayer)+" defini a "+FloatToString(fValue));
SetPWUMFloat(GetFlagName(oPlayer,sFlag),fValue);
}

void SetFlagString(object oPlayer, string sFlag, string sValue)
{
Debug(oPlayer,"Flag "+sFlag+" du personnage "+GetName(oPlayer)+" defini a "+sValue);
SetPWUMString(GetFlagName(oPlayer,sFlag),sValue);
}

void SetFlagLocation(object oPlayer, string sFlag, location lValue)
{
Debug(oPlayer,"Flag "+sFlag+" du personnage "+GetName(oPlayer)+" modifie");
SetPWUMLocationC(GetFlagName(oPlayer,sFlag),lValue);
}

int GetFlagInt(object oPlayer, string sFlag)
{
return GetPWUMInt(GetFlagName(oPlayer,sFlag));
}

float GetFlagFloat(object oPlayer, string sFlag)
{
return GetPWUMFloat(GetFlagName(oPlayer,sFlag));
}

string GetFlagString(object oPlayer, string sFlag)
{
return GetPWUMString(GetFlagName(oPlayer,sFlag));
}

location GetFlagLocation(object oPlayer, string sFlag)
{
return GetPWUMLocation(GetFlagName(oPlayer,sFlag));
}
Et le script des flags utilise une fonction Debug :
//:: Definition des constantes
int DEBUG_OFF = 0;
int DEBUG_PLAYER = 1;
int DEBUG_DM = 2;
int DEBUG_PLAYER_LOGS = 3;
int DEBUG_DM_LOGS = 4;
int DEBUG_TYPE = DEBUG_OFF;

//:: Definition des fonctions

// Fonction Althea
// Cree un debug
void Debug(object oPC, string sDebug);

void Debug(object oPC, string sDebug)
{
//Switch a qui envoyer le debug
switch(DEBUG_TYPE)
{
case 0:
//Pas de debug
break;
case 1:
case 3:
//Debug au joueur
if(GetIsPC(oPC))
{
SendMessageToPC(oPC,"DEBUG: "+sDebug);
}
break;
case 2:
case 4:
//Debug aux DMs
SendMessageToAllDMs("DEBUG: "+sDebug);
break;
default:
break;
}
//Switch pour inscription aux logs
switch(DEBUG_TYPE)
{
case 0:
case 1:
case 2:
//Pas de logs
break;
case 3:
case 4:
//Inscription aux logs
WriteTimestampedLogEntry("DEBUG: "+sDebug);
break;
default:
break;
}
}
J'espère que ça pourra t'aider :)

Mais non ce n'est pas indigeste :D

Par Tyn' le 4/10/2002 à 14:37:15 (#2281061)

Des modifications légères seront à faire en passage en 1.25, sur le script en OnOpen du coffre. Pour cause de disponibilité de GetResRef :amour:

JOL Archives 1.0.1
Par Mind