简介：面向 J2ME 移动游戏开发学习者与怀旧玩家的经典坦克大战项目包，定位于资源受限设备上的 Java 游戏实现与教学拆解。包内以 BattleCity 为核心，可对照可执行文件与源码理解 MIDP、CLDC、Canvas 绘图、按键事件、线程调度、碰撞检测、游戏状态机以及图像声音资源管理等关键环节。压缩包共 139 个文件，约 570KB，含 66 个 class、32 个 html API 文档、21 个 java 源码，以及 jar、jad、bat 构建脚本和 png、gif、img、snd 等素材，体量轻巧却覆盖运行、开发与文档查阅。已有 255 人学习，适合通过完整小项目拆解战场绘制、玩家与敌方坦克逻辑、资源压缩和性能优化思路；HTML 文档便于检索 MIDP API，class 与 java 源码对照可观察编译产物与类结构，地图数组、敌我坦克状态、碰撞算法和资源加载流程也能作为移动游戏入门的拆解样本。也便于在模拟器或低配设备上调试、做课程设计或二次修改，较快建立 J2ME 游戏开发的整体认识。

1. 从 J2ME 手机经典游戏资源包说起：先能跑起来再谈改法

拿到一份 J2ME 手机经典游戏资源包，很多人的第一反应是翻源码，我一般先做另一件事：在模拟器里把坦克大战跑起来，确认 JAD、JAR 和资源路径没有错位。能启动只是入场券，能改逻辑、能在低配设备上稳住帧率，才算真正落地。这份资源适合想复刻功能机时代坦克大战玩法的开发者，也适合把 J2ME 当成轻量游戏循环、瓦片地图、精灵动画练手场景的从业者。它解决的不是“写一个完整引擎”，而是把 MIDlet 生命周期、Canvas 绘制、按键缓存、精灵碰撞、关卡参数这些细碎环节串成一条能跑通的链路。下面按工程拆解、核心对象、敌方 AI、避坑排查和打包验证推进。

2. 拆开 J2ME 坦克大战工程：MIDlet 入口、画布循环与资源目录怎么对齐

资源包拿到手，先别急着改玩法。J2ME 工程最容易翻车的地方不在算法，而在入口、画布和资源目录三者的边界没有对齐：MIDlet 类名和 JAD 清单不一致，Canvas 在构造阶段做了耗时加载，图片路径大小写和打包后的结构对不上，表现就是启动黑屏、闪退或者精灵变白块。这个章节先把工程骨架拆清楚，后面改坦克大战的移动、开火和碰撞才有稳定底座。

2.1 MIDlet 与 Canvas 的启动边界

J2ME 应用的入口是 MIDlet，生命周期由 startApp、pauseApp、destroyApp 三个方法约束。常见做法是把资源加载、线程创建放到 startApp，把暂停标志置位放到 pauseApp，把线程退出和资源释放放到 destroyApp。不要在 MIDlet 构造函数里做重活，部分设备对启动阶段的类加载和内存占用很敏感，构造阶段加载大图容易直接闪退。

画布一般继承 Canvas，在 MIDlet 的 startApp 里用 Display.setCurrent 切过去。游戏画布只负责绘制和按键采集，不直接承担关卡数据解析，这样后面替换地图或调整资源时不需要动入口类。

// 文件：src/com/demo/tank/TankMidlet.java package com.demo.tank; import javax.microedition.midlet.MIDlet; import javax.microedition.lcdui.Display; public class TankMidlet extends MIDlet { private GameCanvas gameCanvas; public TankMidlet() { // 构造阶段只保留轻量对象，避免启动期加载图片和音频 gameCanvas = new GameCanvas(); } protected void startApp() { // 资源加载、游戏线程启动放在这里，入口类不负责具体玩法 gameCanvas.startGame(); Display.getDisplay(this).setCurrent(gameCanvas); } protected void pauseApp() { // 暂停标志让游戏循环主动让出 CPU，避免后台空转 gameCanvas.pauseGame(); } protected void destroyApp(boolean unconditional) { // 退出时停止线程并释放图片、声音、RMS 等资源 gameCanvas.stopGame(); } }

