Hey Leute,
Ich programmiere zurzeit ein kleines Spiel. Man ist ein Bergarbeiter und gräbt sich durch die Erde :D.
Ich speichere die Werte eines Blockes in einen 2-dimensionalen array(10000,10000). Nun möchte ich die Positionen der Blöcke etc. speichern, das wären aber im Extremfall 100000000 Koordinaten mit Werten.

Hat jemand eine Idee wie man eine solche Datenmenge schnell speichern kann ?
Ich habe es bereits mit einer Text-Datei probiert, jedoch ist die Speicherdauer extrem Lange.

Mit Datenbanken habe ich keine Erfahrung weshalb ich auch nicht weiß welche geeignet wäre.

Danke im Voraus :)

Wenn es sich um eine tile-basierte Map handelt, dann kannst du einfach eine Palette an Tiles erstellen und dann ins Array die Indizes schreiben anstatt die ganzen Tile-Informationen.
So speicherst du jedes Tile einmal und dann nur eine Zahl pro Feld.

Ansonsten wird nicht ganz klar, wie dein Spiel aufgebaut ist.

Wie speicherst du denn aktuell und wie viele verschiedene Werte kann ein Feld haben?

//EDIT:
@backtothetoast
Höchstens "manuelle" Serialisierung würde hier was helfen. Die "normale" würde warscheinlich viiiiel größere Dateien erzeugen.

Serialisierung könnte hier evtl. helfen.

Du musst das Spielfeld in kleinere Abschnitte unterteilen und nur diejenigen laden und speichern, bei denen es nötig ist, ansonsten füllst du deinen Arbeitsspeicher enorm zu (alleine die Pointer im Array brauchen schon 400MB , mit den zugehörigen Klassen bist du da schnell in Bereichen, die selbst die besten Highend-PCs nicht mehr tragen können).

Hy, mal kurtz ot aber wird das ein Simulator ?

Also das ganze Spiel ist aufgebaut wie die App Gem Miner (Siehe Bild).


Der Spieler gräbt sich also durch die Erde, ganz einfach gehalten in 2D und ohne XNA etc.
Ich speichere im Array zahlen von 1-20 für verschiedene Sachen/Gegenstände beispielsweise eine Leiter besitzt den Wert 1.


Im Form Paint Sub Überprüfe ich dann welche Spielfelder (Ein Feld ist 40*40px groß) aktuell sichtbar sind, um nicht alles Zeichnen zu müssen.
Danach gucke ich welche Zahl in der Koordinate/in dem Feld steckt und zeichne dann, wenn es z.B. 1 wäre, eine Textur für eine Leiter in das entsprechende Feld.


Da mein Array 10000*10000 groß ist kann der Spieler 100000000 Blöcke weg graben. Gehen wir nun davon aus das es ein Spieler schaft jeden Block zu entfernen, dann müssten 100000000 Einträge abgespeichert werden, jeder mit dem Inhalt, Beispielsweise 4, für ein Leeres Feld.


@Counterbug ich benutze ja bereits dieses Prinzip aber das bringt mir bei 100000000 Zeichen leider nichts.
@backtothetoast von Serialisierung hab ich bis jetzt noch nie was gehört, ich werde es mir in den nächsten Tagen mal genauer anschauen.
@Artentus ich würde natürlich auch nur die entsprechenden Teile der Map laden/generieren. Jedoch müssten wenn ein Spieler alle Felder leer gräbt trotzdem 100000000 Informationen gespeichert werden.
@Andy16823 wie man es nimmt, wenn dann ein sehr sehr unrealistischer 2D Simulator, also eher nein :D
@nafets3646 Aktuell würde ich gucken wie viele Felder der Spieler gesehen hat und diese dann in einer .txt speichern. Bei 100000000 gesehenen Felder(Auch wenn das wahrscheinlich nicht vorkommen wird) ist die Speicherzeit aber nicht ansatzweise aushaltbar.

Danke schon mal für eure Antworten :)

Das ist auf jeden Fall nicht zumutbar, wir sprechen hier von Speicherbelegungen im dreistelligen Gigabyte-Bereich. Du wirst dir da wohl oder übel was anderes einfallen lassen müssen, Stacks aus mehreren Blöcken oder so, das, was du da vorhast, wird nicht laufen.

100.000.000 sind 100 MBit * 32 (integer) = 3,2 Gigabyte!!! Mach es so wie in minecraft. 16*16*256 arrays, die erzeugt werden, wenn man reingeht. (z.b. mit list(of chunk))

ich wüde hier an einen kompressionsalgorithmus denken, denn 3,2Gbyte Nullen sind gut komprimiert weniger als 1 kByte!

