Algorithmus zum anordnen von Gegenstaende...

Also ich wollte meine Gegenstaende anordnen lassen. Dazu habe ich auch schon was versucht zu schreiben. Will aber nicht funktonieren. Dabei sollte aber gesagt sein, dass ich nur aufruecken will. D.h. wenn z.B. wenn der dritte Slot leer ist, wird dieser von dem vierten aufgefuellt... usw. Also will ich euch fragen wo der Fehler steckt oder ob ich an das Problem ganz falsch ran gehe. :confused:

Zum Verstaendnis, erklaere ich erst mal meine Vergabe der Variablen.http://www.multimediaxis.de/images/s.../old/s_009.gif

901 Itempointer: Ist wie gesagt der Pointer der die Items aufuellt. Er faengt dabei bei 921 an und sollte bei 960 aufhoeren.

902 LastSlot: Wie der Name schon sagt, ermittelt diese Variablen den letzten Slot. Sie laeuft mit und ist die Abruchbediengung.

903 Itemvergleich:In dieser Variable wird der Wert des Pointers gespeichert. Sie dient als Vergleich, ob der jeweilige Slot besetzt ist oder nicht

905 ItemID: Hier wird der Wert zugewiesen. D.h. im Shop kauft man nun einen kleinen Heiltrank und die Variablen nimmt in diesem Fall 1 an.

914 Itempointsaver: Diese Variable soll als Zwischenspeicher dienen. Geht der Pointer z.B. auf 922 Speicher er den Wert und uebertraegt diesen auf 921 (siehe screenshot).

Nun gut. Das ist was man alles ueber mein Spiel wissen sollte.

Hier ist nun das Script fuer das "Aufuellen (erhalten) von Gegenstaenden". Dieses funktioniert. Ist ja aber auch nicht so schwer.

http://de.geocities.com/pokiloki01/update.png

Das Script zum ordnen funktioniert gar nicht. Also als erstes wird der Pointer auf den Anfang gestellt. Nun wird in einer Schleife gefragt ob der Slot 0 ist oder nicht ist er 0, sollte der Pointer einen Slot weiter gehen. Ist der naechste groesser als 0, wird der Wert gespeichert (914). Der Pointer geht zureuck und gibt den Wert an den vorhergehenden Slot. Leider funktioniert das gar nicht.

Toll waere aber, wenn mein Ordnungsscript nach Zahlen ordnet. D.h. Zuerst alle Slots mit einsen bestuecken, dann mit zweien usw. Z.B:

1.Slot=1
2.Slot=3
3.Slot=1
4.Slot=2

Nach dem Ordnen sollte es wie folgt aussehen:

1.Slot=1
2.Slot=1
3.Slot=2
4.Slot=3


Ich hoffe ihr wisst was ich meine... Danke schon mal im voraus...;)

Also wenn du nur die leeren Stellen im Inventar weghaben willst, würde ich das so machen (ich gehe mal beim Beispiel davon aus, dass Variablen 1-50 das Inventar sind):

Code:

---

Label 1
Switch "Verschoben" = OFF
Forc Variable 50 > 0
  Forc Variable 49 = 0
    Variable 49 = Variable 50
    Variable 50 = 0
    "Verschoben" = ON
  end
end
... Das Gleiche mit 49/48, 48/47 usw. Der letzte Vergleich ist 2/1.

Forc "Verschoben" = ON
  goto label 1
end

---

Vielleicht gibt es eine bessere Methode, bei der man nicht für jede Variable eine Forc braucht, aber funktionieren tut diese auf jeden Fall. Falls du nach anderen Kriterien (wie z.B. der größten Menge oder so) ordnen willst, müßte das Script natürlich ein wenig verändert werden.

Zitat:

---

Zitat von Kelven

Also wenn du nur die leeren Stellen im Inventar weghaben willst, würde ich das so machen (ich gehe mal beim Beispiel davon aus, dass Variablen 1-50 das Inventar sind):

Code:

---