逻辑说明：MIDlet 只做生命周期转发，GameCanvas 内部维护线程和资源状态。参数说明：startApp里的startGame()负责启动游戏循环；pauseApp不直接杀线程，而是置暂停标志，避免恢复时重新创建线程导致状态丢失；destroyApp必须可重复调用，退出路径要能安全停止。

提示：不同设备的启动内存余量差异很大，入口类里少放静态大对象，静态图片和地图数组尽量在 startApp 之后按需加载。

2.2 游戏循环与按键状态缓存

J2ME 的 Canvas 没有桌面游戏框架那种固定刷新回调，常见做法是自己开一个线程，按固定间隔更新逻辑并调用 repaint。线程里不要做阻塞式资源读取，也不要在 paint 里改游戏状态。帧间隔用Thread.sleep控制，低配设备上宁可逻辑帧低一点，也不要让绘制线程排队。

按键处理要区分“按下一次”和“持续按住”。坦克移动需要持续按住方向键，开火需要按下一次只发一颗子弹。用两个数组分别记录当前按住状态和本帧刚按下状态，在游戏循环末尾清掉刚按下状态，能避免按键粘连和连发。

// 文件：src/com/demo/tank/GameCanvas.java package com.demo.tank; import javax.microedition.lcdui.Canvas; import javax.microedition.lcdui.Graphics; public class GameCanvas extends Canvas implements Runnable { private volatile boolean running; private volatile boolean paused; private Thread gameThread; private boolean[] keyDown = new boolean[8]; private boolean[] keyPressedOnce = new boolean[8]; public void startGame() { running = true; paused = false; gameThread = new Thread(this); gameThread.start(); } public void pauseGame() { paused = true; } public void stopGame() { running = false; paused = false; } public void run() { while (running) { long frameStart = System.currentTimeMillis(); if (!paused) { updateGame(); repaint(); } long cost = System.currentTimeMillis() - frameStart; long sleep = 40 - cost; // 约 25 帧的逻辑节奏，按设备再调 if (sleep > 0) { try { Thread.sleep(sleep); } catch (InterruptedException ignored) { } } clearPressedOnce(); } } private void updateGame() { // 这里推进坦克、子弹、敌人 AI 和碰撞检测 } private void clearPressedOnce() { for (int i = 0; i < keyPressedOnce.length; i++) { keyPressedOnce[i] = false; } } protected void keyPressed(int keyCode) { int action = getGameAction(keyCode); int index = actionToIndex(action); if (index >= 0 && !keyDown[index]) { keyDown[index] = true; keyPressedOnce[index] = true; } } protected void keyReleased(int keyCode) { int action = getGameAction(keyCode); int index = actionToIndex(action); if (index >= 0) { keyDown[index] = false; } } private int actionToIndex(int action) { if (action == UP) return 0; if (action == DOWN) return 1; if (action == LEFT) return 2; if (action == RIGHT) return 3; if (action == FIRE) return 4; return -1; } protected void paint(Graphics g) { // 绘制顺序：地图底层、坦克、子弹、特效、HUD } }

逻辑说明：游戏线程里先更新逻辑再请求重绘，按键数组只在输入回调和帧末修改。参数说明：40是目标帧间隔毫秒数，设备绘制慢时实际帧率会下降；keyPressedOnce用于开火、暂停这类单次动作；keyDown用于移动。若发现方向键斜向移动抖动，优先检查是否在同一帧里同时处理了相反方向，以及是否在 keyPressed 里直接改了坦克坐标。

2.3 资源目录与 JAD 清单对齐

J2ME 打包后，JAR 内部路径就是运行时路径，大小写敏感的设备上res/tank.png和Res/Tank.png是两回事。资源包常见结构是src放 Java 源码，res放图片和关卡文本，bin或deploy放编译产物。先统一目录，再对 JAD 清单，不要反过来。

