pygame滚动 [英] Pygame Scrolling

问题描述

我目前正在参加A级计算机科学课程，在该课程中，我必须为项目创建游戏.我知道这段代码可能效率不高，但是我试图将其保留在我自己的工作中，并希望让我感到困惑的一只手.

I am currently taking an A level computer science course in which I have to create a game for a project. I know this code is probably not efficient but I am trying to keep it to my own work and would like a hand with one bit that I am confused on.

我正在尝试向左和向右滚动屏幕，我知道是通过沿相关方向移动屏幕上的每个对象来完成的.我创建了边界，当机器人在其中时，屏幕应针对其开始移动.但是对于我编写的代码而言，平台可以在屏幕上更新而无需在屏幕上进行更新，并且在这些边界内时机器人的速度也会发生变化

I am trying to scroll the screen right and left which i know is done by moving every object on the screen in the relevant direction. I have created boundaries for which the screen should start to move when the robot is within them. But for the code i have written the platforms move without them being updated on the screen and the speed of the robot changes when it is within these boundaries

任何想法或帮助将不胜感激.

Any ideas or help would be appreciated.

import pygame as pg
import time
import random


pg.init()#initiates pygame

display_height = 690#Creates width and height of screen
display_width = 1024
#Colours
white = (255,255,255) 
black = (0,0,0)
red = (255,0,0)
green = (0,255,0)
blue = (0,0,255)
sky = (73,71,65) # grey

Robot_height = 99#Height of robot
Robot_width = 112#Width of robot
lives = 3 #Robot Lives
Bullet_Fired = False
PowerUp_Active = False
Robot_acc = 0.3 #Robot Acceleration
vec = pg.math.Vector2

gameDisplay = pg.display.set_mode((display_width,display_height)) #Sets display properties of window
pg.display.set_caption ("Game") #Title on window
clock = pg.time.Clock()
robotImg = pg.image.load("robot1.png") #Loads robots image

#Class for platforms
class Platform(pg.sprite.Sprite):
    def __init__(self, x,y,w,h):
        pg.sprite.Sprite.__init__(self)
        self.image = pg.Surface((w,h))
        self.image.fill(blue)
        self.rect = self.image.get_rect()
        self.rect.x = x
        self.rect.y = y

#List of platforms
PLATFORM_LIST = [(0,display_height - 40,display_width,40),
                 (display_width /2 - 50,display_height * 3/4,100,20)]
#Platform group
platforms = pg.sprite.Group()


#class for robot
class RobotClass(pg.sprite.Sprite):
    def __init__(self):
        pg.sprite.Sprite.__init__(self)
        self.image = pg.Surface((Robot_width,Robot_height))
        self.rect = self.image.get_rect()
        self.rect.center = (display_width / 2, display_height / 2)
        self.RobotPos = vec(display_width / 2, display_height / 2)
        self.bottom = (0,0)
        self.vel = vec(0, 0)
        self.acc = vec(0, 0.3)

#Creates Robot
Robot = RobotClass()
for plat in PLATFORM_LIST:
    p = Platform(*plat)
    platforms.add(p)
def draw():
    for plat in PLATFORM_LIST:
            p = Platform(*plat)
            pg.draw.rect(gameDisplay, blue, (p))

#Jump function
def jump():
    #Checks pixel below robot to see if there is a collision
    Robot.rect.x = Robot.rect.x +1
    hits = pg.sprite.spritecollide(Robot , platforms, False)
    Robot.rect.x = Robot.rect.x -1
    if hits:
        #Gives robot velocity of 5 upwards
        Robot.vel.y = -10

