Python 仅当精灵在x轴上移动时，碰撞才会按预期工作

由于某种原因，我的碰撞没有按预期进行。如果我站着不动，我的角色会一路倒下，但如果我开始跑步，我的角色会不知何故猛地站起来。我不确定为什么会发生这种情况，因为我在def update（self）：in main下的冲突代码没有以任何方式包括x速度

import pygame as pg
from settings import *
from sprites import *

class Game:
    def __init__(self):
        # initialize game window, etc
        pg.init()
        pg.mixer.init()
        self.screen = pg.display.set_mode(SCREEN)
        pg.display.set_caption(TITLE)
        self.clock = pg.time.Clock()
        self.spritesheet = Spritesheet(Mario)
        self.running = True

    def new(self):
        # start a new game
        self.all_sprites = pg.sprite.LayeredUpdates()
        self.player = pg.sprite.Group()
        self.platforms = pg.sprite.Group()
        self.player = Player(self)
        self.level()
        self.run()

    def run(self):
        # Game Loop
        self.playing = True
        while self.playing:
            self.clock.tick(FPS)
            self.events()
            self.update()
            self.draw()

    # COLLISION CODE
    def update(self):
        # Game Loop - Update
        self.all_sprites.update()
        hits = pg.sprite.spritecollide(self.player, self.platforms, False)
        if hits:
            lowest = hits[0]
            if self.player.pos.x < lowest.rect.right and self.player.pos.x > lowest.rect.left:
                self.player.pos.y = lowest.rect.top
                self.player.vel.y = 0
                self.player.jumping = False
                self.player.rect.midbottom = self.player.pos


        # make left impossible to go to
        if self.player.pos.x < 0 + self.player.rect.width / 2:
            self.player.pos.x = 0 + self.player.rect.width / 2


        # move screen
        if self.player.pos.x > WIDTH / 2:
            for platform in self.platforms:
                platform.rect.x -= self.player.vel.x


        if self.player.pos.x > WIDTH / 2:
            self.player.pos.x -= self.player.vel.x



    def events(self):
        # Game Loop - events
        for event in pg.event.get():
            # check for closing window
            if event.type == pg.QUIT:
                self.playing = False
                self.running = False
            if event.type == pg.KEYDOWN:
                if event.key == pg.K_SPACE:
                    self.player.jump()
            if event.type == pg.KEYUP:
                if event.key == pg.K_SPACE:
                    self.player.jump_cut()

    def level(self):
        self.levelsss = level
        y=0
        for row in self.levelsss:
            x = 0
            for col in row:
                if col == "1":
                    block(self, x, y)
                x += 1
            y+= 1


    def draw(self):
        # Game Loop - draw
        self.screen.fill(DEEP_SKY_BLUE)
        self.all_sprites.draw(self.screen)
        # *after* drawing everything, flip the display
        pg.display.flip()

    def show_start_screen(self):
        # game splasrh/start screen
        pass

    def show_go_screen(self):
        # game over/continue
        pass

g = Game()
g.show_start_screen()
while g.running:
    g.new()
    g.show_go_screen()

pg.quit()