# 在工程根目录检查资源是否会被打进 JAR find src res -type f | sort # 检查已生成 JAR 的内部结构，重点看资源路径和类路径 jar tf build/tank-demo.jar | sort # JAD 文件关键字段示例，实际值按资源包填写 cat build/tank-demo.jad

JAD 清单里至少要对齐MIDlet-1、MIDlet-Jar-URL、MIDlet-Jar-Size。MIDlet-1的类名必须和源码包名一致；MIDlet-Jar-URL是相对路径或部署路径，模拟器本地调试时保持和 JAR 同目录最省事；MIDlet-Jar-Size在部分模拟器里不校验，但部署到真实设备前要更新，否则安装器可能直接拒绝。

MIDlet-Name: TankDemo MIDlet-Vendor: DemoVendor MIDlet-1: TankMidlet, , com.demo.tank.TankMidlet MIDlet-Jar-URL: tank-demo.jar MIDlet-Jar-Size: 0

参数说明：MIDlet-1第三个字段是完整类名，不要写文件名；MIDlet-Jar-Size先用 0 占位，打包完成后替换为实际字节数；MIDlet-Name只用于展示，不要拿来当资源路径。资源目录对齐后，再改坦克大战的精灵图和关卡文件，定位问题会快很多。

3. 坦克大战的核心对象：瓦片地图、精灵与碰撞检测的落地写法

坦克大战看起来是几个方块在移动，真正落地时绕不开三件事：地图怎么表示可通行与不可通行，坦克和子弹怎么用精灵管理帧状态，碰撞按什么顺序判。顺序错了会出现子弹穿墙、坦克卡角、基地被隔山打牛。这个章节按“地图数据、对象状态、碰撞顺序”拆成可抄的写法。

3.1 瓦片地图分层与可通行标记

地图建议分两层：底层是地形图，负责绘制草地、砖墙、钢墙、水；逻辑层是可通行表，负责碰撞和 AI 采样。绘制和逻辑分开后，换贴图不会影响寻路。瓦片尺寸常见是 16 或 24 像素，坦克尺寸要能被瓦片尺寸整除，否则碰撞边界会出现半像素误差。

// 文件：src/com/demo/tank/MapData.java package com.demo.tank; public class MapData { public static final int TILE_SIZE = 16; public static final int COLS = 15; public static final int ROWS = 15; // 0 可通行，1 砖墙，2 钢墙，3 水，4 基地 public static final int[] TILE_PASSABLE = {1, 0, 0, 0, 0}; // 关卡地图：数字对应地形类型，实际资源包可按行读取 public static final int[][] LEVEL_1 = { {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2}, {2,0,0,0,1,0,0,0,0,0,1,0,0,0,2}, {2,0,2,0,1,0,2,2,2,0,1,0,2,0,2}, {2,0,2,0,1,0,0,0,0,0,1,0,2,0,2}, {2,0,0,0,0,0,1,1,1,0,0,0,0,0,2}, {2,1,1,0,2,0,0,0,0,0,2,0,1,1,2}, {2,0,0,0,2,0,1,4,1,0,2,0,0,0,2}, {2,0,1,0,0,0,1,1,1,0,0,0,1,0,2}, {2,0,1,0,2,0,0,0,0,0,2,0,1,0,2}, {2,0,0,0,2,0,1,1,1,0,2,0,0,0,2}, {2,1,1,0,0,0,0,0,0,0,0,0,1,1,2}, {2,0,0,0,1,1,1,0,1,1,1,0,0,0,2}, {2,0,2,0,0,0,0,0,0,0,0,0,2,0,2}, {2,0,0,0,1,0,0,0,0,0,1,0,0,0,2}, {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2} }; public static boolean canPass(int col, int row) { if (col < 0 || row < 0 || col >= COLS || row >= ROWS) { return false; } int tile = LEVEL_1[row][col]; return TILE_PASSABLE[tile] == 1; } }

