Python+pygame简单飞机射击游戏：主循环、对象池与二次开发

简介：面向j2ME初学者的简单飞机射击游戏代码包，围绕飞机主体与基础射击玩法展开，适合通过完整小项目理解移动游戏开发流程的学习者，可用于课程设计、自学练手或小型案例拆解。包内共200个文件，以138张png图像素材、22个class编译文件、11个java源码及20个mid音频为主，另含jar、jad等手机应用打包与描述文件，压缩包约4.27MB，便于直接查阅素材、源码和运行结构。已有1952人学习，说明该案例在入门实践中具有一定参考价值。读者可从中梳理游戏循环、精灵对象、碰撞检测、按键输入、Graphics绘图、音效播放与多状态管理等核心知识点，并借textPlan中的设计计划或伪代码线索还原游戏逻辑；对有一定经验者，也可作为j2ME平台资源组织、性能优化与代码结构的对照样例。

1. 从一架会开火的飞机开始：这套简单射击类代码能跑出什么

很多人第一次动念写游戏，都是从一架飞机开始的。真上手才发现，卡住人的往往不是射击类玩法本身，而是窗口开不出来、子弹速度跟着帧率飘、敌机越打越卡这些琐碎事。这份简单飞机射击游戏代码把这些坑都填过了：一套可直接运行的 2D 纵向卷轴射击骨架，玩家控制飞机左右移动、持续开火、击落敌机计分、被撞后结算，从头到尾是一条完整的游戏流程，而不是一个只会画矩形的 Demo。

它适合两类人。一类是刚学完 Python 基础语法、想找个完整项目把类、模块、循环真正用一遍的开发者；另一类是需要一份干净底座，往上加 Boss、加弹幕、加道具、换美术的二次开发者。代码量不大，但分层是清醒的：配置、实体、碰撞、刷怪、界面各自独立，改一个数值不用翻三个文件。下面按「它长什么样、怎么跑起来、核心怎么转、哪里容易出错、怎么改成自己的」这个顺序往下拆。

2. 技术选型与目录结构：Python + pygame 为什么适合做射击类小游戏

2.1 选 pygame 而不是引擎的取舍

做 2D 射击，市面上的选择不少，但大多要先装编辑器、学场景树、学预制体、学资源管线，光环境就先耗掉一晚上。这份代码的定位是「拿到就能读、改完就能跑」，所以选了一个 pip 装完就能用的库：pygame。没有编辑器，没有工程文件，所有逻辑都在 .py 里，断点打在哪就停在哪。

性能这块常有人担心纯 Python 撑不住。按这个项目的实际规模算一算：同屏对象通常在 100 到 200 个之间，玩家 1 个、子弹 40 到 60 个、敌机 20 到 30 个、爆炸特效若干，60 帧下每帧的运算量对现在的机器来说很富余。真正拖慢帧率的往往不是 Python 本身，而是每帧重复加载图片、每帧新建 Surface、每帧做一次全量字符串拼接这类操作，这些在资源加载那一节会专门处理。

代价也要说清楚：pygame 没有内置场景管理、没有物理引擎、没有现成的 UI 组件，全都得自己写。好处是逻辑全透明，出问题能一行行跟；坏处是想做大就得自己造轮子。所以这套结构适合「简单射击」这个量级，扩到 Boss 战、多武器、本地存档，加起来千把行也还压得住，再往上就该认真考虑换引擎了。

2.2 目录结构与模块职责

源码的目录是围绕「一帧里发生了什么」来切的，而不是围绕文件类型切。主循环负责串流程，实体只负责自己的状态和绘制，碰撞单独一个模块，刷怪和计分再各自独立。这样拆的好处是，调子弹手感的时候只需要看 bullet 和 settings，不会牵动敌机逻辑。