#game loop
def game_loop():
    pg.draw.rect(gameDisplay, red, Robot.rect, 2)
    Robot_friction = -0.3 #Friction value
    vec = pg.math.Vector2 #Setting vec as vector quantity
    while True:
        for event in pg.event.get():
            if event.type == pg.QUIT:
                pg.quit
                quit()
            #Starts acceleration when key is pressed
            if event.type == pg.KEYDOWN:
                if event.key == pg.K_LEFT:
                    Robot.acc.x = -Robot_acc
                elif event.key == pg.K_RIGHT:
                    Robot.acc.x = Robot_acc
                elif event.key == pg.K_UP:
                    jump()
            #Adds friction to accleration to slow robot down when key is not being pressed
            if event.type == pg.KEYUP:
                if event.key == pg.K_LEFT or event.key == pg.K_RIGHT:
                    Robot.acc.x = Robot.acc.x * Robot_friction

        #Adjusts velocity of robot by adding the acceleration on each cycle
        Robot.vel = Robot.vel+ Robot.acc
        #Fills background
        gameDisplay.fill(sky)
        #Draws the platforms to the screen and adds them to platform group
        draw()
        #Changes Robot position according to its velocity,acceleration and the friction
        Robot.RobotPos = Robot.RobotPos + Robot.vel + 0.5 * Robot.acc
        #Loads robot onto screen
        gameDisplay.blit(robotImg,(Robot.rect))
        pg.draw.rect(gameDisplay, red, Robot.rect, 2)
        #Updates display
        pg.display.update()
        clock.tick(60)

        #Sets bottom of robot to its position
        Robot.rect.midbottom =  Robot.RobotPos

        #Collision detection
        if Robot.vel.y > 0:
            hits = pg.sprite.spritecollide(Robot , platforms, False)
            if hits:
                #Puts Robot on top of platform
                Robot.RobotPos.y = hits[0].rect.top + 1
                Robot.vel.y = 0

        #Scrolling

        if Robot.rect.left < display_width/4:
            print("left")
            Robot.RobotPos.x = Robot.RobotPos.x - abs(Robot.vel.x)
            print(Robot.vel)
            for plat in platforms:
                plat.rect.x = plat.rect.x + abs(Robot.vel.x)
                pg.draw.rect(gameDisplay, blue, (PLATFORM_LIST[0]))
        if Robot.rect.right > (display_width-display_width/4):
            print("right")
            Robot.RobotPos.x = Robot.RobotPos.x + abs(Robot.vel.x)
            print(Robot.vel)
            for plat in platforms:
                plat.rect.x = plat.rect.x - abs(Robot.vel.x)

        #Sets top velocity of robot    
        if Robot.vel.x > 6:
            Robot.vel.x = 6
        if Robot.vel.x < -6:
            Robot.vel.x = -6
        #Makes robot velocity = 0 when it is close to 0
        if Robot.vel.x < 0.05 and Robot.vel.x > -0.05:
            Robot.acc.x = 0
            Robot.vel.x = 0


game_loop()
pg.quit()
quit()

推荐答案

所以我们开始.如果机器人达到极限，则在这里更新平台:

So here we go. Here you are updating the platforms if the robot reached the limit:

for plat in platforms:
    plat.rect.x = plat.rect.x - abs(Robot.vel.x)

但是绘制平台时，您是从原始PLATFORM_LIST列表中绘制的:

But when you draw the platforms you draw from the original PLATFORM_LIST list:

def draw():
    for plat in PLATFORM_LIST:
        p = Platform(*plat)
        pg.draw.rect(gameDisplay, blue, (p))

因此，即使您正确地更新了平台，最终还是会从原始列表中进行绘制，因此，您不会绘制已更新的列表.您应该从要更新的平台列表中得出:

So what ends up happening is even though you are updating the platforms properly, you are drawing from the original list, so you are not drawing the updated the list. You should draw from the platform list you are updating:

def draw():
    for plat in platforms:
        pg.draw.rect(gameDisplay, blue, plat)

其次，我发现一旦您达到左侧滚动限制，则向右返回的移动将使机器人以错误的方式移动.替换为:

Second, I discovered once you hit the left scroll limit, the movement back to the right direction moved the robot the wrong way. replace this:

if Robot.rect.left < display_width/4:
    Robot.RobotPos.x = Robot.RobotPos.x - abs(Robot.vel.x)

(将负号切换为加号)

if Robot.rect.left < display_width/4:
    Robot.RobotPos.x = Robot.RobotPos.x + abs(Robot.vel.x)

我在玩游戏时发现了几件事.

Just a couple things I found while playing around with the game.

更新

舍入也存在问题. Pygame矩形采用整数.您计算出的速度会产生一个浮点，并且您尝试将其添加到此处的矩形的x中:

There is also an issue with rounding. Pygame rectangles take integers. Your calculation of velocity yields a float and you are trying to add that to the x of the rectangle here:

for plat in platforms:
    plat.rect.x = plat.rect.x - abs(Robot.vel.x)

这会导致舍入的问题出现在以特殊方式移动的显示器(平台)中.您可以将它们设置为整数:

This causes issues with rounding that show up in the display (platforms) moving in peculiar ways. You can make them ints:

for plat in platforms:
    plat.rect.x = plat.rect.x - int(abs(Robot.vel.x))

否则，您将必须像制作机器人一样处理平台并处理vec()

Otherwise you will have to make the platforms like you do the Robot and deal in vec()

这篇关于pygame滚动的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！