将pygame导入为pg
从设置导入*
从精灵导入*
班级游戏：
定义初始化（自）：
#初始化游戏窗口等
第init页（）
pg.mixer.init（）
self.screen=pg.display.set_模式（屏幕）
pg.display.set_标题（标题）
self.clock=pg.time.clock（）
self.spritesheet=spritesheet（马里奥）
self.running=True
def新（自我）：
#开始新游戏
self.all_sprites=pg.sprite.LayeredUpdates（）
self.player=pg.sprite.Group（）
self.platforms=pg.sprite.Group（）
self.player=player（self）
self.level（）
self.run（）
def运行（自）：
#游戏循环
自弹=真
自娱自乐时：
自我时钟滴答声（FPS）
self.events（）
self.update（）
self.draw（）
#冲突代码
def更新（自我）：
#游戏循环-更新
self.all_sprites.update（）
hits=pg.sprite.spritecollide（self.player，self.platforms，False）
如果点击：
最低=点击次数[0]
如果self.player.pos.xloost.rect.left：
self.player.pos.y=lower.rect.top
self.player.vel.y=0
self.player.jumping=False
self.player.rect.midboottom=self.player.pos
#使左路无法到达
如果self.player.pos.x<0+self.player.rect.width/2：
self.player.pos.x=0+self.player.rect.width/2
#移动屏幕
如果self.player.pos.x>宽度/2：
对于self.platforms中的平台：
platform.rect.x-=self.player.vel.x
如果self.player.pos.x>宽度/2：
self.player.pos.x-=self.player.vel.x
def事件（自）：
#游戏循环-事件
对于pg.event.get（）中的事件：
#检查车窗是否关闭
如果event.type==pg.QUIT：
自我表现=错误
self.running=False
如果event.type==pg.KEYDOWN：
如果event.key==pg.K_空格：
self.player.jump（）
如果event.type==pg.KEYUP：
如果event.key==pg.K_空格：
self.player.jump_cut（）
def液位（自身）：
self.levelsss=级别
y=0
对于self.levels中的行：
x=0
对于行中的列：
如果列==“1”：
块（自、x、y）
x+=1
y+=1
def牵引（自）：
#游戏循环-平局
self.screen.fill（深蓝）
self.all_sprite.draw（self.screen）
#*绘制完所有内容后，翻转显示器
pg.display.flip（）
def显示启动屏幕（自身）：
#游戏splasrh/开始屏幕
通过
def show_go_屏幕（自身）：
#游戏结束/继续
通过
g=游戏（）
g、 显示启动屏幕（）
g.运行时：
g、 新的（）
g、 显示屏幕（）
第页退出

这是我的雪碧

import pygame as pg
import random
from settings import *

vec = pg.math.Vector2

class Spritesheet:
    # utility class for loading and parsing spritesheets
    def __init__(self, filename):
        self.spritesheet = pg.image.load(filename).convert_alpha()

    def get_image(self, x, y, width, height):
        image = pg.Surface((width, height))
        image.blit(self.spritesheet, (0, 0), (x, y, width, height))
        image = pg.transform.scale(image, (width * 3, height * 3))
        return image

class Player(pg.sprite.Sprite):
    def __init__(self, game):
        self._layer = PLAYER_LAYER
        self.groups = game.all_sprites
        pg.sprite.Sprite.__init__(self, self.groups)
        self.game = game
        self.jumping = False
        self.walking = False
        self.last_update = 0
        self.frame_count = 0
        self.load_images()
        self.image = self.stationary_r[0]
        self.stationary = 0
        self.right = False
        self.left = False
        self.cImage = 0
        self.fImage = 0
        self.update_time = 125
        self.rect = self.image.get_rect()
        self.rect.center = (40, HEIGHT - 100)
        self.pos = vec(70, HEIGHT - 64)
        self.vel = vec(0, 0)
        self.acc = vec(0, 0)


    def update(self):
        self.animates()
        self.acc = vec(0, PLAYER_GRAVITY)
        keys = pg.key.get_pressed()
        if keys[pg.K_a]:
            self.acc.x = -PLAYER_ACC
        if keys[pg.K_d]:
            self.acc.x = PLAYER_ACC



        # apply friction
        self.acc.x += self.vel.x * PLAYER_FRICTION

        # equations of motion
        self.vel += self.acc
        if abs(self.vel.x) < 0.11:
            self.vel.x = 0
        self.pos += self.vel + 0.5 * self.acc
        self.rect.midbottom = self.pos




    def load_images(self):
        self.stationary_r = [self.game.spritesheet.get_image(211, 0, 14, 16)]
        for frame in self.stationary_r:
            frame.set_colorkey(BLACK)
        self.stationary_l = []
        for frame in self.stationary_r:
            frame.set_colorkey(BLACK)
            self.stationary_l.append(pg.transform.flip(frame, True, False))
        self.running_r = [self.game.spritesheet.get_image(241, 0, 14, 16), self.game.spritesheet.get_image(272, 0, 14, 16), self.game.spritesheet.get_image(300, 0, 14, 16)]
        for frame in self.running_r:
            frame.set_colorkey(BLACK)
        self.running_l = []
        for frame in self.running_r:
            frame.set_colorkey(BLACK)
            self.running_l.append(pg.transform.flip(frame, True, False))
        self.turn_r = [self.game.spritesheet.get_image(331, 0, 14, 16)]
        for frame in self.turn_r:
            frame.set_colorkey(BLACK)
        self.turn_l = []
        for frame in self.turn_r:
            self.turn_l.append(pg.transform.flip(frame, True, False))

    def animates(self):
        now = pg.time.get_ticks()
        if self.vel.x != 0.0:
            self.walking = True
        else:
            self.walking = False


        if self.walking:
         if now - self.last_update > 150:
            if now - self.last_update > self.update_time:
                self.last_update = now
                bottom = self.rect.bottom
                self.frame_count += 1
                if self.frame_count >= 3:
                    self.frame_count = 0

                self.rect = self.image.get_rect()
               # running left and right animations
                if self.vel.x >= 0.1:
                    self.image = self.running_r[self.frame_count]
                else:
                    self.image = self.running_l[self.frame_count]


                # stationary animations
                if self.vel.x <= 0.4 and self.vel.x >= 0:
                    self.image = self.stationary_r[0]

                if self.vel.x <= 0 and self.vel.x >= -0.4:
                    self.image = self.stationary_l[0]


                self.rect.bottom = bottom


    def jump_cut(self):
        if self.jumping:
            if self.vel.y < 0:
                self.vel.y *= 0.5

    def jump(self):
        # jump only if standing on a platform
        self.rect.y += 5
        hits = pg.sprite.spritecollide(self, self.game.platforms, False)  # LOOK AT
        self.rect.y -= 5
        if hits and not self.jumping:
            self.jumping = True
            self.vel.y = -20



