将滚动添加到Pygame中的平台游戏
好的，所以我在下面包括了我的项目的代码，我只是在对Pygame进行一些实验。我试图弄清楚如何进行播放器之后的一些非常简单的滚动，因此玩家是相机的中心，它反弹/跟随他。谁能帮我吗？
import pygame
from pygame import *
WIN_WIDTH = 800
WIN_HEIGHT = 640
HALF_WIDTH = int(WIN_WIDTH / 2)
HALF_HEIGHT = int(WIN_HEIGHT / 2)
DISPLAY = (WIN_WIDTH, WIN_HEIGHT)
DEPTH = 32
FLAGS = 0
CAMERA_SLACK = 30
def main():
global cameraX, cameraY
pygame.init()
screen = pygame.display.set_mode(DISPLAY, FLAGS, DEPTH)
pygame.display.set_caption("Use arrows to move!")
timer = pygame.time.Clock()
up = down = left = right = running = False
bg = Surface((32,32))
bg.convert()
bg.fill(Color("#000000"))
entities = pygame.sprite.Group()
player = Player(32, 32)
platforms = []
x = y = 0
level = [
"PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP",
"P P",
"P P",
"P P",
"P P",
"P P",
"P P",
"P P",
"P PPPPPPPPPPP P",
"P P",
"P P",
"P P",
"P P",
"PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP",]
# build the level
for row in level:
for col in row:
if col == "P":
p = Platform(x, y)
platforms.append(p)
entities.add(p)
if col == "E":
e = ExitBlock(x, y)
platforms.append(e)
entities.add(e)
x += 32
y += 32
x = 0
entities.add(player)
while 1:
timer.tick(60)
for e in pygame.event.get():
if e.type == QUIT: raise SystemExit, "QUIT"
if e.type == KEYDOWN and e.key == K_ESCAPE:
raise SystemExit, "ESCAPE"
if e.type == KEYDOWN and e.key == K_UP:
up = True
if e.type == KEYDOWN and e.key == K_DOWN:
down = True
if e.type == KEYDOWN and e.key == K_LEFT:
left = True
if e.type == KEYDOWN and e.key == K_RIGHT:
right = True
if e.type == KEYDOWN and e.key == K_SPACE:
running = True
if e.type == KEYUP and e.key == K_UP:
up = False
if e.type == KEYUP and e.key == K_DOWN:
down = False
if e.type == KEYUP and e.key == K_RIGHT:
right = False
if e.type == KEYUP and e.key == K_LEFT:
left = False
if e.type == KEYUP and e.key == K_RIGHT:
right = False
# draw background
for y in range(32):
for x in range(32):
screen.blit(bg, (x * 32, y * 32))
# update player, draw everything else
player.update(up, down, left, right, running, platforms)
entities.draw(screen)
pygame.display.update()
class Entity(pygame.sprite.Sprite):
def __init__(self):
pygame.sprite.Sprite.__init__(self)
class Player(Entity):
def __init__(self, x, y):
Entity.__init__(self)
self.xvel = 0
self.yvel = 0
self.onGround = False
self.image = Surface((32,32))
self.image.fill(Color("#0000FF"))
self.image.convert()
self.rect = Rect(x, y, 32, 32)
def update(self, up, down, left, right, running, platforms):
if up:
# only jump if on the ground
if self.onGround: self.yvel -= 10
if down:
pass
if running:
self.xvel = 12
if left:
self.xvel = -8
if right:
self.xvel = 8
if not self.onGround:
# only accelerate with gravity if in the air
self.yvel += 0.3
# max falling speed
if self.yvel > 100: self.yvel = 100
if not(left or right):
self.xvel = 0
# increment in x direction
self.rect.left += self.xvel
# do x-axis collisions
self.collide(self.xvel, 0, platforms)
# increment in y direction
self.rect.top += self.yvel
# assuming we're in the air
self.onGround = False;
# do y-axis collisions
self.collide(0, self.yvel, platforms)
def collide(self, xvel, yvel, platforms):
for p in platforms:
if pygame.sprite.collide_rect(self, p):
if isinstance(p, ExitBlock):
pygame.event.post(pygame.event.Event(QUIT))
if xvel > 0:
self.rect.right = p.rect.left
print "collide right"
if xvel < 0:
self.rect.left = p.rect.right
print "collide left"
if yvel > 0:
self.rect.bottom = p.rect.top
self.onGround = True
self.yvel = 0
if yvel < 0:
self.rect.top = p.rect.bottom
class Platform(Entity):
def __init__(self, x, y):
Entity.__init__(self)
self.image = Surface((32, 32))
self.image.convert()
self.image.fill(Color("#DDDDDD"))
self.rect = Rect(x, y, 32, 32)
def update(self):
pass
class ExitBlock(Platform):
def __init__(self, x, y):
Platform.__init__(self, x, y)
self.image.fill(Color("#0033FF"))
if __name__ == "__main__":
main()
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（4）
您需要在绘制实体的位置上应用偏移。让我们称之为 offset a
相机，因为这是我们想要实现的效果。首先，我们不能使用Sprite组的
draw函数，因为精灵不需要知道其位置（rect）不是位置它们将在屏幕上绘制（最后，我们将groupclass和重新完成它是draw以了解相机，但让我们开始慢的）。让我们首先创建
相机类，以保持我们要应用于实体位置的偏移状态：在这里要注意的某些内容：
我们需要存储相机的位置，以及像素的宽度和高度（因为我们想停止在级别的边缘滚动）。我使用
rect存储所有这些信息，但是您可以轻松地使用一些字段。使用
rect在应用函数中派上用场。这是我们将实体在屏幕上的位置重新计算到应用卷轴上的位置。根据主循环的迭代，我们需要更新相机的位置，因此有
update函数。它只是通过调用camera_func函数来改变状态，这将为我们做 。我们以后实施。让我们创建一个相机的速度：
并更改我们的主循环：
我们的相机课程已经非常灵活，却又简单。它可以使用不同种类的滚动（通过提供不同的
camera_func函数），并且可以遵循任何arbitary精灵，而不仅仅是玩家。您甚至可以在运行时更改此操作。现在用于实现
camera_func。一种简单的方法是将播放器（或我们要遵循的任何实体）集中在屏幕上，并且实现直接：我们只需占据
target的位置，然后添加一半的总数屏幕尺寸。您可以通过这样创建相机来尝试一下：到目前为止，一切都很好。但是，也许我们不想看到黑色背景外部级别？怎么样：
在这里，我们只需使用
min/max函数即可确保我们不滚动 exourt out级别。通过创建相机来尝试一下：
我们的最终滚动行动中有一些动画：
这再次是完整的代码。请注意，我更改了一些事情：
pygame.key.get_pressedYou need to apply an offset to the position of your entities when drawing them. Let's call that offset a
camera, since this is the effect we want to achieve with this.First of all, we can't use the
drawfunction of the sprite group, since the sprites don't need to know that their position (rect) is not the position they are going to be drawn on the screen (At the end, we'll subclass theGroupclass and reimplement the it'sdrawto be aware of the camera, but let's start slow).Let's start by creating a
Cameraclass to hold the state of the offset we want to apply to the position of our entities:some things to note here:
We need to store the position of the camera, and the width and height of the level in pixels (since we want to stop scrolling at the edges of the level). I used a
Rectto store all these informations, but you could easily just use some fields.Using
Rectcomes in handy in theapplyfunction. This is where we re-calculate the position of an entity on the screen to apply the scrolling.Once per iteration of the main loop, we need to update the position of the camera, hence there's the
updatefunction. It just alters the state by calling thecamera_funcfunction, which will do all the hard work for us. We implement it later.Let's create an instace of the camera:
and alter our main loop:
Our camera class is already very flexible and yet dead simple. It can use different kinds of scrolling (by providing different
camera_funcfunctions), and it can follow any arbitary sprite, not just the player. You even can change this at runtime.Now for the implementation of
camera_func. A simple approach is to just center the player (or whichever entity we want to follow) at the screen, and the implementation is straight forward:We just take the position of our
target, and add the half total screen size. You can try it by creating your camera like this:So far, so good. But maybe we don't want to see the black background outside the level? How about:
Here we simply use the
min/maxfunctions to ensure we don't scroll outside out level.Try it by creating your camera like this:
There's a little animation of our final scrolling in action:
Here's the complete code again. Note I changed some things:
pygame.key.get_pressedinstead不幸的是，Pygame没有针对此问题的内置解决方案。 pygame使用 在 s 。 Sprites 的属性
.Rect用于绘制对象以及对象之间的碰撞测试。没有内置功能可以在绘制之前将对象坐标转换为屏幕坐标。作为Pygame开发人员的建议：在方法 offset 有一个可选的论点 offset 很高兴/sprite.html#pygame.sprite.group.draw“ rel =” nofollow noreferrer“>
pygame.sprite.group.group.draw。有不同的方法：
而不是移动玩家，您可以沿相反方向移动场景中的任何对象。这是所有方法中最糟糕的。我强烈建议不要这样做。
每次添加一个新对象时，都需要确保它随着玩家的移动而移动。处理对象动画或浮点精度可能是一场噩梦。
创建世界的虚拟屏幕大小，并在虚拟屏幕上绘制整个屏幕。在每个帧的末尾，屏幕上显示了地图的小节。
有两种可能性。您可以通过指定区域参数直接在屏幕上的虚拟屏幕区域：
另一种可能性是定义一个使用
subsurface方法：这种方法的缺点是它可以具有很大的内存足迹。如果虚拟屏幕很大，游戏将滞后。仅当游戏区域的大小不比屏幕大得多时，该解决方案才适合。根据经验，如果播放区域的大小是屏幕大小的两倍以上，您不应该这样（我说的是该区域大小的两倍，而不是其宽度和高度的两倍） 。
对于大型游戏区域，唯一可以使用的方法是在绘制之前添加偏移：
不幸的是 在这种情况下不能直接使用。这种方法在一个高度评价的答案中详细介绍了。
另外，您可以在绘制所有精灵之前移动所有精灵：
最后，有关脏机制和部分屏幕更新的评论：一旦玩家移动，整个屏幕就会脏，需要更新。因此，您是否应该将资源投资于部分更新机制是值得怀疑的。这些算法也需要时间进行运行。在高度动态的场景中，算法的结果是更新所有内容。
Unfortunately, Pygame doesn't have a built-in solution to this problem. Pygame use
pygame.sprite.Spriteobjects organized inpygame.sprite.Groups. The attribute.rectof the Sprites is used for drawing the objects as well as for the collision test between objects. There is no built-in feature that can convert object coordinates to screen coordinates before drawing.As a suggestion for the developers of Pygame: It would be nice to have an optional argument for the camera offset in the method
pygame.sprite.Group.draw.There a different approaches:
Instead of moving the player, you can move any object in the scene in the opposite direction. This is the worst of all approaches. I strongly recommend not doing this.
Every time you add a new object you need to make sure that it moves as the player moves. Dealing with object animation or floating point accuracy can turn out to be a nightmare.
Create a virtual screen size of the world and draw the entire screen on the virtual screen. At the end of each frame, a subsection of the map is displayed on the screen.
There are 2 possibilities. You can
blitan area of the virtual screen directly on the screen by specifying the area argument:The other possibility is to define a subsurface that is linked directly to the source surface using the
subsurfacemethod:The disadvantage of this approach is that it can have a very large memory footprint. If the virtual screen is huge, the game will lag. This solution is only suitable if the size of the game area is not much larger than the screen. As a rule of thumb, if the play area is more than twice the size of the screen, you shouldn't go this way (I'm talking about twice the size of the area, not twice the length of its width and height).
For large play areas, the only approach that can be used is to add an offset to the objects before drawing:
Unfortunately
pygame.sprite.Group.drawcan not be used directly in this case. This approach is detailed in a highly rated answer.Alternatively, you can move all of the sprites before drawing them:
At the end a comment about dirty mechanisms and partial screen updates: As soon as the player moves, the entire screen is dirty and needs to be updated. It is therefore questionable whether you should invest resources in partial update mechanisms. These algorithms also take time to run. In highly dynamic scenes, the result of the algorithm is to update all.
既然知道，您就有一个静态背景，并且您控制的玩家在他所处的位置中亮相，您有2个选项可以始终在中间显示角色。
如果您的映射足够小，则可以根据播放器的位置将其尺寸与屏幕的大小相关，并具有一个大的IMG A，并得出一个矩形。这样，玩家将永远位于中间。 rect.clamp（rect）或rect.clamp_ip（rect）将有助于您。
另一种方法是在屏幕上具有不同的元组。播放器将在屏幕的中心具有恒定值，而背景位置将是播放器位置的负数。
Since right know, you have a static background, and the player that you control, is blitted in the position he is in, you have 2 options to always show the character in the middle.
If you map is small enought, you can have a big img A, and derive a rectangle, based on the position of the player that will be the size of the screen. That way, the player will always be in the middle. A Rect.clamp(Rect) or Rect.clamp_ip(Rect) will aid you in that.
Another approach is to have a different tuple for position on screen. The player will have a constant value in the center of the screen, while the backgrounds position will be the negative of the player position.
这样做的唯一方法是将地图中的逻辑位置与屏幕上的物理位置分开。
与实际在屏幕上绘制地图有关的任何代码 - 在您的情况下，所有
ret属性的属性都必须基于屏幕实际上使用的YOR映射部分的偏移来进行此操作。例如，您的屏幕可能是从左上方的位置（10,10）开始显示的地图 - 所有显示相关的代码（在上面的情况下是
rect属性）应减去屏幕偏移偏离当前逻辑位置 - （例如，字符在地图坐标（12,15） - 因此，应在（12,15） - （10，10） - ＆gt;（2，5） * block_size绘制。 ）在上面的示例中，block_size的硬编码为32,32，因此您想在显示器上以物理像素位置（2 * 32，5 * 32）绘制它）
（提示：避免这种方式进行硬编码，使其在以下声明中恒定声明。代码的开始）
The only way to do that is to separate logical positions in the map, from physical positions on the screen .
Any code related to actually drawing your map on the screen - in your case all the
.rectattributes of your sprites - have to do so based on an offset of what part of yor map the screen is actually using.For example, your screen might be showing your map starting with position (10,10) on the top left - all display related code them (which in the case above are the
.rectattributes) should subtract the screen offset from the current logical position - (say the character is at map coords(12,15) - so, it should be drawn at (12,15) - (10, 10) -> (2, 5) * BLOCK_SIZE)In your example above BLOCK_SIZE is hardcoded to 32,32, so you want to draw it at physical pixel position (2 * 32, 5 * 32) on the display)
(hint: avoid hardcoding things this way, make it a constant declaration at the beginning of your code)