逻辑说明：地图数组按行列存地形类型，canPass把越界直接判不可通行，避免坦克走出边界。参数说明：TILE_SIZE要和贴图裁剪尺寸一致；TILE_PASSABLE的下标对应地形类型，新增冰面、草丛时扩展数组；LEVEL_1的边界先用钢墙包住，调试期能减少大量越界问题。若要做可破坏砖墙，把砖墙单独存一层可破坏表，不要直接改静态地图数组。

3.2 坦克精灵状态机与子弹对象池

坦克精灵用帧序列做移动和开火动画，状态至少拆成停止、移动、开火、死亡。开火状态只持续几帧，不能作为移动阻塞条件。子弹不要每次开火都 new，J2ME 设备垃圾回收敏感，连续开火容易掉帧。常见做法是固定大小的子弹池，用 active 标记复用对象。

// 文件：src/com/demo/tank/BulletPool.java package com.demo.tank; public class BulletPool { public static class Bullet { public boolean active; public int x; public int y; public int dir; // 0 上，1 下，2 左，3 右 public int speed; } private Bullet[] pool; private int nextIndex; public BulletPool(int size) { pool = new Bullet[size]; for (int i = 0; i < size; i++) { pool[i] = new Bullet(); } } public Bullet fire(int x, int y, int dir, int speed) { for (int i = 0; i < pool.length; i++) { int index = (nextIndex + i) % pool.length; if (!pool[index].active) { Bullet b = pool[index]; b.active = true; b.x = x; b.y = y; b.dir = dir; b.speed = speed; nextIndex = (index + 1) % pool.length; return b; } } return null; // 池满时不发射，避免临时扩容 } public void update() { for (int i = 0; i < pool.length; i++) { Bullet b = pool[i]; if (!b.active) continue; if (b.dir == 0) b.y -= b.speed; if (b.dir == 1) b.y += b.speed; if (b.dir == 2) b.x -= b.speed; if (b.dir == 3) b.x += b.speed; if (b.x < 0 || b.y < 0 || b.x > MapData.COLS * MapData.TILE_SIZE || b.y > MapData.ROWS * MapData.TILE_SIZE) { b.active = false; } } } }

逻辑说明：子弹池按环形查找空闲槽位，池满时直接放弃发射，保证最坏情况下内存稳定。参数说明：池大小按同屏最大子弹数加余量设置，坦克大战里通常 16 到 32 足够；speed用像素/帧，低配设备上不要设太大，否则子弹会跳过薄墙；dir用整数枚举，避免字符串比较。坦克本体用 Sprite 时，帧序列按方向分组，切方向时重置帧索引，否则会出现转向后还播放上一方向动画的玄学问题。

3.3 碰撞检测顺序与边界处理

碰撞检测顺序建议固定：地图边界与瓦片、坦克与坦克、子弹与瓦片、子弹与坦克、子弹与基地。先判瓦片再判对象，能避免子弹先撞到坦克再穿墙。坦克卡角多数不是碰撞算法错，而是移动拆成 x、y 两轴后没有分别回退，斜向撞墙时只回退了一个轴。

// 文件：src/com/demo/tank/Collision.java package com.demo.tank; public class Collision { public static boolean rectHit(int ax, int ay, int aw, int ah, int bx, int by, int bw, int bh) { return ax < bx + bw && ax + aw > bx && ay < by + bh && ay + ah > by; } public static boolean tankCanMove(int x, int y, int w, int h) { int left = x / MapData.TILE_SIZE; int top = y / MapData.TILE_SIZE; int right = (x + w - 1) / MapData.TILE_SIZE; int bottom = (y + h - 1) / MapData.TILE_SIZE; for (int row = top; row <= bottom; row++) { for (int col = left; col <= right; col++) { if (!MapData.canPass(col, row)) { return false; } } } return true; } public static void moveTank(Tank tank, int dx, int dy) { // 先走 x 轴，撞了回退；再走 y 轴，撞了回退 int oldX = tank.x; tank.x += dx; if (!tankCanMove(tank.x, tank.y, tank.w, tank.h)) { tank.x = oldX; } int oldY = tank.y; tank.y += dy; if (!tankCanMove(tank.x, tank.y, tank.w, tank.h)) { tank.y = oldY; } } }