Label 1
Switch "Verschoben" = OFF
Forc Variable 50 > 0
  Forc Variable 49 = 0
    Variable 49 = Variable 50
    Variable 50 = 0
    "Verschoben" = ON
  end
end
... Das Gleiche mit 49/48, 48/47 usw. Der letzte Vergleich ist 2/1.

Forc "Verschoben" = ON
  goto label 1
end

---

Vielleicht gibt es eine bessere Methode, bei der man nicht für jede Variable eine Forc braucht, aber funktionieren tut diese auf jeden Fall. Falls du nach anderen Kriterien (wie z.B. der größten Menge oder so) ordnen willst, müßte das Script natürlich ein wenig verändert werden.

---

So kann man das machen. Aber ich wollte doch eigentlich das erst alle einsen und dann alle zweien... Wie ich es oben beschrieben habe. Kann man irgendwie mit einen Pointer machen. Dein Code ist zwar gut, aber leider nicht die Loesung fuer mein Problem;)

Hast du dir mal mein Script angesehen? Weist du wo der Fehler liegt?

Bei deinem Script blicke ich nicht wirklich durch. Wobei das ja auch zum Auffüllen der Gegenstände sein soll. Da fehlen aber irgendwie die Variablen in die die Gegenstände geschrieben werden, oder nicht? Falls es bei dir überhaupt Variablen sind. Ich hätte das ganz stumpf so gescriptet (wieder sind 1-50 die "Slots" für Gegenstände, die ID vom Gegenstand ist Variable 51):

Code:

---

Forc Variable 1 = 0
  Variable 1 = Variable 51
  Goto label 1
end
Forc Variable 2 ... usw.
Label 1

---

Sortieren könntest du mit meinem Algorithmus so:

Code:

---

Label 1
Switch "Verschoben" = OFF
Forc Variable 50 > 0
  Forc Variable 49 = 0
    Variable 49 = Variable 50
    Variable 50 = 0
    "Verschoben" = ON
  else
    Forc Variable 50 < Variable 49
      Variable 51 (temporäre Variable) = Variable 50
      Variable 50 = Variable 49
      Variable 49 = Variable 51
      "Verschoben" = ON
    end
  end
end
... Das Gleiche mit 49/48, 48/47 usw. Der letzte Vergleich ist 2/1.

Forc "Verschoben" = ON
  goto label 1
end

---

Das müßte eigentlich klappen.

Erstmal
@Kelven: lokipoki arbeitet mit Pointern, also "Variablen-Numbers" oder wie das im RPG-Maker heißt (Bei welchem Maker sind wir eigentlich?). Dadurch braucht er nicht für jede Variable eine Fork/Branch machen. Das Programm macht es selbst, indem es an diese Poitervariablen den Inhalt einer anderen, wechselnden Variable übergibt. Außerdem müsste man deine Reihenfolge umdrehen, also von der ersten bis zum letzten Item gehen (1 bis 50), sonst entstehen immer wieder Lücken. Stell dir einen Stau vor in dem das letzte Auto als erstes an den Vordermann aufschließt und danach nichts mehr macht. Nicht effektiv... :rolleyes:

Eh, zu dem Script... Ich versteh jetzt noch nicht wo das Problem liegt: Funktioniert das gezeigte Script oder nicht? Am Anfang hast du geschrieben, dass das Auffüllen Script funktioniert und dann, dass es dort einen Fehler gibt. Ich gucks mir jetzt estmal an und editiere dann hier rein oder poste neu.


EDIT:
Fürs Sortieren würd ich bei so wenig Objekten das einfache Bubble Sort nehmen (man könnte zwar auch Einfüge-Algorithmen nehmen, die sind aber komplizierter und bringen nur zeitliche Vorteile)

