# YAML vs JSON vs XML?

This topic is 1612 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

## Recommended Posts

I'm working on a 2D RPG in Java using LibGdx, and need to find a way to store my game data. The things I've considered are YAML, JSON and XML. I only have experience in working with XML, but the others can't be too hard to learn. What I need to achieve is being able to define items to be generated by listing the components that the item would have and my EntityGenerator would turn them into game objects.

Additionally, I would like to be able to build myself an "Item creator" utility where I can use a GUI to simply check off the components to add for my item and it would add that into the data file.

Any suggestions?

Edited by stein102

##### Share on other sites

I can't really speak to the pros/cons of YML, I wrote a quick and dirty parser for it a while ago for a webapp, but that's my entire experience. As far as JSON is concerned, if you're not using Javascript, there isn't much point. The reason that JSON is so nice in web development is that it is instantly recognized by the browser's JS interpreter as an object so there's no additional parsing necessary. This is only true in Javascript, though. Any other language requires a custom library to interpret JSON.

Personally, I would say work with XML. For one thing, you already know it. For another, a lot of people already know it, so if you end up bringing another person in on your project, they won't be stuck trying to familiarize themselves with a new data format (and if the person you're bringing in isn't at least somewhat comfortable with XML, you might need to ask if they're a good fit).

##### Share on other sites

I think I'll stick to XML like was suggested above. No need to learn extra technologies to achieve something that can be done with a protocol  that I already know.

Does this look like a good structure to you? Or is there a better way?

<?xml version="1.0"?>
<item>
<id>1</id>
<name>sword</name>
<components>
<wieldable></wieldable>
</components>
</item>


##### Share on other sites

I think at the very least you could abbreviate that format -- remember that XML is really meant to be a semantic format -- I might do something like the following:

<item id="1" name="sword" category="weapon">
<description> Just a regular sword.</description>
<components>
<wieldable />
</components>
</item>

There's quite a bit of art to designing and XML schema, but good designs use elements and properties together in a way that reduces redundancy and encourages correct use. You can define your format using a DTD and validate such files before they touch your game or content pipleline.

Keep in mind that <item> might or might not be a valid element in your schema depending on how much commonality all the different kinds of items have with one another. Say, for example, that it makes no sense for some sub-class of items to have any components, but another sub-class of items might require at least one component. You could enforce this just in the DTD, but it could make maintaining the DTD complicated -- it might be better to not have a generic <item> element, but instead have elements for the different subsets, say <weapon> and <potion>. Like I said, there's some art and intuition behind these kinds of decisions, just think carefully about them rather than tossing the first thing that comes to mind together.

Edited by Ravyne

##### Share on other sites

I think at the very least you could abbreviate that format -- remember that XML is really meant to be a semantic format -- I might do something like the following:

<item id="1" name="sword" category="weapon">
<description> Just a regular sword.</description>
<components>
<wieldable />
</components>
</item>

There's quite a bit of art to designing and XML schema, but good designs use elements and properties together in a way that reduces redundancy and encourages correct use. You can define your format using a DTD and validate such files before they touch your game or content pipleline.

Keep in mind that <item> might or might not be a valid element in your schema depending on how much commonality all the different kinds of items have with one another. Say, for example, that it makes no sense for some sub-class of items to have any components, but another sub-class of items might require at least one component. You could enforce this just in the DTD, but it could make maintaining the DTD complicated -- it might be better to not have a generic <item> element, but instead have elements for the different subsets, say <weapon> and <potion>. Like I said, there's some art and intuition behind these kinds of decisions, just think carefully about them rather than tossing the first thing that comes to mind together.

I'm not fully sure what I'll need for my items yet as I'm just starting development. I like the idea of not using a generic <item> element, but using elements for different categories of items there could be. Do you have any other suggestions that I may need to have? I'm sure I'll be running into complications in no time otherwise.

##### Share on other sites

As for the verbosity of XML, it is fairly simple to use zlib to compress the XML. In the case of network transfer, is may be quite worth to spend the extra CPU-cycles and send a XMLZ-file.

You then have the tooling of XML in a fairly (albeit not the most) compact format.

##### Share on other sites

Remember the various security pitfalls of parsing XML from an untrusted source. If you're not doing that, then you're fine though.

##### Share on other sites

As far as I can tell, many systems are moving towards json for config etc. I can't speak for the rest, but I personally switched from xml (or xml-plists actually) to json because editing (and finding errors) is so much easier in json. Not to mention that json can be much more compact while still retaining readability.

My vote's for json.

##### Share on other sites
...
There's quite a bit of art to designing and XML schema, but good designs use elements and properties together in a way that reduces redundancy and encourages correct use. You can define your format using a DTD and validate such files before they touch your game or content pipleline.
...

+1 but use XSD instead of the deprecated DTD for validation purposes

As far as I can tell, many systems are moving towards json for config etc. I can't speak for the rest, but I personally switched from xml (or xml-plists actually) to json because editing (and finding errors) is so much easier in json. Not to mention that json can be much more compact while still retaining readability.

My vote's for json.

Well, in my experience it's alot easier to spot formatting errors in XML than in json. If your texteditor did not spot it already, just use XSD-validation, it tells you exactly where the error is. Finding errors in data content is even harder in json.

##### Share on other sites

I think at the very least you could abbreviate that format -- remember that XML is really meant to be a semantic format -- I might do something like the following:

<item id="1" name="sword" category="weapon">
<description> Just a regular sword.</description>
<components>
<wieldable />
</components>
</item>

I think you could abbreviate that a bit further, by removing the <components> tag, since it is kind of redundant. Any child elements of "item" could be seen as components of the item, and the "description" is one of them.

