I know this should be a rather simple concept, but atm, I'm working on a game that has gameplay similar to the game known as Bejeweled and I'm having a bit of trouble managing the squares in one aspect. When a square is elliminated, the squares above it are supposed to fall until it reaches the bottom of the boundary, or until it lands on top of another square. I've tried to write my own algorithm to do this for weeks, but I can't get it to work to save my life.


i = 0;
while( i < 10 * 15 )
{
int move_down = Yes;

/* When there's a space below the square, move it down
until it hits the bottom or the square below it. */
if( squares.active )
{
struct square_t* sq = &squares;
int j = 0;

while( j < 10 * 15 )
{
/* Avoid testing the same square against itself */
/* Also skip inactive squares */
if( i == j || !squares[j].active )
{
j++;
continue;
}

/* Skip squares that are already at the bottom */
if( squares[j].pos.y - squares[j].size.y >= ( ( SQUARE_SIZE + 3.0f ) * 14.0f ) )
{
j++;
move_down = No;
continue;
}

/* Is this square directly below the one we're testing? */
if( sq->pos.x == squares[j].pos.x )
{
if( sq->pos.y == ( squares[j].pos.y - ( SQUARE_SIZE + 3.0f ) ) )
{
move_down = No;
break;
}
}

j++;
}

if( move_down )
squares.pos.y += 1.0f;
}

i++;
}


I hate to just dump some random code on you all, but I need to have this concept ready ASAP. I've played around with the signs a bit, and each time I get some different and funky results, but never the one I need. And the +3.0f is just the amount of space between each square on the screen.

Any ideas? Thanks.

If the amount of space between each square on the screen appears at all in the code that handles the logic of how blocks behave, you probably have a bigger problem than what you described. You should have a data structure with the contents of the grid on which you do all the logic. You then reflect changes in the grid by displaying animations, but the details of the representation on the screen shouldn't leak back into the logic of what goes on in the grid.

Hm, I figured that using an array like structure would be a bit more work, but at this point, as long as the concept works and works efficiently, I have no complaints.