Bei Bubble Sort vergleicht man immer zwei benachbarte Zahlen und macht die größere nach hinten. Man geht dabei von den ersten beiden Zahlen (zB. 1-2) zu den letzten beiden (zB. 49-50). Dadurch ist die größte Zahl auf jeden Fall jetzt ganz am Ende (es ist wichtig bis jetzt verstanden zu haben, warum das so ist).
Dann macht man das gleiche nochmal von vorne (1-2), geht aber nur bis zur Vorletzten Zahl (48-49). Jetzt sind die beiden letzten Zahlen an der richtigen Stelle. Man wiederholt das ganze jetzt so oft (verringert den Bereich immer um eins), bis man Zahl eins und zwei sortieren muss. Fertig.
Insgesamt braucht man dafür nur wenige Zeilen schreiben.
Zwei verschachtelte Schleifen/Loops: Die innere erhöht bei jedem Durchgang die Nummer der zu tauschende Variable um 1 und die äußere Schleife verringert die als letztes zu tauschende Variablennummer um eins. Der Inhalt der beiden Schleifen ist nur der Tauschvorgang zweier benachbarter Zahlen: Die eine Zahl wird gemerkt (in eine andere Variable speichern), die andere auf diese eine draufkopiert und dann die andere mit dem gemerkten Wert bestückt.
Einziges Problem ist die Tatsache, dass ein Item zwei Informationen hat: Position und Menge. Du musst also die Positionsnummer und Mengenzahl gleichzeitig vertauschen, sond weißt du hinterher nicht mehr welche Zahl zu welchem Item gehört.

Var1 = Itemazahl
Var2 = 0

..loop
....Var1 -1
....loop
......Var2 +1

.......if Var2 <= Var1 //kleiner gleich
.........if ItemID[Var2] > ItemID[Var2+1]
...........*Tausch ItemID[Var2] und ItemID[Var2+1]*
...........*Tausch Anzahl[Var2] und Anzahl[Var2+1]*
.........end
.......else
.........Var2 = 0
.........brake
.......end

......end
......if Var1 = 1 --> brake
....end

dashier ordnet der reihe nach...
http://img85.imageshack.us/img85/5595/ordnency0.png

wobei die vari 0020 slotdurchlauf ganz am anfang den wert des anfangsitemsslots-1 bekommt..
in deinem falle also 920
und die abbruchsbedingungen (die forks wo dann zu den labels gesprungen wird...) sind dann nicht bei <10 sondern bei <960 (also die nummer des letzten itemslots)

mfg
üH

@CapSeb
So was gibt es beim Maker? Ich sollte mir die Funktionen vielleicht doch lieber mal genauer ansehen. XD Hm ja, von oben anfangen sollte auch gehen, so genau kenne ich mich mit der Effizienz von Sortieralgorithmen nicht aus. Bei der kleinen Menge Datein beim Makern macht es aber wohl keinen Unterschied.

Mit meinen neugewonnenen Makerkenntnissen hab ich jetzt nochmal versucht den Algorithmus zu überarbeiten ;) Der Faulheit halber schreibe ich das aber wieder in Pseudocode.

Variablen 1-20 sind Inventar
Variable 21 ist der Counter
Variable 22 ist der Nachfolger des Counters
Variablen 23-25 sind temporäre Variablen zum Testen
Switch 1 ist zum Testen ob getauscht wurde

Code:

---

Label 1
Variable21 = 1
Switch1 = OFF

Loop
  if Variable21 = 20
    Break
  else
    Variable22 = Variable 21
    Variable22 += 1 #Der Nachfolger vom Counter
    Variable23 = Pointer[Variable21] #Inhalt von Counter
    Variable24 = Pointer[Variable22] #Inhalt vom Nachfolger
    if Variable23 = 0
      if Variable24 > 0
        Pointer[Variable21] = Variable24
        Pointer[Variable22] = 0 #Die Null wird nach unten geschoben
        Switch1 = ON
      end
    else
      if Variable23 > Variable24
        if Variable24 != 0
          Pointer[Variable21] = Variable24
          Pointer[Variable22] = Variable23 #Beide Werte werden getauscht
          Switch1 = ON
        end
      end
    end
  end
  Variable21 += 1
end