Personally, I try to put everything in tags and arguments too, since I find it easier to write the parser for with tinyxml.

So I'd write

<description text="Just a regular sword."/>

That way, you also avoid the end tags, and get the format a little bit more brief.

So this:

<item id="1" name="sword" category="weapon">
<description text="Just a regular sword."/>
<wieldable/>
</item>

or something...

That's one problem with xml, so many ways to do it.

But I like it.

Edited by Olof Hedman

##### Share on other sites

As far as JSON is concerned, if you're not using Javascript, there isn't much point. The reason that JSON is so nice in web development is that it is instantly recognized by the browser's JS interpreter as an object so there's no additional parsing necessary. This is only true in Javascript, though. Any other language requires a custom library to interpret JSON.

This is becoming increasingly less true.  Many of the NoSQL databases for example expect and return JSON.  More and more web services are moving from XML to JSON as well.  There are increasingly parsers for JSON in more and more languages, often many times lighter than XML.  Frankly, if you aren't having to describe/discover the data's type, XML is overkill.

Since you are working in Java ( or C++ is another option here ), I would also consider checking out ProtocolBuffers.  Ultra light weight and better, can actually generate java code to create a Builder for the type you define.

##### Share on other sites

As for the verbosity of XML, it is fairly simple to use zlib to compress the XML. In the case of network transfer, is may be quite worth to spend the extra CPU-cycles and send a XMLZ-file.

You then have the tooling of XML in a fairly (albeit not the most) compact format.

this works pretty good IME.

though, granted, it is possible to get the speed/compression tradeoff a little better with a specialized binary serialization, but this is a bit more work (IOW: may involve working with entropy-coded bitstreams, ...).

a minor issue of XML+Deflate, is that it isn't by itself ideally suited for transmitting a stream of messages, so generally needs to be wrapped in some sort of container. in a typical example, this will be a tag-value, followed by a length, followed by the compressed data.

in some cases, it may also make sense to "escape code" the data, such that a tag may never appear in data. this may allow things like resynchronizing with a data stream.

as for data representations:

I also use S-Expressions to some extent as well, though these are not as widely popular.

another option is basically creating a byte-oriented data serialization, and then feeding this through zlib / deflate.

Edited by cr88192

##### Share on other sites

I've had very positive experiences with Protocol Buffers. They are fast, compact and have text and binary representation (even convertible from one form into the other using just a small tool). They are just so little work and versatile that I am using them for lots if different things: Network protocols, configuration files, save games, ...

I have found few libraries that made my life as much easier as protobuf did.

##### Share on other sites

Protocol buffers looks really nice for anything that isn't a tree. (or am I missing something?)

I guess XML is at its best when you have to describe a tree, but I will definitely look into protocol buffers some more for things that isn't, and sending stuff

Edited by Olof Hedman

##### Share on other sites

Basically all I need this to do is the following:

-Have "Item" class and "ItemLoader" class

-ItemLoader reads the data file and creates an instance of item for each item in the file

-Item has very limited fields/methods(Id/description/name)

-ItemLoader reads the data file and adds all components to the item(ex. Consumable, wieldable, weapon, shield, etc.)

-Easy to manipulate via API(Going to be editing and creating items from a GUI)

##### Share on other sites

Perhaps just wrap it one level higher, so you can easily switch it out depending on the job at hand.

At work, we tend to swap between JSON and XML weekly ;)

##### Share on other sites

Protocol buffers looks really nice for anything that isn't a tree. (or am I missing something?)

I guess XML is at its best when you have to describe a tree, but I will definitely look into protocol buffers some more for things that isn't, and sending stuff

message X {
optional X x = 1;
optional X y = 2;
}


This works just fine. Trees!

##### Share on other sites
<?xml version="1.0"?>
<item id="1">
<name>sword</name>
<components>
<component wieldable="true" />
</components>
</item>

##### Share on other sites

<components>
<component wieldable="true" />
</components>

That's a little weird. Why is wieldable a property of component? Isn't wieldable the component? Would you want to define multiple component properties on the same component like <component wieldable="true" throwable="true" />? Are you meant to enumerate all components of the item in a single component? If so, what's the purpose of the <components> parent element? Can a component property ever be false? What does that mean? Why not just leave it out in the first place? Is it more than a binary state?

##### Share on other sites

Well isn't wieldable just a boolean state? And item can have components, so having a component element can't be that strange? As an (Final Fantasy 7) example, an item would be a sword with name: DragonFang. It can have components such as: spells and materia. Spells are castable and Materia are wieldable or equippable.

Or maybe I've just completely misunderstood the XML schema.

##### Share on other sites

Sure, what you posted succeeds at encoding the information, I just think there are better ways to encode it. Like you said, whether something is "wieldable" or not is a Boolean state, but there's many ways to encode that -- as a property on an element as you've done is one way, the presence of an element named <wieldable> is another. In the former, one has to modify the component element schema every time a new component ability is added (component is going to keep growing too!), in the latter, you just define a new element type and add it to the list of acceptable child elements of <componenents>. In the former, its difficult to add any information about the wieldable-ness of the object -- perhaps its only wieldable by a certain class of character, or requires a certain amount of strength to wield-- in the latter, because wieldable is its own element, it can have its own properties and child elements that further describe it, and everything is neatly organized -- Wieldable might have an entirely different set of properties and children that describe it than Equipable does.

This goes back to one of the things I said early on, which is that unlike JSON or YAML, XML is as much a language for describing the data format as it is for exchanging data using said format. Its a truly structured document, rather than a list of information loosely organized by convention alone. Because of this, the way you structure your format has a big impact not only on your data interchange, but also on the effectiveness of other very useful tools in the XML ecosystem, like validators, XSLT, and XPath.