逻辑说明：tankCanMove用坦克矩形覆盖到的瓦片范围做可通行判断，moveTank分轴移动并回退，能解决大部分卡角。参数说明：w、h取坦克碰撞盒而不是贴图尺寸，贴图可以比碰撞盒大一圈；边界判断里(x + w - 1)是为了避免正好压在瓦片边界时多算一格；子弹与坦克的命中盒可以比坦克碰撞盒小 2 到 4 像素，减少“擦边算命中”的体感问题。

4. 敌方坦克 AI 与关卡节奏：随机游走不够时怎么拆有限状态机

坦克大战的敌方 AI 不需要复杂寻路，但完全随机游走会显得很笨：敌人贴着墙抖、子弹朝空地打、玩家蹲在基地旁边时敌人绕不过来。更稳的做法是有限状态机加低频地图采样，状态少、转移条件清楚，低配设备也扛得住。关卡节奏则靠参数表控制，不要把敌人数、生成间隔、开火概率散落在代码各处。

4.1 有限状态机拆巡逻、追击、开火

敌方坦克至少拆巡逻、追击、开火、死亡四个状态。巡逻阶段按当前方向前进，撞墙或定时器到期后换方向；追击阶段在玩家进入一定距离后朝玩家方向做一次方向选择；开火状态只负责冷却和发射，不阻塞移动。状态转移不要每帧都算，用 200 到 400 毫秒的决策间隔，减少抖动。

// 文件：src/com/demo/tank/EnemyTank.java package com.demo.tank; public class EnemyTank extends Tank { public static final int PATROL = 0; public static final int CHASE = 1; public static final int FIRE = 2; public static final int DEAD = 3; public int state = PATROL; private int decisionTimer; private int fireCooldown; public void update(PlayerTank player, BulletPool bullets) { if (state == DEAD) return; decisionTimer--; fireCooldown--; int distance = Math.abs(x - player.x) + Math.abs(y - player.y); if (distance < 120 && state == PATROL) { state = CHASE; decisionTimer = 12; } if (state == CHASE && decisionTimer <= 0) { chooseDirToPlayer(player); decisionTimer = 18; if (canSee(player) && fireCooldown <= 0) { state = FIRE; } } if (state == FIRE) { bullets.fire(x + w / 2, y + h / 2, dir, 4); fireCooldown = 30; state = CHASE; } if (state == PATROL) { if (decisionTimer <= 0 || blockedAhead()) { dir = (dir + 1 + randomStep()) % 4; decisionTimer = 30; } } moveByDir(); } private void chooseDirToPlayer(PlayerTank player) { int dx = player.x - x; int dy = player.y - y; if (Math.abs(dx) > Math.abs(dy)) { dir = dx > 0 ? 3 : 2; } else { dir = dy > 0 ? 1 : 0; } } private boolean canSee(PlayerTank player) { // 简化版视线：同轴且中间瓦片可通行，实际可按步长采样 return x / MapData.TILE_SIZE == player.x / MapData.TILE_SIZE || y / MapData.TILE_SIZE == player.y / MapData.TILE_SIZE; } private boolean blockedAhead() { int nx = x, ny = y; if (dir == 0) ny -= 2; if (dir == 1) ny += 2; if (dir == 2) nx -= 2; if (dir == 3) nx += 2; return !Collision.tankCanMove(nx, ny, w, h); } private int randomStep() { return (int) (System.currentTimeMillis() % 2); } private void moveByDir() { int dx = 0, dy = 0; if (dir == 0) dy = -2; if (dir == 1) dy = 2; if (dir == 2) dx = -2; if (dir == 3) dx = 2; Collision.moveTank(this, dx, dy); } }

