Pygame - Collision entre un mask et un rect

[Simlock]

Bonjour,

Je viens vers vous car je n’arrive pas à gérer une collision comme je le souhaite.

Je dispose d’une map de collision sur laquelle j’ai fait un mask car il y a pleins de formes complexes autre que des rectangles.

J’ai ensuite mon sprite joueur sur laquelle je souhaite appliquer un rect plus petit que sa taille originale pour gérer les collisions car seulement une partie de mon sprite au centre m’interesse et non pas ce qui l’entoure.

Comment puis-je détecter une collision entre mon mask et une petite partie (rect) de mon sprite joueur ? La fonction collide_mask fonctionne mais prend en paramètre un mask et non mon rect.

Mon code au cas où :
import pygame as pg
import sys
from os import path
from settings import *
from Player import *

class Game:
    def __init__(self):
        pg.init()
        self.screen = pg.display.set_mode((WIDTH, HEIGHT))
        pg.display.set_caption(TITLE)
        self.clock = pg.time.Clock()
        self.load_data()
 
    def load_data(self):
        self.background = pg.image.load(IMG_MAP).convert_alpha()
        self.player_img = pg.image.load(IMG_PLAYER).convert_alpha()
 
        self.mapCollision = pg.sprite.Sprite()
        self.mapCollision.image = pg.image.load(IMG_HITBOX).convert_alpha()
        self.mapCollision.rect = self.mapCollision.image.get_rect()
        self.mapCollision.mask = pg.mask.from_surface(self.mapCollision.image)
 
    def new(self):
        # Initialise les variables et les paramètres de jeu
        self.all_sprites = pg.sprite.Group()
        self.player = Player(self, POS_START_X, POS_START_Y)
 
    def run(self):
        # Boucle principale
        self.playing = True
        while self.playing:
            self.dt = self.clock.tick(FPS) / 1000.0
            self.events()
            self.update()
            self.draw()
 
    def quit(self):
        pg.quit()
        sys.exit()
 
    def update(self):
        # update portion of the game loop
        self.all_sprites.update()
 
    def draw(self):
        self.screen.blit(self.background, (0,0))
        self.screen.blit(self.mapCollision.image, (0,0))
        for sprite in self.all_sprites:
            self.screen.blit(sprite.image, sprite.rect)
        pg.display.flip()
 
    def events(self):
        # catch all events here
        for event in pg.event.get():
            if event.type == pg.QUIT:
                self.quit()
            if event.type == pg.KEYDOWN:
                if event.key == pg.K_ESCAPE:
                    self.quit()
 
 
# create the game object
g = Game()
while True:
    g.new()
    g.run()

Ma classe joueur :
#Importation des bibliotheques necessaires
import pygame as pg
from pygame.locals import *
from settings import *
vec = pg.math.Vector2

class Player(pg.sprite.Sprite):
    def __init__(self, game, x, y):
        self.groups = game.all_sprites
        pg.sprite.Sprite.__init__(self, self.groups)
        self.game = game
        self.image = game.player_img#.subsurface(pg.Rect(25, 20, 20, 75))
        self.rect = self.image.get_rect()
        #self.mask = pg.mask.from_surface(self.image)
        self.drawRect = pg.draw.rect(self.image,(255,0,0),self.rect,1)
        self.vel = vec(0, 0)
        self.pos = vec(x, y)
        self.rot = 0
 
    def get_keys(self):
        self.rot_speed = 0
        self.vel = vec(0, 0)
        keys = pg.key.get_pressed()
        if keys[pg.K_LEFT] or keys[pg.K_a]:
            self.rot_speed = PLAYER_ROT_SPEED
        if keys[pg.K_RIGHT] or keys[pg.K_d]:
            self.rot_speed = -PLAYER_ROT_SPEED
        if keys[pg.K_UP] or keys[pg.K_w]:
            self.vel = vec(0, -PLAYER_SPEED).rotate(-self.rot)
        if keys[pg.K_DOWN] or keys[pg.K_s]:
            self.vel = vec(0, PLAYER_SPEED).rotate(-self.rot)
 
    def collide_with_isle(self):
        test_collision = pg.sprite.collide_mask(self, self.game.mapCollision)
        print(test_collision)
 
    def update(self):
        self.get_keys()
        self.rot = (self.rot + self.rot_speed * self.game.dt) % 360
        self.image = pg.transform.rotate(self.game.player_img, self.rot)
        self.rect = self.image.get_rect()
        self.rect.center = self.pos
        self.pos += self.vel * self.game.dt
        self.collide_with_isle()