if Switch1 = ON
  Goto Label 1
end

---

Boah, was Text! :eek:
(Ich hab übrigens die Lösung in meinen älteren Beitrag reineditiert)

Zitat:

---

Zitat von Kelven

Hm ja, von oben anfangen sollte auch gehen, so genau kenne ich mich mit der Effizienz von Sortieralgorithmen nicht aus. Bei der kleinen Menge Datein beim Makern macht es aber wohl keinen Unterschied.

---

Leider geht es von "unten" garnicht. Nochmal zum Stau-Beispiel: Platz 1, 2,3, 5 und 6 sind besetzt. Platz 4 frei. Auto 6 kann nicht fahren. Auto 5 geht an Stelle 4. Auto 3 bis 1 sind korrekt vorne.
Aber jetzt müsste Auto 6 fahren, denn Platz 5 ist frei geworden. Seine Fork ist aber schon vorbei, bleibt also stehen. Andersrum geht das Auffahren auch nur dann, wenn man nach dem Weiterfahren auch die nächste Lücke beachtet: Auto 1, 2 und 3 bleiben stehen. Auto 5 schließt auf, fährt aber nicht weiter, denn Platz 3 ist voll. Auto 6 fährt auf Platz 5. Da er weiterfahren könnte, muss man auch Platz 4 überprüfen. Weil dieser frei ist, muss er auch dorthin fahren.

Insgesamt also nicht so einfach wies am Anfang scheint.

Zitat:

---

Zitat von Kelven

Mit meinen neugewonnenen Makerkenntnissen hab ich jetzt nochmal versucht den Algorithmus zu überarbeiten. Der Faulheit halber schreibe ich das aber wieder in Pseudocode.

---

Jo, das mit den Pointern sieht richtig aus. Nur:
wenn 0 < Variable23 < Variable24 wird der Schlalter nicht aktiviert. Bei teils vorsortierten Feldern kann das durchaus passieren.
Außerdem muss beim Tauschen die eine Variable zwischengespeichert werden, weil sie sonst überschrieben wird. Die erste Variable erhält den Wert der zweiten. Aber welchen Wert bekommt die zweite Variable, den Wert der ersten gibt es ja nicht mehr!?
Auch wird der Sortiervorgang leider nicht funktionieren. Wenn zum Beispiel Zahl sechs (10 Einheiten groß) und Zahl fünf (18 Einheiten groß) gleich am Anfang sortiert werden, wird eine von beiden als die kleinere definiert (10 Einheiten groß) und deshalb nachher nicht mehr beachtet auch wenn Zahl zwei viel kleiner ist. So sieht es zumindest meinem Wissensstand nach aus.

@übelster Held
:eek: ..kann sein. :D Sorry, hab da kein Durchblick.

@CapSeb

Zitat:

---

Leider geht es von "unten" garnicht.

---

Ne, das kann nicht sein, ich hab das schon seit Ewigkeiten so bei meinen Spielen gemacht. Klappte ohne Probleme. Die Liste wird durch den Switch solange durchlaufen bis nicht getauscht wurde. Man hat zwar mehr Durchläufe, aber bei der geringen Datenmenge geht das nicht auf die Performance.

Zitat:

---

wenn 0 < Variable23 < Variable24

---

Wenn dieser Fall eintritt steht Variable24 an der richtigen Stelle. Es soll ja von klein nach groß sortiert werden (und die Nullen ans Ende).

Zitat:

---

Außerdem muss beim Tauschen die eine Variable zwischengespeichert werden, weil sie sonst überschrieben wird. Die erste Variable erhält den Wert der zweiten. Aber welchen Wert bekommt die zweite Variable, den Wert der ersten gibt es ja nicht mehr!?

---

Die beiden Testvariablen werden nicht überschrieben und die weise ich dann den Inventarvariablen zu. Deswegen ist ein Zwischenspeichern nicht nötig (da sie ja schon zwischengespeichert sind).

Zitat:

---