逻辑说明：状态机用计时器控制决策频率，FIRE 只持续一帧就回到 CHASE，避免敌人站着不动。参数说明：distance < 120是追击触发距离，按地图尺寸调整；decisionTimer单位是帧，不是毫秒，帧率变化时要同步改；fireCooldown控制开火密度，太小会让玩家没有走位空间。randomStep只是示例，实际可以用轻量伪随机，但不要每帧调用耗时的随机源。

4.2 寻路与地图采样

坦克大战的地图格子不大，完整 BFS 每帧跑会浪费 CPU。常见做法是低频采样：敌人每隔几帧检查前方、左右三个方向的可通行性，选一个离玩家更近的方向；追击阶段只做轴对齐选择，不做全局最短路径。这样 AI 看起来有目的性，又不会因为寻路把帧率拖垮。

// 文件：src/com/demo/tank/EnemyPath.java package com.demo.tank; public class EnemyPath { public static int chooseDirection(EnemyTank enemy, PlayerTank player) { int bestDir = enemy.dir; int bestScore = Integer.MIN_VALUE; int[] dirs = {0, 1, 2, 3}; for (int i = 0; i < dirs.length; i++) { int dir = dirs[i]; int nx = enemy.x, ny = enemy.y; if (dir == 0) ny -= MapData.TILE_SIZE; if (dir == 1) ny += MapData.TILE_SIZE; if (dir == 2) nx -= MapData.TILE_SIZE; if (dir == 3) nx += MapData.TILE_SIZE; if (!Collision.tankCanMove(nx, ny, enemy.w, enemy.h)) { continue; } int dist = Math.abs(nx - player.x) + Math.abs(ny - player.y); int score = -dist + (dir == enemy.dir ? 2 : 0); if (score > bestScore) { bestScore = score; bestDir = dir; } } return bestDir; } }

逻辑说明：只对四个方向做一格采样，用曼哈顿距离打分，保持当前方向给一点惯性分。参数说明：采样步长取一个瓦片，避免敌人贴着墙反复横跳；惯性分2不要太大，否则敌人会固执地撞墙；如果地图有水域，tankCanMove已经处理不可通行，不需要在 AI 里重复判断。

4.3 关卡参数表与难度曲线

关卡难度不要靠散落的魔法数字。把敌人数、同屏上限、生成间隔、敌人速度、子弹速度、开火概率、AI 决策间隔集中到参数表，调关卡时只改表。下面是一份按关卡递增的参数示例，数值按资源包实际手感再调。

// 文件：src/com/demo/tank/LevelConfig.java package com.demo.tank; public class LevelConfig { public final int enemyTotal; public final int maxOnScreen; public final int spawnInterval; public final int enemySpeed; public final int bulletSpeed; public final int fireCooldown; public LevelConfig(int level) { if (level <= 1) { enemyTotal = 8; maxOnScreen = 2; spawnInterval = 90; enemySpeed = 1; bulletSpeed = 3; fireCooldown = 40; } else if (level <= 3) { enemyTotal = 12; maxOnScreen = 3; spawnInterval = 70; enemySpeed = 1; bulletSpeed = 4; fireCooldown = 30; } else { enemyTotal = 16; maxOnScreen = 4; spawnInterval = 50; enemySpeed = 2; bulletSpeed = 4; fireCooldown = 22; } } }

逻辑说明：构造函数按关卡区间返回一组参数，游戏循环只读配置，不写死数值。参数说明：maxOnScreen受设备内存和绘制量限制，低配设备上同屏 4 个坦克加子弹已经接近上限；spawnInterval用帧计数，切换帧率时要换算；enemySpeed不要超过瓦片尺寸的一半，否则容易穿墙。

