Cell cells[MAX_CELLS];

And to go from a position (x,y) to a cell index you do:

i = hash( floor(x/grid_size), floor(y/grid_size) )

I.e. you just hash the cell position to a value in the range 0..MAX_CELLS-1. Two nice things about this solution, is that it takes care of the problem with objects ending up “outside” the grid and that it decouples the number of cells from the grid size, so you can choose grid_size based on your object sizes, and MAX_CELLS based on the object count and the maximum objects you want to end up in the same cell.

With this solution you don’t know that objects are in the same part of the grid just because they ended up in the same cell. They could be at different (x,y) coordinates that just happen to hash to the same cell index. So you must do an extra check for that. But typically you do such checks anyway (and just use the grid for “broad phase” culling).

BTW allowing null by default is source of countless bugs.

Powerful type system can express what you have to do check in Lua using several unit tests. And when it comes to real unit tests I can write them where really needed. NS2 Scoreboard bug is nice example.

There was a vote on website/conference (I don’t remember): which dynamic language do you like the most? Most people chose F# which in most cases doesn’t require specifying types but is statically typed.

Did you mean ‘intermediate format’?

>chance that you will be struck by lighting

You probably meant ‘lightning’ (thunderbolt). Being struck by lighting (illumination) is really sad .

At Square, I used it to generate lots of shader permutations so that if an artist needed varying numbers of resources like shadow maps, they could just get the right shader with a few clicks (and I only needed to write a single “core” file).

When I was at NVIDIA I was able to write shaders that could be re-emitted as DX9, DX10, CgFX, and bits of Cg (for translation into GLSL, which officially lacks an #include in its preprocessor). That was an extreme case, but you probably get my drift.