Auch wird der Sortiervorgang leider nicht funktionieren. Wenn zum Beispiel Zahl sechs (10 Einheiten groß) und Zahl fünf (18 Einheiten groß) gleich am Anfang sortiert werden, wird eine von beiden als die kleinere definiert (10 Einheiten groß) und deshalb nachher nicht mehr beachtet auch wenn Zahl zwei viel kleiner ist. So sieht es zumindest meinem Wissensstand nach aus.

---

Im Maker hat das bei mir allen Anschein nach funktioniert. Es wird auch bei diesem Algorithmus solange von vorne angefangen, bis nicht getauscht wurde.

Zitat:

---

Zitat von Kelven

Die Liste wird durch den Switch solange durchlaufen bis nicht getauscht wurde.

---

Ich bin irgendwie blind heute. Hab den Label garnicht beachtet. Stimmt, dann gehts auf jeden Fall. :)

Zitat:

---

Zitat von Kelven

Wenn dieser Fall eintritt steht Variable24 an der richtigen Stelle.

---

em, ja... das gleiche wie beim ersten. Das Switch Ausschalten steht ja im Loop, es muss also nur ein einziges Mal getauscht werden, damit er angeht. :)

Zitat:

---

Zitat von Kelven

Die beiden Testvariablen werden nicht überschrieben und die weise ich dann den Inventarvariablen zu.

---

Ich hab... egal. Du hast einfach nur Recht :) ... :D

Zitat:

---

Zitat von Kelven

Im Maker hat das bei mir allen Anschein nach funktioniert. Es wird auch bei diesem Algorithmus solange von vorne angefangen, bis nicht getauscht wurde.

---

Ich geb mich geschlagen. Das nächste Mal werd ich wohl etwas genauer hingucken müssen. http://www.multimediaxis.de/images/s.../old/sm_12.gif http://www.multimediaxis.de/images/s.../old/s_009.gif
..Nur ein Problem bleibt: Es enthält sehr viele ungenutzte Durchgänge. Bei 50 Items denk ich aber, dass es da "noch" keine Probleme geben dürfte.

Danke erstmal an alle. Ich werde es mal ausprobieren.

@CapSeb:

Ok der Alogrithmus hat zwei Nachteile.

1.Erverschiebt alle Items nach "hinten". D.h. wenn ich z.B. 5 Items habe, werden diese auch sortiert, erscheinen aber auf den hinteren Slots.

2. "Luecken" werden nicht aufgefuellt. D.h. wenn z.B. Slot 1 und Slot 3 belegt sind, werden diese Stellen zwar verreuckt/geordnet, aber die Luecke bleibt.

Kannst mir dabei helfen die beiden Probleme zu beseitigen?

naja... mein code hätte das prob nich...^^"

Es lässt vermuten, dass du verschiedene Variablen hast, die als Namen das Item und als Wert die Position haben.
Du müsstest es genau andersrum machen, so dass die Variable "ItemPosi1" einen Wert hat, der die ItemID angibt. "ItemPosi1 = 6" heißt dann, dass an erster Stelle das Item mit der ID 6 steht (zB. Antidote). Somit würde Bubble Sort komplett funktionieren, wenn man es richtig umstellt.
Das Ganze hat sogar noch den Vorteil, dass du nur so viele "ItemPosiX"-Variablen brauchst, wie du maximal Items aufnehmen kannst, auch wenn es theoretisch 1000 verschiedene Items gibt.
Dieser Vorteil tritt aber nur auf, wenn du nicht alle Items unsortiert in die ItemPosi-Liste kopieren müsstests, was bei Bubble Sort leider der Fall ist. Denn man kann nur das tauschen, was schon existiert. Aber die ItemPosis sind ja am Anfang noch leer... :rolleyes:
Deswegen würde ich ein anderes Verfahren benutzen: Strait Insertion.

