I'm pretty sure this is what we have so far. It combines elements of darwinianism as well as elements from Lamarckianism to create a changing environment within given boundaries.


Auto-Evo will be based on biomes divided up into niches. Each niche will be a scripted class that contains it's dependency (I.E. What it eats or lives in), it's primary food source, the current organism filling that niche, the current population of that niche, a function that decides how well a creature fits that niche, and a function that decides the new population based on it's dependencies.

A dependency will usually be another niche. In the future, niches may be able to handle multiple dependencies, but for now they're only dependent on one. It could look something like this:

Code:

Niche * m_dependency;

It's c++ because I'm not sure what the scripting language is.


The primary food source will often be the same thing as it's dependency. It's here for the population deciding function.

Code:

Niche * m_primaryFoodSource;

I'm not sure if it should be a Niche or an Organism, but both will serve the same purpose.


The organism variable, is the current organism living in that niche.

Code:

Organism * m_currentOrganism;

Finally, the population variable is an integer representing how many of this species live in this niche.

Code:

int m_currentPopulation;

When we skip generations, we'll need a way to calculate the new population. This function can take into account the primary food source and dependency, or whatever it needs based on the niche, as well as how many years have passed.

Code:

int calculateNewPopulation(int _years) {     //DO STUFF HERE     return m_dependency->m_currentPopulation/2; }

When we need to calculate how well a creature fits, we'll use this function. It's probably the most important part of auto-evo and will require much tweaking. It returns a float from 0 to 1 that represents how well the creature fits.

Code:

float calculateFitness(Organism * _organism) {     float returnVal;     if(_organism->canClimb)     {         returnVal += .5;     }     return returnVal; }

If every niche follows this pattern, we can create an entire alien ecosystem very easily. It opens up the doors for creativity, while at the same time limiting organisms into their niches.

~BIOMES~

Basically, a biome is a collection of niches. It contains a list of dependencies for the niches to be fulfilled adequately, and the list of niches themselves.

When a biome is told to go to the next generation, it calculates the new population of all the niches by going up the food tree. We have to go from bottom to top due to the fact that populations depend on eachother.

Biomes will be spread around the planet using ecosystem brushes, and will vary from planet to planet based on sunlight level, climate, etc.

~NPC's~

During the course of the game, there will be other creatures besides the player's creature. These creatures will be randomly deviated every generation, and then compared with their current niche (See above). They will be kicked out or go extinct if they don't fit any other niches.

Once we can calculate fitness, auto evo with npc's is much easier.

~PUTTING IT ALL TOGETHER~

At the end of each generation, we need to randomly modify the NPC's and change the player's species based on what they choose. This would take into account the number of years skipped in between generations as well.

After the species change, we calculate how well all the species fit in with their niches. We then handle extinction, niche swapping, and possibly biome switching here. Creating new biomes will also be handled here, as we now have a bunch of random species to choose from that have the possibility of filling niches.

Now that we know the species in each niche, we calculate their populations from the base up.

The game then happily starts the next generation.




Assuming you read all of that, you may have noticed some holes. Here's some questions that still need to be answered.

Should an npc evolve to fill it's niche better? If so, when would it go extinct?
Will the player's creature be able to kick another species out during simulation?
Will the player be able to destroy a niche completely during simulation?
What happens when two creatures try to move into the same niche at the same time?
Could a biome be switched? If so, how?
How do we keep populations from remaining the same every generation? I.E. where do we introduce random deviations in population?


If you've thought of anything else that needs to be changed or added, please comment.

This is really a good thread, and it will probably be stickied eventually. The code sieems quite simple and straightforward, though I'm not a coder, so I cant say too much about it.

However:

-I don't think we reached a consensus on Player evolution yet, so you shoudl probably leave that blank for now.

-Add in that Biomes will be determined/populated by ecosystem brushes (see PPG thread for details on those)

-Can you write code for the NPC mutation process I wrote?

Quote:

What if we could cut down on thenumber of mutations and the variables in the environment? Say each time a creature reproduces that you don't see, it produces three types of offspring that directly tweak one variable- one stays the same, one lowers the variable, one heightens the variable, and the computer randomly chooses between the three which one will survive? We could even cycle what type of variable is tweaked in between generations. This way, each species will have one variable change every generation, unless the computer decides to "split" a generation so that more species could evolve. That would only rely on code for determining A:which sections of share code can be modified (which doesn't even have to work very well, really) B:dice roll (which one will survive) C: cycles of modification and splitting I know it's still pretty complex due to the sheer number of creatures, but we could also cycle what's getting evolved. We could retire a species from evolution for a while, then make it go through a rapid series of generations with mutations, simulating punctuated equilibrium.