5. 避坑排查：J2ME 坦克大战在模拟器与老设备上的五类翻车

J2ME 的坑很分散：模拟器能跑不代表真机能跑，真机能跑不代表按键手感对，按键对了又可能声音卡、存档丢。下面五类问题是我在资源包里最常遇到的翻车点，按现象、原因、解决三段处理。排查时先固定一个能复现的模拟配置，再换另一档配置对比，不要一次改五个地方。

5.1 启动黑屏或闪退：先查 JAD 与 MIDlet-1

现象：模拟器里点启动后黑屏几秒退出，或者直接提示应用无法安装。原因多数是 JAD 里的MIDlet-1类名和实际包名不一致，或者 JAR 内没有对应的 class；也有资源图片路径大小写不一致，启动加载时抛异常。解决顺序是先看 JAD 清单，再看 JAR 内部结构，最后看启动日志。用jar tf确认类文件存在，用unzip -l或解压工具确认资源路径。

# 确认 JAR 内类文件和资源路径 jar tf build/tank-demo.jar | grep -E "TankMidlet|res/" # 确认 JAD 中 MIDlet-1 的完整类名 grep "MIDlet-1" build/tank-demo.jad

逻辑说明：先排除清单与包结构问题，再查资源加载。参数说明：MIDlet-1第三个字段必须是com.demo.tank.TankMidlet这种完整类名；JAR 内路径不要带绝对路径；资源文件名不要用中文和空格，老设备文件系统容易出问题。

5.2 按键粘连与斜向移动抖动

现象：松手后坦克还在走，或者斜向按两个方向时坦克抖动、卡住。原因通常是 keyPressed 里直接改了坐标，keyReleased 没有清状态，或者同一帧同时处理了相反方向。解决是把输入采集和移动更新分开：keyPressed 只置位，游戏循环里根据 keyDown 数组决定移动向量，遇到相反方向同时按下时给一个优先级或直接归零。

// 在 updateGame 中统一处理移动，不在按键回调里改坐标 int dx = 0, dy = 0; if (keyDown[0] && !keyDown[1]) dy = -speed; if (keyDown[1] && !keyDown[0]) dy = speed; if (keyDown[2] && !keyDown[3]) dx = -speed; if (keyDown[3] && !keyDown[2]) dx = speed; if (dx != 0 || dy != 0) { Collision.moveTank(player, dx, dy); }

逻辑说明：相反方向同时按下时直接不移动，避免抖动。参数说明：speed取 1 到 2 像素/帧，低配设备上不要靠高速度补帧；如果设备方向键没有游戏动作映射，先用原始键码做一次映射表，再进逻辑。

5.3 精灵闪烁与画面撕裂

现象：坦克移动时闪烁，或者地图和精灵交替出现。原因常见是每帧全屏重绘且绘制顺序不稳定，或者在 paint 里加载图片。解决是固定绘制顺序，先把地图画到缓冲 Image，再画坦克、子弹、HUD；paint 里只做 drawImage 和 fillRect，不做资源解码。

// paint 中固定顺序，避免同一帧内多次创建 Image protected void paint(Graphics g) { g.drawImage(backgroundBuffer, 0, 0, Graphics.TOP | Graphics.LEFT); drawTanks(g); drawBullets(g); drawHud(g); }

逻辑说明：背景缓冲只在关卡加载时生成一次，每帧复用。参数说明：缓冲 Image 尺寸取画布宽高，不要超过设备可分配内存；部分设备对drawImage的锚点支持有差异，统一用左上角锚点；如果闪烁只在某台设备出现，优先降低重绘频率，而不是加更多绘制调用。

5.4 声音资源不播放或卡顿

现象：背景音乐播到一半卡住，或者开火音效把移动音效顶掉。原因通常是音频文件过大、解码占用高，或者同时创建多个播放器。解决是短音效预加载、单通道复用，背景音乐和音效分开管理；资源格式按资源包目标设备支持的格式选，不要直接在低配模拟配置上放大文件。