Dieses Sortierverfahren gleicht dem menschlichen Kartensortieren beim Kartenspiel. Alle zu sortierenden Handkarten liegen verdeckt auf dem Tisch. Man nehme eine Karte auf die Hand. Dann die zweite. Man guckt jetzt von links nach rechts, wo sie hinpasst. Dazu vergleicht man sie mit der ersten Handkarte von links. Ist sie größer, wird sie eingefügt. (wir wollen ja zuerst die häufigsten items). Wenn nicht wird die zweite von links überprüft (das geht natürlich erst, wenn man schon zwei Karten auf der Hand hat), usw. Hat man zB. schon sechs Karten auf der Hand, nimmt man die siebte und vergleicht sie "...mit der ersten - zu klein. Mit der zweiten- zu klein. mit der dritten - ah, größer!" Jetzt werden alle hinteren Karten um eins nach rechts verschoben. Das heißt die vierte Stelle, fünfte Stelle, sechste... Man muss nur aufpassen, dass man eine Karte nur aufnimmt, wenn sie größer null ist (macht man normalerweise nie, deswegen fehlt es im Quelltext) und die Kartenhand nicht voll ist (Anzahl der ItemPosi-Variablen minus 1 auf der Hand vor der Aufnahme).

#Label1
*Komlette ItemPosi-Liste leeren mit Schleife oder einzeln*
Var1 := Variablen-Nummer von ItemPosi1
Var2 := ID des aufgenommenen Items
Var3 := Variablen-Nummer der letzten ItemPosi
Var4 := Variablen-Nummer der letzten ItemPosi -1
..loop
....wenn (Var2 = Pointer[Var1]) dann
......Pointer[Var2] +1
......goto #Label1
....end
....wenn ("letzte ItemPosi" = 0)
......wenn (Pointer [Var2] > Pointer[Pointer[Var1]]) dann
........loop
..........pointer[Var3] := pointer [Var4]
..........wenn (Var4 = Var1) dann
............pointer[Var1] := Var2
............goto #Label2
..........end
..........Var3 -1
..........Var4 -1
........end loop
........goto #Label2
......end
....end
....wenn Var1 = Var3 --> goto #Label2
....Var1 +1
..end loop
#Label2

...Wer Fehler findet, bitte melden.
...Wer Verständnis-Fragen hat, genau nachhaken.
..und, ach ja: Der Doppel-Pointer ist schon richtig so (ItemPosi-->ItemID-->Anzahl)

Also welches Verfahren, das Bubble oder das Strait Insertion Verfahren, laesst sich auf mein "Problem" anwenden?

Wie es fuer mich aussieht, wuerde ich erst mal das Strait Insertion Verfahren... :confused:

Zitat:

---

Zitat von CapSeb

Dieses Sortierverfahren gleicht dem menschlichen Kartensortieren beim Kartenspiel. Alle zu sortierenden Handkarten liegen verdeckt auf dem Tisch. Man nehme eine Karte auf die Hand. Dann die zweite. Man guckt jetzt von links nach rechts, wo sie hinpasst. Dazu vergleicht man sie mit der ersten Handkarte von links. Ist sie größer, wird sie eingefügt. (wir wollen ja zuerst die häufigsten items). Wenn nicht wird die zweite von links überprüft (das geht natürlich erst, wenn man schon zwei Karten auf der Hand hat), usw. Hat man zB. schon sechs Karten auf der Hand, nimmt man die siebte und vergleicht sie "...mit der ersten - zu klein. Mit der zweiten- zu klein. mit der dritten - ah, größer!" Jetzt werden alle hinteren Karten um eins nach rechts verschoben. Das heißt die vierte Stelle, fünfte Stelle, sechste... Man muss nur aufpassen, dass man eine Karte nur aufnimmt, wenn sie größer null ist (macht man normalerweise nie, deswegen fehlt es im Quelltext) und die Kartenhand nicht voll ist (Anzahl der ItemPosi-Variablen minus 1 auf der Hand vor der Aufnahme).