P.S: auf deinem Bild sind ca. 50*50 Blöcke abgebildet. Es wird somit nahezu unmöglich in einem 10.000*10.000 -Raster diesen Ausschnitt jemals wiederzufinden!

Als byte ist ja noch ok...
100.000.000 * 8 (Byte) = 800 megabyte, geht dann aber nur von 0 - 255 (integer hat einen größeren zahlenbereich, aber so viele sachen braucht man ja auch nicht.)

@00yoshi
Wat? Was du da rechnest, ergibt überhaupt keinen Sinn.
Es sind 100.000.000 Elemente. Wären es alles Bytes, dann entspräche das exakt 100MB. Es sind aber vermutlich Pointer auf Klassen, welche auf 32Bit-Systemen 4Byte und auf 64Bit-Systemen 8Byte groß sind. Bei 32Bit macht das dann 100.000.000 * 4 = 400MB und bei 64Bit sind es 100.000.000 * 8 = 800MB. Hinter jedem Pointer liegt aber noch ne Klasse, und wenn die auch nur 100 Byte groß wäre, dann sind wir schon bei 10GB.

Ich werde die Map einfach kleiner machen und nur wirklich vom Spieler gesehene Teile speichern, der Rest wird dann zufällig nach generiert. Damit sollte es dann in Akzeptabler Geschwindigkeit funktionieren und die gespeicherte Datei auch nicht allzu groß werden.

Die Werte würden auch leider nicht im Byte bereich liegen.

Trotzdem Danke für eure Antworten :)

@Artentus

Du hast Recht, aber als Byte ist es doch auch sinnvoll? (Minecraft: Speichert alles so, nur bei speziellen dingen erstellt es dann eine datei dafür.)

Ja, beim Speichern in der Datei. Aber im laufenden Spiel muss viel mehr geladen werden, als nur ein einfacher Index.

Mach es so, wie es schon vorgeschlagen wurde mit Chunks.
Das ist die beste Lösung die jetzt dein Problem (wahrscheinlich auch am schnellsten) löst.

Das mit den Chunks wäre wahrscheinlich die beste Lösung, da das aber mein erstes Spiel ist und ich jetzt kein Profi in VB bin, halte ich das speichern möglichst einfach.
Ich hab die Map jetzt entsprechend verkleinert, so das die Speicherzeit sehr gering ist.

Wenn ich nochmal ein Spiel scripte dann werde ich auch die Chunks-Methode verwenden.

Danke, für eure Antworten :)

Zeig doch trotztem mal deine aktuelle Speichermethode. Da kann man sicher noch viel verbessern :).

Das glaub ich auch :D
Hier der Aktuelle Code zum speichern:

Variablen:

VB.NET-Quellcode

1. Public Seen_LST As New List(Of String) 'Liste aller gesehenen Blöcke
2. Public _Save_String As String = "" 'Finale Datei
3. Dim Field_Size As New Size(500, 1000) 'Feldgröße
4. Public Field(Field_Size.Width, Field_Size.Height) As Integer 'Feld Array
5. Public MapX As Integer = 250 'Horizontale Verschiebung der Map (Für Bewegung)
6. Public MapY As Integer = 0 'Vertikale Verschiebung der Map (Für Bewegung)

Backgroundworker (Alle gesehenen Blöcke werden in Seen_LST hinzugefügt, danach wird _Save_String die Koordinaten+Inhalt hinzugefügt. Wird bei jeder Spieler/Map Bewegung gestartet):





der eigentliche Code zum speichern ist dann nur noch:

VB.NET-Quellcode

1. System.IO.File.WriteAllText("MapS.txt", _Save_String)

Eine gespeicherte Datei sieht dann z.B. so aus:




Sorry für die schlechte Formatierung/Einrückung, ging irgendwie nicht besser :)

Mal ein paar Punkte, wie du es verbessern könntest:
-Anstatt die Stringe mit dem &-Operator zu verbinden, nutze einen StringBuilder, der ist schneller
-Für was die Koordinaten der einzelnen Felder speichern? Du brauchst nur die Startkoordinate, den Rest kannste dir berechnen
-Arbeite auf der Byte-Ebene anstatt mit Strings, da haste in einem Zeichen in deiner Datei entweder 2 Felder a 16 Möglichkeiten oder 1 Feld mit 256 Möglichkeiten. Bei der zweiten Variante hast du also 1 Byte pro Feld, wobei du für jedes Feld 256 Möglichkeiten speichern kannst -> viel weniger Speicherplatzverbrauch.