save load gui

[spondox_]

hi

ich bin auf der suche nach einem save/load gui wie is scummvm hat nur halt mit buttons save load quit evtl about .. kann mir da jemand weiterhelfen ?

[[ZENSIERT]]

Sinitrena, dein Auftritt!
Ich weiß nur das man eine Listbox mit "ListBoxSaveGameList" füllen kann

[Sinitrena]

Code: Alles auswählen

Tutorial: Erstellen eines eigenen Lade- und Speicher GUIS

Um mit diesem Tutorial etwas anfangen zu können sollte man mit dem Scripting vertraut sein und sich auch einigermaßen mit GUIs auskennen. Sollte man das noch nicht beherrschen sollten zuerst die Tutorials zu diesen Themen durchgelesen werden.
Der standardmäßige Lade- und Speicherdialog sieht ziemlich langweilig aus, daher versuchen wir es jetzt mit einem eigenen, außerdem fügen wir die Möglichkeit Spielstände zu löschen ein.
Natürlich gibt es mehrere Möglichkeiten einen Lade- und SpeicherGUI zu erschaffen, vielleicht auch andere die dir praktischer erscheinen, doch ich werde die Möglichkeit beschreiben, die für mich am brauchbarsten ist.

Das Erstellen der nötigen GUIs

Für diese Version benötigen wir fünf verschiedene GUIs:
1.	Einen LadeGUI, der eine ListBox, einen „Abbrechen“ und einen „Laden“ Button und wenn du es willst ein Label mit einem Text wie zum Beispiel „Wähle den zu ladenden Spielstand“. Diesen GUI nennen wir im folgenden „LOAD“, wie er auch im Script heißen wird.
2.	Einen SpeicherGUI mit einer ListBox und vier Button: „ausgewählten Spielstand überschreiben“, „neuen Spielstand anlegen“, „Spielstand löschen“ und „Abbrechen“. Dazu natürlich noch ein Label mit einem Text wie „Was möchtest du tun?“. Dieser GUI heißt im übrigen Tutorial und im Script „SAVE“.
3.	Einen GUI der eine TextBox und zwei Button „Speichern“ und „Abbrechen“ enthält, genannt „TXTBOX“
4.	Nochmal das gleiche (später mehr dazu warum), diesmal „TEXTBOXA“ genannt.
5.	Ein GUI namens „LOESCHEN“ mit drei Label: Erstens: „Soll der Spielstand“. Zweitens: „Auswahl“. Drittens: „wirklich gelöscht werden?“ (die Erklärung warum wir drei Label brauchen erfolgt im Script), und zwei Button: „Löschen“ und „Abbrechen“.
Erstelle die GUIs und gestallte sie wie du es möchtest. Natürlich kannst du auch andere Texte oder andere GUINamen verwenden.
WICHTIG: Vergiss nicht alle GUIs  bei „Visible“ auf „Popup Modul“ zu stellen und bei allen Button bei „Left Click“ „Run Script“ zu aktivieren.

Das Ausrichten der GUIs

Ich nehme an, du weißt das, aber ich sag es trotzdem: Die fünf GUIs richten wir im Global Script mit dem Befehl CentreGUI so aus, dass sie sich in der Mitte befinden.

Das Öffnen von „LOAD“ und „SAVE“

