save system für rpg (Spielfortschritt und Optionen getrennt)

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • save system für rpg (Spielfortschritt und Optionen getrennt)

    Hi,
    ich habe schon extrem viel im Internet gesucht aber nichts wirklich hilfreiches gefunden.
    ich möchte für mein rpg ein besseres Speicher system erstellen. bisher mache ich das über das game maker basis speichern.
    ich möchte das 4 spiel stände möglich sind die alle spiel variablen und ähnliches enthalten aber nicht die Options variablen.
    die Options variablen sollen in einem 5. speicherpunkt gespeichert werden der nur diese variablen enthält und beim starten des Spiels geöffnet werden.
    Beim laden des spiels sollen die optionen beibehalten werden aber der spielstand geladen werden.
    In den Optionen ist z.B enthalten welches gui Design genutzt wird und welche bonusinhalte man schon freigeschaltet hat (via code)
    In den Spielständen soll alles andere drinn sein was sich im spiel verändert: die zeit (variablen time, day, jear) , die position wo der spieler steht (room,x,y) die spieler eigenschaften (name, birthday, char), beziehungen zu npcs, das inventory und viele weitere variablen.
    außerden sollen die räume beibehalten werden (bei den räumen ist der haken bei persistend aktiv)
    ps: einige Objekte haben status variablen die sich im laufe der zeit verändern, dies sind keine globalvars wie die bisher genanten sollen aber auch gespeichert werden.

    (zur Erklärung: mein rpg wird so was ähnliches wie harvest moon)

    kann mir bitte jemand helfen?

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von SnowNight ()

  • Klingt so als bräuchtest du ini dateien oder textdateien, wahlweise dann auch verschlüsselt.

    GML-Quellcode

    1. var file;
    2. file = working_directory + 'save.ini'
    3. ini_open(file);
    4. ini_write_real("room_01","keys",keys);
    5. ini_write_real("room_01","posx",x);
    6. ini_write_real("room_01","posy",y);
    7. ini_close();

    so etwa zB um abzuspeichern wo sich dein Charakter in room_01 befindet und wieviele Schlüssel er hat.
    und laden mit:

    GML-Quellcode

    1. var file;
    2. file = working_directory + 'save.ini';
    3. if file_exists(file)
    4. {
    5. ini_open(file);
    6. keys=ini_read_real("room_01","keys",0);
    7. x=ini_read_real("room_01","posx",0);
    8. y=ini_read_real("room_01","posy",0);
    9. ini_close();
    10. }
    11. else
    12. {
    13. SaveProgress();
    14. LoadProgress();
    15. }
    Alles anzeigen

    falls save.ini noch nciht existiert schreibt er eine standart savedatei mit den default werten und lädt diese dann.
    Mehr dazu findest du hier: docs.yoyogames.com/source/dadi…ling/ini files/index.html

    ancient-pixel.com
    youtube.com/user/SebastianMerkl <<< ich freu mich über einen Besuch ;)
  • Also muss ich alle variablen so einbinden:

    Quellcode

    1. var file;
    2. file = working_directory + 'save.ini'
    3. ini_open(file);
    4. //ini_write_real("???",variablenname,name) fur jede variable
    5. ini_close();

    oder?
    Frage:
    1. was ist mit den persistend sachen des raumes?**
    2. was ist mit Object bezogenen variablen die merfach vorkommen?*
    3. kann ich stad save.ini auch save1.ini nutzen?

    *z.b Feldpflanzen haben den wert growstate der natürlich öfter vorkommt
    ** ich nutze das um draußen herumliegende items beizubehalten
  • Zu drittens:
    die Datei kann so heißen wie du willst, also auch save1.ini
    room_01 war in dem Beispiel dann eine Section der ini datei, also ein art kapitel, darin gibts dann quasi unterkapitel bzw stichwörter und die haben einen Wert gespeichert

    GML-Quellcode

    1. ini_write_real(Section/Kapitel,key/Stichwort,Wert);
    2. variable = ini_read_real(Section/Kapitel,key/Stichwort,StandartWertFallsKeinWertExisitert);


    2.: Das ist schon schwieriger und ist vielleicht sogar besser mit Textdateien zu lösen, aber das Prinzip ist so: Du gehst in einer Schleife, alle Objekte durch und speicherst ID/Typ, Position, bestimmte Variablen ab. Falls ein Objekt 2 und das andere 3 interne Variablen hat, speicherst du zB einfach 0 ab. Beim Laden des Raums wird im Creation Code jedes Objekts, in der Datei nach seiner ID/Typ gesucht und die Werte daraus geladen.

    1.: Also die persistenz ist kein Problem, du musst nur beim verlassen des Raumes alle wichtigen Variablen speichern und beim Eintritt eines Raums laden. Weil die persistenz der Räume vom Gamemaker so nicht abgespeichert wird.


    Ja, das ganze ist sehr umfangreich, deswegen solltest du dir genau überlegen, was du abspechern musst und welche Werte nicht abgespeichert werden müssen, zB könnte die Startposition der Gegner oder NPCs immer an der selben Stelle sein und du musst deren Position wenn der Spieler den Raum verlässt nicht unbedingt abspeichern.

    ancient-pixel.com
    youtube.com/user/SebastianMerkl <<< ich freu mich über einen Besuch ;)
  • dann muss ich das mit den pflanzen und items anders lösen?
    bis her mache ich das so:
    es gibt ein object das z.B. ne kartoffel pflanzt.
    wenn du eine bestimte taste drückst erscheint in blickrichtung vor dir nun das object_potato_plant
    dieses objects hat die variable growstate (keine global var!)
    bisher wird das object über persistent an ort und stelle gehalten, auch wenn man den raum verlässt.
    wenn man eine weitere kartoffel pflanzt dann hat die natürlich auch die variable growstate die natürlich eine andere höhe hat als die von der 1. kartoffel.
    aber besser wäre es wahrscheinlich wenn ich die orte an denen etwas liegen kann als slots festlege die globalvars haben...
    dann brauce ich auch persistend nicht mehr und die object bezogenen variablen verschwinden komplett.
    oh man das wird arbeit, oder verstehe ich das jetzt falsch? *bin verwirt*
    wie funktioniert das mit der schleife?

    Npcs sind kein problem da deren position anhand der globalvar time und day berechnet wird.
  • Das hast du ganz richtig verstanden, du kannst ein grid oder array für den ganzen Raum anlegen, das sind dann quasi die slots die mit variablen gefüllt werden. Dieses grid gehst du mit einer doppelschleife durch einal für die x position udn einmal für die y position. Dadurch entsteht eine art datei für das level

    GML-Quellcode

    1. for (i = 0; i <32 ; i+=1)
    2. {
    3. for (j = 0; j <32; j+=1)
    4. {
    5. //position und variablen an der stelle i/j im array auslesen
    6. tmp_growstate = ini_read_real();
    7. neu = instance_create(i*32,j*32,instance);
    8. neu.growstate = tmp_growstate;
    9. //usw für alle möglichen Variablen
    10. }
    11. }
    Alles anzeigen

    Du musst daher nur darauf achte geben wieviele variablen ein objekt maximal hat, alle überflüssigen sind dann auf 0 oder irgendeinem wert und werden ja sowieso nicht benutzt im objekt. I und j werden in dem beispiel deswegen mit 32 multipliziert damit dann das Objekt auf einem 32x32 Slot im Raum erscheint. Beim abspechern genauso nur dividiert. Wenn du die Datei dann im Texteditor ansiehst solltest du eine Auflistung der einzelnen Slots sehen, mit der ID des objekts und den variablen. Jede ID wird dann in deiner ini zu einer Section/Kapitel und die einzelnen variablen sind Subsections davon. In einem Schleifendurchgang wird so eine Section ausgelesen und dann die nächste und das Level so befüllt oder abgespeichert.

    Wie gesagt mit Textfiles geht es wasl noch angenehmer, dort hast du keine Sections sondern kannst einfach ganze Zeilen auslesen. Damit kannst du quasi das array so abspeichern:

    Quellcode

    1. id,x,y,var1,var2,var3,var4,var5
    2. 0001,32,32,0,1,0,0,0
    3. 0002,32,64,1,1,0,0,0
    4. 0003,32,96,1,2,1,54,0
    5. //etc


    Das kommt darauf an was sich dann als handlicher erweist, am besten ist du schreibst einen kleinen prototypen mit zwei kleinen Räumen die du voll füllst, mit Objekten die einige Variablen haben und testest was am Besten funktioniert und wie die savedateien nachher aussehen :)

    PS: Am Besten du siehst dir ein Tutorial an wie man im Gamemaker einen Leveleditor ingame macht um Maps zu erstellen und später laden zu können, da bekommst du alle wichtigen Dinge mit die du für dein Spiel brauchst, durch das bepflanzen veränderst du das Level, beim verlassen des Raums wirds gespeichert und dann geladen, wie ein leveleditor halt.

    ancient-pixel.com
    youtube.com/user/SebastianMerkl <<< ich freu mich über einen Besuch ;)

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Aku_Ryou ()

  • Also beim verlassen des Raumes wird das Script aufgerufen:

    GML-Quellcode

    1. for (i = 0 ; i < room_width/32 ; i += 1)
    2. {
    3. for (j = 0 ; j < room_heigth/32 ; j += 1)
    4. {
    5. if instance_exists(obj_spieler)
    6. {
    7. for (k = 0 ; k < instance_count(obj_spieler) ; k += 1)
    8. {
    9. find = instance_find(obj_spieler,k);
    10. ini_write_real(string(find), "ID", find.id);
    11. ini_write_real(string(find), "posx", find.x);
    12. ini_write_real(string(find), "posy", find.y);
    13. ini_write_real(string(find), "var1", find.var1);
    14. ini_write_real(string(find), "var2", find.var2);
    15. }
    16. if instance_exists(obj_pflanze)
    17. {
    18. for (k = 0 ; k < instance_count(obj_pflanze) ; k += 1)
    19. {
    20. find = instance_find(obj_pflanze,k);
    21. ini_write_real(string(find), "ID", find.id);
    22. ini_write_real(string(find), "posx", find.x);
    23. ini_write_real(string(find), "posy", find.y);
    24. ini_write_real(string(find), "var1", find.growstate);
    25. ini_write_real(string(find), "var2", find.var2);
    26. }
    27. }
    28. }
    29. }
    Alles anzeigen


    Aber wie gesagt, sieh dir ein Tutorial zu ingame Level editoren an, dann verstehst du was du machen musst und findest wasl sogar eine wesentlich elegantere Lösung als das hier.

    ancient-pixel.com
    youtube.com/user/SebastianMerkl <<< ich freu mich über einen Besuch ;)