plane-shooter/ ├── main.py # 入口：初始化、状态机、主循环 ├── settings.py # 所有可调数值集中在这里 ├── requirements.txt # 依赖清单 ├── game/ │ ├── __init__.py │ ├── scene.py # 场景/状态机：开始、游戏中、暂停、结算 │ ├── entity.py # 实体基类，统一坐标、速度、血量、出屏回收 │ ├── player.py # 玩家飞机：输入、开火节奏、无敌帧 │ ├── enemy.py # 敌机：三种基础行为（直下、斜飞、俯冲） │ ├── bullet.py # 子弹与对象池 │ ├── spawner.py # 刷怪器：波次配置驱动 │ ├── collision.py # 碰撞判定与命中处理 │ ├── score.py # 计分、连击、最高分 │ ├── hud.py # 血量条、分数、暂停遮罩 │ └── assets.py # 资源加载与缓存 └── assets/ ├── images/ # 飞机、子弹、爆炸序列帧 └── sounds/ # 开火、爆炸、受击

表格里把职责再摊开一遍，二次开发时按这张表定位改动点最省事。

2.3 依赖安装与第一次启动

环境用虚拟环境隔开，避免和系统里其他 pygame 版本打架，这个习惯在同时维护几个小项目时特别值钱。

# 1. 建虚拟环境（3.8 以上都行，3.10/3.11 最稳） python -m venv .venv source .venv/bin/activate # Windows 用 .venv\Scripts\activate # 2. 装依赖，requirements.txt 里通常只有一行 pygame>=2.1 pip install -r requirements.txt # 3. 启动 python main.py

requirements.txt的内容一般就一行pygame>=2.1。写死下限而不是精确版本，是因为 pygame 2.x 的 Surface 和 mixer 接口在小版本之间基本没变过，锁死反而会在换机器时卡住。启动之后应该看到一个固定尺寸的窗口，玩家飞机贴在底部中间，按方向键或 WASD 能左右平移，按住空格连续出弹，敌机从顶部往下落。

如果窗口一闪就退，先看终端有没有打印异常。最常见的两个是资源路径不对和 mixer 初始化失败：前者表现为FileNotFoundError，多数是用了相对路径但没从项目根目录启动；后者表现为pygame.error: No available audio device，在无音频设备的环境里跑就会遇到，处理办法在排查那一章细说。

3. 核心循环拆解：一次 update 里，飞机、子弹和敌机都做了什么

3.1 主循环与固定时间步长

整个游戏的骨架就是这个 while 循环。看着简单，但这里面藏着一个最容易翻车的地方：时间到底按帧算还是按秒算。

# main.py import pygame from game.scene import SceneManager def run(): pygame.init() screen = pygame.display.set_mode((480, 800)) pygame.display.set_caption("Plane Shooter") clock = pygame.time.Clock() scene = SceneManager(screen) running = True while running: # 单帧时间上限 50ms：切窗口、拖拽、系统卡顿时防止一帧跳出去几百像素 dt = min(clock.tick(60) / 1000.0, 0.05) for event in pygame.event.get(): if event.type == pygame.QUIT: running = False scene.handle_event(event) scene.update(dt) # 逻辑：移动、刷怪、碰撞 scene.draw(screen) # 渲染：先背景后实体最后 HUD pygame.display.flip() pygame.quit() if __name__ == "__main__": run()

clock.tick(60)做两件事：限制帧率上限，同时返回上一帧到这一帧经过的毫秒数。除以 1000 得到秒，后面所有速度都用「像素/秒」表示，乘以 dt 就是这一帧该走的距离。这样在 30 帧和 144 帧的机器上，子弹飞过屏幕用的时间是一样的。

外层那个min(..., 0.05)是后悔药。不加的话，用户把窗口拖到副屏、或者系统弹了个对话框，下一帧的 dt 可能是 0.8 秒，所有物体瞬间瞬移，碰撞全漏，表现就是「莫名其妙被撞死」。把单帧时间钳在 50ms 以内，最坏情况只是画面卡一下，逻辑不会崩。

3.2 实体基类与精灵组

玩家、敌机、子弹看着是三样东西，实际共享同一套状态：图像、矩形、速度、血量、是否存活。抽一个基类出来，剩下的都是配置差异。

