游戏代码概述

• 游戏类型说明
  • 平台跳跃（Platformer），像素风格，单关卡
• 核心功能特点
  • 方向键左右移动，向上键或空格跳跃
  • 收集星星计分
  • 敌人简单巡逻与重力，碰到敌人会复位并统计死亡次数
  • 关卡内使用矩形碰撞（平台、敌人、星星）
  • 收集完所有星星后出口开启，到达出口即关卡结束
  • 结束界面显示：用时、收集数、死亡次数与简单评价，支持重新开始
• 技术实现要点
  • 使用PyGame精灵系统和主循环
  • 基于低分辨率虚拟画面+整数缩放的像素风渲染
  • 轴向分离的矩形碰撞处理
  • 巡逻敌人的边缘检测（前方悬空或撞墙时反向）
  • 关卡字符串解析生成Tile、道具、敌人、玩家与出口

完整代码

# 完整的PyGame平台跳跃游戏代码（像素风）
# 需求特性：
# - 方向键移动与跳跃
# - 收集星星
# - 敌人简单巡逻
# - 主循环内处理键盘事件与矩形碰撞
# - 关卡结束显示得分与简单报告提示
# - 像素风格（低分辨率渲染到高分辨率窗口）

import pygame
import sys
from pygame.math import Vector2

# ----------------------------
# 基本设置（像素风低分辨率 + 整数放大）
# ----------------------------
pygame.init()
VIRTUAL_W, VIRTUAL_H = 320, 180      # 虚拟渲染分辨率（像素风）
SCALE = 3                            # 窗口缩放倍数（整数，保证像素清晰）
WIN_W, WIN_H = VIRTUAL_W * SCALE, VIRTUAL_H * SCALE
TILE = 16                            # 瓦片大小（像素）
FPS = 60

# 颜色定义（简洁像素调色）
COL_BG = (25, 25, 35)         # 背景深蓝灰
COL_PLATFORM = (60, 60, 80)   # 平台块深灰
COL_PLAYER = (90, 200, 255)   # 玩家青蓝
COL_PLAYER_OUTLINE = (20, 40, 55)
COL_ENEMY = (240, 90, 90)     # 敌人桃红
COL_STAR = (255, 220, 90)     # 星星黄
COL_STAR_GLOW = (255, 255, 180)
COL_TEXT = (240, 240, 240)    # 文本
COL_DOOR_LOCK = (120, 120, 160)
COL_DOOR_OPEN = (120, 200, 120)

# ----------------------------
# 关卡数据（20列 x 11行）
# 字符说明：
# . 空 | X 平台 | S 星星 | E 敌人 | P 玩家出生点 | D 出口
# ----------------------------
LEVEL_DATA = [
    "....................",
    "...S....XXX....S....",
    "...X.........E......",
    "...........XXX......",
    "..XXX.............S.",
    "...........S........",
    ".P....XXX...........",
    "XXXX.........XXXX...",
    ".....S....E.........",
    ".................D..",
    "XXXXXXXXXXXXXXXXXXXX",
]

ROWS = len(LEVEL_DATA)
COLS = len(LEVEL_DATA[0])

# ----------------------------
# 工具函数：创建简单像素块贴图
# ----------------------------
def make_block_surface(w, h, color, outline=None):
    surf = pygame.Surface((w, h), pygame.SRCALPHA)
    surf.fill(color)
    if outline:
        pygame.draw.rect(surf, outline, surf.get_rect(), 1)
    return surf

def clamp(v, lo, hi):
    return max(lo, min(hi, v))

# ----------------------------
# 精灵类定义
# ----------------------------
class Platform(pygame.sprite.Sprite):
    def __init__(self, x, y):
        super().__init__()
        self.image = make_block_surface(TILE, TILE, COL_PLATFORM)
        self.rect = self.image.get_rect(topleft=(x, y))