#Label1
*Komlette ItemPosi-Liste leeren mit Schleife oder einzeln*
Var1 := Variablen-Nummer von ItemPosi1
Var2 := ID des aufgenommenen Items
Var3 := Variablen-Nummer der letzten ItemPosi
Var4 := Variablen-Nummer der letzten ItemPosi -1
..loop
....wenn (Var2 = Pointer[Var1]) dann
......Pointer[Var2] +1
......goto #Label1
....end
....wenn ("letzte ItemPosi" = 0)
......wenn (Pointer [Var2] > Pointer[Pointer[Var1]]) dann
........loop
..........pointer[Var3] := pointer [Var4]
..........wenn (Var4 = Var1) dann
............pointer[Var1] := Var2
............goto #Label2
..........end
..........Var3 -1
..........Var4 -1
........end loop
........goto #Label2
......end
....end
....wenn Var1 = Var3 --> goto #Label2
....Var1 +1
..end loop
#Label2

...Wer Fehler findet, bitte melden.
...Wer Verständnis-Fragen hat, genau nachhaken.
..und, ach ja: Der Doppel-Pointer ist schon richtig so (ItemPosi-->ItemID-->Anzahl)

---

Habe ich das richtig verstanden, dass das Strait Insertion Verfahren aufgerufen wird wenn ich ein Item aufnehme und es dann automatisch geordnet wird?

Und wieso "*Komlette ItemPosi-Liste leeren mit Schleife oder einzeln*"? Hab ich auch nicht ganz verstanden...

Ist es denn eigentlich notwendig, dass gleiche Items doppelt vorkommen können? Weil wenn alle gleichen Items zusammengefasst werden, gibt es auch einfachere Methoden, bei denen man ohne Sortierung auskommt.

Zitat:

---

Zitat von Kelven

Ist es denn eigentlich notwendig, dass gleiche Items doppelt vorkommen können? Weil wenn alle gleichen Items zusammengefasst werden, gibt es auch einfachere Methoden, bei denen man ohne Sortierung auskommt.

---

Das hat mich an den meisten alten RPgs schon immer gestoert. Z.B. Breath of Fire 2. Man hatte dort einen Slot und konnte 9 Gegenstaende "reinhauen". Heut zu tage, z.B. Diablo, Gothic oder Morrowind, haben Slots auch ihre Berechtigung, auch wirklich fuer einen Gegenstande da zu sein...

Und so wollte ich das auch in meinem Spiel haben. Ein Slot, ein Gegenstand. So wie es sein sollte. Anders seids, verliert der Bergiff Slot, in meinen Augen, seine Bedeutung...

Bei den östlichen Spielen hat man auch heute noch unbegrenzte Inventare. Das ist zwar unrealistisch, aber mMn praktischer.

Zitat:

---

Zitat von Kelven

Bei den östlichen Spielen hat man auch heute noch unbegrenzte Inventare. Das ist zwar unrealistisch, aber mMn praktischer.

---

So geht aber irgendwie der Taktik im KS floeten. So kann man soviele Heiltraenke wie man will mit sich rumschleppen und sich immer wieder heilen...

Das kommt darauf an was beim KS die Taktik ausmachen soll, aber im Prinzip ist das ja auch deine Entscheidung. Bei einem unbegrenzten Inventar hat man den Vorteil die Gegenstände von Vorne rein in einer festgelegten Reihenfolge anzuzeigen und die leeren Plätze einfach auszulassen.

Zitat:

---

Zitat von lokipoki

Also welches Verfahren, das Bubble oder das Strait Insertion Verfahren, laesst sich auf mein "Problem" anwenden?

---

Wie du willst. Das ganze "Script" muss an deine Vorstellungen und Ideen angepasst werden. Deswegen hab ich keinen direkten RPG Maker Code geschrieben, sondern verallgemeinert. Strait Insertion ist schwieriger, passt aber besser.

Zitat:

---

Zitat von lokipoki

Habe ich das richtig verstanden, dass das Strait Insertion Verfahren aufgerufen wird wenn ich ein Item aufnehme und es dann automatisch geordnet wird?

---