# game/entity.py import pygame class Entity(pygame.sprite.Sprite): """所有可见对象的基类，坐标用浮点存，渲染前再取整""" def __init__(self, image, pos, speed=(0, 0), hp=1): super().__init__() self.image = image self.rect = image.get_rect(center=pos) # 浮点坐标单独存一份：rect 只接受整数，直接改 rect 会悄悄丢精度 self.x, self.y = float(self.rect.x), float(self.rect.y) self.speed = pygame.Vector2(speed) # 单位：像素/秒 self.hp = hp self.score_value = 0 def update(self, dt): self.x += self.speed.x * dt self.y += self.speed.y * dt self.rect.x, self.rect.y = int(self.x), int(self.y) # 出屏自动回收，省掉每个子类各写一遍边界判断 if self.rect.bottom < -64 or self.rect.top > 864: self.kill()

浮点坐标那两行是血泪经验。如果每帧直接写self.rect.x += speed * dt，1.5 会被截成 1，速度慢的敌机实际移动比你设定的少三分之一，调数值怎么调都不对，而且不同帧率下误差还不一样，非常玄学。存一份 float，渲染前取整，手感就稳定了。

update里最后那个出屏回收也值得说。它挂在基类上，意味着玩家子弹、敌机、特效全都自动生效，不用在每个子类里重复写四行边界判断。子类只需要管自己的行为，比如敌机怎么走、子弹要不要拐弯。

3.3 子弹对象池：别每帧 new 一个

射击游戏一秒能打十几个子弹，如果每次开火都Bullet()新建对象、出屏再交给垃圾回收，时间一长帧率会呈现明显的锯齿状波动。做法是预分配一个池子，反复复用。

# game/bullet.py import pygame from game.entity import Entity class Bullet(Entity): def reset(self, pos, velocity, damage=1): """复用对象时重设状态，不要重新 new""" self.rect.center = pos self.x, self.y = float(self.rect.x), float(self.rect.y) self.speed = pygame.Vector2(velocity) self.damage = damage return self class BulletPool: def __init__(self, image, size=64): # 预分配，容量不够时再按需扩容 self._free = [Bullet(image, (0, 0)) for _ in range(size)] self._alive = pygame.sprite.Group() def acquire(self, pos, velocity, damage=1): bullet = self._free.pop() if self._free else Bullet(self._free_image, (0, 0)) self._alive.add(bullet.reset(pos, velocity, damage)) return bullet def release_dead(self): # 每帧把飞出去的子弹收回池子，而不是销毁 for b in list(self._alive): if not b.alive() or b.rect.bottom < -32: self._alive.remove(b) self._free.append(b) @property def alive(self): return self._alive

参数上，size=64是按「同屏最多 60 发左右」估的，留了一点余量。velocity用元组传入，实际转换成 Vector2，方便后面做扇形弹幕时直接做旋转。release_dead里那句list(self._alive)必须加：直接遍历 Group 的同时 remove，会跳过元素甚至抛异常，这是新手最常见的翻车点之一。

池子最直接的好处是内存曲线变平，垃圾回收不再每隔几秒抖一下。第二个好处是方便统计，len(pool.alive)就是当前弹数，做「弹幕上限」这类限制时不用另外维护计数器。

3.4 碰撞检测与命中处理

判定用 pygame 自带的分组碰撞就够，两两求矩形相交，100 多个对象的规模下完全感觉不到开销。

# game/collision.py import pygame def resolve(player, bullet_pool, enemies, fx, score): bullets = bullet_pool.alive # 1. 玩家子弹 × 敌机：子弹必删，敌机按血量扣 hits = pygame.sprite.groupcollide(enemies, bullets, False, True) for enemy, hit_bullets in hits.items(): enemy.hp -= sum(b.damage for b in hit_bullets) if enemy.hp <= 0: enemy.kill() score.add(enemy.score_value, enemy.rect.center) fx.explode(enemy.rect.center) # 2. 敌机 × 玩家：玩家受伤后进入短暂无敌，避免同帧连扣 if not player.invincible: for enemy in pygame.sprite.spritecollide(player, enemies, True): player.take_hit(enemy.rect.center) fx.explode(enemy.rect.center) break # 一帧只结算一次伤害，不然满血瞬间见底

groupcollide的后两个参数分别是「碰撞后敌机是否删除」和「子弹是否删除」，这里让子弹无条件消失、敌机按血量走。返回的是个字典，键是敌机、值是撞上它的子弹列表，用sum(b.damage ...)累加，这样两发子弹同帧命中同一架敌机也能正确扣两点血。

