Creatures Caves

@bifrost using light would make it even slower, the only reason lights work is that you can expect there to be < 100 of them moving across all metarooms. Similar code is used for vision, so this will likely be the ultimate bottleneck of number of creatures. Regardless, because there will be > 100 food items at any given time, just checking if a creature is near one becomes an ordeal.

Okay this is the basic problem of the smells: the rooms need to be small so the smell 'flows' right, the basic math of it is simple: This is the smell code:

void SmellGrid::interpolateTick(float dt)
{
const int N = (squares.x-1)*(squares.y-1);
const int w = squares.x;

for(int i = w; i < N; ++i)
{
uPoint2B rate = diffusionRate[ i];

for(int k = 0; k < NUMBER_SMELLS; ++k)
{
int temp = (smells[ i-1][k] + smells[ i+1][k])*rate.x
+ (smells[i-squares.x][k] + smells[i+squares.x][k])*rate.y;
next[ i][k] = std::max((temp >> 10) + emitters[ i][k], 0);
}
}
}

The problem with the regular grid is that each square of the grid needs to be small: if each cell is 1256x256 then a floor can be in the middle of one cell, and in the middle of the one right above it, the 256 px is enough for a creature to walk there, but oops: there's no cell! cause both intersect with something!

Now let's try 128x128. Well that usually works, but in sloped tunnels it fails completely.

So I made them 64x64: slopes work, enough space. And any time a creature queries a cell it could be found. (probably it will start at the head and go down until it finds a cell it can read from).

If I make there be 1/2 as many cells: now you can have 2 metarooms before it slows down. yay. Reducing time between updates might be an option. But I would need some way to stagger them also. Doing all the metarooms in 1 tick periodically would cause the same problems intermittently.

Now you might say: "well just caclulate a smell room map from the transparent part of the room map image." Which sounds good but doesn't work. The problem is that smells can't be divided into tiles like rooms are, they need to be divided differently, and this means that the rooms generated will get progressively smaller as we go towards the bottom right of the map. So it would ultimately be worse.

The solution would be either: make smell maps by hand, or GPU accelerate it. I'm not sure how viable the second is given that the GPU is being used for things, but that code is the kind of thing GPUs are REALLY good at. (I have no idea how to GPU accelerate code).

Does anyone know what the update rate of CAs in the original game? I tried checking openc2e, but I couldn't find what actually calls the update function.