Ja. Sozusagen ist die Item-Posi-Liste eine Highscoreliste mit den zB. zehn meist vorhandenen Items. Nur wird es nie einen elften "Rang" geben, da das ja beim Item-Aufsammeln ausgeschlossen werden muss. Ist also noch ein Platz frei, wird das neue Item eingeordnet indem die entsprechenden alten verrrückt werden.

Zitat:

---

Zitat von lokipoki

Und wieso "*Komlette ItemPosi-Liste leeren mit Schleife oder einzeln*"? Hab ich auch nicht ganz verstanden...

---

Ja, gut mitgedacht. Da hab ich einen Fehler gemacht um im Nachhinein vergessen was zu sagen:
Wenn das aufgesammelte Item noch nicht im Inventar ist, wird es einfach reingesteckt - also der Code ausgeführt. Gibt es aber das Item im Inventar schon (was häufig der Fall sein wird), müsste man es ja an eine andere Position stellen. Deswegen löscht man vor dem Aufnehmen des Items den Inhalt der ItemPosiVars (auf null setzen) uns sortiert noch mal die ganze ItemPosiListe (Kartenhand) von vorne. Beim Kartenspiel-Beispiel würde das bedeuten, dass es auch nuller Karten gibt die beim Ziehen auf dem Tisch liegen gelassen werden.
Beim genannten Quellcode bedeutet also *Komplette ItemPosi-Liste leeren mit Schleife oder einzeln* dass es nochmal einen Loop ganz außenrum gibt, der die Var2 definiert. Es wird also nicht nur das gerade aufgenommene Item einsortiert, sondern alle Items > null in die Liste einfügt. Damit das jetzt nicht zu kompliziert wird, nochmal der Vorgang in Stichpunkten:

1. Das Item +1 (statt zum zB. sechs jetzt sieben Heiltränke)
2. Die ItemPosiVars = 0 (Highscoreliste der Itemanzahl leeren)
3. Erstes Item mit Anzahl > Null suchen und einsortieren (Erste Karte in die Hand nehmen)
4. Zweites Item mit Anzahl > Null suchen und einsortierem (zweite Karte in die Hand sortieren)
5. So oft wiederholen wie ItemPosiVars vorhanden (Karten aufnehmen und einsortieren, wenn max. Kartenhandzahl noch nicht erreicht)

Würde man Bubble Sort nehmen, müsste man bei 1000 verschiedenen Items im Spiel auch 1000 ItemPosiVars machen.

Ok hab jetzt alles verstanden. Nochmals ein grosses DANKE.

Doch leider kann ich mit dem Strait Insertion nichts anfangen, da ich dem Spieler es das Ordnen selber ueberlassen will. D.h. das ich in meinem Menue eine button ordnen habe, und der auch diese bewerkstelligen sollen. Aufsteigend, nach ItemID, ordnen und eben Luecken aufuellen...

Geht doch mit Strait Insertion. :D Genau dazu ist es ja gedacht.
Wenn es so funktionieren soll, wird beim Aufsammeln des Items nur geguckt ob die Tasche nicht schon voll ist und erst beim Betreten des Menüs sortiert (je nachdem welche Sortier-Kategorie gerade angezeigt wird). Drückst du einen der Buttons zum "Sortieren nach was auch immer" wird die Itemliste gelöscht und entsprechend sortiert:
1. erstes Item der entsprechenden Kategorie größer null einfügen
2. zweites Item der entsprechenden Kategorie größer null einsortieren*
3. drittes Item ...
4. ...
n. letztes Item der entsprechenden Kategorie größer null einsortieren*

(*einsortieren heißt nach hinten verschieben der Items die kleiner sind)


Such dir eine Methode aus:
- von Übelster Held (hab ich nicht analysiert)
- von Kelven (jedes Item braucht zwei Variablen (Quelltextänderung nötig), häufige Durchläufe)
- Bubble Sort (jedes Item braucht zwei Variablen)
- Strait Insertion (komplizierter, jedes Item braucht eine Var, ItemPosiVars)