下面那段玩家受击里的break是刻意的。不加的话，几架敌机同帧压上来，一次结算扣掉三四点血，玩家会觉得「我明明满血怎么一下就死了」。配合player.invincible的短暂无敌帧，手感才正常。

判定精度上还有个可以调的地方：矩形判定对圆形飞机来说略微偏大，边缘会「隔空」撞上。想更准可以改成圆形距离判定，代价是对象多了以后开销上升。这个项目的规模下，矩形足够了，别过早优化。

4. 难度曲线与刷怪逻辑：让简单射击不至于三分钟劝退

4.1 刷怪器与波次配置

刷怪最忌讳写死一堆 if。做法是把难度做成一张表，刷怪器只负责查表和执行。

# game/spawner.py import random # t 是开局后经过的秒数，参数随时间推进整体收紧 WAVES = [ {"t": 0, "interval": 1.20, "speed": 120, "hp": 1, "patterns": ["straight"]}, {"t": 20, "interval": 0.90, "speed": 150, "hp": 1, "patterns": ["straight", "zigzag"]}, {"t": 45, "interval": 0.65, "speed": 180, "hp": 2, "patterns": ["zigzag", "dive"]}, {"t": 80, "interval": 0.45, "speed": 210, "hp": 3, "patterns": ["dive", "straight", "zigzag"]}, ] class Spawner: def __init__(self, enemy_factory): self.factory = enemy_factory self.elapsed = 0.0 self.cooldown = 0.0 self.current = WAVES[0] def update(self, dt): self.elapsed += dt # 找到当前时间对应的波次，表按 t 升序排列，顺序扫即可 for wave in WAVES: if self.elapsed >= wave["t"]: self.current = wave self.cooldown -= dt if self.cooldown <= 0: self.cooldown = self.current["interval"] pattern = random.choice(self.current["patterns"]) self.factory(pattern, self.current["speed"], self.current["hp"])

interval控制密度，speed控制压迫感，hp控制击杀成本，三个维度分开调，比笼统加一个「难度系数」好用得多。想做更长的关卡，往表里加行就行，不用动任何逻辑代码。

elapsed用的是累加的 dt，不是帧数，所以不管跑在什么机器上，第 45 秒进入第三波这件事是确定的。

4.2 三种敌机行为与难度参数

patterns里的三个名字对应三种移动方式，实现都落在enemy.py里，共用同一个update签名。

# game/enemy.py import math from game.entity import Entity class Enemy(Entity): def __init__(self, image, pattern, speed, hp): super().__init__(image, (0, -40), (0, speed), hp) self.pattern = pattern self.base_x = 0 self.t = 0.0 self.score_value = hp * 10 def spawn_at(self, x): self.rect.centerx = x self.x = float(self.rect.x) self.base_x = x return self def update(self, dt): self.t += dt if self.pattern == "zigzag": # 左右摆动 ±60 像素，频率 2Hz self.speed.x = math.sin(self.t * math.pi * 2) * 60 elif self.pattern == "dive": # 前 1.5 秒直下，之后加速俯冲，制造突然的压迫 if self.t > 1.5: self.speed.y = min(self.speed.y + 300 * dt, 480) super().update(dt)

难度参数的实际取值建议记一下，这几个数是我调了很多次才定下来的：

第一波故意设得很松，间隔 1.2 秒、血量 1，让玩家在前 20 秒建立节奏感。20 秒后开始混入摆动型，45 秒后加入加速俯冲，80 秒之后三型混刷。这个节奏大约能撑住 2 到 3 分钟不腻，也刚好是这类小游戏一局的合理时长。

4.3 计分、连击与结算

计分本身两行代码就够，真正影响体验的是连击和结算时的反馈。

# game/score.py class ScoreBoard: def __init__(self): self.value = 0 self.combo = 0 self.combo_timer = 0.0 self.best = 0 def update(self, dt): # 2 秒内没有新击杀就断连击 if self.combo > 0: self.combo_timer -= dt if self.combo_timer <= 0: self.combo = 0 def add(self, base, pos): self.combo += 1 self.combo_timer = 2.0 # 每连击 +10%，上限 3 倍，避免分数后期爆炸 multiplier = min(1.0 + self.combo * 0.1, 3.0) self.value += int(base * multiplier) def settle(self): self.best = max(self.best, self.value) return {"score": self.value, "best": self.best}

