Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Werbeanzeige

Lindraupe

Frischling

  • »Lindraupe« ist der Autor dieses Themas

Beiträge: 62

Wohnort: Wien

  • Private Nachricht senden

1

02.06.2016, 21:00

Wie level speichern?

Wie ist es eurer Meinung nach am Besten Level zu speichern?
Die beiden Möglichkeiten, die ich bisher gefunden habe waren die Serialisierung und das Schreiben und Lesen über Kons-/Destruktoren.

Danke im Vorhinein
lindraupe

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

2

02.06.2016, 21:04

Also ich finde XML dafür ganz schön (oder auch YAML).

Nimelrian

Alter Hase

Beiträge: 1 216

Beruf: Softwareentwickler (aktuell Web/Node); Freiberuflicher Google Proxy

  • Private Nachricht senden

3

02.06.2016, 21:10

JSON ist auch noch eine Alternative.
Ich bin kein UserSideGoogleProxy. Und nein, dieses Forum ist kein UserSideGoogleProxyAbstractFactorySingleton.

BlueCobold

Community-Fossil

Beiträge: 10 738

Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer

  • Private Nachricht senden

4

02.06.2016, 21:10

YAML, echt? Ich finde YAML grauenvoll ^^. XML oder JSON könnten aber schon sehr üblich sein.
Teamleiter von Rickety Racquet (ehemals das "Foren-Projekt") und von Marble Theory

Willkommen auf SPPRO, auch dir wird man zu Unity oder zur Unreal-Engine raten, ganz bestimmt.[/Sarkasmus]

dot

Supermoderator

Beiträge: 9 757

Wohnort: Graz

  • Private Nachricht senden

5

02.06.2016, 21:21

Ich würde mal sagen: Das hängt erstmal von der Art von Level/Spiel ab. Und wie sollen die Levels denn gebaut werden? Am besten für die Ladezeit ist natürlich immer ein custom binary Format...

BlueCobold

Community-Fossil

Beiträge: 10 738

Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer

  • Private Nachricht senden

6

02.06.2016, 21:27

True dat. Aber bevor wir hier unnötige Erwartungen wecken, sollte man ihm sagen, dass er vermutlich keine Level-Files mit mehreren hundert MB hat, die ohne Optimierung viel zu lange laden würden. Wahrscheinlicher ist es, dass es total egal ist, welches Format er wählt, weil er eben ein Hobby-Projekt baut und keinen AAA-Titel.
Teamleiter von Rickety Racquet (ehemals das "Foren-Projekt") und von Marble Theory

Willkommen auf SPPRO, auch dir wird man zu Unity oder zur Unreal-Engine raten, ganz bestimmt.[/Sarkasmus]

CeDoMain

Alter Hase

Beiträge: 587

Wohnort: Ilmenau

Beruf: Student für Mechatronik

  • Private Nachricht senden

7

02.06.2016, 23:22

Bei meiner Lichtsoftware implementieren alle Objekte, die gespeichert werden können eine Methode ToSaveData. Wenn das Projekt gespeichert wird, dann wird von den obersten Objekten diese Methode aufgerufen, die dann rekursiv ToSaveData von ihren Membern aufrufen, usw...

Das sieht dann so ungefähr aus:

C#-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Von Klasse Fixture
public XElement ToSaveData()
{
    return new XElement(TypeName,
        new XAttribute("PresetName", PresetName),
        new XAttribute("FixtureName", FixtureName),
        new XAttribute("StartAddress", StartAddress),
        new XAttribute("Universe", Universe),
        new XAttribute("Hue", RGBValue.ToHexColorString(Hue)),
        new XElement("Functions", Functions.Select(f => f.ToSaveData())));
}

// Von Klasse "Function"
public XElement ToSaveData()
{
    return new XElement(TypeName,
        new XAttribute("FunctionName", FunctionName),
        new XAttribute("Hue", RGBValue.ToHexColorString(Hue)),
        new XAttribute("IsFreezed", IsFreezed),
        new XAttribute("IsEnabled", IsEnabled),
        new XElement("Input", Input.ToSaveData()),
        new XElement("Value", Value.ToSaveData()));
}

Wenn eine Datei geladen wird, dann wird das über den Konstruktor gelöst:

C#-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public Fixture(XElement SaveData)
{
    Functions = new List<IFunction>();
    Hue = RGBValue.FromHexColorString(SaveData.Attribute("Hue").Value);
    FixtureName = SaveData.Attribute("FixtureName").Value;
    PresetName = SaveData.Attribute("PresetName").Value;
    Universe = Convert.ToByte(SaveData.Attribute("Universe").Value);
    StartAddress = Convert.ToUInt16(SaveData.Attribute("StartAddress").Value);

    // Funktionen aus Preset und Save laden
    var FunctionsPresetData = Presets.LoadPreset(PresetName).Element("Functions").Elements();
    var FunctionsSaveData = SaveData.Element("Functions").Elements();
    foreach (var DataPair in FunctionsPresetData.Zip(FunctionsSaveData, (fpd, fsd) => new KeyValuePair<XElement, XElement>(fpd, fsd)))
        Functions.Add(GenericBuilder.CreateFunction(this, DataPair.Key, DataPair.Value));

    foreach (var f in Functions)
        f.PropertyChanged += Function_PropertyChanged;
}