class Star(pygame.sprite.Sprite):
    def __init__(self, x, y):
        super().__init__()
        # 星星是小块，加轻微发光边
        self.base = make_block_surface(TILE, TILE, (0, 0, 0, 0))
        pygame.draw.rect(self.base, COL_STAR, pygame.Rect(5, 5, 6, 6))
        pygame.draw.rect(self.base, COL_STAR_GLOW, pygame.Rect(4, 4, 8, 8), 1)
        self.image = self.base.copy()
        self.rect = self.image.get_rect(topleft=(x, y))
        self.t = 0.0

    def update(self, dt):
        # 简单闪烁动画
        self.t += dt
        pulse = (pygame.math.sin(self.t * 6.0) + 1.0) * 0.5  # 0..1
        # 通过Alpha实现闪烁
        self.image = self.base.copy()
        self.image.set_alpha(180 + int(75 * pulse))


class Enemy(pygame.sprite.Sprite):
    def __init__(self, x, y, solids_map):
        super().__init__()
        # 敌人是16x12的小矩形，带描边
        self.image = make_block_surface(TILE, TILE - 4, COL_ENEMY, outline=(80, 20, 20))
        self.rect = self.image.get_rect(midbottom=(x + TILE // 2, y + TILE))
        self.pos = Vector2(self.rect.x, self.rect.y)
        self.vel = Vector2(40.0, 0.0)  # 初速度向右
        self.solids_map = solids_map
        self.gravity = 900.0
        self.speed = 40.0

    def is_solid_at(self, px, py):
        tx = int(px // TILE)
        ty = int(py // TILE)
        if 0 <= tx < COLS and 0 <= ty < ROWS:
            return self.solids_map[ty][tx]
        return False

    def update(self, dt, platforms):
        # 重力
        self.vel.y += self.gravity * dt
        # 水平巡逻：前方阻挡或前方地面缺失则反向
        dir_sign = 1 if self.vel.x >= 0 else -1
        ahead_x = self.rect.centerx + dir_sign * (self.rect.width // 2 + 1)
        foot_y = self.rect.bottom + 1
        # 检查前方是否墙
        if self.is_solid_at(ahead_x, self.rect.centery) or self.is_solid_at(ahead_x, self.rect.top + 1):
            self.vel.x *= -1
        else:
            # 检查前方脚下是否有地面
            if not self.is_solid_at(ahead_x, foot_y):
                self.vel.x *= -1

        # 应用水平位移
        self.pos.x += self.vel.x * dt
        self.rect.x = int(self.pos.x)
        # 水平方向碰撞（防止嵌入墙体）
        hits = pygame.sprite.spritecollide(self, platforms, False)
        for p in hits:
            if self.vel.x > 0:
                self.rect.right = p.rect.left
            elif self.vel.x < 0:
                self.rect.left = p.rect.right
            self.pos.x = self.rect.x
            self.vel.x *= -1  # 撞墙反向

        # 竖直方向
        self.pos.y += self.vel.y * dt
        self.rect.y = int(self.pos.y)
        hits = pygame.sprite.spritecollide(self, platforms, False)
        for p in hits:
            if self.vel.y > 0:
                self.rect.bottom = p.rect.top
            elif self.vel.y < 0:
                self.rect.top = p.rect.bottom
            self.pos.y = self.rect.y
            self.vel.y = 0.0


class Player(pygame.sprite.Sprite):
    def __init__(self, x, y):
        super().__init__()
        # 玩家：14x16，有外描边
        self.image = make_block_surface(14, 16, COL_PLAYER, outline=COL_PLAYER_OUTLINE)
        self.rect = self.image.get_rect(midbottom=(x + TILE // 2, y + TILE))
        self.pos = Vector2(self.rect.x, self.rect.y)
        self.vel = Vector2(0.0, 0.0)
        self.move_speed = 110.0
        self.gravity = 900.0
        self.jump_speed = 270.0
        self.on_ground = False
        # 跳跃辅助（容错）
        self.coyote_time = 0.1
        self.coyote_timer = 0.0
        self.jump_buffer_time = 0.12
        self.jump_buffer_timer = 0.0

    def handle_input(self, dt):
        keys = pygame.key.get_pressed()
        left = keys[pygame.K_LEFT]
        right = keys[pygame.K_RIGHT]
        self.vel.x = 0.0
        if left: self.vel.x -= self.move_speed
        if right: self.vel.x += self.move_speed

    def queue_jump(self):
        self.jump_buffer_timer = self.jump_buffer_time

    def update(self, dt, platforms):
        # 输入
        self.handle_input(dt)

        # 更新计时器
        if self.on_ground:
            self.coyote_timer = self.coyote_time
        else:
            self.coyote_timer = max(0.0, self.coyote_timer - dt)
        self.jump_buffer_timer = max(0.0, self.jump_buffer_timer - dt)

        # 跳跃判定（缓冲 + 土狼时间）
        if self.jump_buffer_timer > 0 and self.coyote_timer > 0:
            self.vel.y = -self.jump_speed
            self.on_ground = False
            self.jump_buffer_timer = 0.0

        # 重力
        self.vel.y += self.gravity * dt
        self.vel.y = clamp(self.vel.y, -1000, 1000)

        # X轴移动 + 碰撞
        self.pos.x += self.vel.x * dt
        self.rect.x = int(self.pos.x)
        hits = pygame.sprite.spritecollide(self, platforms, False)
        for p in hits:
            if self.vel.x > 0:
                self.rect.right = p.rect.left
            elif self.vel.x < 0:
                self.rect.left = p.rect.right
            self.pos.x = self.rect.x

        # Y轴移动 + 碰撞
        self.pos.y += self.vel.y * dt
        self.rect.y = int(self.pos.y)
        hits = pygame.sprite.spritecollide(self, platforms, False)
        self.on_ground = False
        for p in hits:
            if self.vel.y > 0:
                self.rect.bottom = p.rect.top
                self.on_ground = True
            elif self.vel.y < 0:
                self.rect.top = p.rect.bottom
            self.pos.y = self.rect.y
            self.vel.y = 0.0

        # 限制在屏幕内（虚拟坐标）
        self.rect.left = max(0, self.rect.left)
        self.rect.right = min(VIRTUAL_W, self.rect.right)
        self.pos.x = self.rect.x

        # 若掉出屏幕底部，交由Game处理复位

class Door(pygame.sprite.Sprite):
    def __init__(self, x, y):
        super().__init__()
        self.closed_img = make_block_surface(TILE, TILE*2, COL_DOOR_LOCK, outline=(50, 50, 70))
        self.open_img = make_block_surface(TILE, TILE*2, COL_DOOR_OPEN, outline=(50, 70, 50))
        self.image = self.closed_img
        self.rect = self.image.get_rect(bottomleft=(x, y + TILE))  # 门两格高，底对齐地面
        self.is_open = False

    def set_open(self, open_state: bool):
        self.is_open = open_state
        self.image = self.open_img if self.is_open else self.closed_img


# ----------------------------
# 游戏主类
# ----------------------------
class Game:
    def __init__(self):
        pygame.display.set_caption("像素平台跳跃 - 收集星星")
        self.screen = pygame.display.set_mode((WIN_W, WIN_H))
        self.canvas = pygame.Surface((VIRTUAL_W, VIRTUAL_H))
        self.clock = pygame.time.Clock()
        self.font = pygame.font.SysFont("arial", 10, bold=False)

        self.running = True
        self.state = "playing"  # "playing" or "finished"

        # 关卡与对象容器
        self.platforms = pygame.sprite.Group()
        self.stars = pygame.sprite.Group()
        self.enemies = pygame.sprite.Group()
        self.all_sprites = pygame.sprite.Group()
        self.door = None
        self.player = None

        # 统计
        self.star_total = 0
        self.star_collected = 0
        self.deaths = 0
        self.time_elapsed = 0.0

        # solids map（用于快速检测瓦片是否为实心）
        self.solids_map = [[False for _ in range(COLS)] for _ in range(ROWS)]

        self.load_level()
        self.reset_runtime_stats()

    def reset_runtime_stats(self):
        self.state = "playing"
        self.star_collected = 0
        self.deaths = 0
        self.time_elapsed = 0.0

    def load_level(self):
        # 清空
        self.platforms.empty()
        self.stars.empty()
        self.enemies.empty()
        self.all_sprites.empty()
        self.door = None
        self.player = None
        # 重建solids map
        for r in range(ROWS):
            for c in range(COLS):
                self.solids_map[r][c] = (LEVEL_DATA[r][c] == 'X')

        # 解析关卡
        spawn_pos = (0, 0)
        door_pos = None

        for r, row in enumerate(LEVEL_DATA):
            for c, ch in enumerate(row):
                x, y = c * TILE, r * TILE
                if ch == 'X':
                    block = Platform(x, y)
                    self.platforms.add(block)
                elif ch == 'S':
                    star = Star(x, y)
                    self.stars.add(star)
                    self.all_sprites.add(star)
                elif ch == 'E':
                    enemy = Enemy(x, y, self.solids_map)
                    self.enemies.add(enemy)
                    self.all_sprites.add(enemy)
                elif ch == 'P':
                    spawn_pos = (x, y)
                elif ch == 'D':
                    door_pos = (x, y)

        self.star_total = len(self.stars)

        # 创建玩家与门
        self.player = Player(*spawn_pos)
        self.all_sprites.add(self.player)
        if door_pos:
            self.door = Door(*door_pos)
            self.all_sprites.add(self.door)

        # 平台需要在独立组中用于碰撞
        # 绘制时两者都画到canvas上

    def respawn_player(self):
        # 找到出生点
        for r, row in enumerate(LEVEL_DATA):
            for c, ch in enumerate(row):
                if ch == 'P':
                    x, y = c * TILE, r * TILE
                    self.player.rect.midbottom = (x + TILE // 2, y + TILE)
                    self.player.pos = Vector2(self.player.rect.x, self.player.rect.y)
                    self.player.vel = Vector2(0, 0)
                    return

    def finish_level(self):
        self.state = "finished"

    def draw_text(self, surf, text, x, y, color=COL_TEXT, align="topleft"):
        img = self.font.render(text, True, color)
        rect = img.get_rect(**{align: (x, y)})
        surf.blit(img, rect)

    def update_play(self, dt):
        self.time_elapsed += dt

        # 处理事件（跳跃按键在事件循环里加缓冲）
        # 移动输入在Player内部处理

        # 更新对象
        for star in self.stars:
            star.update(dt)

        for enemy in self.enemies:
            enemy.update(dt, self.platforms)

        self.player.update(dt, self.platforms)

        # 掉出屏幕底部 -> 复位并计死亡
        if self.player.rect.top > VIRTUAL_H + 50:
            self.deaths += 1
            self.respawn_player()

        # 碰到敌人 -> 复位并计死亡
        if pygame.sprite.spritecollide(self.player, self.enemies, False):
            self.deaths += 1
            self.respawn_player()

        # 收集星星
        hits = pygame.sprite.spritecollide(self.player, self.stars, dokill=True)
        if hits:
            self.star_collected += len(hits)

        # 门状态
        if self.door:
            self.door.set_open(self.star_collected >= self.star_total)
            # 开门后碰撞即通关
            if self.door.is_open and self.player.rect.colliderect(self.door.rect):
                self.finish_level()

    def draw_world(self):
        # 背景
        self.canvas.fill(COL_BG)

        # 绘制平台
        for p in self.platforms:
            self.canvas.blit(p.image, p.rect)

        # 绘制道具与敌人、玩家、门
        # 控制层级：星星 -> 敌人 -> 门 -> 玩家（随意，像素风简单）
        for star in self.stars:
            self.canvas.blit(star.image, star.rect)

        for enemy in self.enemies:
            self.canvas.blit(enemy.image, enemy.rect)

        if self.door:
            self.canvas.blit(self.door.image, self.door.rect)

        self.canvas.blit(self.player.image, self.player.rect)

        # UI
        self.draw_text(self.canvas, f"Stars: {self.star_collected}/{self.star_total}", 4, 4)
        self.draw_text(self.canvas, f"Deaths: {self.deaths}", 4, 16)
        self.draw_text(self.canvas, f"Time: {self.time_elapsed:0.2f}s", 4, 28)

        # 像素放大绘制到窗口
        surf_scaled = pygame.transform.scale(self.canvas, (WIN_W, WIN_H))
        self.screen.blit(surf_scaled, (0, 0))
        pygame.display.flip()

    def draw_finish(self):
        # 背景 + 结束面板
        self.canvas.fill(COL_BG)

        # 简单报告
        total = self.star_total
        got = self.star_collected
        deaths = self.deaths
        time_used = self.time_elapsed

        # 简单评级（仅提示）
        rank = "S"
        if deaths >= 3 or time_used > 60:
            rank = "B"
        elif deaths >= 1 or time_used > 40:
            rank = "A"

        # 面板
        panel = pygame.Surface((VIRTUAL_W - 40, VIRTUAL_H - 60))
        panel.fill((35, 35, 50))
        pygame.draw.rect(panel, (80, 80, 110), panel.get_rect(), 2)

        # 文本内容
        cx = panel.get_width() // 2
        self.draw_text(panel, "关卡完成！", cx, 14, align="midtop")
        self.draw_text(panel, f"用时: {time_used:0.2f} 秒", cx, 38, align="midtop")
        self.draw_text(panel, f"收集: {got}/{total} 颗星星", cx, 54, align="midtop")
        self.draw_text(panel, f"死亡: {deaths} 次", cx, 70, align="midtop")
        self.draw_text(panel, f"评价: {rank}", cx, 86, align="midtop")

        self.draw_text(panel, "按 R 重新开始，Esc 退出", cx, panel.get_height() - 22, color=(200, 220, 255), align="midtop")

        self.canvas.blit(panel, (20, 30))

        surf_scaled = pygame.transform.scale(self.canvas, (WIN_W, WIN_H))
        self.screen.blit(surf_scaled, (0, 0))
        pygame.display.flip()

    def run(self):
        while self.running:
            dt = self.clock.tick(FPS) / 1000.0

            # 事件处理
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.running = False
                elif event.type == pygame.KEYDOWN:
                    if self.state == "playing":
                        if event.key in (pygame.K_UP, pygame.K_SPACE):
                            self.player.queue_jump()
                        if event.key == pygame.K_ESCAPE:
                            self.running = False
                    elif self.state == "finished":
                        if event.key == pygame.K_r:
                            # 重置关卡（重新加载星星与敌人，统计归零）
                            self.load_level()
                            self.reset_runtime_stats()
                        if event.key == pygame.K_ESCAPE:
                            self.running = False

            # 更新与绘制
            if self.state == "playing":
                self.update_play(dt)
                self.draw_world()
            else:
                self.draw_finish()

        pygame.quit()
        sys.exit()


if __name__ == "__main__":
    Game().run()

代码说明

• 关键函数和类的作用说明

  • Game：游戏主控制器，负责主循环、状态管理（playing/finished）、事件处理、关卡加载、绘制与统计
  • Player：玩家角色，支持左右移动与跳跃，带“土狼时间”和“跳跃缓冲”，进行轴向分离的矩形碰撞
  • Enemy：敌人带重力，沿地面巡逻；遇到墙或前方悬空时反向；与玩家碰撞会触发玩家复位并统计死亡
  • Star：收集物，带简单闪烁动画；玩家碰撞后被移除并加分
  • Platform：静态平台块，用于碰撞
  • Door：出口；在收集完全部星星后开启；玩家接触开启的出口后进入结束界面
  • LEVEL_DATA：关卡字符数组，解析为对象；X为平台，S为星星，E为敌人，P为玩家出生点，D为出口
  • 像素风渲染：先绘制到320x180虚拟画布，再使用整数倍缩放到窗口，保证像素清晰

• 运行要求和依赖说明

  • Python 3.8+（建议）
  • pygame 2.x
  • 运行方式：安装pygame后，直接执行该脚本
    • pip install pygame
    • python game.py

• 可能的扩展和改进建议

  • 多关卡与关卡切换：将LEVEL_DATA列表扩展为多个关卡，完成一关后进入下一关
  • 更完善的敌人交互：例如允许从上方踩敌人让其短暂眩晕，而非直接复位
  • 动画与特效：为玩家、敌人、星星与门添加更丰富的逐帧动画和粒子效果
  • 音效与背景音乐：收集星星、跳跃、通关等加入音效与简单BGM（使用自制或开源音源）
  • 相机与大地图：加入摄像机跟随以支持大尺寸关卡滚动
  • UI完善：添加生命值、暂停菜单、设置选项、可视化按键提示
  • 性能优化：将平台碰撞切分为网格桶（spatial hashing）以支持更大更复杂的关卡

本代码严格遵循矩形碰撞与主循环最佳实践，逻辑清晰、即开即玩，适合学习与原型开发。