multiplier上限设成 3 倍是有意为之。不封顶的话，连击到 30 以上分数会离谱到失去意义，玩家反而没感觉。连击窗口 2 秒也是个经验值：1 秒太紧，稍微停手就断；3 秒太松，几乎必然连上。

分数只放在内存里，最高分想持久化就写个 JSON 到用户目录，别写进项目目录，否则打包成可执行文件后大概率没有写权限。

4.4 音频初始化与资源缓存

音效这块的坑比想象中多。最常见的是「开火声延迟半秒」和「同时开火时爆音」，根因都在初始化参数上。

# game/assets.py import os import pygame # 必须在 pygame.mixer.init() 之前调用，否则参数不生效 pygame.mixer.pre_init(frequency=44100, size=-16, channels=2, buffer=512) _cache = {} def load_image(name): if name not in _cache: path = os.path.join("assets", "images", name) # convert_alpha 把图片转成和屏幕一致的像素格式，不转的话每帧都要现场转换 _cache[name] = pygame.image.load(path).convert_alpha() return _cache[name] def load_sound(name): if name not in _cache: _cache[name] = pygame.mixer.Sound(os.path.join("assets", "sounds", name)) return _cache[name]

buffer=512是关键。默认值通常偏大，延迟在 100ms 以上，开火声听着像慢半拍；调到 512 之后延迟降到 10 到 20ms，跟手了。代价是极小概率出现爆音，如果目标机器性能很弱，可以退到 1024 折中。

convert_alpha()那句也别省。不调用的话，pygame 每次 blit 都要做一次格式转换，同屏几十张图叠加起来，帧率能掉三分之一。而且这个转换只需要做一次，缓存住就行。

5. 常见问题排查：跑不起来、卡顿、打不中，五个真实踩坑记录

5.1 启动报 No available audio device

现象：在有声卡的机器上跑得好好的，换到某个环境里直接抛pygame.error: No available audio device，窗口都出不来。

原因：pygame.mixer.init()在找不到可用音频输出设备时会抛异常，而很多初始化代码把它和pygame.init()写在一起，没有做异常保护。

解决：把音频初始化包一层 try，失败就置一个全局静音标志，后续所有play()调用前先判断。别因为没声音就让整个游戏起不来，这是本末倒置。

AUDIO_OK = True try: pygame.mixer.init() except pygame.error: AUDIO_OK = False # 静音模式，逻辑照跑

5.2 帧率一高子弹就变快

现象：在开发机上速度正常，换到高刷屏笔记本上，子弹明显飞得更快，敌机也冲得更急。

原因：速度写成了「每帧移动 N 像素」，self.rect.y += 8，没有乘 dt。帧率越高，每秒执行的帧数越多，实际速度就越快。

解决：所有位移统一改成速度(像素/秒) * dt(秒)，并检查一遍有没有漏网的直接改 rect 的写法。改完在两个不同帧率上限下各跑一次，比较「子弹飞过屏幕用了多少秒」，应该基本一致。

5.3 敌机越打越少，最后不刷了

现象：玩到一两分钟后场上敌机越来越少，但分数还在涨，看起来像刷怪器停了。

原因：遍历精灵组的同时调用kill()或remove()。Group 内部是列表，边遍历边删会导致迭代器跳过元素，某些敌机既没被删除也没被正确处理，卡在中间状态。

解决：遍历前先转成列表，for e in list(enemies):；或者把要删的对象先收集到一个待删列表，循环结束后统一处理。这个坑在子弹池、特效池、敌机管理里都会重复出现，写一次记住。

5.4 切出去再切回来，飞机瞬移或者直接死

现象：Alt+Tab 切到别的窗口几秒，切回来时玩家飞机已经飞到屏幕外，或者血量莫名掉了一大截。

原因：窗口失去焦点时，某些平台的clock.tick()会返回一个非常大的时间差，dt 可能是好几秒，一次位移就把飞机推出边界，同时碰撞判定一次跑了很多轮。

