Question

I’ve got quite a lot of code here, but it’s relatively straightforward.

This is all snippets from different classes, all references are right, but I think I’ve done a math-based error somewhere and I can’t find it. It always finds a collision on the y axis a pixel before it should. I haven’t tried it with different X axis positions but it seems to fall past blocks next to it fine.

The struct “mapSection” just contains two Vector2s- A top-left block and bottom-left block coordinate.

tileManager.def_ts is the default tile width and height (32). The player’s size is 32×64.

The toWorldSpace function does nothing right now other than return so that’s not the problem.

When I say block coordinate I mean which index the block is in the tile array (Ex 0, 0 is the first block, 0, 1 is the second block on the Y axis, 1, 3 is 1 block in on the X axis and 3 on the Y axis, I do not mean actual pixels.)

From tile engine class:

    public mapSection toMapMinMax(Vector2 position, Vector2 size)
    {
        position = toWorldSpace(position);

        position.X = (float)Math.Floor(position.X / tileManager.def_ts);
        position.Y = (float)Math.Floor(position.Y / tileManager.def_ts);

        size.X = (float)Math.Floor(size.X / tileManager.def_ts);
        size.Y = (float)Math.Floor(size.Y / tileManager.def_ts);

        return new mapSection(position, position + size);
    }

    public bool collision(Vector2 screenPosition, Vector2 size)
    {
        mapSection mapCollisionPossibilities = toMapMinMax(screenPosition, size);

        for (int y = (int)mapCollisionPossibilities.topLeft.Y; y <= mapCollisionPossibilities.bottomRight.Y; y++)
        {
            for (int x = (int)mapCollisionPossibilities.topLeft.X; x <= mapCollisionPossibilities.bottomRight.X; x++)
            {
                if (x >= 0 && y >= 0 && y < tiles.Count && x < tiles[y].Count)
                {
                    if (tileManager.tileTypes[tiles[y][x]].collideable == true)
                    {
                        return true;
                    }
                }
            }
        }

        return false;
    }

And this is the code from the player class:

        if (!tEngine.collision(position + new Vector2(0, 1), new Vector2(32, 64)))
        {
            position.Y += 1;
        }

I add “Vector2(0, 1)” because I want to see if there’s a collision a pixel further down; so that he falls until he hits something. It’s very basic right now but it’s only to test the collision engine, which isn’t working.

There’s a picture of the error. You can see the player is a pixel too high.

In the picture, “X:” is the top-left block coordinate on X axis, “X2:” is the bottom-right block coordinate on the X axis, and same with “Y:” and “Y2: except Y axis. They’re read from the mapSection directly.

If anyone can notice why this is happening, it would be massively appreciated.

Thanks.

If you cannot understand any section of the code just post in the comments and I’ll be happy to explain, or if you think I’ve been a bit too unspecific in some area of this post.

Answer 1

EDIT: For the tile coordinates issue, your toMapMinMax code should be more like this:

EDIT2: have subtracted (1, 1) from bottomRight, since it is a size we are adding.

public mapSection toMapMinMax(Vector2 position, Vector2 size)
{
    Vector2 topLeft = position;
    Vector2 bottomRight = position + size - new Vector2(1, 1);

    topLeft.X = (float)Math.Floor(topLeft.X / tileManager.def_ts);
    topLeft.Y = (float)Math.Floor(topLeft.Y / tileManager.def_ts);
    bottomRight.X = (float)Math.Floor(bottomRight.X / tileManager.def_ts);
    bottomRight.Y = (float)Math.Floor(bottomRight.Y / tileManager.def_ts);

    return new mapSection(topLeft, bottomRight);
}

Also, I was wrong in my above comment; you do want <= signs in your two for loops, because most of the time you will be checking 6 tiles.

for the off-by-one-pixel issue:

In order for you to see the character off by some amount of pixels, the draw code and the collision code must be different. If they were identical, for example if they were both off by 15 pixels (you collide 15 pixels too early, but you are also drawing 15 pixels ahead), you wouldn’t see any change.

The 1 pixel gap indicates a 1 pixel difference between the draw coordinate calculation and the collision coordinate calculation. This 1 pixel difference is most likely caused by differences in rounding, probably that you are calling Math.Floor in the collision code, but are not rounding the coordinates in the draw code. (I would guess you are probably just passing the position Vector2 straight to the SpriteBatch.Draw method).