Gravity Collision Issue with pygame

Question

Creating a platformer in pygame and im using vectors for the gravity and movement. Right now im stuck on the collisions with the platforms because the plat will hit the platform and sink almost entirely in the platform like this:

Player sunk into platform block

(EDIT) People wanted more code info so...

Main Class:

import pygame as pg
import sys

from sprites import *

class Game:

    def __init__(self):
        pg.init()
        pg.mixer.init()
        pg.display.set_caption(TITLE)
        self.screen = pg.display.set_mode((WIDTH, HEIGHT))
        self.clock = pg.time.Clock()
        self.running = True
        self.load_data()
        self.new_game()

    def load_data(self):
        # Eventually will load data
        pass

    def new_game(self):
        # Creates new instances of all of the sprites
        # groups and re-renders sprites at starting locations
        self.all_sprites = pg.sprite.Group()
        self.platform_sprites = pg.sprite.Group()
        self.player = Player(self, 60, 60)

        # Creates some test platforms
        for x in range(10):
            Platform(self, x, 6)

    def run(self):
        # Basic game loop
        while self.running:
              self.dt = self.clock.tick(FPS) # Get time passed since last        update / Set FPS
            self.events()
            self.render()
            self.update()

    def events(self):
        for event in pg.event.get():
            if event.type == pg.QUIT:
                self.running = False
            if event.type == pg.KEYDOWN:
                if event.key == pg.K_ESCAPE:
                    self.running = False
    # Check for quit event and close window

    def render(self):
        self.screen.fill(WHITE)
        self.all_sprites.draw(self.screen) # Draws all sprites to screen
        pg.display.flip() # updates screen

    def update(self):
        self.all_sprites.update() # calls the update function of all of the sprites

if __name__ == '__main__':
    g = Game()
    while g.running:
        g.run()
    pg.quit()
    sys.exit()

.... Player and platform sprite code:

import pygame as pg

from constants import *
vec = pg.math.Vector2


class Player(pg.sprite.Sprite):
    def __init__(self, game, x, y):
        self.groups = game.all_sprites
        self.game = game
        super().__init__(self.groups)
        self.image = pg.Surface((40, 70))
        self.image.fill(BLUE)
        self.rect = self.image.get_rect()
        pg.draw.rect(self.image, BLACK, (0, 0, self.rect.width, self.rect.height), 3)

        self.pos = vec(x, y)
        self.vel = vec(0, 0)
        self.acc = vec(0, 0)

    def move(self):

        self.acc = vec(0, 0)
        keypress = pg.key.get_pressed()
        if keypress[pg.K_a]:
            self.acc.x += -PLAYER_MOVE_SPEED
        if keypress[pg.K_d]:
            self.acc.x += PLAYER_MOVE_SPEED

        self.acc += self.vel * PLAYER_FRICTION
        self.vel += self.acc
        self.pos += self.vel + 0.5 * self.acc
        self.rect.midbottom = self.pos

    def collisions(self, axis):
        if axis == 'y':
            for plat in self.game.platform_sprites:
                if self.acc.y > 0:
                    if pg.Rect.colliderect(self.rect, plat.rect):
                        self.acc.y = 0
                        self.pos.y = plat.rect.top

    def update(self):
        self.move()
        self.collisions('y')



class Platform(pg.sprite.Sprite):
    def __init__(self, game, x, y):
        self.groups = game.all_sprites, game.platform_sprites
        self.game = game
        super().__init__(self.groups)
        self.image = pg.Surface((TILESIZE, TILESIZE))
        self.image.fill(GREEN)
        self.rect = self.image.get_rect()
        self.x = x * TILESIZE
        self.y = y * TILESIZE

    def update(self):
        self.rect.x = self.x
        self.rect.y = self.y

The "Constants" file only has stuff like the screen size, colors, and player speed defined. IF any of that's needed I'll add it.

Answer 1

In the Player.collisions:

if self.acc.y > 0:
    if pg.Rect.colliderect(self.rect, plat.rect):
        self.acc.y = 0
        self.pos.y = plat.rect.top

1. The main cause of your issue is the player's velocity:

   You're resetting the vertical acceleration (acc.y) and position (pos.y), but it seems like you're forgetting about the vertical speed (vel.y). The player's sinking because it still has downward velocity, which you can remedy with self.vel.y = 0.
   .

2. Another more minor issue might be, as @LarryMcMuffin correctly guessed, that there is an ordering issue between your moving/drawing:

   You may be updating Player.pos.y correctly so the player stands perfectly on top of the platform, but you also need to update self.rect.midbottom if you want your character to be drawn at its new position -- which you do, but in Player.move, which is called before. You could reorder the move/collision functions, but my suggestion is to simply move self.rect.midbottom = self.pos from Player.move to the very end of Player.update.

End result:

def collisions(self, axis):
    if axis == 'y':
        for plat in self.game.platform_sprites:
            if self.acc.y > 0:
                if pg.Rect.colliderect(self.rect, plat.rect):
                    self.acc.y = 0
                    self.vel.y = 0
                    self.pos.y = plat.rect.top

def update(self):
    self.move()
    self.collisions('y')
    self.rect.midbottom = self.pos

---

Another thing I'd like to point out, even though it's probably not related to the issue you described: Use the delta-time.

See, you have two values that influence your character's position:

• velocity (vel): expresses a change of position over time
• acceleration (acc): expresses a change of velocity over time

The over time is key here -- since the time elapsed between two calls of move is variable, this matters: as more/less time passed, the speed should act more/less upon the position. Fortunately, you're saving the time elapsed between two frames/updates in Game.dt. Pass it to your player and use it more or less like so:

self.acc += self.vel * PLAYER_FRICTION
self.vel += self.acc * dt
self.pos += (self.vel + 0.5 * self.acc) * dt

It won't fix it completely so that two calls with dt = .5 produce the same effect as one call with dt = 1, but it will "fill the gap". I don't think you can achieve it without either updating the physics on a fixed-interval basis, or resorting to expensive and complex calculations (using the power function).