-I'm not sure what's meant by "parts" since in the OE, there really aren't "parts".


Questions at the bottom:

What happens when a creature doesn't fit it's niche?
-Most likely, it will be given a mutation. with that mutation, It can either
--evolve to better fit its own niche
--evolve to fit a different niche

--regress backint othe last role that fit its niche. Alligators and sharks haven't changed much for hundreds of millions of years because they are almost perfectly adapted to their niches.

Should an npc evolve to be better within it's niche? If so, when would it go extinct?
-"better"? do you mean to fit its niche better? If mutations are basically random, then we can't stop it from doing so.

Will the player's creature be able to kick another species out during simulation?
-Tough question.

Will the player be able to destroy a niche completely during simulation?
-Again, difficult
What happens when two creatures try to move into the same niche at the same time?
- I believe we went over this on the last thread.

Quote:

If two species try to inhabit the same niche, we could easily handle it arbitrarily, but again, that would really just push one out of the niche. If a species can adapt for another niche, it will survive.

We can simply do a diceroll, and one gets pushed out, then we return to the processes I mentioned in the first question.
Could a biome be switched? If so, how?
Yes, Biomes shoudl definitely be able to change. This probably would apply more to the planet as a whole and its systems. Again, I'd say an arbitrary mechanic decides when a biome starts to change into another.

NPC randomization is tricky.

I'm afraid that randomizing NPC's too much will cause them to fall out of their niche and go extinct. In evolution, animals tend to evolve to fit their niche, and that is why they still exist today.

Also, the code you specified doesn't exactly work in c++. Variable variables are easier to do in javascript, because you can get the variable by a string.

For example:

Code:

this["var1"] += 1;

Would work.

A randomization function that takes into account an amount (say a float) would be easier to hard code into the engine.

Code:

Organism animal1; animal1.randomize(.1)

This would go through and randomize it, but until we have an actual creature class I can't do anything.

All right.

I just had a thought.

The populations will all be calculated from the producer's energy source. There need to be other ways to change the populations, otherwise the organisms' populations will be the same EVERY generation.

How could we include simulation population into the population calculation algorithms?

So basically a random number in the calculatePopulation() function equation?

I would think people would want more things included.

Come to think of it that makes sense. Oh well.

FFFFFFFFFFFFFFFFFFFF- I just made an extremely long post, and then accidentally refreshed the page, losing it. The gist of it, however, was:

Each organism has an amount, formed by using size multiplied by population. This forms the biomass.

The biomass must take enough food from other sources to reduce it to 0. All food source intakes can be increased by a margin of 5%, if you can't find enough food from another source.

Fitness is lost if your final score is above or below 0 (no one prospers from over-eating!).

If your fitness is too low, your species dies out.

These amounts (trying to get your score as close to a set number as possible) can be applied to other things as well. Polar environments could be trying to get a score of 0 for temperature, while scorching places could require 500.

Specialisation can either move fitness directly (in the case of non-competitive things, like temperature fitness) or (like with food) help you hold onto a resource better so you don't lose fitness from having competition. Each generation of species can have populations within them that have different requirements.

For example, a population of shrew is trying to get 10% of food from small underwater organisms and 90% from small land organisms, but is actually eating 15% of underwater organisms and is losing fitness by getting 85% of small land organisms, meaning the computer decides for it to specialise in getting small underwater organisms. Another place has 10% hot and 90% cold, meaning the shrew needs a score of 20 in temperature, while is trying to get 50.

In the next generation, it changes so that the first shrew is trying to get a score of 15% underwater organisms and 85% land organisms, and the second one is trying to get a score of 20.

Something like this would mean the computer dumps disadvantageous parts, while hoards advantageous parts.

Well that was an inactive forum then.

I just moved onto this topic after reading the other one, which had someone posting in it on that day. Guess someone had necro'd that other one as well.

Dun worry, necros get annoying anyway. In one of my first forums, I think I sometimes looked at topics from the back, and just necro'd EVERYTHING....