What exactly happens during INI parsing? If it's just the creation of game objects, can't those objects be "cached" via serialization to avoid the need to parse INIs each time? The game can just check the "last modified" timestamp on each INI to determine whether the cache is obsolete.

It sorta kinda somehow does... But not quite.

First time loading CC can take up to 20 seconds or more (With no mods), but after that, it takes about half as much time to load.

So something is definitely going on...

Or rather, something didn't go on. The data is still held in RAM until another application wants to use the RAM, which is then cleared out. Thus, if you don't use many other applications between the time you end the first CC session and begin the second, the data that's still in memory is used again instead of loading it from the HDD.

Doesn't work like that. Programs can't be taught a new language and use it like humans can. The program has to know how to take the language it's being given, translate it into its native language and then use it, no matter what.

Advancements in neural networks may render that statement incorrect.

Exception aside, it might be nice to be able to load in files as how they are stored in CC's memory, so it does not have to process the inis.

Well, the only other way it could be done would be to have a program that takes the inis and condenses them all into binary files for reading ahead of time. That would mean losing a lot of the flexibility of ini mods, though.

it would also mean you'd have to compile your mod before testing. i dont want to have to do that every time i want to tweak one value Oo;

Have it allow both ways.

Or we could (this is a crazy one) not tell data to change the system, thus taking extra time for a benefit measured in scant seconds.

Honestly, I'd rather he fixed lua implementation and finished the damn game rather than doing something that'd take a while and have little to no benefit.

You already ARE compileing you mod every time every time you tweak one value. THAT is the reason it takes so long for slow computers to start up the game

It would be Nice to have a way to complie you mods before running the game to decrease loading times, but i have to agree with Grif and say that there is no point. If you dont like the "long" loading times, then do what i do and watch TV while you mod.

...
Really?
I always thought it was just loading C++ objects based on the .ini input...

That could be true for the ini files, but what about Lua scripting, you can't have uncompiled complex scripts, it would cause massive lag.
Compiling just makes sence
-at least to me-

There's nothing to compile, people.

.ini files are not compiled they are interpreted.

The engine is C-based, but your text files are totally arbitrary. The game engine reads the ini files and interprets them into objects and formats that the game engine can understand.

I just love when people start talking about computer-related things they don't understand. Allstone is the only other person who seems to understand this.

This is the only really good idea here, except for the fact that the objects would be destroyed upon program termination--as such removing the point of caching the objects.

Although the potential for using file hashing to check for changes provides interesting opportunities

Objects destroyed on program termination? Not if they're serialized to disk. This is a common approach for games that interpret text files to game objects at startup, such as Dwarf Fortress.



All you really need to do is check the modification timestamp. Hashing would be a nice extra to check whether a file modification produced an actual change or not, but it wouldn't be useful very often.

To clarify for everyone else: you would not have to precompile your INIs or anything strange like that. All this means is that the game would store the results of its previous loading process to avoid re-parsing. The only change for the player/modder would be faster loading times.



Serialization is very easy to implement, and the loading time for a heavily modified game can be several minutes. It's as worthwhile as anything else that makes modders' lives easier.

Lua can be compiled to VM bytecode.