class block(pg.sprite.Sprite):
    def __init__(self, game, x, y):
        self._layer = PLATFORM_LAYER
        self.groups = game.platforms, game.all_sprites
        pg.sprite.Sprite.__init__(self, self.groups)
        self.image = pg.image.load("block.png").convert_alpha()
        self.rect = self.image.get_rect()
        self.rect.x = x*32
        self.rect.y = y*32

将pygame导入为pg
随机输入
从设置导入*
向量=pg.math.Vector2
类别精神表：
#用于加载和分析spritesheet的实用程序类
def uuu init uuu（self，文件名）：
self.spritesheet=pg.image.load（文件名）.convert_alpha（）
def get_图像（自身、x、y、宽度、高度）：
图像=pg.表面（（宽度、高度））
图像.blit（自精神表，（0,0），（x，y，宽度，高度））
图像=pg.transform.scale（图像，（宽度*3，高度*3））
返回图像
职业玩家（第三页精灵）：
定义初始（自我，游戏）：
self.\u层=玩家层
self.groups=game.all\u精灵
pg.sprite.sprite.\uuuu init\uuuu（self，self.groups）
self.game=游戏
自我跳跃=错误
self.walking=False
self.last_update=0
self.frame\u计数=0
self.load_图像（）
self.image=self.stational\u r[0]
自静止=0
self.right=False
self.left=False
self.cImage=0
self.fImage=0
self.update_time=125
self.rect=self.image.get_rect（）
self.rect.center=（40，高度-100）
self.pos=vec（70，高度-64）
self.vel=vec（0,0）
self.acc=vec（0,0）
def更新（自我）：
self.animates（）
self.acc=vec（0，玩家重力）
keys=pg.key.get_pressed（）
如果键[pg.K_a]：
self.acc.x=-PLAYER\u acc
如果键[pg.K_d]：
self.acc.x=玩家
#施加摩擦力
自加速x+=自加速x*玩家摩擦
#运动方程
self.vel+=self.acc
如果abs（自身等级x）<0.11：
self.vel.x=0
self.pos+=self.vel+0.5*self.acc
self.rect.midbottom=self.pos
def加载_图像（自）：
self.stational\u r=[self.game.spritesheet.get\u image（211,0,14,16）]
对于处于自静止状态的机架：
帧。设置颜色键（黑色）
自静止
对于处于自静止状态的机架：
帧。设置颜色键（黑色）
自固定附加（pg.transform.flip（帧，真，假））
self.running\u r=[self.game.spritesheet.get\u image（241,0,14,16），self.game.spritesheet.get\u image（272,0,14,16），self.game.spritesheet.get\u image（300,0,14,16）]
对于自动运行中的帧：
帧。设置颜色键（黑色）
self.running_l=[]
对于自动运行中的帧：
帧。设置颜色键（黑色）
self.running_l.append（pg.transform.flip）（帧，真，假