Bdtjtk

I am implementing collision detection and want to check if a rectangular object is touching the player. My wall uses .set_colorkey(background) where background is the specified background colour. The problem is that when I get my wall's rectangle with .get_rect(), it gets the full image's size which includes the transparent parts instead of just the opaque parts.

I thought about making the wall image file smaller in size to remove the background but that would be inconvenient as I would need to do this for each partially transparent image I have. I also thought about using arrays to get the colour and checking if it matches the background colour and getting the rectangle's size from there but that would be slow and cumbersome.

for x, y in ((i, j) for i in land_x for j in land_y):

# land_x, land_y hold the tiles to be checked

    try:

        tx1, ty1, tx2, ty2 = 

             texture[land[y][x]].get_rect()

        # tx1, ty1 coordinates of top-left corner

        # tx2, ty2 width and height respectively

        if tx2 == 0 and ty2 == 0:

            continue    # skip to other objects

        tx1 = x*64 - tx2/2

        ty1 = y*64 - ty2/2

        px1, py1, px2, py2 = 

             PLAYER.get_rect()

        px1 = player_x - px2/2

        py1 = -player_y - py2/2

        if p.Rect(px1, py1, px2, py2).colliderect(

            p.Rect(tx1, ty1, tx2, ty2)

        ):

            player_x -= direction_x

            break    # go outside loop to start checking y

    except IndexError:    # incase player is outside map

        pass    # skip to other objects

The .get_rect() outputs a rectangle the size of the whole image whereas I want a rectangle that doesn't include the transparent parts.

Example:
texture is a 64x64 image with a 48x48 block in the centre.
The background colour is removed and a 48x48 solid coloured block is left (even though the image size is still 64x64).

Expected Output:
texture.get_rect() should output a rectangle of size 48x48.

Actual Output:
texture.get_rect() instead outputs a rectangle of size 64x64.

Any help on this would be appreciated :D

If you want to ignore the transparent pixels in your collision detection, you're talking about pixel-perfect collision.

To do this in pygame, pygame offers the Mask class. You usually create your masks with pygame.mask.from_surface and use it together with pygame.sprite.spritecollide and pygame.sprite.collide_mask.

Maybe think about using pygame's Sprite class to make use of all the features it offers.

Even if you don't want to use pygame's build-in collision detection, you can take a look at the source to see how it works.

You are making this too hard. You know the size of your objects. Add a smaller collision rect to each of your objects at creation time and use that for collision. Or use a circle if that is better for the object.

tile.crect = Rect(whatever)

Or just multiply the existing rect dimensions by some scale factor for your collision rect. Don't do all of these calculations. Store a Rect for each collideable object and have a rect for the player.

    tx1 = x*64 - tx2/2

    ty1 = y*64 - ty2/2

    px1, py1, px2, py2 = 

         PLAYER.get_rect()

    px1 = player_x - px2/2

    py1 = -player_y - py2/2

Then just test collision directly:

for t in tiles:

    if player.rect.colliderect( t.rect ):

If the player is a sprite its rect moves around. Look at the example code in the doc.

https://www.pygame.org/docs/ref/sprite.html