public Function(Fixture Owner, XElement PresetData, XElement SaveData)
{
    Hue = RGBValue.FromHexColorString(SaveData.Attribute("Hue").Value);
    FunctionName = PresetData.Attribute("FunctionName").Value;
    this.Owner = Owner;
    IsFreezed = Convert.ToBoolean(SaveData.Attribute("IsFreezed").Value);
    IsEnabled = Convert.ToBoolean(SaveData.Attribute("IsEnabled").Value);
    Value = (T)GenericBuilder.CreateValue(SaveData.Element("Value").GetFirstElement());

    // Eingang erzeugen
    Input = new InputPin<T>(this, SaveData.Element("Input").GetFirstElement());
    Input.ValueChanged += Input_ValueChanged;

    // Kanäle aus Preset laden
    Channels = new List<Channel>();
    foreach (var ChannelPresetData in PresetData.Element("Channels").Elements())
        Channels.Add(new Channel(ChannelPresetData)
        {
            StartAddress = Owner.StartAddress,
            Universe = Owner.Universe
        });
}
Wenn du genau schaust, dann siehst du, dass für die Funktionen gleichzeitig noch "PresetData" geladen wird. Das sind XML-Daten, die nicht mitgespeichert werden, sondern aus einem getrennten File kommen (was für alle Projekte gilt). Diese XML-Daten werden einfach mit an den Function-Konstruktor übergeben. Hoffe der Code ist verständlich. ;)
Mit freundlichem Gruß
CeDo
Discord: #6996 | Skype: cedomain

Lass solche persönlichen Angriffe lieber bleiben, meine sind härter.

BlueCobold

Community-Fossil

Beiträge: 10 738

Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer

  • Private Nachricht senden

8

03.06.2016, 07:11

Das hättest Du mit dem Standard-XML-Serializer viel einfacher und mit weniger Aufwand haben können ;)
Teamleiter von Rickety Racquet (ehemals das "Foren-Projekt") und von Marble Theory

Willkommen auf SPPRO, auch dir wird man zu Unity oder zur Unreal-Engine raten, ganz bestimmt.[/Sarkasmus]

Lindraupe

Frischling

  • »Lindraupe« ist der Autor dieses Themas

Beiträge: 62

Wohnort: Wien

  • Private Nachricht senden

9

03.06.2016, 07:13

Danke für die Vorschläge :thumbsup:

Ich glaube nicht, dass die einzelnen Level files größer als 100 MB werden, und wenns ein bisschen länger lädt wird es das Spiel auch verkraften ;)
Achja, ich habe vorher vergessen zu sagen dass das Spiel in C++ ist, aber soweit ich gesehen habe funktionieren dort auch alle.

@dot Ich hab auf jetzt grade keinen Zugang zum Code, aber irgendwann heute kann ich den Teil noch schicken. Bis jetzt hab ich einfach Klassen erstellt und in Listen gegeben und halt Levelbreite und so gespeichert.

Schorsch

Supermoderator

Beiträge: 5 145

Wohnort: Wickede

Beruf: Softwareentwickler

  • Private Nachricht senden

10

03.06.2016, 12:12

XML und JSON wurden ja schon genannt. Mit den richtigen Bibliotheken kannst du da auch Klassen direkt (de)serialisieren oder schreibst dir selbst Code um zu (de)serialisieren. Es gibt aber auch noch andere Möglichkeiten. Es gibt noch ini-Files, falls du Minecraft spielst und mal in die server.properties geguckt hast, das ist ein ähnliches Format. Dafür gibts auch fertige Bibliotheken. Was ich am Anfang viel gemacht habe ist einfach meine Werte Zeile für Zeile in einer Textdatei zu speichern. Als Beispiel stand die Breite der Karte in der ersten Zeile, die Höhe in der zweiten Zeile und dann Zeile für Zeile jeweils ein Tile meiner Tilemap. Die Anzahl der Tiles wurde implizit durch Breite*Höhe gegeben. Teilweise habe ich es so gemacht dass 1 Zeichen einem Tile entspricht und dann entsprach eine Zeile einfach einer Zeile in der Welt.
Bei Speicherformaten für Einheiten hatte ich dann zum Beispiel die HP in der ersten Zeile, den Angriffswert in der zweiten Zeile, den Defensivwert in der dritten, den Namen in der vierten und so weiter. XML, JSON und co sind an sich schöner da du eine Zuweisung der Werte hast. Du musst dir nicht merken dass der Wert in Zeile 5 den Lebenspunkten entspricht da der Wert eben benannt ist. Für den Anfang einfacher ist aber vermutlich das eigene Format da du dich nicht mit Bibliotheken etc beschäftigen musst.
„Es ist doch so. Zwei und zwei macht irgendwas, und vier und vier macht irgendwas. Leider nicht dasselbe, dann wär's leicht.
Das ist aber auch schon höhere Mathematik.“

Werbeanzeige