Hello,
I tried to make the title as clear as possible but there is a little explanation. In some type of game such as RPG, there is a lot and a lot of information. It could be dialog, object description, or informations about a spell (name, cost, damage, effect, etc...)
My question is : How do these informations are stocked. They could be hardcoded, but I thought that parsing text files would be better. What is your opinion?
Thanks
How to stock large amount of data for a game
Author
If I understand correctly, your question is about keeping level data.
Start hard coded, when it gets too hard spend time building a level file.
In my opinion, storing data in json or xml is the best way to acomplish that.
Keeps things simple, the early you start the easier it gets.
when it gets too hard
When it gets too hard you will spend more time going over your code than if you actualy did the right thing at the beginning.
50% of the programmers work is to figure out how not to do the other 50%.
When dealing with large amounts of data, not only are you not going to want anything hard coded, but you'll quickly find yourself wanting to take the time to write custom editors to make the generation of all that data easier to handle.
In fact, I think it's safe to say that no project will ever actually reach the point of really having large amounts of data without the appropriate editors to generate and manage it. It's simply too time consuming, cumbersome, error prone, and unmanageable to generate that much data without them.
None of the content for your game should be hardcoded, it should be parsed from other files which are independent from your game.exe.
A few reasons for this are noted below:
- Making small changes such as adding a new item will require a user to redownload EVERYTHING because it's hard coded. If it's in a small file.txt than that's much easier to update and manage.
- Add's modularity. People like being able to take a game and add their own twists to it. Many games today are released in a way that allows modding for new features and content.
- Doesn't waste space. What's the point of having the phrase "You have beaten the game" loaded into memory if it won't see use until the last few seconds of the game? Smart memory management will be even more important as you start making more and more advanced programs.
Not everything, however, can easily be fit to go inside a xml or text files and you'll want to consider designing your own filetype so you can package information at a bit by bit level with your own in house editor. This is better since it's a lot more easier to handle complex operations with your own editor rather than with a general xml editor( this is when dealing with megabytes of information ). This is generally true for things like levels. There's also plenty of already existing file types which you can use and plenty of importing/exporting libraries to make everything easier.
50% of the programmers work is to figure out how not to do the other 50%.
+1 for this :)
Author
Thanks a lot for your answers, theses will be useful.
If I understand correctly, your question is about keeping level data.
That's right, and also things like spell details, monsters and/or base states, object value and description. And so one.
I often hardcode for the first versions (for exemple the level, or spells). But it's true it rapidly get annoying to go into the code and compile each time I want to change a value.
50% of the programmers work is to figure out how not to do the other 50%.
Ahah, nice.
rpg/person sim, fps interface:
~100 monster types, ~250 object types, ~60 weapon types, ~45 skill types, ~200 meshes, ~300 textures, ~ 10 materials, ~100 models, ~30 animations, 2500x2500 mile game world.
models and animations are made using an in-game editor, and saved to disk. the list of models and animations to load is hard coded.
meshes (.x) and textures (.bmp or .dds) are loaded from file. the list of files to load is hard coded.
the game world is procedurally generated.
everything else is hard coded: monster types, object types, weapon types, materials, skill types, etc.
the reasoning is as follows:
1. for everything hard coded, the final values will be known constants for the final release version. so soft coding is only an aid in dialing in these "tune-able constants", such as the list of all meshes to load (the game loads everything once at program start). none of this stuff changes very much, only while dialing in the game. and it doesn't change at all once dialed in. and it never changes in versions released to the public - only in updates. granted, a zipped 2K text file list of meshes to load is smaller than a 1.2 meg zipped exe, but unless your releases are minor updates, odds are the code will change too. as always it depends on what you're doing.
2. since soft coding is not required for release, and since i have full source access, and rebuilt times are not bad, its overkill.
3. in the end, you have to "hard code" or type in this data somewhere using some syntax. if there's no difference except running faster and less code complexity, why not just do it in the native programming language? no need to learn a scripting language, no need to write hooks and calling wrappers for game engine functions so your scripts can invoke calls to the game engine, no need to find and integrate a scripting solution into the project. no slow 4gl / 5gl / scritping BS, no need to use multiple languages to code a game, and so on.
so i soft code the models and animations. they are the type of data (scales, rotations, offsets, mesh and texture ID #'s) that really scream for an editor. i mean could you imagine having to use a markup language to do this:
and having to picture in your head what the model looks like?
but everything else is more or less a set it one time and forget it kind of thing, unless you need to tweak stats. IE just add the info for a new whatever to the "list" or "database" when you add a new mesh, or monster type, or object type, or whatever.
so its really easiest to just use code to say essentially: monstertype[new_monster].hp=100. and be done with it.
sure you may have to go back later and tweak that "100", but only if you didn't figure out the correct value the first time. you should have the "rules" of the game figured out before you code. 
you should have the "rules" of the game figured out before you code.
And you should write bug free code as well.
And you should write bug free code as well.
definitely.
one thing at a time, do it very well, then move on.
programming is about precision.
mind your p's and q's - cross your i's and dot your t's <g>.
always think ahead about what you're doing and what potential pitfalls could be: ok, this call here does memory allocation i need to deal with. this other snippet is "critical section" stuff where i have invalid addresses and such and the normal rules don't apply (constructor issues), etc.
nobody's perfect, but the only bugs in your program are ones you put in.
so divide and conquer. modular-ize until the parts are so simple you can't F-up <g>.
turn complexity into a hierarchy of layered simplicity.
This topic is closed to new replies.
Advertisement
Popular Topics
Advertisement