Damit die beiden GUIs richtig geöffnet werden müssen wir im Global Script folgendes verändern:
Wir gehen hierbei von der Standard Iconbar aus.
Bei Button 6 vom Interface ICONBAR löschen wir zunächst die Zeile „SaveGameDialog ()“ Anschließend setzen wir „ListBoxSaveGameList“ und in die Klammer schreiben wir den SAVE GUI und die Nummer der TextBox vom SAVE GUI. Die dient dazu, dass AGS die bereits gespeicherten Spielstände in der TextBox setzt, beziehungsweise erneuert. Anschließend schalten wir den GUI mit „GUIOn“ ein. Das Ergebnis für das Öffnen des SAVE GUI sieht dann so aus:
    else if (button == 6) {    // save game      ListBoxSaveGameList (SAVE, 3);      GUIOn (SAVE);      }
Mit dem LOAD GUI ist es jetzt ein wenig komplizierter, da wir nicht wollen, dass er angezeigt wird, wenn noch gar kein Spielstand gespeichert wurde. Dazu benutzen wir eine Variable Namens „index“, die wir mit „int index“ einfügen. Anschließend sorgen wir wieder dafür, dass die bereits gespeicherten Spielstände in den GUI kommen, indem wir wieder „ListBoxSaveGameList“ nehmen, nur dieses Mal in die ListBox des LOAD GUI. Danach müssen wir überprüfen, wie viele Speicherstände in der ListBox vorhanden sind. „ListBoxGetNumItems“ gibt diese Zahl wieder. Deshalb setzen wir die Variable gleich diesem Befehl. Nun überprüfen wir mit einem if, else statement den index Wert. Wenn index kleiner eins soll eine Nachricht angezeigt werden, die uns sagt, dass noch kein Spielstand gespeichert wurde. Andernfalls soll der LOAD GUI angezeigt werden. Wie das dann insgesamt aussieht, siehst du hier:
    else if (button == 7)   { // load game      int index;      ListBoxSaveGameList (LOAD, 3);      index = ListBoxGetNumItems (LOAD, 3);      if (index<1) {        Display ("Es wurde noch kein Spielstand gespeichert.");        }      else {        GUIOn (LOAD);        }
Bei der on_key_press function geben wir bei dem keycode für laden und dem keycode für speichern die selben Befehle ein wie bei dem Interface Iconbar. Solltest du noch andere Möglichkeiten in deinem Spiel haben zum Speichern und Laden zu gelangen, verändere es da natürlich auch.

Der LOAD GUI

Beim LOAD GUI benötigen wir zwei Button: erstens einen zum laden und zweitens einen zum Abbrechen. Der Zum Abbrechen funktioniert einfach: Es ist nur ein GUIOff Befehl notwendig.
Um ein gespeichertes Spiel tatsächlich zu laden braucht man ein wenig mehr Befehle. Zunächst benötigt man auch hier eine Variable, hier index genannt, andere Namen sind aber auch problemlos möglich. Mit einem if statement wird der Laden Button abgefragt. Jetzt muss das Spiel natürlich wissen, welcher Spielstand geladen werden soll. Für uns ist das natürlich logischerweise der, der ausgewählt ist, aber AGS müssen wir das erst noch sagen. Mit dem Befehl ListBoxGetSelected rufen wir den ausgewählten Spielstand ab. In der Klammer ist bei diesem Befehl der GUI in dem wir arbeiten (also LOAD) und die Nummer der ListBox (in diesem Fall 3) einzugeben. Diesen Befehl setzen wir mit index gleich, so dass unser int dann den Wert des ausgewählten Spielstand erhält.
Nun muss dieser Spielstand natürlich noch wiederhergestellt werden. Dafür benutzen wir RestoreGameSlot. Eigentlich verlangt dieser Befehl die Nummer des wiederherzustellenden Spielstandes, die wir nicht wissen, aber das Spiel. Also rufen wir den int ab, den wir gerade eben gefüllt haben. Dazu benutzen wir noch savegameindex, eine globale Variable, in deren eckige Klammer wir unsere eigene Variable index schreiben. Dadurch wird der ausgewählte Spielstand geladen.
Alles zusammen sollte das dann etwa so aussehen:
if (interface==LOAD) {  int index;  if (button==0) {    index=ListBoxGetSelected (LOAD, 3);    RestoreGameSlot (savegameindex [index]);    }  if (button==2) {    GUIOff (LOAD);    }  }

Einen neuen Spielstand anlegen:

Einen neuen Spielstan legt man natürlich im SAVE GUI an, und zwar (irgendwie logisch) mit dem Button „neuen Spielstand anlegen“, bei mir Button 4. Aber bevor wir dazu kommen sei noch kurz erwähnt, dass man beim „Abbrechen“ Button diesmal nicht nur ein einfaches GUIOff Kommando benötigt. Der Grund dafür ist einfach: (ich finde es so sinnvoller, aber es muss eigentlich nicht unbedingt sein). Wir werden zum Speichern und löschen weitere GUIs aufrufen. Wenn jetzt aber einer dieser anderen GUIs aufgerufen ist, soll der „Abbrechen“ Button nicht funktionieren und alle anderen auch nicht, daher überprüfen wir bei jedem Button bevor wir weiter machen, ob die anderen GUIs an oder aus sind. Dazu benutzen wir IsGUIOn mit den entsprechenden GUIs in der Klammer. Die Zahl 0 bedeutet hierbei, die GUIs sind aus, wohingegen 1 bedeuten würde, sie sind an und es geschieht nichts. Um unser Script übersichtlicher zu machen benutzen wir zwischen den einzelnen Abfragen natürlich den && Operator und nicht eine Kette von if statements. Das Ergebnis sieht dann so aus:
if (button==1) {if((IsGUIOn(TEXTBOX)==0)&&(IsGUIOn(TEXTBOXA)==0)&&(IsGUIOn(LOESCHEN)==0)){      GUIOff (SAVE);      }
Aber jetzt zurück zum Speichern: Es soll also ein neuer Spielstand erstellt werden. Auch hierbei fragen wir zunächst wieder ab, ob die anderen GUIs an sind, die von dem SAVE GUI aus aufgerufen werden können, an sind. Das geht genau wie oben, nur jetzt eben beim Button „neuen Spielstand anlegen“. Danach brauchen wir eine weitere if Abfrage, die überprüft welchen Wert index hat. Index ist hier (muss am Beginn des Interface SAVE eingegeben werden) gleich ListBoxGetNumItems (SAVE, x), wobei x in dem Fall natürlich für die Nummer des Objekts der List Box steht. Diese if Abfrage brauchen wir, weil wir nur Platz für 20 Spielstände haben, weil hier die Save Game List benutzt wird, die von AGS erstellt wird, und die nur 20 Plätze hat. Wenn nun alle 20 Spielstände belegt sind, soll eine Nachricht angezeigt werden, dass ein bereits existierender Spielstand überschrieben werden soll. Das wird dann mit einem else statement und einem Display Kommando gemacht (siehe Script). Bei mir ist noch ein PlaySound Kommando mit drin, das aber nicht nötig ist, sondern nur die ganze Sache etwas abgeschlossener für den Spieler wirken lässt.
Zurück zum ersten Teil des if else statements: Wir haben also die Größe von index abgefragt. Jetzt könnten wir eigentlich gleich den neuen GUI TEXTBOX öffnen, der den Spieler nach einem Namen für den Spielstand fragt, aber vorher empfiehlt sich noch ein weiterer Befehl: Mit SetTextBoxText (TEXTBOX, 0, „“) leeren wir die Textbox des GUIs TEXTBOX, da sonst immer der Name des Spielstandes darin stehen würde, unter dem zuletzt ein neuer Spielstand angelegt wurde und das wäre eigentlich nicht sinnvoll.
Hier siehst du jetzt das Script für den „neuen Spielstand anlegen“ Button vom GUI SAVE:
if (button==4) {if((IsGUIOn(TEXTBOX)==0)&&(IsGUIOn(TEXTBOXA)==0)&&(IsGUIOn(LOESCHEN)==0)){    if (index<20) {      SetTextBoxText (TEXTBOX, 0, "");      GUIOn (TEXTBOX);      }    else {      PlaySound (7);      Display ("Alle Spielstaende sind belegt. Du musst einen bereits existierenden Spielstand ueberschreiben.");      }    }  }
Natürlich ist der Spielstand so noch nicht gespeichert. Dazu benötigen wir jetzt den GUI TEXTBOX. Hier haben wir zwei Button: Abbrechen und speichern. Bei Abbrechen wird wie üblich der GUI einfach ausgeschaltet (GUIOff (TEXTBOX)). Auch hier benötigen wir wieder einen int index, der die Anzahl der Spielstände in der ListBox vom SAVE GUI überprüft, hier allerdings zu einem anderen Zweck, nämlich um einen weiteren Spielstand zu der Liste hinzufügen zu können (dazu süäter mehr). Außerdem benötigen wir noch einen string, der den Namen des neuen Spielstandes enthalten wird.
Wenn der Speichern Button angeklickt wird, muss das Spiel zunächst den zukünftigen Namen des neuen Spielstandes abfragen und ihn in dem string „zwischenlagern“. Das macht man mit GetTextBoxText. Jetzt sollte man annehmen, müsste nur noch das Spiel gespeichert werden, aber wenn man jetzt diesen Befehl geben würde, würde man beim laden des Spielstandes immer den Bildschirm mit den beiden offenen GUIs haben, also schalten wir als nächstes die beiden GUIs aus.
Jetzt wird der Spielstand gespeichert. Hier benötigen wir den Befehl SaveGameSlot und wir brauchen unseren int index und den string. In die Klammer schreiben wir index+1, damit zu der Liste ein weiterer Spielstand hinzugefügt wird, und den Namen des sting, um unter diesem Namen zu speichern.
Das folgende Script fasst das alles noch mal zusammen:
if (interface==TEXTBOX) {  string neu;  int index;  index=ListBoxGetNumItems (SAVE, 3);  if (button==2) {    GUIOff (TEXTBOX);    }  if (button==1) {    GetTextBoxText (TEXTBOX, 0, neu);    GUIOff (TEXTBOX);    GUIOff(SAVE);    SaveGameSlot (index+1, neu);    PlaySound (8);    }  }
An dieser Stelle lohnt es sich das Spiel zu testen. Wenn du alles richtig gemacht hast, müsstest du jetzt einen neuen Spielstand anlegen können und auch in der Lage sein ihn wieder zu laden.

Einen existierenden Spielstand überschreiben:

Um einen existierenden Spielstand überschreiben zu können muss zunächst überhaup schon ein Spielstand existieren. Davor setzen wir allerdings die Überprüfung, ob bereits ein anderer weiterer GUI an ist, denn auch die Nachricht, das es noch keinen Spielstand gibt sollte nur angezeigt werden, wenn keine andere Operation bereits im Gange ist. Wie die Abfrage funktioniert kannst du weiter oben oder im untenstehenden Script nachlesen.
Es muss also wiedermal nachgeprüft werden, wie viele Spielstände schon gespeichert wurden, dazu setzen wir wie immer index mit ListBoxGetNumItems gleich. In der if else Abfrage fragen wir jetzt ab, ob index>=1 ist, also ob schon ein Spielstand in der Liste steht, wenn nicht (else) soll eine Nachricht angezeigt werden, die dem Spieler sagt, dass es noch keinen Spielstand zu überschreiben gibt.
Wenn bereits ein Spielstand existiert, soll wieder ein GUI mit der Frage nach dem Namen angezeigt werden. Da wir allerdings einen Spielstand überschreiben entfielt es sich, dem Spieler auch in dem neuen GUI zu sagen welchen Spielstand er überschreibt. Natürlich ist das nicht nötig, aber es wirkt etwas besser. Also fragen wir den Text aus der ListBox mit ListBoxGetItemText ab und lagern den Name im string text zwischen. Als nächstes setzen wir den Text in die TextBox des GUI TEXTBOXA und zwar mit SetTextBoxText. Danach müssen wir nur noch den GUI TEXTBOXA einschalten.
string text;  int index;  index=ListBoxGetNumItems (SAVE, 3);    if (button==0) { if((IsGUIOn(TEXTBOX)==0)&&(IsGUIOn(TEXTBOXA)==0)&&(IsGUIOn(LOESCHEN)==0)){     if (index>=1) {       ListBoxGetItemText (SAVE, 3, ListBoxGetSelected (SAVE, 3), text);       SetTextBoxText (TEXTBOXA, 0, text);       GUIOn (TEXTBOXA);       }     else {       PlaySound (7);       Display ("Es existiert noch kein Spielstand, der ueberschrieben werden koennte.");       }    }
Natürlich haben wir auch im GUI TEXTBOXA einen Abbrechen Button. Ich denke, ich muss dazu nichts mehr sagen.
Beim Speichern Button verfahren wir wie beim anlegen eines neuen Spielstandes mit einem Unterschied: Wir speichern natürlich nicht auf eine neue Position, sondern auf die ausgewählte. Wir arbeiten stattdessen mit der Globalen Variablen savegameindex mit dem int index in der eckigen Klammer. Dadurch wird auf den Spielstandplatz index gespeichert.
WICHTIG: Vergiss hier nicht index mit ListBoxGetSelected gleichzusetzen. Wenn du es vergisst, wird zwar der korekte Spielstand in der TextBox angezeigt, da wir das vom SAVE GUI aus gemacht haben, es wird aber über den ersten Spielstand in der Liste gespeichert, wovon der Spieler vermutlich nicht sehr begeistert wäre.
HINWEIS: Auf den ersten Blick könnte man meinen, es sei überflüssig für die beiden Speichervarinten zwei verschiedene GUIs zu benutzen. Das ist allerdings nötig, da der letztendliche Speichervorgang voneinander abweicht, also gerade das entscheidende.
if (interface==TEXTBOXA) {  int index;  string wort;  index=ListBoxGetSelected (SAVE, 3);  if (button==2) {    GUIOff (TEXTBOXA);    }  if (button==1) {    GetTextBoxText (TEXTBOXA, 0, wort);    GUIOff (TEXTBOXA);    GUIOff (SAVE);    SaveGameSlot (savegameindex [index], wort);    PlaySound (8);    }  }

Einen Spielstand löschen

Die if else Abfragen funktionieren hier genauso wie beim überschreiben eines existierenden Spielstandes, eigentlich logisch, denn wenn es keinen Spielstand zum überschreiben gibt, gibt es auch keinen zum löschen.
Um einen Spielstand zu löschen fragen wir erst einmal ab, welchen Namen der ausgewählte Spielstand hat und setzen diesen Namen in das entsprechende Label mit SetLabelText. Danach wird der LOESCHEN GUI aufgerufen.
HINWEIS: Wie oben gesagt brauchen wir in dem LOESCHEN GUI drei Label (je nach Formulierung würden auch zwei genügen). Das liegt daran, dass man nicht nur einen Teil eines Label Textes durch das Script beeinflussen kann, sondern nur das gesamte Label. Wenn wir also wollen, dass der Spieler erfährt welchen Spielstand er zu löschen beabsichtigt, müssen wir es in mehrere Label aufteilen. (Es gäbe noch eine andere Möglichkeit mit strcat, die das Script allerdings komplizierter machen würde. Mit diesem Befehl hängt man ean einen string einen anderen an. Man könnte also an den string, der den Namen des ausgewählten Spielstandes enthält einen string mit dem Inhalt „wirklich gelöscht werden? Anhängen, und davor einen string mit dem Inhalt „Soll der Spielstand“. Diese Methode würde zum selben Ergebnis führen, erscheint mir allerdings unpraktischer. Letztlich ist es aber Geschmackssache, daher sind hier beide Methoden erwähnt.
HINWEIS: Natürlich ist der LOESCHEN GUI im Grunde überflüssig. Man könnte auch direkt beim klick auf den Button löschen. Der zusätzliche GUI dient ausschließlich zur Sicherheit, damit der Spieler nicht versehendlich einen Spielstand löscht, den er noch behalten möchte.
if (button==5) {    if((IsGUIOn(TEXTBOX)==0)&&(IsGUIOn(TEXTBOXA)==0)&&(IsGUIOn(LOESCHEN)==0)){      if (index>=1) {        ListBoxGetItemText (SAVE, 3, ListBoxGetSelected (SAVE, 3), auswahl);            SetLabelText (LOESCHEN, 3, auswahl);        GUIOn (LOESCHEN);        }      else {        PlaySound (7);        Display ("Es gibt keinen Spielstand der geloescht werden koennte.");      }    }  }
Auch bein LOESCHEN GUI haben wir natürlich wieder einen Abbrechen Button. (Wird langsam langweilig, oder?) Der Befehl zum Löschen eines Spielstandes lautet DeleteSaveSlot. Welcher Spielstand gelöscht werden soll wird wieder über die Globale Variable savegameindex und dem int index definiert. Auch hier ist es wieder wichtig, index mit ListBoxGetSelected gleichzusetzen, da sonst der falsche Spielstand gelöscht wird.
if (interface==LOESCHEN) {  int index;  index=ListBoxGetSelected (SAVE, 3);  if (button==2) {    GUIOff (LOESCHEN);    }  if (button==1) {    DeleteSaveSlot (savegameindex [index]);    ListBoxSaveGameList (SAVE, 3);    PlaySound (9);    GUIOff (LOESCHEN);    }  }

Das ganze Script in einem:

So, das war es eigentlich. Da das alles aber ein bisschen viel war gibt es hier noch mal einen Großteil des Scripts in einem (das einzige was nicht dabei ist, ist das Aufrufen des LOAD und SAVE GUI).
If (interface==LOAD) {  int index;  if (button==0) {    index=ListBoxGetSelected (LOAD, 3);    RestoreGameSlot (savegameindex [index]);    }  if (button==2) {    GUIOff (LOAD);    }  }if (interface==SAVE) {  string text;  int index;  string auswahl;  index=ListBoxGetNumItems (SAVE, 3);    if (button==0) {       if((IsGUIOn(TEXTBOX)==0)&&(IsGUIOn(TEXTBOXA)==0)&&(IsGUIOn(LOESCHEN)==0)){     if (index>=1) {       ListBoxGetItemText (SAVE, 3, ListBoxGetSelected (SAVE, 3), text);       SetTextBoxText (TEXTBOXA, 0, text);       GUIOn (TEXTBOXA);       }     else {       PlaySound (7);       Display ("Es existiert noch kein Spielstand, der ueberschrieben werden koennte.");       }    }  }  if (button==4) {   if((IsGUIOn(TEXTBOX)==0)&&(IsGUIOn(TEXTBOXA)==0)&&(IsGUIOn(LOESCHEN)==0)){    if (index<20) {      SetTextBoxText (TEXTBOX, 0, "");      GUIOn (TEXTBOX);      }    else {      PlaySound (7);      Display ("Alle Spielstaende sind belegt. Du musst einen bereits existierenden Spielstand ueberschreiben.");      }    }  }  if (button==1) {    if((IsGUIOn(TEXTBOX)==0)&&(IsGUIOn(TEXTBOXA)==0)&&(IsGUIOn(LOESCHEN)==0)){      GUIOff (SAVE);      }    }  if (button==5) {    if((IsGUIOn(TEXTBOX)==0)&&(IsGUIOn(TEXTBOXA)==0)&&(IsGUIOn(LOESCHEN)==0)){      if (index>=1) {        ListBoxGetItemText (SAVE, 3, ListBoxGetSelected (SAVE, 3), auswahl);            SetLabelText (LOESCHEN, 3, auswahl);        GUIOn (LOESCHEN);        }      else {        PlaySound (7);        Display ("Es gibt keinen Spielstand der geloescht werden koennte.");      }    }  }}if (interface==TEXTBOX) {  string neu;  int index;  index=ListBoxGetNumItems (SAVE, 3);  if (button==2) {    GUIOff (TEXTBOX);    }  if (button==1) {    GetTextBoxText (TEXTBOX, 0, neu);    GUIOff (TEXTBOX);    GUIOff(SAVE);    SaveGameSlot (index+1, neu);    PlaySound (8);    }  }if (interface==TEXTBOXA) {  int index;  string wort;  index=ListBoxGetSelected (SAVE, 3);  if (button==2) {    GUIOff (TEXTBOXA);    }  if (button==1) {    GetTextBoxText (TEXTBOXA, 0, wort);    GUIOff (TEXTBOXA);    GUIOff (SAVE);    SaveGameSlot (savegameindex [index], wort);    PlaySound (8);    }  }if (interface==LOESCHEN) {  int index;  index=ListBoxGetSelected (SAVE, 3);  if (button==2) {    GUIOff (LOESCHEN);    }  if (button==1) {    DeleteSaveSlot (savegameindex [index]);    ListBoxSaveGameList (SAVE, 3);    PlaySound (9);    GUIOff (LOESCHEN);    }  }
Im Grund sollte alles funktionieren. Wie gesagt ist das hier vielleicht nicht die optimale Lösung für einen eigenen Speichern und Laden GUI, aber es ist die Methode, die ich selbst benutze und die mir eigentlich auch sehr gut gefällt.
Viel Spaß beim umsetzen dieser Methode oder beim entwickeln einer eigenen!

Das dürfte alles enthalten, was du brauchst. (und nein, ich hab das nicht gerade eben geschrieben)

Sinitrena, dein Auftritt!

Bin schon da!

[spondox_]

danke

ich werd mich gleich ma hinhoggn und basteln.

[Jones]

Hallo Sinitrena,

irgendwie funktioniert das bei mir nicht. Speichern scheint auf den ersten Blick kein Problem zu sein, die Namen werden auch im Lade-GUI angezeigt, aber ich kann kein Spiel laden (es kommt immer die Meldung "Noch kein Spiel gespeichert").
Ich poste hier mal den Quellcode, vielleicht fällt dir ja ein Fehler auf? Wäre super, wenn du dir das mal anschauen könntest!

Viele Grüße,
Jones

Code: Alles auswählen

//-----------------------------------------------------------------------------------
if (interface == QUITGUI) {    //Gui zum Beenden

           if (button == 1) {   //Ja, Spiel verlassen
	      QuitGame(0);
	      }
	   if (button == 2) {    //Nein, Spiel nicht verlassen
	      GUIOff(QUITGUI);
	    }
  }    
  
//-----------------------------------------------------------------------------------
if (interface == LOAD)          //Ladegui
  {
    CentreGUI(LOAD);
    int index;
    //ListBoxSaveGameList (LOAD,0);
    //index = ListBoxGetNumItems (LOAD,0);
    
       if (button==3)                                //Laden
	  {

             if (index<1) 
	       {
               Display ("Noch kein Spiel gespeichert.");
               }
             else 
	       {
	       ListBoxSaveGameList (LOAD,0);
               index=ListBoxGetSelected (LOAD,0);
	       RestoreGameSlot (savegameindex [index]);
               }
	 }
     if (button==4)                                 //Abbrechen
	 {
	   GUIOff(LOAD);
	  }
      
  }


//-----------------------------------------------------------------------------------
if (interface == SAVE)            //Speicherngui
  {
    CentreGUI(SAVE);
    string text;
    int index;
    string auswahl;
    index=ListBoxGetNumItems (SAVE, 0);
    //ListBoxSaveGameList (SAVE,0);
    
      if (button==8)               //Neuen Spielstand anlegen
	{
	 //int index;
	 ListBoxSaveGameList (SAVE,0);
	 if((IsGUIOn(TXTBOX)==0)&&(IsGUIOn(TEXTBOXA)==0)&&(IsGUIOn(LOESCHEN)==0))
		{    
		  if (index<20) 
		  {      
		   SetTextBoxText (TXTBOX, 0, "");
	           CentreGUI(TXTBOX);
	           GUIOn (TXTBOX);      
		  }    
		  else 
		  {     
	          Display ("Alle Spielstaende sind belegt. Du musst einen bereits existierenden Spielstand ueberschreiben.");
		  }
	        }
        } 
    


    if (button==6)               //Abbrechen
	{
	if((IsGUIOn(TXTBOX)==0)&&(IsGUIOn(TEXTBOXA)==0)&&(IsGUIOn(LOESCHEN)==0))
		{      
		GUIOff (SAVE);
		} 
	}
    if (button==7)               //Speichern
         {
            //string text;
	    //int index;
	    index=ListBoxGetNumItems (SAVE,0);
		 { 
		 if((IsGUIOn(TXTBOX)==0)&&(IsGUIOn(TEXTBOXA)==0)&&(IsGUIOn(LOESCHEN)==0))
		     {     
		      if (index>=1) 
			{       ListBoxGetItemText (SAVE,0, ListBoxGetSelected (SAVE,0), text);
			        SetTextBoxText (TEXTBOXA, 0, text);
			        CentreGUI(TEXTBOXA);
			        GUIOn (TEXTBOXA);       
			}     
		      else 
			{       
				Display ("Es existiert noch kein Spielstand, der überschrieben werden könnte.");
		        }
		     }     
                  }
	  }
    if (button==5)   //Löschen
        {   
        
	    if((IsGUIOn(TXTBOX)==0)&&(IsGUIOn(TEXTBOXA)==0)&&(IsGUIOn(LOESCHEN)==0))
		{      
		    if (index>=1) 
			{        
			   ListBoxGetItemText (SAVE, 0, ListBoxGetSelected (SAVE, 0), auswahl);
			   SetLabelText (LOESCHEN, 1, auswahl);
			   CentreGUI(LOESCHEN);
			   GUIOn (LOESCHEN);
			}      
		    else 
			{        
			   Display ("Es gibt keinen Spielstand der gelöscht werden könnte.");
		        }    
		 }  
	}
}

//-----------------------------------------------------------------------------------
if (interface == TXTBOX)
  {
     CentreGUI(TXTBOX);
     string neu;
     int index;
     index=ListBoxGetNumItems (SAVE,0);
     
       if (button==2)       //Abbrechen
        {
	GUIOff(TXTBOX);
	}
       if (button==1)         //Speichern
        {  
        GetTextBoxText (TXTBOX, 0, neu);
	GUIOff (TXTBOX);
        GUIOff(SAVE);
        SaveGameSlot (index+1, neu);
        } 
   }
 
//-----------------------------------------------------------------------------------     
if (interface==TEXTBOXA)
	{
	  CentreGUI(TEXTBOXA);
	  int index;
	  string wort;
	  index=ListBoxGetSelected (SAVE,0);
	  
	    if (button==2)        //Abbrechen
		    {
		      GUIOff(TEXTBOXA);
		    }
            if (button==1) 
		    {    
		      GetTextBoxText (TEXTBOXA, 0, wort);
		      GUIOff (TEXTBOXA);    
		      GUIOff (SAVE);
		      SaveGameSlot (savegameindex [index], wort);
		    }
		
	}

//-----------------------------------------------------------------------------------
if (interface==LOESCHEN)
	{
	 CentreGUI(LOESCHEN);
	 int index;
	 index=ListBoxGetSelected (SAVE, 0);
	 
	  if (button==3)   //Löschen
		  {
		   DeleteSaveSlot (savegameindex [index]);
		   ListBoxSaveGameList (SAVE, 0);
		   GUIOff (LOESCHEN);    
		  }  
	  
	  if (button==4)   //Abbrechen
		  {
		   GUIOff (LOESCHEN); 
		   }
	}

[Sinitrena]

Mir fallen jetzt auf den ersten Blick zwei Sachen auf:
1. Beim load GUI hast du die Zeilen ListBoxSaveGameList (LOAD, 3); und index = ListBoxGetNumItems (LOAD, 3); durch // aus dem Script ausgeklammert, somit kann das natürlich nicht gehen (oder hast du das gemacht, weil sonst eine Fehlermeldung kommt?)
Folgendes passiert so wie du es jetzt hast: int index wird erzeugt sobald du den LOAD GUI öffnest (Standartmäßig hat ein int bei der erstellung den Wert 0). Die nächsten beiden Zeilen sind ausgeklammert und werden ignoriert. Wenn button 3 gedrückt wird prüft AGS den Wert von index, der genau 0 beträgt, weil du ihn nicht anders definiert hast. Wichtig ist die Zeile index=ListBoxGetNumItems, denn dann wird gezählt wie viele Spielstände gespeichert sind und dann hat index auch einen Wert 1 oder größer.
Außerdem muss die ListBox schon gefüllt sein, bevor du überhaupt damit arbeiten kannst (mehr dazu unter2))
2. Ich würde die Abfrage, ob schon ein Spielstand gespeichert wurde nicht bei dem Load GUi setzen, sondern da, wo der GUI aufgerufen wird, also z.B. bei on_key_press. Dazu gehört auch ListBoxSaveGameList, denn das füllt die ListBox erst überhaupt mit einem Inhalt.

Ich hoffe das löst jetzt dein Problem, ansonsten sag es, dann seh ich mir das Script nochmal genauer an.

[Jones]

Hallo Sinitrena,

erstmal vielen Dank, es hat funktioniert so wie du es mir beschrieben hast! Der Fehler lag wohl darin, dass ich bei on_key_press noch falsche Sachen eingetragen hatte!
Laden kann ich jetzt, allerdings nur den ersten Spielstand von oben. Sobald ich einen Spielstand weiter unten anklicke, "springt" die Anzeige wieder in das oberste Feld. Weisst du da zufällig auch Rat?

[Sinitrena]

Ich bin mir nicht sicher. Es könnte an der Zeile ListBoxSaveGameList (LOAD,0); vor index=ListBoxGetSelected (LOAD,0); und RestoreGameSlot (savegameindex [index]); liegen. Versuch es indem du sie einfach entfernst. Im Grunde brauchst du sie nicht, weil das schon bei on_key_press bestimmt werden müsste. Eine andere Idee hab ich im Moment auch nicht. Versuch das mal und sag mir ob es funktioniert hat und wenn nicht, dann kopier nochmal den aktuellen Code damit ich mir nochmal ansehen kann.

[Jones]

Hmm...jetzt kann ich zwar die einzelnen Spielstände auswählen aber es wird immer der geladen, der als letztes gespeichert wurde.

Bin mir ziemlich sicher dass ich was bei on_key_press vergessen habe...dort steht folgendes:

Code: Alles auswählen

 if (keycode==17)  
		{
		CentreGUI(QUITGUI);
		GUIOn (QUITGUI);
		}// QuitGame(1);// Ctrl-Q
  if (keycode==363) 
		{
		CentreGUI(SAVE);
		ListBoxSaveGameList(4,0);
		GUIOn(SAVE);
		}//SaveGameDialog();//// // F5
  if (keycode==365)
		 {
		    CentreGUI(LOAD);
		    int index;
		    ListBoxSaveGameList (LOAD,0);
		    index = ListBoxGetNumItems (LOAD,0);
		    GUIOn(LOAD);
	         }

Und im Script von der GUI sieht es jetzt so aus:

Code: Alles auswählen

//-----------------------------------------------------------------------------------
if (interface == LOAD)          //Ladegui
  {
    CentreGUI(LOAD);
    int index;
    //ListBoxSaveGameList (LOAD,0);
    index = ListBoxGetNumItems (LOAD,0);
    
       if (button==3)                                //Laden
	  {

             if (index<1) 
	       {
               Display ("Noch kein Spiel gespeichert.");
               }
             else 
	       {
	       ListBoxSaveGameList (LOAD,0);
               index=ListBoxGetSelected (LOAD,0);
	       RestoreGameSlot (savegameindex [index]);
               }
	 }
     if (button==4)                                 //Abbrechen
	 {
	   GUIOff(LOAD);
	  }
      
  }


//-----------------------------------------------------------------------------------
if (interface == SAVE)            //Speicherngui
  {
    CentreGUI(SAVE);
    string text;
    int index;
    string auswahl;
    index=ListBoxGetNumItems (SAVE, 0);
    //ListBoxSaveGameList (SAVE,0);
    
      if (button==8)               //Neuen Spielstand anlegen
	{
	 //int index;
	 ListBoxSaveGameList (SAVE,0);
	 if((IsGUIOn(TXTBOX)==0)&&(IsGUIOn(TEXTBOXA)==0)&&(IsGUIOn(LOESCHEN)==0))
		{    
		  if (index<20) 
		  {      
		   SetTextBoxText (TXTBOX, 0, "");
	           CentreGUI(TXTBOX);
	           GUIOn (TXTBOX);      
		  }    
		  else 
		  {     
	          Display ("Alle Spielstaende sind belegt. Du musst einen bereits existierenden Spielstand ueberschreiben.");
		  }
	        }
        } 
    


    if (button==6)               //Abbrechen
	{
	if((IsGUIOn(TXTBOX)==0)&&(IsGUIOn(TEXTBOXA)==0)&&(IsGUIOn(LOESCHEN)==0))
		{      
		GUIOff (SAVE);
		} 
	}
    if (button==7)               //Speichern
         {
            //string text;
	    //int index;
	    index=ListBoxGetNumItems (SAVE,0);
		 { 
		 if((IsGUIOn(TXTBOX)==0)&&(IsGUIOn(TEXTBOXA)==0)&&(IsGUIOn(LOESCHEN)==0))
		     {     
		      if (index>=1) 
			{       ListBoxGetItemText (SAVE,0, ListBoxGetSelected (SAVE,0), text);
			        SetTextBoxText (TEXTBOXA, 0, text);
			        CentreGUI(TEXTBOXA);
			        GUIOn (TEXTBOXA);       
			}     
		      else 
			{       
				Display ("Es existiert noch kein Spielstand, der überschrieben werden könnte.");
		        }
		     }     
                  }
	  }
    if (button==5)   //Löschen
        {   
        
	    if((IsGUIOn(TXTBOX)==0)&&(IsGUIOn(TEXTBOXA)==0)&&(IsGUIOn(LOESCHEN)==0))
		{      
		    if (index>=1) 
			{        
			   ListBoxGetItemText (SAVE, 0, ListBoxGetSelected (SAVE, 0), auswahl);
			   SetLabelText (LOESCHEN, 1, auswahl);
			   CentreGUI(LOESCHEN);
			   GUIOn (LOESCHEN);
			}      
		    else 
			{        
			   Display ("Es gibt keinen Spielstand der gelöscht werden könnte.");
		        }    
		 }  
	}
}

//-----------------------------------------------------------------------------------

Wär echt super, wenn du mir nochmal helfen könntest Sinitrena!

[Sinitrena]

Kurze Frage: Warum machst du die Abfrage, ob überhaupt schon ein Spielstand gespeichert wurde erst wenn der LOAD GUI schon offen ist? Das ergibt wenig Sinn. Der Spieler kann selbst sehen, wenn dort nichts gespeichert wurde, außerdem kann ja etwas nicht vorhandenes auch nicht geladen werden. Es ist also vollkommen unlogisch das beim Button vom LOAD GUI abzufragen. Ich würde es so machen:

Code: Alles auswählen

on_key_press
...
if (keycode==365)
       {
          CentreGUI(LOAD);
          int index;
          ListBoxSaveGameList (LOAD,0);
          index = ListBoxGetNumItems (LOAD,0);
          if (index<1) {
              Display ("Noch kein Spielstang gespeichert");
               }
           else {
          GUIOn(LOAD);
                }
            }
...

und dann beim LOAD GUI:

Code: Alles auswählen

if (interface==LOAD) {  
int index;  
 if (button==3) {  
    index=ListBoxGetSelected (LOAD, 3);
    RestoreGameSlot (savegameindex [index]);
    }
  if (button==4) {
    GUIOff (LOAD);
    }
  }

Der Unterschied besteht jetzt hauptsächlich darin, wo was abgefragt wird.