解决：主循环里钳住 dt 上限，dt = min(clock.tick(60) / 1000, 0.05)。另外监听pygame.WINDOWFOCUSLOST事件主动暂停，切回来时给一个 3 秒倒计时再恢复，体验上更稳。

5.5 敌机看着没碰到就爆炸了

现象：玩家反馈「明明躲开了还是被打中」，尤其是擦着机翼飞过的时候。

原因：image.get_rect()拿的是整张图的包围盒，如果美术资源留了透明边距，判定框会比飞机本体大一圈。子弹同理，弹头前端留白会让命中判定提前。

解决：给每个实体加一个hitbox属性，手动收缩几个像素，碰撞判定用 hitbox 而不是 rect。飞机一般四周各收 6 到 10 像素，子弹只收尖端。调完之后让判定框可视化跑一遍（把 hitbox 用红色描边画出来），肉眼确认和贴图基本贴合，再撤掉调试绘制。

6. 二次开发：把这份简单代码改成你自己的射击游戏

拿到这套代码之后，多数人的第一个念头是「加东西」。我的建议是先别急着写新功能，花二十分钟把结构摸清楚，后面能省掉大量返工。

6.1 先把数值从代码里搬出去

最容易见效的改造是让settings.py真的成为唯一数值源。现在很多地方还散着硬编码，比如玩家的子弹冷却写在player.py的0.16，敌机俯冲的加速度写在enemy.py的300。这些数值在对玩法调整时会被反复改，散着写迟早改漏一个，表现就是「我明明调了速度怎么没变」——翻车的经典来源。

做法是把它们集中成常量，再按PLAYER、ENEMY、BULLET分组。改完之后，调手感这件事就变成改一个文件、跑一次、看效果，循环特别短。做到位的话，还能进一步换成 JSON 配置，运行时热加载，改完不用重启。

6.2 加武器等级和扇形弹幕

在现有结构上加武器系统，改动点其实很集中：BulletPool.acquire已经支持传velocity，所以只要在开火时按等级算出多个方向和伤害即可。

# game/player.py WEAPON_TABLE = { 1: {"count": 1, "spread": 0, "damage": 1, "cooldown": 0.16}, 2: {"count": 2, "spread": 8, "damage": 1, "cooldown": 0.14}, 3: {"count": 3, "spread": 14, "damage": 1, "cooldown": 0.12}, 4: {"count": 5, "spread": 20, "damage": 2, "cooldown": 0.11}, } def fire(self, pool): cfg = WEAPON_TABLE[self.weapon_level] n, spread = cfg["count"], cfg["spread"] for i in range(n): # 中间那发永远垂直，两侧按 spread 度均匀散开 offset = (i - (n - 1) / 2) * spread vel = pygame.Vector2(0, -720).rotate(offset) pool.acquire(self.rect.midtop, vel, cfg["damage"]) self.cooldown = cfg["cooldown"]

spread单位是度，5 发、20 度意味着最外侧两发偏 ±40 度，覆盖范围大约 120 像素，和敌机的宽度对得上。damage单独给 5 级武器设成 2，是为了让后期高血量敌机不至于拖慢节奏。

同样的思路可以直接搬到敌机上做弹幕：给Enemy加一个fire_timer，到点就往玩家方向发弹。敌机子弹和玩家子弹分两个池子、两个 Group，碰撞时各自对应，别混在一起。

6.3 改完之后怎么验证

加完功能最容易犯的错是「看着能跑就完事」，结果玩两分钟才暴露问题。我一般会固定跑三个检查：第一，在update里临时打一条同屏对象数日志，玩三分钟看这条曲线的峰值，超过 300 就该回头看池子和回收逻辑；第二，故意把帧率限到 30，看手感和 60 帧下差多少，差太多说明还有地方没乘 dt；第三，用无敌模式挂机两分钟，看敌机是不是持续在刷、分数是不是在涨，排除「刷怪器悄悄停了」这类静默失败。

这三步走下来，多数结构性问题都能提前抓到。从那以后我每次改完这类射击游戏，哪怕只动了一行参数，也强制走一遍「30 帧 + 挂机两分钟 + 看对象数峰值」，比事后靠玩家反馈定位问题省太多时间。希望帮到你。

本文还有配套的精品资源，点击获取