// 短音效复用同一个 Player，播放前先 stop 再播放 if (firePlayer != null) { try { firePlayer.stop(); firePlayer.play(); } catch (Exception ignored) { } }

逻辑说明：开火音效高频触发，复用播放器比每次 new 更稳。参数说明：音效文件尽量短，采样率不要超过目标设备常见能力；异常要吞掉并记录状态，不能让声音失败把游戏循环打断。

5.5 存档丢失与 RMS 容量越界

现象：退出游戏后最高分没了，或者写入存档时抛异常。原因常见是 RecordStore 没关闭、写入超过单条记录上限，或者用固定 recordId 覆盖时没有判断是否存在。解决是打开、写入、关闭成对出现；存档用版本号加字段，读取失败时回退默认值。

// 存档写入：打开后必须在 finally 中关闭 RecordStore rs = null; try { rs = RecordStore.openRecordStore("tank_save", true); byte[] data = encodeSave(highScore, level); if (rs.getNumRecords() == 0) { rs.addRecord(data, 0, data.length); } else { rs.setRecord(1, data, 0, data.length); } } catch (Exception e) { // 存档失败不阻塞游戏，记录状态即可 } finally { if (rs != null) { try { rs.closeRecordStore(); } catch (Exception ignored) {} } }

逻辑说明：用固定记录号 1 存单条存档，读写都包在异常处理里。参数说明：encodeSave里把最高分和关卡写成固定长度字节，读的时候按同样长度解；RecordStore 名称不要随版本改，否则老存档读不到；容量越界时优先删旧记录或压缩字段，不要盲目扩容。

6. 打包与性能验证：让坦克大战在低配 J2ME 设备上稳住帧率

最后一章落到打包和验证。资源包能跑之后，真正决定能不能交付的是 JAR/JAD 对齐、预审核结果和低配设备上的帧率。常见做法是先编译、再预审核、再打包，每一步都留一个可回退的产物；不要在一个命令里把编译、混淆、打包全串完，翻车时找不到是哪一步坏了。

6.1 预审核与 JAR/JAD 对齐的打包命令

# 1. 按目标 CLDC 配置编译，输出到 classes javac -source 1.3 -target 1.3 \ -bootclasspath "$CLDC_API:$MIDP_API" \ -d build/classes $(find src -name "*.java") # 2. 预审核，输出到 preverified preverify -classpath "$CLDC_API:$MIDP_API" \ -d build/preverified build/classes # 3. 复制资源并打包 cp -r res/* build/preverified/ jar cf build/tank-demo.jar -C build/preverified . # 4. 更新 JAD 中的 JAR 大小 SIZE=$(wc -c < build/tank-demo.jar) sed -i "s/^MIDlet-Jar-Size:.*/MIDlet-Jar-Size: $SIZE/" build/tank-demo.jad

逻辑说明：编译产物先预审核再打包，资源在打包前复制到输出目录。参数说明：CLDC_API、MIDP_API指向工具包提供的 API 路径，按实际环境替换；-source/-target按资源包目标配置调整；sed在部分环境写法不同，可以手工改 JAD。预审核报错时先看类名和异常栈，不要先怀疑资源。

6.2 低配设备帧率与内存验证表

我一般会在低配模拟配置上连续跑三关，再开一局连续开火，观察帧率和内存。若某一关开始卡，先看敌人同屏上限和子弹池大小，再看 AI 决策间隔，最后才动绘制。

6.3 一个可复用的发布前检查习惯

发布前我会固定做一遍“启动、按键、精灵、声音、存档”五项检查，每项只改一个变量做对比。那次血泪经验是改了碰撞顺序又换了资源路径，结果黑屏排查了半天，最后发现是 JAD 类名没同步。从那以后我每次改坦克大战的碰撞顺序，都先把启动、按键、精灵、声音、存档这五项在低配模拟配置上走一遍，再谈打包。希望帮到你。

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