Microbe Stage Progress Report

That sounds like a good idea, and it's an okay from me. I'll post those on to the Building Microbe Stage's 2nd post (https://thrivegame.canadaboard.net/t1031-building-microbe-stage#20110), where I was looking for a list of steps to take to developing.

I am planning on programming the saving and loading of cells. Please tell me if this is not what I should be doing.

I am considering the save format of cells to be (anything in parentheses is used for elaboration):

Code:

Name (Chosen by creator)
:Badaba (That was the name of my first SPORE creature)

(optional empty lines go here)

Description (Chosen by creator, may allow some special formatting tools, but for now, plain text. Colons help the reader know when the description is complete)
:A vicious carnivore. He attacks enemies with its ferocious claws, even though he is a microbe and does not have any claws.
:
:His skills are:
:Eating
:Fighting
:Spelunking

Shape (May be revised to be a boolean yes or no rather than a list of coordinates contained. Currently uses hex q, r axial coordinates)
:0 0
:-1 0
:0 -1
(Empty lines can also go here, and they will not affect the reading of the file)
:1 -1
:1 0
:0 1

Texture (The format for this may change, depending on how texture is implemented)
:255 0 0 (Color #1)
:255 196 64 (Color #2)
:3 (Texture ID)

Organelles (Numbers may be replaced with strings, depending on which implementation is more efficient)
:0 (Organelle class, 0=nucleus, 1=vacuole, 2=other)
:0 (Organelle type, each specific type of organelle has its own ID)
:0 (Number of upgrades on the organelle)
:0 0 1 (q, r, and orientation of the organelle, orientation is from 1 to 6, may change to 0 to 5, corresponding to hex-side corresponding to the front of the organelle)

:1
:0 (I really don't know what ID each organelle will have, yet)
:4
:-1 0 2
End (If it's easy to reach the end of the file and finalize everything, then this keyword will be eliminated)

The location of the functional edge of organelles that have them depends on the orientation of the organelle. Orientation would also affect which hex cells are taken for organelles that are bigger than one hex space.

Writing to the file would be relatively straight forward, just following the script. Parsing the file will ignore empty lines and use lines beginning with colons as content. For instance, the parser would be able to detect the end of the description by finding the first non-empty line without a colon preceding it, ("Shape").

The parser would not actually interpret the words "Shape" or "Description" or "Name." It would instead return an error if the correct word is not included. These names instead serve as dividers between the different specifications of the cell. The parser notices them because they are lacking the distinctive colon at the beginning.

If "Name" and/or "Description" end up being unnecessary for the project, they may serve as good placeholders.

Please tell me if you want this format modified in any way. I will begin work on the Lua parser for these files. Is there a way to get default files like these included in the installation of Thrive? I assume it involves editing some manifest file somewhere.

Is this for saving the player's cell? Also, I don't think skills are necessary.

What are size upgrades? The player alters size by just adding or removing hexes.

EDIT: Here are all the organelles I know of that will be in the game:

Kernel (This is something that can't be added or removed, including within it the nucleus, endoplasmic reticulum, etc.)
Mitochondrion
Chloroplast
Thermoplast
Vacuole
Agent Vacuole
Cilia
Flagellum

We could number these off for their ID's, or give them acronym ID's.

The skills are a part of the description. It would be as if the user decided to type in a set of skills for the fun of it. It has nothing to do with gameplay.

Regarding size upgrades, I can only assume that the goal is to eventually transfer from the microbe stage to the creature stage. To do that with hex cells of a fixed size would require billions of hex cells. I was thinking that, instead, the size upgrades are used to make the microbe get bigger at an exponential rate.

The cell save files would be used for the engine to be able to save microbe designs. It's a possible method to be able to create a database of different microbes and would be necessary if there are preset AI microbe designs.

In short, it is for saving the player cell and the AI cells.

EDIT: I was informed that there is a stage between the cell stage and creature stage (aware stage) that handles the increase of size from microbe to non-microscopic. In that case, the size upgrades are irrelevant.

Uhh, the game will go through a multicellular stage as well before the traditional creature stage. This is unlocked through the gluer part and the player places it to place another copy of their cell on the other end. This will go on and on until they have a mass of their cells big enough to qualify for the next stage.

Ah, I have been corrected. According the the wiki, the multicellular stage is the stage after the microbe stage. In that case, yes, the size field is irrelevant, and I will eliminate it. I didn't realize there would be a 3D stage in the microscopic level (If there isn't the wiki needs updating).

Yes, before becoming a 3D organism the player must bond with other cells through acquiring a specific enzyme. After reaching 100 or more cells in their colony, the game undergoes a camera transition in which the 3rd dimension is revealed, and the players colony is somehow converted into a 3D organism of similar shape and ability.

Oh okay if skills were just an example of something to write in the description box, that's fine. 

If AI cells are saved using this method when saving and loading the game, I would like to point out that the descriptions for other cells should always be blank by default. Names also are generated based off of the generational lineage of the cell. I'm pretty sure there is a thread on it, so if I can find it I'll post that here. Here it is:

https://thrivegame.canadaboard.net/t223-naming-critters?highlight=naming

I think we should discuss naming a bit more to settle with something, but before that I'll address the other points.

Microbe Stage is 3D as well, but is fixed to a top down movement grid and camera focus. When reaching 100 cells the camera rotates in a way to show the player that the 2D pool they have been playing in this whole time was actually the sea floor of a 3D ocean.

When encountering AI cells/organisms, the player should be able to select one, rename it, and change it's description. Descriptions should be blank for all creatures. Names should be generated based off of their ancestry.

Okay, so regarding naming creatures, as soon as the player gives them a custom name they are saved into a vault, or fossilized.

EDIT:

After reading through the naming thread, here is what I think is the best solution:

~sciocont wrote:

Procedural names are easier and the player can always rename them. In fact, in game, there's no reason to show the procedural names. If you examine a creature that you haven't yet named, you will see it as "unnamed" once you name it, it gets saved to your hard drive.
I just solved two problems at once- storing creatures and naming. The game should only store the creatures that you bother to name. Once an org goes extinct or evolves, it is lost forever, except in its own lineage. The "lineage" could simply be a bunch of small pictures showing how the org evolved over time.
The game could also choose to randomly save some species by "fossilizing" them.

I have been looking through the code, and I have noticed that the hex coordinates are only stored in the organelles and the cell is entirely made up of its organelles. I believe that in the real version, cells will have their own shape and may have empty space rather than organelles in some places.

Also, how do you set the position of a microbe?

Yes empty space, i.e. just plain cytoplasm, should be an option. A hex must first be filled with cytoplasm, or "added" to the cell, before it can have an organelle placed in it.

I don't think a separate save format for pre-defined microbes is absolutely necessary. If anything, it's only useful for some testing because eventually, the microbes should be generated procedurally (except for the player microbe which is to be built in the microbe editor). So the goal is to make the different species be part of the game state, i.e. serialized into the savegame.

If you really want to make a human-readable format for describing statically defined microbes, I would strongly recommend using Lua tables instead of a custom format that requires a non-trivial parser. Your example would look something like this:

Code:

local BadabaMicrobe = {
    name = "Badaba",
    description = "A vicious carnivore. He attacks enemies with...",
    shape = {
        {0, 0},
        {-1, 0},
        {0, -1},
        {1, -1},
        {1, -},
        {0, 1},
    },
    texture = {
        ColourValue(255, 0, 0),
        ColourValue(255, 196, 64),
        3
    },
    organelles = {
        {
            class = 0, -- Maybe a string would be more expressive here
            type = 0,
            upgrades = 0,
            q = 0,
            r = 0,
            orientation = 1,
        },
        {
            class = 1,
            type = 0,
            upgrades = 4,
            q = -1,
            r = 0,
            orientation = 2,
        },
    },
}

The organelle classes and their subtypes can be described the same way. Then a few Lua functions could easily build a microbe just from that table, without the need of an additional file format.

I very much agree with the rest of your plan (simple AI, spawning microbes where necessary, cell interaction).

OK, that makes a bit more sense. I still believe that there will be more than one instance of a single type of microbe, so having some sort of MicrobeTypeEntity (or some similar name) would still be desirable. When a microbe of a certain type spawns, it would look at that MicrobeTypeEntity to figure out its attributes.

Nimbal wrote:

I don't think a separate save format for pre-defined microbes is absolutely necessary. If anything, it's only useful for some testing because eventually, the microbes should be generated procedurally (except for the player microbe which is to be built in the microbe editor). So the goal is to make the different species be part of the game state, i.e. serialized into the savegame.

If you really want to make a human-readable format for describing statically defined microbes, I would strongly recommend using Lua tables instead of a custom format that requires a non-trivial parser. Your example would look something like this:

Code:

local BadabaMicrobe = {
    name = "Badaba",
    description = "A vicious carnivore. He attacks enemies with...",
    shape = {
        {0, 0},
        {-1, 0},
        {0, -1},
        {1, -1},
        {1, -},
        {0, 1},
    },
    texture = {
        ColourValue(255, 0, 0),
        ColourValue(255, 196, 64),
        3
    },
    organelles = {
        {
            class = 0, -- Maybe a string would be more expressive here
            type = 0,
            upgrades = 0,
            q = 0,
            r = 0,
            orientation = 1,
        },
        {
            class = 1,
            type = 0,
            upgrades = 4,
            q = -1,
            r = 0,
            orientation = 2,
        },
    },
}

The organelle classes and their subtypes can be described the same way. Then a few Lua functions could easily build a microbe just from that table, without the need of an additional file format.

I very much agree with the rest of your plan (simple AI, spawning microbes where necessary, cell interaction).

Eventually we want to be converting the cells into a 3d model. (I am back by the way)
so I'm still not sure if a lua table is the best idea...
I am probably worrying for no reason.
Also great work on everything you have done Nimbal. Sadly i still may not have time to work on the code.

So, we should come up with a decision pretty soon. How will we save cell types (this will be necessary even for procedurally generated cells)?

I see three options:

1. Use Lua tables.
   
2. Use a text file format similar to the one I proposed, maybe with a different format
   
3. Use a binary format. This may be the most efficient in terms of disk space and read time, but writing such a file would require running a program to generate it.
   
4. Do something I did not think about. I know I said three options, but this doesn't really count.
   

And my opinion on each one:

1. I am not in favor of Lua tables, since it would easily be readable with C code, and it is not as efficient as other possible options.
   
2. A text file format would be readable by both Lua and C. So would a binary format, but a text file format is human readable and human writable, making it easier to debug initially.
   
3. A binary format may be the most efficient in terms of disk space and read time, but writing such a file would require running a program to generate it.
   
4. I cannot evaluate this option because I added it in case I missed something.
   

My personal favorite is a binary format. How is everyone else?

Also, should we create a new thread for save format, or will that be unnecessary?

By the way, there already is a binary serialization format implemented, see engine/serialization.h, especially the StorageContainer class. It's a key-value storage. For examples on how to use it, look for the storage() and load() functions of any Component subclass.

Can a single component be serialized to a custom file, or is everything always serialized together? If it is the former, storage() and load() should work. I believe saving.cpp handles all the saving and loading, currently, and it does everything at once. What, do you think, is the best way of saving microbe templates separately? We will want to be able to share microbes we created, after all.

The serialization mechanism is designed quite general. At the moment, all components are serialized together because that's what a savegame needs to be - a complete snapshot of the gamestate. But saving just part of the game is trivial. Create a StorageContainer, fill it with the data you want to save, and write it to a file with its stream operator.

And exactly because it is so trivial, I don't consider it critical to worry about it now. Because the bigger hurdle before "exporting" microbes is to have a microbe editor. Until we have a functional editor, the only way to create microbes is programmatically. And why export a microbe to a binary format when you can just copy / paste the script that created the microbe?

Just as a heads-up, I've tentatively added a milestone in GitHub to complete a prototype for the microbe stage (without editor, mind you) by the end of December. That prototype will still be far from what the microbe stage is eventually supposed to be, but it should give us some feedback on microbe movement and the interaction between compounds and microbes.

You can read about the features I've planned for it here. As always, no promises that the deadline will actually be met or that all of the features listed will be included. Nevertheless, at the current pace, with jjonj / crovea and patowen95 (is that SuperLala from the forums?) chomping through issues almost as fast as I can assign them, I think the goals are realistic.

Nimbal wrote:

and patowen95 (is that SuperLala from the forums?)

Yes it is. I didn't really consider that the fact that my GIT username is different from my forum username would be confusing.

I'm glad that this game is making progress. I joined because I was worried that it wasn't.

Yeah things are going forward quite well, the deadline should be no problem!

jjonj is my original username that i use for general stuff (like programming) but crovea is my gamer tag, which evolved on its own! Gets a bit confusing when my gaming and programming identities confront =P

Spectacular work guys! I really wish I could help more but these days I am really pressed for time.

One question though, what is oxytoxy?

Just a small joke between me and nimbal. "Oxytoxy-neuro-toxin", I needed to come up with a product using oxygen as a component

I hate to be so critical, but what role does oxytoxy play? Why does it destory RpAse? Is it related to anything real in cells?

Don't read too much into it, I just needed something to create a "Game Over" state. I could just as well have called it "poison compound 1". As I said, the planned prototype won't be representative of the eventual microbe gameplay, so don't worry too much about names, let alone whether they make sense.

Yeah okay, I suspected as much, since I also noticed that the game is "lost" when RpAse reaches 0. Speaking of which, is there yet a concept on how cell's will live (i.e. what will define their health?)

Just to ask, where can I find the compiled version?

Also, great job, Nimbal, SuperLaLa and crovea!