What's the best approach for collision in a vertex array tilemap?

[The Terminator]

Hi there,

I've utilized the vertex array tilemap, but I'm having issues with collision. My current system is really hit and miss and often doesn't work at all, and it depends on checking for bounding-box intersection between the tiles (in the form of FloatRects). Is there a better way to more accurately measure collision?

Thanks

[zsbzsb]

More than likely there is something wrong with your code. That is why you should always post a complete and minimal example.

[The Terminator]

Here's the methods where I check if the next position requested by the user is feasible. I was just trying to get it working so please excuse the dirty code:

bool SPlayer::nextPosValid(const sf::Vector2f& offset)
    {
        sf::Vector2f offsettedPos(m_sprite.getPosition().x + offset.x, m_sprite.getPosition().y + offset.y);

        //The bounding rectangle of the future player
        sf::FloatRect rect(offsettedPos,
                           sf::Vector2f(m_sprite.getGlobalBounds().width, m_sprite.getGlobalBounds().height));

        if (SSceneManager::getWorld().getCurrentCell()->getTileMap().check(offsettedPos, 2))
        {
            Ataxia::TileMap::Tile tempTile = SSceneManager::getWorld().getCurrentCell()->getTileMap().check2(rect, 2);

            if (rect.intersects(tempTile.bounds))
                return false;
        }

        return true;
    }

bool check(const sf::Vector2f& pos, int tileType)
        {
            for (auto& iter : m_tiles)
            {
                if (iter.tileType == tileType)
                {
                    if (iter.bounds.contains(pos))
                        return true;
                }
            }

            return false;
        }

        Tile& check2(const sf::FloatRect& rect, int tileType)
        {
            for (auto& iter : m_tiles)
            {
                if (iter.tileType == tileType)
                {
                    if (iter.bounds.intersects(rect))
                        return iter;
                }
            }
        }

Thanks!

[zsbzsb]

Checking a single point before checking the actual bounding box isn't going to get you very far. 

[The Terminator]

Oh I see. So when checking if the player's position is contained within a tile, check all the four vertices of the square?

[zsbzsb]

Really you should combine those checks, and check the bounding box for intersection (like check2) and return true/false. Having multiple checks when just dealing with rectangles is redundant.

[The Terminator]

Would I have to create four FloatRects? One for each vertice?

[Ixrec]

All you need to do is use intersects() on the bounding box of the player and the bounding box of the tile.  You don't need to do any additional checks before or after (assuming you just want to know whether he's in the tile or not).

[The Terminator]

I did exactly that, but it was not accurate and often didn't work. I'm not using a sprite for the tiles, since it's a vertex array tilemap.

[zsbzsb]

Doesn't matter that you are vertex arrays, either way you need to get a bounding box for each tile.

[G.]

I'm not sure I understand, it doesn't matter if you're using sprites or a vertex array.

If your tile is an axis aligned rectangle made of 4 vertices you can easily create an sf::FloatRect(x, y, w, h) from these.
x and y are the coordinates of the top left vertex of the tile. w is the difference between the abscissa of one of the vertices on the right side of the tile and the abscissa of one of the vertices on the left side of the tile. h is the difference between the ordinate of one of the vertices on the bottom side of the tile and the ordinate of one of the vertices on the top side of the tile.

Same thing for the bounding box of your player (or if it's a sprite you can retrieve it with getGlobalBound).

[The Terminator]

Got it working. Thanks a lot for the detailed explanation G, I was just confused on how to exactly construct the tile's FloatRect, but you cleared that up.

Thanks again!