Thread: Smooth walking on tile based map system

So you want to use a grid for your background basically, but you don't want to actually make movement stick to this grid? You want it to slide slowly across from one tile to the next? Well, then just decide how many frames you are going to use for sliding, and update that many times.

You need to remember that now you can't use the indexes of the background tiles for movement points, but will instead have to use the position on the screen. IE: Take "frames" number of baby steps across, rather than one big jump.

Now, do you move your character on your background, or does your character stay centered, and the background moves around them?

>> I did not completely comprehend your idea; if you could reword it, it would be great.

In other words, forget about the tiles for a moment. You have a sprite, and the coordinate attached to some point on the sprite (eg: center, corner, etc). To make things simple the coordinate is relative to the screen (upper left point being origin on most systems, but it varies). When you move the 'character', you simply update the coordinate associated with the sprite, and then call a redraw function that copies the sprite at that position on the screen. So if you're coordinate was attached to the center of the sprite, the x offset would be:
start_x = screen_x + sprite_x - ( sprite_width / 2 )
Of course screen_x is probably 0, so that could be ommited. Naturally, using the top left corner of the sprite instead make the calculation much simpler.

Once you have that working, just set it up so that the background is drawn first, of course.

Originally Posted by abraham2119

That was not my specific question, but no matter, your reply helped me come up with a simplistic idea.

Actually, it was your specific question.

If you want them to not be instantly from one tile to the next, then you need to draw them at various stages along the way from tile A to tile B. That was exactly your question.


Quzah.

The sprite has both a tile where it is located and an offset in pixels from the corner of that tile. To move the sprite, you increment the pixel offset smoothly and check for when it exits the bounds of the tile, and move it to the next tile. (Of course, the sprite also has an origin with respect to it's position, which I didn't implement here since that's orthogonal to this problem. I also didn't do any bounds checking, since the game should do that, not the sprite)

Code:

class Sprite
{
    Sprite( int initialX, int initialY )
        : mOffsetX( initialX ), mOffsetY( initialY )
    {
        mTileX = mOffsetX / TILE_WIDTH;
        mOffsetX = mOffsetX % TILE_WIDTH;
        mTileY = mOffsetY / TILE_HEIGHT;
        mOffsetY = mOffsetY % TILE_HEIGHT;
    }

    void Move( int moveX, int moveY )
    {
        BumpCoordinate( mOffsetX, mTileX, TILE_WIDTH, moveX );
        BumpCoordinate( mOffsetY, mTileY, TILE_HEIGHT, moveY );
    }

    // Get the coordinate of the current tile (measured in tiles)
    int GetTileX() const { return mTileX; }
    int GetTileY() const { return mTileY; }

    // Get the absolute position in pixels
    int GetX() const { return mTileX * TILE_WIDTH + mOffsetX; }
    int GetY() conset { return mTileY * TILE_HEIGHT + mOffsetY; }

private:
    int mTileX;
    int mTileY;
    int mOffsetX;
    int mOffsetY;

    void BumpCoordinate( int &coord, int &tile, int size, int bump )
    {
        coord += bump;
        // Avoid division and modulus for the common case where we don't move
        // farther than a single tile at once.
        while( coord >= size ) { coord -= size; ++tile; }
        while( coord < 0 ) { coord += size; --tile; }
    }
};