update：优化赏金赛记录

update：优化个人训练
update：优化新手教程
2026-08-31 16:14:57 +08:00 · 2026-08-28 11:12:28 +08:00 · 2026-08-27 17:24:25 +08:00 · 2026-08-26 17:23:36 +08:00 · 2026-08-26 15:36:45 +08:00 · 2026-08-26 15:23:02 +08:00
199 changed files with 19471 additions and 1469 deletions
@@ -1,3 +1,9 @@
 {
-    "i18n-ally.localesPaths": []
-}
+  "i18n-ally.localesPaths": [],
+  "files.watcherExclude": {
+    "**/dist/**": true
+  },
+  "search.exclude": {
+    "**/dist/**": true
+  }
+}
@@ -264,6 +264,7 @@ AI 应主动：
 * 少解释
 * 优先 patch
 * 优先 diff
+* 写好中文注释

 除非用户明确要求：
 否则不要输出完整项目。
@@ -113,4 +113,134 @@ git push origin test
 2. **每次合并前先拉取最新代码**，避免覆盖他人改动
 3. **体验版发布前确认代码已提交**，避免遗漏
 4. **开发分支命名建议**：`feature/姓名-功能名`，如 `feature/zhangsan-login`
-5. **删除已合并的开发分支**：`git branch -d feature/your-name-work`
+5. **删除已合并的开发分支**：`git branch -d feature/your-name-work`
+
+---
+
+## 六、比赛服 Proto 更新流程
+
+### 1. 新开发人员快速接手
+
+首次拉取项目后，先安装依赖并确认当前协议与运行时解码器一致：
+
+```bash
+npm install
+npm run proto:check
+npm run build
+```
+
+如果 `proto:check` 提示协议不同步，先执行 `npm run proto:generate`，不要直接修改生成区块。
+
+### 2. 相关文件职责
+
+| 文件 | 职责 | 修改规则 |
+|------|------|----------|
+| `src/utils/match.min.js` | 后端比赛服协议描述，是生成字段表的输入文件 | 后端协议更新时整体替换；禁止在小程序运行时代码中导入 |
+| `scripts/generate-match-schema.mjs` | 解析协议、校验字段并生成运行时字段表 | 只有新增通用协议能力时才修改 |
+| `src/utils/matchProtocol.js` | 小程序实际使用的 protobuf 编解码器 | `<match-schema-generated>` 标记区间内禁止手动修改 |
+| `src/matchWebsocket.js` | 服务端消息路由、ACK 和业务事件分发 | 新增消息业务行为时人工接入 |
+| `src/utils/matchAdapter.js` | 将解码结果从 snake_case 统一转换为 camelCase | 页面继续使用适配后的字段名 |
+
+`match.min.js` 不是小程序运行时解码器。运行时仍使用 `protobufjs/minimal.js` 的 `Reader/Writer`，`int64` 字段统一保留为字符串，避免大整数精度丢失。
+
+### 3. 日常协议更新步骤
+
+```text
+替换 src/utils/match.min.js
+        ↓
+执行 npm run proto:update
+        ↓
+检查生成差异和业务接入范围
+        ↓
+执行 git diff --check
+        ↓
+微信开发者工具检查包体并上传
+```
+
+具体操作：
+
+1. 从后端获取最新的 `match.min.js`，整体覆盖 `src/utils/match.min.js`。
+2. 执行推荐命令：
+
+```bash
+npm run proto:update
+```
+
+3. 该命令会依次完成：
+   - 解析 `match.min.js`
+   - 更新 `matchProtocol.js` 内的生成区块
+   - 校验生成区块与协议源文件一致
+   - 执行微信小程序正式构建
+4. 检查 Git 差异。普通字段更新通常只应涉及：
+   - `src/utils/match.min.js`
+   - `src/utils/matchProtocol.js` 的生成区块
+5. 如果新增了消息业务行为，再单独检查 `src/matchWebsocket.js`、页面或组件的接入改动。
+6. 执行空白和换行检查：
+
+```bash
+git diff --check
+```
+
+7. 打开微信开发者工具，导入 `dist/build/mp-weixin`，检查代码依赖分析和主包体积后再上传。
+
+### 4. Proto 命令说明
+
+| 命令 | 用途 | 是否修改文件 |
+|------|------|--------------|
+| `npm run proto:generate` | 根据 `match.min.js` 更新生成区块 | 是 |
+| `npm run proto:check` | 检查生成区块是否与协议同步 | 否 |
+| `npm run proto:update` | 执行生成，然后运行正式构建 | 是，日常更新推荐使用 |
+| `npm run dev` | 启动开发构建，启动前自动执行 `proto:check` | 协议不同步时直接中止 |
+| `npm run build` | 执行正式构建，构建前自动执行 `proto:check` | 协议不同步时直接中止 |
+
+`npm run dev` 和 `npm run build` 只负责检查，不会自动改写协议；发现不同步时应执行 `npm run proto:generate` 或 `npm run proto:update`。
+
+### 5. 自动生成与人工接入边界
+
+以下内容由生成器自动处理：
+
+- 服务端和客户端消息枚举
+- 普通 scalar 字段
+- 嵌套 message
+- repeated message
+- 当前解码器支持的 map
+- snake_case 字段名和 oneof 兼容信息
+
+以下情况仍需人工处理：
+
+- **新增服务端消息类型**：枚举会自动生成，但 `matchWebsocket.js` 的路由、ACK、音频或页面事件仍需接入。
+- **新增客户端指令**：枚举会自动生成，但发送函数、字段编码和业务调用入口仍需接入。
+- **修改既有字段编号或类型**：属于协议兼容性变更，必须先与后端确认，不能只看构建是否通过。
+- **新增解码器不支持的类型**：生成器会直接报错，需要同时扩展生成器和 `matchProtocol.js` 的通用解码能力。
+
+当前生成器会拒绝不支持的 scalar、map key、字段规则以及 packed scalar repeated，避免继续构建后静默丢字段。
+
+### 6. 常见报错处理
+
+| 报错或现象 | 原因 | 处理方式 |
+|------------|------|----------|
+| 生成区块与 `match.min.js` 不同步 | 替换协议后没有重新生成 | 执行 `npm run proto:update` |
+| 找不到 `Root.create(...)` | 后端提供的文件格式发生变化或文件不完整 | 停止更新，确认协议文件来源和生成格式 |
+| 使用了不支持的类型、规则或 map key | 新协议超出当前通用解码器能力 | 不要手补生成区块，先扩展生成器和解码器并补充验证 |
+| packed scalar repeated 不支持 | protobuf 默认可能使用 packed 编码，当前通用解码器未覆盖 | 增加 packed 解码能力后再重新生成 |
+| `matchProtocol.js` 缺少生成区块标记 | 标记被误删或生成区块被手改 | 恢复 `<match-schema-generated>` 标记，重新执行生成 |
+| 协议生成成功但构建失败 | 问题位于项目构建或业务代码，不是字段表同步 | 保留生成结果，按构建错误继续定位 |
+
+### 7. 禁止事项与验收清单
+
+禁止：
+
+- 禁止在运行时代码中导入 `match.min.js`。
+- 禁止手动修改 `<match-schema-generated>` 与 `</match-schema-generated>` 之间的内容。
+- 禁止绕过 `proto:check` 后直接上传。
+- 禁止把 `int64` 字段直接转换为普通 `Number`。
+- 禁止把“枚举已经生成”等同于“业务消息已经完成接入”。
+
+每次协议更新至少确认：
+
+1. `npm run proto:check` 通过。
+2. `npm run build` 通过，或直接确认 `npm run proto:update` 已完整通过。
+3. `git diff --check` 通过。
+4. 生成区块之外没有意外改动。
+5. 新消息已完成必要的 WebSocket 路由和页面验证。
+6. 微信开发者工具中的主包、分包体积符合上传限制。
@@ -12,5 +12,6 @@
  },
  "vueCompilerOptions": {
    "plugins": ["@uni-helper/uni-types/volar-plugin"]
-  }
+  },
+  "exclude": ["node_modules", "dist"]
 }
@@ -26,6 +26,8 @@
        "@dcloudio/uni-quickapp-webview": "3.0.0-4060620250520001",
        "@dcloudio/uni-ui": "^1.5.11",
        "pinia": "2.0.36",
+        "pinia-plugin-persistedstate": "3.2.1",
+        "protobufjs": "^8.7.0",
        "vue": "^3.4.21",
        "vue-i18n": "^9.1.9"
      },
@@ -2422,6 +2424,70 @@
        "vite": "^5.2.8"
      }
    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.20.2.tgz",
+      "integrity": "sha512-D+EBOJHXdNZcLJRBkhENNG8Wji2kgc9AZ9KiPr1JuZjsNtyHzrsfLRrY0tk2H2aoFu6RANO1y1iPPUCDYWkb5g==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.20.2.tgz",
+      "integrity": "sha512-t98Ra6pw2VaDhqNWO2Oph2LXbz/EJcnLmKLGBJwEwXX/JAN83Fym1rU8l0JUWK6HkIbWONCSSatf4sf2NBRx/w==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.20.2.tgz",
+      "integrity": "sha512-mRzjLacRtl/tWU0SvD8lUEwb61yP9cqQo6noDZP/O8VkwafSYwZ4yWy24kan8jE/IMERpYncRt2dw438LP3Xmg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.20.2.tgz",
+      "integrity": "sha512-btzExgV+/lMGDDa194CcUQm53ncxzeBrWJcncOBxuC6ndBkKxnHdFJn86mCIgTELsooUmwUm9FkhSp5HYu00Rg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
    "node_modules/@esbuild/darwin-arm64": {
      "version": "0.20.2",
      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.20.2.tgz",
@@ -2438,6 +2504,294 @@
        "node": ">=12"
      }
    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.20.2.tgz",
+      "integrity": "sha512-tBcXp9KNphnNH0dfhv8KYkZhjc+H3XBkF5DKtswJblV7KlT9EI2+jeA8DgBjp908WEuYll6pF+UStUCfEpdysA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.20.2.tgz",
+      "integrity": "sha512-d3qI41G4SuLiCGCFGUrKsSeTXyWG6yem1KcGZVS+3FYlYhtNoNgYrWcvkOoaqMhwXSMrZRl69ArHsGJ9mYdbbw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.20.2.tgz",
+      "integrity": "sha512-d+DipyvHRuqEeM5zDivKV1KuXn9WeRX6vqSqIDgwIfPQtwMP4jaDsQsDncjTDDsExT4lR/91OLjRo8bmC1e+Cw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.20.2.tgz",
+      "integrity": "sha512-VhLPeR8HTMPccbuWWcEUD1Az68TqaTYyj6nfE4QByZIQEQVWBB8vup8PpR7y1QHL3CpcF6xd5WVBU/+SBEvGTg==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.20.2.tgz",
+      "integrity": "sha512-9pb6rBjGvTFNira2FLIWqDk/uaf42sSyLE8j1rnUpuzsODBq7FvpwHYZxQ/It/8b+QOS1RYfqgGFNLRI+qlq2A==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.20.2.tgz",
+      "integrity": "sha512-o10utieEkNPFDZFQm9CoP7Tvb33UutoJqg3qKf1PWVeeJhJw0Q347PxMvBgVVFgouYLGIhFYG0UGdBumROyiig==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.20.2.tgz",
+      "integrity": "sha512-PR7sp6R/UC4CFVomVINKJ80pMFlfDfMQMYynX7t1tNTeivQ6XdX5r2XovMmha/VjR1YN/HgHWsVcTRIMkymrgQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.20.2.tgz",
+      "integrity": "sha512-4BlTqeutE/KnOiTG5Y6Sb/Hw6hsBOZapOVF6njAESHInhlQAghVVZL1ZpIctBOoTFbQyGW+LsVYZ8lSSB3wkjA==",
+      "cpu": [
+        "mips64el"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.20.2.tgz",
+      "integrity": "sha512-rD3KsaDprDcfajSKdn25ooz5J5/fWBylaaXkuotBDGnMnDP1Uv5DLAN/45qfnf3JDYyJv/ytGHQaziHUdyzaAg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.20.2.tgz",
+      "integrity": "sha512-snwmBKacKmwTMmhLlz/3aH1Q9T8v45bKYGE3j26TsaOVtjIag4wLfWSiZykXzXuE1kbCE+zJRmwp+ZbIHinnVg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.20.2.tgz",
+      "integrity": "sha512-wcWISOobRWNm3cezm5HOZcYz1sKoHLd8VL1dl309DiixxVFoFe/o8HnwuIwn6sXre88Nwj+VwZUvJf4AFxkyrQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.20.2.tgz",
+      "integrity": "sha512-1MdwI6OOTsfQfek8sLwgyjOXAu+wKhLEoaOLTjbijk6E2WONYpH9ZU2mNtR+lZ2B4uwr+usqGuVfFT9tMtGvGw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.20.2.tgz",
+      "integrity": "sha512-K8/DhBxcVQkzYc43yJXDSyjlFeHQJBiowJ0uVL6Tor3jGQfSGHNNJcWxNbOI8v5k82prYqzPuwkzHt3J1T1iZQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.20.2.tgz",
+      "integrity": "sha512-eMpKlV0SThJmmJgiVyN9jTPJ2VBPquf6Kt/nAoo6DgHAoN57K15ZghiHaMvqjCye/uU4X5u3YSMgVBI1h3vKrQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.20.2.tgz",
+      "integrity": "sha512-2UyFtRC6cXLyejf/YEld4Hajo7UHILetzE1vsRcGL3earZEW77JxrFjH4Ez2qaTiEfMgAXxfAZCm1fvM/G/o8w==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.20.2.tgz",
+      "integrity": "sha512-GRibxoawM9ZCnDxnP3usoUDO9vUkpAxIIZ6GQI+IlVmr5kP3zUq+l17xELTHMWTWzjxa2guPNyrpq1GWmPvcGQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.20.2.tgz",
+      "integrity": "sha512-HfLOfn9YWmkSKRQqovpnITazdtquEW8/SoHW7pWpuEeguaZI4QnCRW6b+oZTztdBnZOS2hqJ6im/D5cPzBTTlQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.20.2.tgz",
+      "integrity": "sha512-N49X4lJX27+l9jbLKSqZ6bKNjzQvHaT8IIFUy+YIqmXQdjYCToGWwOItDrfby14c78aDd5NHQl29xingXfCdLQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
    "node_modules/@intlify/core-base": {
      "version": "9.1.9",
      "resolved": "https://registry.npmjs.org/@intlify/core-base/-/core-base-9.1.9.tgz",
@@ -3424,6 +3778,32 @@
        }
      }
    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.39.0.tgz",
+      "integrity": "sha512-lGVys55Qb00Wvh8DMAocp5kIcaNzEFTmGhfFd88LfaogYTRKrdxgtlO5H6S49v2Nd8R2C6wLOal0qv6/kCkOwA==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.39.0.tgz",
+      "integrity": "sha512-It9+M1zE31KWfqh/0cJLrrsCPiF72PoJjIChLX+rEcujVRCb4NLQ5QzFkzIZW8Kn8FTbvGQBY5TkKBau3S8cCQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
    "node_modules/@rollup/rollup-darwin-arm64": {
      "version": "4.39.0",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.39.0.tgz",
@@ -3437,6 +3817,227 @@
        "darwin"
      ]
    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.39.0.tgz",
+      "integrity": "sha512-mKXpNZLvtEbgu6WCkNij7CGycdw9cJi2k9v0noMb++Vab12GZjFgUXD69ilAbBh034Zwn95c2PNSz9xM7KYEAQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.39.0.tgz",
+      "integrity": "sha512-jivRRlh2Lod/KvDZx2zUR+I4iBfHcu2V/BA2vasUtdtTN2Uk3jfcZczLa81ESHZHPHy4ih3T/W5rPFZ/hX7RtQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.39.0.tgz",
+      "integrity": "sha512-8RXIWvYIRK9nO+bhVz8DwLBepcptw633gv/QT4015CpJ0Ht8punmoHU/DuEd3iw9Hr8UwUV+t+VNNuZIWYeY7Q==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.39.0.tgz",
+      "integrity": "sha512-mz5POx5Zu58f2xAG5RaRRhp3IZDK7zXGk5sdEDj4o96HeaXhlUwmLFzNlc4hCQi5sGdR12VDgEUqVSHer0lI9g==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.39.0.tgz",
+      "integrity": "sha512-+YDwhM6gUAyakl0CD+bMFpdmwIoRDzZYaTWV3SDRBGkMU/VpIBYXXEvkEcTagw/7VVkL2vA29zU4UVy1mP0/Yw==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.39.0.tgz",
+      "integrity": "sha512-EKf7iF7aK36eEChvlgxGnk7pdJfzfQbNvGV/+l98iiMwU23MwvmV0Ty3pJ0p5WQfm3JRHOytSIqD9LB7Bq7xdQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.39.0.tgz",
+      "integrity": "sha512-vYanR6MtqC7Z2SNr8gzVnzUul09Wi1kZqJaek3KcIlI/wq5Xtq4ZPIZ0Mr/st/sv/NnaPwy/D4yXg5x0B3aUUA==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loongarch64-gnu": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.39.0.tgz",
+      "integrity": "sha512-NMRUT40+h0FBa5fb+cpxtZoGAggRem16ocVKIv5gDB5uLDgBIwrIsXlGqYbLwW8YyO3WVTk1FkFDjMETYlDqiw==",
+      "cpu": [
+        "loong64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-powerpc64le-gnu": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.39.0.tgz",
+      "integrity": "sha512-0pCNnmxgduJ3YRt+D+kJ6Ai/r+TaePu9ZLENl+ZDV/CdVczXl95CbIiwwswu4L+K7uOIGf6tMo2vm8uadRaICQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.39.0.tgz",
+      "integrity": "sha512-t7j5Zhr7S4bBtksT73bO6c3Qa2AV/HqiGlj9+KB3gNF5upcVkx+HLgxTm8DK4OkzsOYqbdqbLKwvGMhylJCPhQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.39.0.tgz",
+      "integrity": "sha512-m6cwI86IvQ7M93MQ2RF5SP8tUjD39Y7rjb1qjHgYh28uAPVU8+k/xYWvxRO3/tBN2pZkSMa5RjnPuUIbrwVxeA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.39.0.tgz",
+      "integrity": "sha512-iRDJd2ebMunnk2rsSBYlsptCyuINvxUfGwOUldjv5M4tpa93K8tFMeYGpNk2+Nxl+OBJnBzy2/JCscGeO507kA==",
+      "cpu": [
+        "s390x"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.39.0.tgz",
+      "integrity": "sha512-t9jqYw27R6Lx0XKfEFe5vUeEJ5pF3SGIM6gTfONSMb7DuG6z6wfj2yjcoZxHg129veTqU7+wOhY6GX8wmf90dA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.39.0.tgz",
+      "integrity": "sha512-ThFdkrFDP55AIsIZDKSBWEt/JcWlCzydbZHinZ0F/r1h83qbGeenCt/G/wG2O0reuENDD2tawfAj2s8VK7Bugg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.39.0.tgz",
+      "integrity": "sha512-jDrLm6yUtbOg2TYB3sBF3acUnAwsIksEYjLeHL+TJv9jg+TmTwdyjnDex27jqEMakNKf3RwwPahDIt7QXCSqRQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.39.0.tgz",
+      "integrity": "sha512-6w9uMuza+LbLCVoNKL5FSLE7yvYkq9laSd09bwS0tMjkwXrmib/4KmoJcrKhLWHvw19mwU+33ndC69T7weNNjQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.39.0.tgz",
+      "integrity": "sha512-yAkUOkIKZlK5dl7u6dg897doBgLXmUHhIINM2c+sND3DZwnrdQkkSiDh7N75Ll4mM4dxSkYfXqU9fW3lLkMFug==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
    "node_modules/@sinonjs/commons": {
      "version": "1.8.6",
      "resolved": "https://registry.npmjs.org/@sinonjs/commons/-/commons-1.8.6.tgz",
@@ -7535,6 +8136,12 @@
      "dev": true,
      "license": "MIT"
    },
+    "node_modules/long": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz",
+      "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==",
+      "license": "Apache-2.0"
+    },
    "node_modules/lru-cache": {
      "version": "5.1.1",
      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
@@ -8222,6 +8829,15 @@
        }
      }
    },
+    "node_modules/pinia-plugin-persistedstate": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/pinia-plugin-persistedstate/-/pinia-plugin-persistedstate-3.2.1.tgz",
+      "integrity": "sha512-MK++8LRUsGF7r45PjBFES82ISnPzyO6IZx3CH5vyPseFLZCk1g2kgx6l/nW8pEBKxxd4do0P6bJw+mUSZIEZUQ==",
+      "license": "MIT",
+      "peerDependencies": {
+        "pinia": "^2.0.0"
+      }
+    },
    "node_modules/pirates": {
      "version": "4.0.7",
      "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz",
@@ -8530,6 +9146,18 @@
        "node": ">= 6"
      }
    },
+    "node_modules/protobufjs": {
+      "version": "8.7.0",
+      "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-8.7.0.tgz",
+      "integrity": "sha512-uu52JNxLh3vsL7tXU/h0gDaywufvuUCTbGSi0NKQKBZ2ZopkmrWQJSQO/EFqzu/5YhiwgVM8rq/a/iVpx4eZ0g==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "long": "^5.3.2"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
    "node_modules/proxy-addr": {
      "version": "2.0.7",
      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
@@ -3,7 +3,12 @@
  "version": "0.1.0",
  "private": true,
  "scripts": {
+    "proto:generate": "node scripts/generate-match-schema.mjs",
+    "proto:check": "node scripts/generate-match-schema.mjs --check",
+    "proto:update": "npm run proto:generate && npm run build",
+    "predev": "npm run proto:check",
    "dev": "uni -p mp-weixin",
+    "prebuild": "npm run proto:check",
    "build": "uni build -p mp-weixin"
  },
  "dependencies": {
@@ -26,6 +31,7 @@
    "@dcloudio/uni-ui": "^1.5.11",
    "pinia": "2.0.36",
    "pinia-plugin-persistedstate": "3.2.1",
+    "protobufjs": "^8.7.0",
    "vue": "^3.4.21",
    "vue-i18n": "^9.1.9"
  },
@@ -3,7 +3,248 @@
  "compileType": "miniprogram",
  "libVersion": "3.7.7",
  "packOptions": {
-    "ignore": [],
+    "ignore": [
+      {
+        "type": "file",
+        "value": "static/common/dialog-light.png"
+      },
+      {
+        "type": "file",
+        "value": "static/common/dialog-bg.png"
+      },
+      {
+        "type": "file",
+        "value": "static/common/dialog-icon.png"
+      },
+      {
+        "type": "file",
+        "value": "static/prompt-bg-square.png"
+      },
+      {
+        "type": "file",
+        "value": "static/coach-comment.png"
+      },
+      {
+        "type": "file",
+        "value": "static/screen-hint-bg.png"
+      },
+      {
+        "type": "file",
+        "value": "static/red-team-win.png"
+      },
+      {
+        "type": "file",
+        "value": "static/blue-team-win.png"
+      },
+      {
+        "type": "file",
+        "value": "static/my-grow.png"
+      },
+      {
+        "type": "file",
+        "value": "static/gold-shining.png"
+      },
+      {
+        "type": "file",
+        "value": "static/bow-target.png"
+      },
+      {
+        "type": "file",
+        "value": "static/matching-bg.png"
+      },
+      {
+        "type": "file",
+        "value": "static/versus.png"
+      },
+      {
+        "type": "file",
+        "value": "static/point-champion.png"
+      },
+      {
+        "type": "file",
+        "value": "static/my-practise.png"
+      },
+      {
+        "type": "file",
+        "value": "static/shining-bg.png"
+      },
+      {
+        "type": "file",
+        "value": "static/donate.png"
+      },
+      {
+        "type": "file",
+        "value": "static/friend-battle.png"
+      },
+      {
+        "type": "file",
+        "value": "static/user-upgrade.png"
+      },
+      {
+        "type": "file",
+        "value": "static/finish-frame.png"
+      },
+      {
+        "type": "file",
+        "value": "static/vip/svip-jian.png"
+      },
+      {
+        "type": "file",
+        "value": "static/battle-header.png"
+      },
+      {
+        "type": "file",
+        "value": "static/battle-header-melee.png"
+      },
+      {
+        "type": "file",
+        "value": "static/player-bg.png"
+      },
+      {
+        "type": "file",
+        "value": "static/mvp-blue.png"
+      },
+      {
+        "type": "file",
+        "value": "static/finish-tip.png"
+      },
+      {
+        "type": "file",
+        "value": "static/2unfinish-tip.png"
+      },
+      {
+        "type": "file",
+        "value": "static/have-no-device.png"
+      },
+      {
+        "type": "file",
+        "value": "static/device-icon.png"
+      },
+      {
+        "type": "file",
+        "value": "static/unfinish-tip.png"
+      },
+      {
+        "type": "file",
+        "value": "static/test-tip.png"
+      },
+      {
+        "type": "file",
+        "value": "static/mvp-red.png"
+      },
+      {
+        "type": "file",
+        "value": "static/vip/svip-lie.png"
+      },
+      {
+        "type": "file",
+        "value": "static/mvp-tip.png"
+      },
+      {
+        "type": "file",
+        "value": "static/rank/battle-choose.png"
+      },
+      {
+        "type": "file",
+        "value": "static/back-to-game-bg.png"
+      },
+      {
+        "type": "file",
+        "value": "static/complete-light1.png"
+      },
+      {
+        "type": "file",
+        "value": "static/complete-light2.png"
+      },
+      {
+        "type": "file",
+        "value": "static/title-2v2.png"
+      },
+      {
+        "type": "file",
+        "value": "static/tab-bg.png"
+      },
+      {
+        "type": "file",
+        "value": "static/scan.png"
+      },
+      {
+        "type": "file",
+        "value": "static/choose-battle-mode.png"
+      },
+      {
+        "type": "file",
+        "value": "static/shooter.png"
+      },
+      {
+        "type": "file",
+        "value": "static/my-growth.png"
+      },
+      {
+        "type": "file",
+        "value": "static/juezhanbang.png"
+      },
+      {
+        "type": "file",
+        "value": "static/title-3v3.png"
+      },
+      {
+        "type": "file",
+        "value": "static/point-book-tip-bg.png"
+      },
+      {
+        "type": "file",
+        "value": "static/reward-us.png"
+      },
+      {
+        "type": "file",
+        "value": "static/rank/star.png"
+      },
+      {
+        "type": "file",
+        "value": "static/tab-point-book.png"
+      },
+      {
+        "type": "file",
+        "value": "static/pk-icon.png"
+      },
+      {
+        "type": "file",
+        "value": "static/first-try.png"
+      },
+      {
+        "type": "file",
+        "value": "static/row-yellow-bg.png"
+      },
+      {
+        "type": "file",
+        "value": "static/room-notfound-title.png"
+      },
+      {
+        "type": "file",
+        "value": "static/title-mvp.png"
+      },
+      {
+        "type": "file",
+        "value": "static/long-bubble-tall.png"
+      },
+      {
+        "type": "file",
+        "value": "static/battle-result.png"
+      },
+      {
+        "type": "file",
+        "value": "static/tab-mall.png"
+      },
+      {
+        "type": "folder",
+        "value": "static/training-home"
+      },
+      {
+        "type": "folder",
+        "value": "static/training-difficulty-design"
+      }
+    ],
    "include": []
  },
  "setting": {
@@ -0,0 +1,441 @@
+import { createHash } from "node:crypto";
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import vm from "node:vm";
+
+const scriptDirectory = dirname(fileURLToPath(import.meta.url));
+const projectRoot = resolve(scriptDirectory, "..");
+const sourcePath = resolve(projectRoot, "src/utils/match.min.js");
+const runtimePath = resolve(projectRoot, "src/utils/matchProtocol.js");
+const generatedStartMarker = "// <match-schema-generated>";
+const generatedEndMarker = "// </match-schema-generated>";
+
+const supportedScalarKinds = new Set([
+  "int32",
+  "int64",
+  "float",
+  "double",
+  "bool",
+  "string",
+  "bytes",
+]);
+const supportedMapKeyKinds = new Set(["int32", "int64", "bool", "string"]);
+// 新版描述文件未携带旧协议的 oneof 元数据，保留现有解码结果中的 payload 标识。
+const compatibilityOneofs = {
+  ServerMessage: {
+    match_info: "payload",
+    shoot_data: "payload",
+    practice_info: "payload",
+  },
+};
+
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function extractRootCreateArgument(source) {
+  const match = /(?:\$protobuf\.)?Root\.create\s*\(/.exec(source);
+  if (!match) {
+    throw new Error("match.min.js 中未找到 Root.create(...) 协议描述");
+  }
+
+  const openIndex = source.indexOf("(", match.index);
+  let depth = 0;
+  let quote = "";
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+
+  for (let index = openIndex; index < source.length; index += 1) {
+    const char = source[index];
+    const next = source[index + 1];
+
+    if (lineComment) {
+      if (char === "\n") lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (char === "*" && next === "/") {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = "";
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === "(") {
+      depth += 1;
+      continue;
+    }
+    if (char === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        return source.slice(openIndex + 1, index).trim();
+      }
+    }
+  }
+
+  throw new Error("match.min.js 中的 Root.create(...) 括号不完整");
+}
+
+function stripQuotedText(source) {
+  let output = "";
+  let quote = "";
+  let escaped = false;
+
+  for (const char of source) {
+    if (quote) {
+      output += " ";
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = "";
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      output += " ";
+    } else {
+      output += char;
+    }
+  }
+
+  return output;
+}
+
+function parseDescriptor(argumentSource) {
+  if (!argumentSource.startsWith("{") || !argumentSource.endsWith("}")) {
+    throw new Error("Root.create(...) 参数不是静态对象字面量");
+  }
+
+  try {
+    return JSON.parse(argumentSource);
+  } catch {
+    // 兼容旧版 pbjs 生成的未加引号对象键；只允许静态对象语法。
+    const syntaxOnly = stripQuotedText(argumentSource);
+    if (/[();`=]/.test(syntaxOnly)) {
+      throw new Error("旧版协议描述包含非静态表达式，已拒绝执行");
+    }
+    const descriptor = vm.runInNewContext(
+      `(${argumentSource})`,
+      Object.create(null),
+      { timeout: 1000 }
+    );
+    return JSON.parse(JSON.stringify(descriptor));
+  }
+}
+
+function findProtocolNamespace(node, path = []) {
+  if (!isRecord(node)) return null;
+  const entries = isRecord(node.nested) ? node.nested : node;
+
+  if (isRecord(entries.ServerMessage?.fields) && isRecord(entries.ClientMessage?.fields)) {
+    return { entries, path };
+  }
+
+  for (const [name, child] of Object.entries(entries)) {
+    if (!isRecord(child) || isRecord(child.fields)) continue;
+    const found = findProtocolNamespace(child, [...path, name]);
+    if (found) return found;
+  }
+
+  return null;
+}
+
+function getEnumValues(definition) {
+  if (!isRecord(definition)) return null;
+  const candidate = isRecord(definition.values) ? definition.values : definition;
+  const entries = Object.entries(candidate);
+  if (entries.length === 0 || entries.some(([, value]) => !Number.isInteger(value))) {
+    return null;
+  }
+  return Object.fromEntries(entries.sort((left, right) => left[1] - right[1]));
+}
+
+function normalizeTypeName(type) {
+  return String(type || "")
+    .replace(/^\./, "")
+    .split(".")
+    .pop();
+}
+
+function getOneofByField(definition) {
+  const result = new Map();
+  if (!isRecord(definition.oneofs)) return result;
+
+  for (const [groupName, groupDefinition] of Object.entries(definition.oneofs)) {
+    const fieldNames = Array.isArray(groupDefinition)
+      ? groupDefinition
+      : groupDefinition?.oneof;
+    if (!Array.isArray(fieldNames)) continue;
+    for (const fieldName of fieldNames) result.set(fieldName, groupName);
+  }
+
+  return result;
+}
+
+function buildSchema({ messageName, definition, messages, enumNames }) {
+  const schema = {};
+  const usedIds = new Set();
+  const oneofByField = getOneofByField(definition);
+
+  for (const [fieldKey, fieldDefinition] of Object.entries(definition.fields)) {
+    const id = Number(fieldDefinition.id);
+    if (!Number.isInteger(id) || id <= 0) {
+      throw new Error(`${messageName}.${fieldKey} 的字段编号无效`);
+    }
+    if (usedIds.has(id)) {
+      throw new Error(`${messageName} 存在重复字段编号 ${id}`);
+    }
+    usedIds.add(id);
+
+    const rule = fieldDefinition.rule;
+    if (rule && !["optional", "required", "repeated", "map"].includes(rule)) {
+      throw new Error(`${messageName}.${fieldKey} 使用了不支持的规则 ${rule}`);
+    }
+
+    const fieldName = fieldDefinition.protoName || fieldKey;
+    const typeName = normalizeTypeName(fieldDefinition.type);
+    const keyTypeName = normalizeTypeName(
+      fieldDefinition.keyType ?? fieldDefinition.keytype
+    );
+    const isMap = rule === "map" || Boolean(keyTypeName);
+
+    if (isMap) {
+      if (!supportedMapKeyKinds.has(keyTypeName)) {
+        throw new Error(
+          `${messageName}.${fieldKey} 使用了不支持的 map key 类型 ${keyTypeName}`
+        );
+      }
+      const valueIsMessage = messages.has(typeName);
+      const valueKind = enumNames.has(typeName) ? "int32" : typeName;
+      if (!valueIsMessage && !supportedScalarKinds.has(valueKind)) {
+        throw new Error(
+          `${messageName}.${fieldKey} 使用了不支持的 map value 类型 ${typeName}`
+        );
+      }
+      schema[id] = valueIsMessage
+        ? {
+            name: fieldName,
+            kind: "map",
+            keyKind: keyTypeName,
+            valueKind: "message",
+            valueType: typeName,
+          }
+        : {
+            name: fieldName,
+            kind: "map",
+            keyKind: keyTypeName,
+            valueKind,
+          };
+      continue;
+    }
+
+    const isMessage = messages.has(typeName);
+    const kind = enumNames.has(typeName) ? "int32" : typeName;
+    if (!isMessage && !supportedScalarKinds.has(kind)) {
+      throw new Error(`${messageName}.${fieldKey} 使用了不支持的类型 ${typeName}`);
+    }
+
+    const repeated = rule === "repeated";
+    if (repeated && !isMessage && !["string", "bytes"].includes(kind)) {
+      throw new Error(
+        `${messageName}.${fieldKey} 是 packed scalar repeated，当前通用解码器尚不支持`
+      );
+    }
+
+    const field = isMessage
+      ? { name: fieldName, kind: "message", type: typeName }
+      : { name: fieldName, kind };
+    if (repeated) field.repeated = true;
+
+    const oneof =
+      fieldDefinition.oneof ||
+      oneofByField.get(fieldKey) ||
+      compatibilityOneofs[messageName]?.[fieldName];
+    if (oneof) field.oneof = oneof;
+    schema[id] = field;
+  }
+
+  return schema;
+}
+
+function formatPropertyKey(key) {
+  return /^(?:[A-Za-z_$][\w$]*|\d+)$/.test(key) ? key : JSON.stringify(key);
+}
+
+function formatJsValue(value, depth = 0) {
+  if (!isRecord(value)) return JSON.stringify(value);
+
+  const entries = Object.entries(value);
+  if (entries.length === 0) return "{}";
+
+  const indent = "  ".repeat(depth);
+  const primitiveEntries = entries.every(([, child]) => !isRecord(child));
+  if (primitiveEntries && value.kind !== "map") {
+    const singleLine = `{ ${entries
+      .map(([key, child]) => `${formatPropertyKey(key)}: ${JSON.stringify(child)}`)
+      .join(", ")} }`;
+    if (indent.length + singleLine.length <= 100) return singleLine;
+  }
+
+  const childIndent = "  ".repeat(depth + 1);
+  const lines = entries.map(
+    ([key, child]) =>
+      `${childIndent}${formatPropertyKey(key)}: ${formatJsValue(child, depth + 1)},`
+  );
+  return `{\n${lines.join("\n")}\n${indent}}`;
+}
+
+function createGeneratedSource(source) {
+  const descriptor = parseDescriptor(extractRootCreateArgument(source));
+  const namespace = findProtocolNamespace(descriptor);
+  if (!namespace) {
+    throw new Error("协议描述中未找到 ServerMessage 和 ClientMessage");
+  }
+
+  const messages = new Map();
+  const enums = new Map();
+  for (const [name, definition] of Object.entries(namespace.entries)) {
+    if (isRecord(definition?.fields)) {
+      messages.set(name, definition);
+      continue;
+    }
+    const values = getEnumValues(definition);
+    if (values) enums.set(name, values);
+  }
+
+  const serverMessageType = enums.get("ServerMessageType");
+  const clientMessageType = enums.get("ClientMessageType");
+  if (!serverMessageType || !clientMessageType) {
+    throw new Error("协议描述缺少 ServerMessageType 或 ClientMessageType");
+  }
+
+  const enumNames = new Set(enums.keys());
+  const schemaByName = new Map();
+  for (const [messageName, definition] of messages) {
+    schemaByName.set(
+      messageName,
+      buildSchema({ messageName, definition, messages, enumNames })
+    );
+  }
+
+  const reachable = new Set();
+  function collectReachable(messageName) {
+    if (reachable.has(messageName)) return;
+    const schema = schemaByName.get(messageName);
+    if (!schema) throw new Error(`找不到消息定义 ${messageName}`);
+    reachable.add(messageName);
+    for (const field of Object.values(schema)) {
+      if (field.kind === "message") collectReachable(field.type);
+      if (field.kind === "map" && field.valueKind === "message") {
+        collectReachable(field.valueType);
+      }
+    }
+  }
+  collectReachable("ServerMessage");
+
+  const schemas = {};
+  for (const messageName of messages.keys()) {
+    if (reachable.has(messageName)) schemas[messageName] = schemaByName.get(messageName);
+  }
+
+  const sourceHash = createHash("sha256").update(source).digest("hex").slice(0, 16);
+  const namespaceName = namespace.path.join(".") || "root";
+  const fieldCount = Object.values(schemas).reduce(
+    (total, schema) => total + Object.keys(schema).length,
+    0
+  );
+  const generatedBlock = [
+    generatedStartMarker,
+    "// 此区块由 scripts/generate-match-schema.mjs 自动生成，请勿手动修改。",
+    `// 来源：src/utils/match.min.js（sha256: ${sourceHash}）`,
+    `// 协议命名空间：${namespaceName}；消息数：${Object.keys(schemas).length}；字段数：${fieldCount}`,
+    "",
+    `export const ServerMessageType = ${formatJsValue(serverMessageType)};`,
+    "",
+    `export const ClientMessageType = ${formatJsValue(clientMessageType)};`,
+    "",
+    `const SCHEMAS = ${formatJsValue(schemas)};`,
+    generatedEndMarker,
+  ].join("\n");
+
+  return {
+    generatedBlock,
+    messageCount: Object.keys(schemas).length,
+    fieldCount,
+  };
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const unknownArgs = args.filter((arg) => arg !== "--check");
+  if (unknownArgs.length > 0) {
+    throw new Error(`未知参数：${unknownArgs.join(", ")}`);
+  }
+
+  // 统一换行符，避免 Windows 的 CRLF 让未变更的协议产生不同哈希。
+  const source = readFileSync(sourcePath, "utf8").replace(/\r\n?/g, "\n");
+  const { generatedBlock, messageCount, fieldCount } = createGeneratedSource(source);
+  const runtimeSource = readFileSync(runtimePath, "utf8");
+  const startIndex = runtimeSource.indexOf(generatedStartMarker);
+  const endMarkerIndex = runtimeSource.indexOf(generatedEndMarker);
+  if (startIndex < 0 || endMarkerIndex < startIndex) {
+    throw new Error("matchProtocol.js 缺少协议生成区块标记");
+  }
+  const endIndex = endMarkerIndex + generatedEndMarker.length;
+  const currentBlock = runtimeSource.slice(startIndex, endIndex);
+
+  if (args.includes("--check")) {
+    if (currentBlock !== generatedBlock) {
+      throw new Error(
+        "matchProtocol.js 的生成区块与 match.min.js 不同步，请运行 npm run proto:generate"
+      );
+    }
+    console.log(`[match-schema] 同步校验通过：${messageCount} 个消息，${fieldCount} 个字段`);
+    return;
+  }
+
+  if (currentBlock === generatedBlock) {
+    console.log(`[match-schema] 无需更新：${messageCount} 个消息，${fieldCount} 个字段`);
+    return;
+  }
+
+  const nextRuntimeSource =
+    runtimeSource.slice(0, startIndex) + generatedBlock + runtimeSource.slice(endIndex);
+  writeFileSync(runtimePath, nextRuntimeSource, "utf8");
+  console.log(`[match-schema] 已生成：${messageCount} 个消息，${fieldCount} 个字段`);
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(`[match-schema] ${error.message}`);
+  process.exitCode = 1;
+}
@@ -7,9 +7,13 @@
 		onHide
 	} from "@dcloudio/uni-app";
 	import websocket from "@/websocket";
+	import matchWebsocket from "@/matchWebsocket";
 	import {
 		getDeviceBatteryAPI
 	} from "@/apis";
+	import {
+		MESSAGETYPES
+	} from "@/constants";
 	import useStore from "@/store";
 	import {
 		storeToRefs
@@ -17,11 +21,14 @@
 	import audioManager from "./audioManager";
 	const store = useStore();
 	const {
-		user
+		user,
+		device,
+		online
 	} = storeToRefs(store);
 	const {
 		updateUser,
 		updateOnline,
+		showDeviceChargingDialog,
 		clearSessionState,
 		clearDevice
 	} = store;
@@ -36,6 +43,9 @@
 				websocket.createWebSocket(token, onShootWsMsg);
 			}
 			if (!newVal) {
+				matchWebsocket.closeMatchWebSocket({
+					reason: "logout"
+				});
 				websocket.closeWebSocket();
 			}
 		}, {
@@ -61,7 +71,11 @@

 	async function emitUpdateOnline() {
 		const data = await getDeviceBatteryAPI();
-		updateOnline(data.online);
+		const wasOnline = Boolean(online.value);
+		const nextOnline = Boolean(data.online);
+		updateOnline(nextOnline);
+		if (!device.value.deviceId || wasOnline === nextOnline) return;
+		audioManager.play(nextOnline ? "设备已连接" : "设备连接已断开");
 	}

 	function onDeviceBindInvalid() {
@@ -69,22 +83,59 @@
 		uni.setStorageSync("calibration", false);
 	}

+	function onDeviceCharging() {
+		showDeviceChargingDialog();
+	}
+
 	function onDeviceShoot() {
 		// audioManager.play("射箭声音")
 	}

+	function onNetworkStatusChange(status) {
+		matchWebsocket.handleMatchNetworkStatusChange(status);
+	}
+
+	function connectMatchServerFromMessage(content) {
+		const messages = Array.isArray(content) ? content : [content];
+		messages.forEach((message) => {
+			if (
+				message?.constructor ===
+				MESSAGETYPES.ShootSyncBattleCreateMatchLinkID
+			) {
+				matchWebsocket.connectMatchWebSocketFromNotice(
+					message,
+					user.value.id
+				);
+			}
+		});
+	}
+
 	function onShootWsMsg(content) {
 		if(content.type === 'shoot-trigger'){
 			onDeviceShoot()
 		}
+		connectMatchServerFromMessage(content);
 		uni.$emit("socket-inbox", content);
 	}

 	onShow(() => {
+		void audioManager.warmButton();
 		uni.$on("update-user", emitUpdateUser);
 		uni.$on("update-online", emitUpdateOnline);
 		uni.$on("session-kicked-out", onSessionKickedOut);
 		uni.$on("device-bind-invalid", onDeviceBindInvalid);
+		uni.$on("device-charging", onDeviceCharging);
+		if (typeof uni.offNetworkStatusChange === "function") {
+			uni.offNetworkStatusChange(onNetworkStatusChange);
+		}
+		if (typeof uni.onNetworkStatusChange === "function") {
+			uni.onNetworkStatusChange(onNetworkStatusChange);
+		}
+		if (typeof uni.getNetworkType === "function") {
+			uni.getNetworkType({
+				success: onNetworkStatusChange
+			});
+		}
 		const token = uni.getStorageSync(
 			`${uni.getAccountInfoSync().miniProgram.envVersion}_token`
 		);
@@ -99,6 +150,13 @@
 		uni.$off("update-online", emitUpdateOnline);
 		uni.$off("session-kicked-out", onSessionKickedOut);
 		uni.$off("device-bind-invalid", onDeviceBindInvalid);
+		uni.$off("device-charging", onDeviceCharging);
+		if (typeof uni.offNetworkStatusChange === "function") {
+			uni.offNetworkStatusChange(onNetworkStatusChange);
+		}
+		matchWebsocket.closeMatchWebSocket({
+			reason: "app-hide"
+		});
 		websocket.closeWebSocket();
 	});
 </script>
@@ -1,3 +1,5 @@
+import { normalizeBattleApiResult } from "@/utils/matchAdapter";
+
 let BASE_URL = "https://api.shelingxingqiu.com/api/shoot"; // 默认正式版

 try {
@@ -24,9 +26,9 @@ try {
 }

 const ADDONS_BASE_URL = BASE_URL.replace(/\/api\/shoot$/, "/api/shoot");
-
-// 统一处理业务接口请求，包含登录态、业务错误和 WiFi 连接空响应兼容。
-function request(method, url, data = {}, baseUrl = BASE_URL) {
+const API_ROOT_URL = BASE_URL.replace(/\/api\/shoot$/, "");
+// 统一处理业务接口请求，包含登录态、业务错误和特定接口空响应兼容。
+function request(method, url, data = {}, baseUrl = BASE_URL, successCodes = [0]) {
    const token = uni.getStorageSync(
        `${uni.getAccountInfoSync().miniProgram.envVersion}_token`
    );
@@ -40,13 +42,17 @@ function request(method, url, data = {}, baseUrl = BASE_URL) {
            data,
            timeout: 10000,
            success: (res) => {
-                if (url === "/user/hardwareBox/connectWifi" && res.statusCode === 200 && res.data && Object.keys(res.data).length === 0) {
+                const acceptsEmptyResponse = [
+                    "/user/hardwareBox/connectWifi",
+                    "/user/device/unbindByQrcodeId",
+                ].includes(url);
+                if (acceptsEmptyResponse && res.statusCode === 200 && res.data && Object.keys(res.data).length === 0) {
                    resolve({});
                    return;
                }
                if (res.data) {
                    const {code, data, message} = res.data;
-                    if (code === 0) resolve(data);
+                    if (successCodes.includes(code)) resolve(data);
                    else if (message) {
                        const error = {code, data, message};
                        if (message.indexOf("登录身份已失效") !== -1) {
@@ -185,8 +191,19 @@ export const getDailyCountAPI = () => {
    return request("GET", "/index/dailyCount", {}, ADDONS_BASE_URL);
 };

-export const getHomeData = (seasonId) => {
-    return request("GET", `/user/myHome?seasonId=${seasonId}`);
+export const getHomeData = async (seasonId) => {
+    const data = await request("GET", `/user/myHome?seasonId=${seasonId}`);
+    if (!data?.user) return data;
+
+    // 段位信息由 myHome 接口直接返回，统一并入用户数据供各页面展示。
+    return {
+        ...data,
+        user: {
+            ...data.user,
+            rankIcon: data.rankIcon,
+            rankName: data.rankName,
+        },
+    };
 };

 export const getProvinceData = () => {
@@ -230,6 +247,12 @@ export const checkUserBindAPI = async (code) => {
    });
 };

+export const tempBindOrgAPI = (scene) => {
+    return request("POST", "/user/org/device/tempBind", {
+        scene,
+    });
+};
+
 export const bindDeviceAPI = (device) => {
    return request("POST", "/user/device/bindDevice", {
        device,
@@ -248,6 +271,11 @@ export const unbindDeviceAPI = (deviceId) => {
    });
 };

+// 测试环境根据设备二维码编号解绑设备，不校验设备归属。
+export const unbindDeviceByQrcodeIdAPI = (id) => {
+    return request("POST", "/user/device/unbindByQrcodeId", {id});
+};
+
 export const getMyDevicesAPI = () => {
    // "/user/device/getBinding?deviceId=9ZF9oVXs"
    return request("GET", "/user/device/getBindings");
@@ -261,18 +289,36 @@ export const createPractiseAPI = (arrows, time, target) => {
    });
 };

-export const startPractiseAPI = () => {
-    return request("POST", "/user/practice/begin");
+export const createPractiseV2API = (trainingType, difficultyLevel) => {
+    return request("POST", "/user/practice/create/v2", {
+        trainingType,
+        difficultyLevel,
+    });
 };

-export const endPractiseAPI = () => {
-    return request("POST", "/user/practice/stop");
+export const getCurrentPractiseAPI = () => {
+    return request("GET", "/user/practice/current");
+};
+
+export const startPractiseAPI = (id) => {
+    return request("POST", "/user/practice/begin", { id });
+};
+
+export const endPractiseAPI = (id) => {
+    return request("POST", "/user/practice/stop", { id });
 };

 export const getPractiseAPI = async (id) => {
    return request("GET", `/user/practice/get?id=${id}`);
 };

+export const getPractiseDetailAPI = async (id) => {
+    return request(
+        "GET",
+        `/user/practice/detail?id=${encodeURIComponent(id)}`
+    );
+};
+
 export const createRoomAPI = (gameType, teamSize, targetType) => {
    return request("POST", "/user/createroom", {
        gameType,
@@ -306,12 +352,12 @@ export const startRoomAPI = (number) => {
    return request("POST", "/user/room/start", {number});
 };

-export const getPractiseResultListAPI = async (page = 1, page_size = 15) => {
-    const reuslt = await request(
+export const getPractiseResultListAPI = async (page = 1, pageSize = 15) => {
+    const result = await request(
        "GET",
-        `/user/practice/list?page=${page}&page_size=${page_size}`
+        `/user/practice/mylist?page=${page}&pageSize=${pageSize}&status=0`
    );
-    return reuslt.list;
+    return Array.isArray(result?.list) ? result.list : [];
 };

 export const matchGameAPI = (match, gameType, teamSize) => {
@@ -330,9 +376,11 @@ export const readyGameAPI = (battleId) => {
    });
 };

-export const simulShootAPI = (device_id, x, y) => {
+export const simulShootAPI = (device_id, x, y, targetType = 40) => {
    const data = {
        device_id,
+        // 模拟射箭仅支持 20cm、40cm 靶纸，未传或传入无效值时默认使用 40cm。
+        targetType: Number(targetType) === 20 ? 20 : 40,
    };
    if (x !== undefined && y !== undefined) {
        data.x = x;
@@ -451,6 +499,15 @@ export const getPractiseDataAPI = async () => {
    return request("GET", "/user/practice/statistics");
 };

+export const getPersonalTrainingAPI = async () => {
+    return request("GET", "/personal/training");
+};
+
+export const getTrainingDifficultyListAPI = async (type) => {
+    const query = type ? `?type=${encodeURIComponent(type)}` : "";
+    return request("GET", `/training/difficulty/list${query}`);
+};
+
 export const getBattleDataAPI = async () => {
    return request("GET", "/user/fight/statistics");
 };
@@ -481,6 +538,25 @@ export const laserAimAPI = async () => {
    return request("POST", "/user/device/laserAim");
 };

+// 调瞄续期只负责发送请求，不等待或处理响应，避免阻塞下一次续期。
+export const aimRenewAPI = () => {
+    const token = uni.getStorageSync(
+        `${uni.getAccountInfoSync().miniProgram.envVersion}_token`
+    );
+    const header = {};
+    if (token) header.Authorization = `Bearer ${token}`;
+
+    uni.request({
+        url: `${BASE_URL}/user/device/aimRenew`,
+        method: "POST",
+        header,
+        data: {},
+        timeout: 10000,
+        success: () => {},
+        fail: () => {},
+    });
+};
+
 export const laserCloseAPI = async () => {
    return request("POST", "/user/device/closeAim");
 };
@@ -553,9 +629,10 @@ export const getReadyAPI = (roomId) => {
 };

 export const getBattleAPI = async (battleId) => {
-    return request("POST", "/user/match/info", {
+    const result = await request("POST", "/user/match/info", {
        id: battleId,
    });
+    return normalizeBattleApiResult(result);
 };

 export const kickPlayerAPI = (number, userId) => {
@@ -624,3 +701,76 @@ export const getMyTenRingRank = (seasonId) => {
    if (seasonId !== undefined && seasonId !== null) data.seasonId = seasonId;
    return request("GET", "/index/myTenRingRank", data);
 };
+
+// 获取当前用户的金币统计，可按门店查询。
+export const getMyGoldAPI = (storeId) => {
+    const data = {};
+    if (storeId !== undefined && storeId !== null) data.storeId = storeId;
+    return request("GET", "/index/gold/my", data);
+};
+
+// 分页获取当前用户的金币流水，type：1=获得，2=兑换。
+export const getGoldLogAPI = ({page = 1, pageSize = 20, type, storeId} = {}) => {
+    const data = {page, pageSize};
+    if (type !== undefined && type !== null) data.type = type;
+    if (storeId !== undefined && storeId !== null) data.storeId = storeId;
+    return request("GET", "/index/gold/log", data);
+};
+
+// 前台礼品接口位于站点根路径，并使用 code=200 表示成功。
+export const getGiftListAPI = ({
+    page = 1,
+    pageSize = 20,
+    sort = "coin_desc",
+    storeId,
+} = {}) => {
+    const data = {page, page_size: pageSize, sort};
+    if (storeId !== undefined && storeId !== null && storeId !== "") {
+        data.store_id = storeId;
+    }
+    return request(
+        "GET",
+        "/gin/api/v1/gift/list",
+        data,
+        API_ROOT_URL,
+        [0, 200]
+    );
+};
+
+export const getGiftDetailAPI = (id) => {
+    return request(
+        "GET",
+        `/gin/api/v1/gift/${id}`,
+        {},
+        API_ROOT_URL,
+        [0, 200]
+    );
+};
+
+// 根据用户定位分页获取附近门店。
+export const getNearbyStoresAPI = ({
+    longitude,
+    latitude,
+    radius = 65535,
+    page = 1,
+    pageSize = 20,
+} = {}) => {
+    return request("GET", "/store/nearby", {
+        longitude,
+        latitude,
+        radius,
+        page,
+        pageSize,
+    });
+};
+
+// 分页获取指定门店的公开金币规则。
+export const getStoreGoldRuleListAPI = ({storeId, page = 1, pageSize = 20} = {}) => {
+    return request(
+        "GET",
+        `/gin/api/v1/super-admin/gold-rule/store/${storeId}/list`,
+        {page, page_size: pageSize},
+        API_ROOT_URL,
+        [0, 200]
+    );
+};
@@ -635,7 +635,7 @@ export function renderScores(ctx, arrows = [], bgImg) {
        );
      } else {
        ctx.drawImage(
-          "../static/score-bg.png",
+          "/static/score-bg.png",
          16 + (i % 9) * 30,
          290 + Math.ceil((i + 1) / 9) * 30,
          27,
@@ -657,7 +657,7 @@ export function renderScores(ctx, arrows = [], bgImg) {
        ctx.drawImage(bgImg, 24 + rowIndex * 42, i > 5 ? 362 : 320, 38, 38);
      } else {
        ctx.drawImage(
-          "../static/score-bg.png",
+          "/static/score-bg.png",
          24 + rowIndex * 42,
          i > 5 ? 362 : 320,
          38,
@@ -706,22 +706,39 @@ export async function sharePractiseData(canvasId, type, user, data) {
    );
    const bgImg = await loadCanvasImage(canvas, bgImgSrc);

-    const avatarImgPromise = loadImage(user.avatar).then((path) =>
-      loadCanvasImage(canvas, path)
-    );
-    const lvlImgPromise = loadImage(user.lvlImage).then((path) =>
-      loadCanvasImage(canvas, path)
-    );
+    // 头像与段位框属于装饰图片，缺失时使用兜底或跳过，避免阻断分享。
+    const loadProfileImage = async (src, fallbackSrc = "", label = "") => {
+      const normalizedSrc =
+        typeof src === "string" && src.startsWith("../static/")
+          ? src.slice(2)
+          : src;
+      if (normalizedSrc) {
+        try {
+          const path = await loadImage(normalizedSrc);
+          return await loadCanvasImage(canvas, path);
+        } catch (error) {
+          console.warn(`share ${label} image load failed`, error);
+        }
+      }
+      return fallbackSrc ? loadCanvasImage(canvas, fallbackSrc) : null;
+    };

-    let titleImageSrc = "../static/first-try-title.png";
+    const avatarImgPromise = loadProfileImage(
+      user?.avatar,
+      "/static/user-icon.png",
+      "avatar"
+    );
+    const lvlImgPromise = loadProfileImage(user?.lvlImage, "", "level");
+
+    let titleImageSrc = "/static/first-try-title.png";
    if (type == 2) {
-      titleImageSrc = "../static/practise-one-title.png";
+      titleImageSrc = "/static/practise-one-title.png";
    } else if (type == 3) {
-      titleImageSrc = "../static/practise-two-title.png";
+      titleImageSrc = "/static/practise-two-title.png";
    }
    const titleImgPromise = loadCanvasImage(canvas, titleImageSrc);
-    const scoreBgImgPromise = loadCanvasImage(canvas, "../static/score-bg.png");
-    const qrCodeImgPromise = loadCanvasImage(canvas, "../static/qr-code.png");
+    const scoreBgImgPromise = loadCanvasImage(canvas, "/static/score-bg.png");
+    const qrCodeImgPromise = loadCanvasImage(canvas, "/static/qr-code.png");

    const [avatarImg, lvlImg, titleImg, scoreBgImg, qrCodeImg] =
      await Promise.all([
@@ -738,8 +755,8 @@ export async function sharePractiseData(canvasId, type, user, data) {

    ctx.drawImage(bgImg, 0, 0, width, height);

-    drawRoundImage(ctx, avatarImg, 17, 20, 32, 32, 20);
-    ctx.drawImage(lvlImg, 12, 15, 42, 42);
+    if (avatarImg) drawRoundImage(ctx, avatarImg, 17, 20, 32, 32, 20);
+    if (lvlImg) ctx.drawImage(lvlImg, 12, 15, 42, 42);

    renderText(ctx, user.nickName, 13, "#fff", 58, 34);
    renderRankTitle(ctx, user.lvlName);
@@ -57,6 +57,30 @@ const props = defineProps({
 	  src="https://static.shelingxingqiu.com/shootmini/static/rank/rank-bg.png"
 	  mode="widthFix"
 	/>
+  <image
+      class="bg-image"
+      v-if="type === 7"
+      src="https://static.shelingxingqiu.com/shootmini/static/app-bg6.png"
+      mode="widthFix"
+    />
+    <image
+      class="bg-image"
+      v-if="type === 8"
+      src="https://static.shelingxingqiu.com/shootmini/static/app-bg7.png"
+      mode="widthFix"
+    />
+    <image
+      class="bg-image"
+      v-if="type === 9"
+      src="https://static.shelingxingqiu.com/shootmini/static/app-bg8.png"
+      mode="widthFix"
+    />
+    <image
+      class="bg-image"
+      v-if="type === 11"
+      src="https://static.shelingxingqiu.com/shootmini/static/app-bg9.png"
+      mode="widthFix"
+    />
  <image
 	  class="bg-image"
 	  v-if="type === 10"
@@ -1,8 +1,8 @@
 <script setup>
 const tabs = [
  { image: "../static/tab-vip.png" },
-  { image: "../static/tab-point-book.png" },
-  { image: "../static/tab-mall.png" },
+  { image: "https://static.shelingxingqiu.com/shootmini/static/tab-point-book.png" },
+  { image: "https://static.shelingxingqiu.com/shootmini/static/tab-mall.png" },
 ];

 function handleTabClick(index) {
@@ -26,7 +26,7 @@ function handleTabClick(index) {

 <template>
  <view class="footer">
-    <image class="footer-bg" src="../static/tab-bg.png" mode="widthFix" />
+    <image class="footer-bg" src="https://static.shelingxingqiu.com/shootmini/static/tab-bg.png" mode="widthFix" />
    <view
      v-for="(tab, index) in tabs"
      :key="index"
@@ -43,9 +43,13 @@ function handleTabClick(index) {

 <style scoped>
 .footer {
-  height: 120px;
+  /* height: 120px; */
+  height: 190rpx;
  width: 100vw;
-  position: relative;
+  /* position: relative; */
+  position: fixed;
+  bottom: 0;
+  left: 0;
  display: flex;
  justify-content: space-around;
  align-items: center;
@@ -1,5 +1,5 @@
 <script setup>
-import { ref, onMounted, watch } from "vue";
+import { computed, ref, watch } from "vue";
 import useStore from "@/store";
 import { storeToRefs } from "pinia";
 const store = useStore();
@@ -26,12 +26,33 @@ const props = defineProps({
    type: Number,
    default: 45,
  },
+  sizeUnit: {
+    type: String,
+    default: "px",
+  },
+  imageMode: {
+    type: String,
+    default: "widthFix",
+  },
  borderColor: {
    type: String,
    default: "",
  },
 });
 const avatarFrame = ref("");
+const sizeValue = computed(() => `${Number(props.size)}${props.sizeUnit}`);
+const frameSizeValue = computed(() => `${Number(props.size) + 10}${props.sizeUnit}`);
+const avatarImageStyle = computed(() => ({
+  width: sizeValue.value,
+  height: sizeValue.value,
+  minHeight: sizeValue.value,
+  borderColor: props.borderColor || "#fff",
+}));
+const avatarFrameStyle = computed(() => ({
+  width: frameSizeValue.value,
+  height: frameSizeValue.value,
+}));
+
 watch(
  () => [config.value, props.rankLvl],
  () => {
@@ -51,10 +72,7 @@ watch(
      v-if="avatarFrame"
      :src="avatarFrame"
      mode="widthFix"
-      :style="{
-        width: Number(size) + 10 + 'px',
-        height: Number(size) + 10 + 'px',
-      }"
+      :style="avatarFrameStyle"
      class="avatar-frame"
    />
    <image
@@ -78,13 +96,8 @@ watch(
    <view v-if="rank > 3" class="rank-view">{{ rank }}</view>
    <image
      :src="src || '../static/user-icon.png'"
-      mode="widthFix"
-      :style="{
-        width: size + 'px',
-        height: size + 'px',
-        minHeight: size + 'px',
-        borderColor: borderColor || '#fff',
-      }"
+      :mode="imageMode"
+      :style="avatarImageStyle"
      class="avatar-image"
    />
  </view>
@@ -4,6 +4,7 @@ import { onShow } from "@dcloudio/uni-app";

 import { getBattleAPI, getUserGameState } from "@/apis";
 import { debounce } from "@/util";
+import { returnToBattle } from "@/utils/matchReturn";

 import useStore from "@/store";
 import { storeToRefs } from "pinia";
@@ -66,12 +67,7 @@ const onClick = debounce(async () => {
    loading.value = true;
    const result = await getBattleAPI();
    if (result && result.matchId) {
-      await uni.$checkAudio();
-      if (result.mode <= 3) {
-        await navigateOnce(`/pages/team-battle/index?battleId=${result.matchId}`);
-      } else {
-        await navigateOnce(`/pages/melee-battle?battleId=${result.matchId}`);
-      }
+      await returnToBattle(result, navigateOnce);
      return;
    }
    if (game.value.roomID) {
@@ -100,9 +96,9 @@ onBeforeUnmount(() => {
    class="back-to-game"
    @click="onClick"
  >
-    <image src="../static/back-to-game-bg.png" mode="widthFix" />
+    <image src="https://static.shelingxingqiu.com/shootmini/static/back-to-game-bg.png" mode="widthFix" />
    <block v-if="game.inBattle">
-      <image src="../static/pk-icon.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/pk-icon.png" mode="widthFix" />
      <text>返回进行中的对局</text>
    </block>
    <block v-else-if="game.roomID">
@@ -31,7 +31,7 @@ const normalRounds = computed(() => {
 <template>
  <view class="container">
    <view class="guide-row">
-      <image src="../static/shooter.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/shooter.png" mode="widthFix" />
      <view
        :style="{
          marginBottom: '10px',
@@ -42,7 +42,7 @@ const normalRounds = computed(() => {
      </view>
    </view>
    <view>
-      <image src="../static/battle-header-melee.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/battle-header-melee.png" mode="widthFix" />
      <text>蓝队({{ bluePoints }})</text>
      <text>红队({{ redPoints }})</text>
    </view>
@@ -38,16 +38,16 @@ const isMember = (player = {}) => player.vip === true || player.sVip === true;
 </script>

 <template>
-  <view class="container" :style="{ paddingTop: showHeader ? '5px' : '0' }">
+  <view class="container">
    <image
      v-if="showHeader"
-      :src="`../static/battle-header${players.length ? '-melee' : ''}.png`"
+      :src="`https://static.shelingxingqiu.com/shootmini/static/battle-header${players.length ? '-melee' : ''}.png`"
      mode="widthFix"
    />
    <view
      v-if="!players.length && blueTeam.length && redTeam.length"
      class="players"
-      :style="{ paddingTop: showHeader ? '15px' : '0' }"
+      :style="{ paddingTop: showHeader ? '48rpx' : '0' }"
    >
      <view>
        <view
@@ -113,6 +113,7 @@ const isMember = (player = {}) => player.vip === true || player.sVip === true;
      v-if="players.length"
      class="players-melee"
      scroll-x
+      :show-scrollbar="false"
      @touchmove="(e) => players.length > 5 && e.stopPropagation()"
      :style="{ paddingTop: showHeader ? '15px' : '0' }"
    >
@@ -151,13 +152,15 @@ const isMember = (player = {}) => player.vip === true || player.sVip === true;
 .container {
  width: 100%;
  position: relative;
+  z-index: 999;
  margin-bottom: 10px;
 }
 .container > image:first-child {
  position: absolute;
  width: 100%;
-  top: -5px;
+  /* top: -5px; */
  z-index: 1;
+  pointer-events: none;
 }
 .players {
  display: flex;
@@ -188,15 +191,12 @@ const isMember = (player = {}) => player.vip === true || player.sVip === true;
 .players-melee {
  height: 80px;
  width: 100%;
-}
-.players-melee::-webkit-scrollbar {
-  width: 0;
-  height: 0;
-  color: transparent;
+  white-space: nowrap;
 }
 /* 小程序 scroll-view 不支持直接 flex，通过内层 wrapper 承载横向排列 */
 .players-melee-inner {
-  display: flex;
+  display: inline-flex;
+  min-width: 100%;
  height: 100%;
  flex-wrap: nowrap;
 }
@@ -4,18 +4,34 @@ import { getDeviceBatteryAPI } from "@/apis";

 const power = ref(0);
 const timer = ref(null);
+let disposed = false;
+let requestInFlight = false;
+
+const refreshPower = async () => {
+  if (disposed || requestInFlight) return;
+  requestInFlight = true;
+  try {
+    const data = await getDeviceBatteryAPI();
+    if (!disposed) power.value = data.battery;
+  } catch (_) {
+    // 电量轮询失败时等待下一轮，避免产生未处理的 Promise 拒绝。
+  } finally {
+    requestInFlight = false;
+  }
+};

 onMounted(async () => {
-  const data = await getDeviceBatteryAPI();
-  power.value = data.battery;
-  timer.value = setInterval(async () => {
-    const data = await getDeviceBatteryAPI();
-    power.value = data.battery;
+  await refreshPower();
+  if (disposed) return;
+  timer.value = setInterval(() => {
+    void refreshPower();
  }, 1000 * 10);
 });

 onBeforeUnmount(() => {
+  disposed = true;
  clearInterval(timer.value);
+  timer.value = null;
 });
 </script>

@@ -22,10 +22,22 @@ const props = defineProps({
    type: Number,
    default: 0,
  },
+  targetLeft: {
+    type: Number,
+    default: 0,
+  },
+  targetTop: {
+    type: Number,
+    default: 0,
+  },
  hitOffsetPx: {
    type: Number,
    default: 0,
  },
+  viewportMode: {
+    type: Boolean,
+    default: false,
+  },
 });

 const emit = defineEmits(["complete", "impact"]);
@@ -35,11 +47,14 @@ const activePlayKey = ref("");
 const animationKey = ref("");
 const impactEmitted = ref(false);
 const activeShot = ref(null);
+const activeLayout = ref(null);
 let timers = [];

 const isActive = computed(() => phase.value !== "idle");
 const ARROW_IMPACT_MS = 340;
 const COMPLETE_FALLBACK_MS = 980;
+// 箭头尖端统一从屏幕中下区域出发，箭身自然延伸到屏幕底部之外。
+const SHOT_START_VIEWPORT_Y_RATIO = 0.82;

 const safeTargetRadius = computed(() => {
  const radius = Number(props.targetRadius);
@@ -49,12 +64,33 @@ const safeTargetRadius = computed(() => {
 const safeTargetSize = computed(() => {
  const width = Number(props.targetWidth);
  const height = Number(props.targetHeight);
+  const left = Number(props.targetLeft);
+  const top = Number(props.targetTop);
  return {
    width: Number.isFinite(width) && width > 0 ? width : 0,
    height: Number.isFinite(height) && height > 0 ? height : 0,
+    left: Number.isFinite(left) ? left : 0,
+    top: Number.isFinite(top) ? top : 0,
  };
 });

+function getWindowSize() {
+  try {
+    const info =
+      typeof uni.getWindowInfo === "function"
+        ? uni.getWindowInfo()
+        : uni.getSystemInfoSync();
+    const width = Number(info?.windowWidth);
+    const height = Number(info?.windowHeight);
+    return {
+      width: Number.isFinite(width) && width > 0 ? width : 0,
+      height: Number.isFinite(height) && height > 0 ? height : 0,
+    };
+  } catch {
+    return { width: 0, height: 0 };
+  }
+}
+
 function hasShotPoint(shot) {
  const x = Number(shot?.x);
  const y = Number(shot?.y);
@@ -62,6 +98,17 @@ function hasShotPoint(shot) {
 }

 const effectiveShot = computed(() => activeShot.value || props.shot);
+const effectiveTargetSize = computed(
+  () => activeLayout.value?.target || safeTargetSize.value
+);
+const effectiveWindowSize = computed(
+  () => activeLayout.value?.window || getWindowSize()
+);
+const isViewportMode = computed(() =>
+  activeLayout.value
+    ? activeLayout.value.viewportMode
+    : props.viewportMode === true
+);

 const shotPoint = computed(() => {
  const x = Number(effectiveShot.value?.x);
@@ -105,23 +152,69 @@ const hitPercent = computed(() => {
  };
 });

-const arrowAngle = computed(() => {
-  const size = safeTargetSize.value;
-  if (!size.width || !size.height) {
-    const dx = hitPercent.value.left - 50;
-    const dy = 114 - hitPercent.value.top;
-    const fallbackAngle = Math.atan2(dx, dy || 1) * (180 / Math.PI);
-    return Math.max(-18, Math.min(18, fallbackAngle));
+const flightPath = computed(() => {
+  const size = effectiveTargetSize.value;
+  const windowSize = effectiveWindowSize.value;
+
+  if (
+    isViewportMode.value &&
+    size.width > 0 &&
+    size.height > 0 &&
+    windowSize.width > 0 &&
+    windowSize.height > 0
+  ) {
+    const startX = windowSize.width * 0.5;
+    const endX =
+      size.left +
+      size.width * (hitPercent.value.left / 100) +
+      hitOffset.value.x;
+    const endY =
+      size.top +
+      size.height * (hitPercent.value.top / 100) +
+      hitOffset.value.y;
+    // 常规情况下从视口底部进入；靶面局部超出视口时仍保证起点在命中点下方。
+    const startY = Math.max(windowSize.height + 16, endY + 80);
+    const dx = endX - startX;
+    const dy = endY - startY;
+
+    return {
+      startX,
+      startY,
+      endX,
+      endY,
+      translateX: dx,
+      translateY: dy,
+      angle: Math.atan2(dx, -dy) * (180 / Math.PI),
+    };
  }

-  const startX = size.width * 0.5;
-  const startY = size.height * 1.14;
-  const endX = size.width * (hitPercent.value.left / 100) + hitOffset.value.x;
-  const endY = size.height * (hitPercent.value.top / 100) + hitOffset.value.y;
+  const hasScreenCoordinates =
+    size.width > 0 &&
+    size.height > 0 &&
+    windowSize.width > 0 &&
+    windowSize.height > 0;
+  const startX = hasScreenCoordinates
+    ? windowSize.width * 0.5 - size.left
+    : size.width * 0.5;
+  const startY = hasScreenCoordinates
+    ? windowSize.height * SHOT_START_VIEWPORT_Y_RATIO - size.top
+    : size.height * 1.14;
+  const endX =
+    size.width * (hitPercent.value.left / 100) + hitOffset.value.x;
+  const endY =
+    size.height * (hitPercent.value.top / 100) + hitOffset.value.y;
  const dx = endX - startX;
-  const dy = startY - endY;
-  const angle = Math.atan2(dx, dy || 1) * (180 / Math.PI);
-  return Math.max(-18, Math.min(18, angle));
+  const dy = endY - startY;
+
+  return {
+    startX,
+    startY,
+    endX,
+    endY,
+    translateX: dx,
+    translateY: dy,
+    angle: Math.atan2(dx, -dy) * (180 / Math.PI),
+  };
 });

 function formatPxOffset(value) {
@@ -135,10 +228,19 @@ function formatTargetPosition(percent, offset) {
  return pxOffset ? `calc(${percent}%${pxOffset})` : `${percent}%`;
 }

-const crackStyle = computed(() => ({
-  left: formatTargetPosition(hitPercent.value.left, hitOffset.value.x),
-  top: formatTargetPosition(hitPercent.value.top, hitOffset.value.y),
-}));
+const crackStyle = computed(() => {
+  if (isViewportMode.value) {
+    return {
+      left: `${flightPath.value.endX}px`,
+      top: `${flightPath.value.endY}px`,
+    };
+  }
+
+  return {
+    left: formatTargetPosition(hitPercent.value.left, hitOffset.value.x),
+    top: formatTargetPosition(hitPercent.value.top, hitOffset.value.y),
+  };
+});

 function getTargetTranslate(percent) {
  const absPercent = Math.abs(percent);
@@ -147,23 +249,24 @@ function getTargetTranslate(percent) {
 }

 const arrowMoveStyle = computed(() => {
-  const size = safeTargetSize.value;
+  const size = effectiveTargetSize.value;
+  const path = flightPath.value;
  let x = getTargetTranslate(hitPercent.value.left - 50);
  let y = getTargetTranslate(hitPercent.value.top - 114);

-  if (size.width && size.height) {
-    const startX = size.width * 0.5;
-    const startY = size.height * 1.14;
-    const endX = size.width * (hitPercent.value.left / 100) + hitOffset.value.x;
-    const endY = size.height * (hitPercent.value.top / 100) + hitOffset.value.y;
-    x = `${endX - startX}px`;
-    y = `${endY - startY}px`;
+  if (isViewportMode.value || (size.width && size.height)) {
+    x = `${path.translateX}px`;
+    y = `${path.translateY}px`;
  }

  return {
+    "--shot-start-x":
+      isViewportMode.value || size.width ? `${path.startX}px` : "50%",
+    "--shot-start-y":
+      isViewportMode.value || size.height ? `${path.startY}px` : "114%",
    "--shot-tx": x,
    "--shot-ty": y,
-    "--shot-angle": `${arrowAngle.value}deg`,
+    "--shot-angle": `${path.angle}deg`,
  };
 });

@@ -189,6 +292,7 @@ function finish(playKey) {
  phase.value = "idle";
  activePlayKey.value = "";
  activeShot.value = null;
+  activeLayout.value = null;
  emit("complete", playKey);
 }

@@ -202,6 +306,11 @@ function play() {
  animationKey.value = `${props.playKey}`;
  impactEmitted.value = false;
  activeShot.value = { ...props.shot };
+  activeLayout.value = {
+    target: { ...safeTargetSize.value },
+    window: getWindowSize(),
+    viewportMode: props.viewportMode === true,
+  };
  phase.value = "playing";

  queueTimer(() => {
@@ -236,7 +345,11 @@ onBeforeUnmount(() => {
 <template>
  <view
    v-show="isActive"
-    :class="['shot-effect', `shot-effect--${phase}`]"
+    :class="[
+      'shot-effect',
+      `shot-effect--${phase}`,
+      { 'shot-effect--viewport': isViewportMode },
+    ]"
    :style="arrowMoveStyle"
  >
    <view
@@ -246,7 +359,7 @@ onBeforeUnmount(() => {
    >
      <image
        class="shot-arrow"
-        src="../static/vip/svip-jian.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/vip/svip-jian.png"
        mode="heightFix"
      />
    </view>
@@ -263,7 +376,7 @@ onBeforeUnmount(() => {
      <image
        :key="`crack-${animationKey}`"
        class="shot-crack"
-        src="../static/vip/svip-lie.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/vip/svip-lie.png"
        mode="aspectFit"
        @animationend="handleCrackAnimationEnd"
      />
@@ -284,10 +397,16 @@ onBeforeUnmount(() => {
  transform: translateZ(0);
 }

+.shot-effect--viewport {
+  position: fixed;
+  width: 100vw;
+  height: 100vh;
+}
+
 .shot-arrow-track {
  position: absolute;
-  left: 50%;
-  top: 114%;
+  left: var(--shot-start-x);
+  top: var(--shot-start-y);
  width: 0;
  height: 0;
  opacity: 0;
@@ -12,7 +12,7 @@ import PointSwitcher from "@/components/PointSwitcher.vue";
 import BowShotEffect from "@/components/BowShotEffect.vue";

 import { MESSAGETYPES, MESSAGETYPESV2 } from "@/constants";
-import { simulShootAPI } from "@/apis";
+import { simulShootAPI, laserAimAPI, laserCloseAPI } from "@/apis";
 import useStore from "@/store";
 import { storeToRefs } from "pinia";
 const store = useStore();
@@ -43,10 +43,18 @@ const props = defineProps({
    type: String,
    default: "solo", // solo 单排，team 双排
  },
+  missAsZero: {
+    type: Boolean,
+    default: false,
+  },
  stop: {
    type: Boolean,
    default: false,
  },
+  targetType: {
+    type: [Number, String],
+    default: 40,
+  },
  targetRadius: {
    type: Number,
    default: 20,
@@ -59,6 +67,14 @@ const props = defineProps({
    type: Number,
    default: 5,
  },
+  stableShotEffect: {
+    type: Boolean,
+    default: false,
+  },
+  enableShotEffect: {
+    type: Boolean,
+    default: true,
+  },
 });

 const pMode = ref(true);
@@ -69,15 +85,23 @@ const dirTimer = ref(null);
 const angle = ref(null);
 const circleColor = ref("");
 const shotEffect = ref(null);
+const pendingShotEffect = ref(null);
 const hiddenRedLatestKey = ref("");
 const hiddenBlueLatestKey = ref("");
 const targetShaking = ref(false);
-const targetSize = ref({ width: 0, height: 0 });
+const targetRect = ref({ left: 0, top: 0, width: 0, height: 0 });
 const shakeTimer = ref(null);
 const instance = getCurrentInstance();
+let shotEffectRequestGeneration = 0;
 const ROUND_TIP_OFFSET_Y = -32;
 const EXPERIENCE_TIP_OFFSET_Y = -68;

+function getRoundText(shot) {
+  if (shot?.ringX) return "X环";
+  if (shot?.ring) return `${shot.ring}环`;
+  return props.missAsZero ? "0环" : "未上靶";
+}
+
 function buildShotEffectKey(team, shot, index) {
  return [
    team,
@@ -97,7 +121,13 @@ function hasShotPoint(shot) {
 }

 function shouldPlayShotEffect(shot) {
-  return props.isSvip && !!shot && Number(shot.ring) > 0 && hasShotPoint(shot);
+  return (
+    props.enableShotEffect &&
+    props.isSvip &&
+    !!shot &&
+    Number(shot.ring) > 0 &&
+    hasShotPoint(shot)
+  );
 }

 function clearTipTimer() {
@@ -125,7 +155,7 @@ function showShotTip(team, shot) {
  }, 1000);
 }

-function triggerShotEffect(team, shot, index) {
+function triggerShotEffect(team, shot, index, viewportMode = false) {
  const key = buildShotEffectKey(team, shot, index);

  if (shotEffect.value?.team === "red") hiddenRedLatestKey.value = "";
@@ -139,7 +169,29 @@ function triggerShotEffect(team, shot, index) {
    hiddenBlueLatestKey.value = key;
  }

-  shotEffect.value = { key, team, shot };
+  shotEffect.value = { key, team, shot, viewportMode };
+}
+
+async function prepareShotEffect(team, shot, index) {
+  const requestGeneration = ++shotEffectRequestGeneration;
+  const key = buildShotEffectKey(team, shot, index);
+  pendingShotEffect.value = { generation: requestGeneration, team, key };
+  clearTipTimer();
+  if (team === "red") latestOne.value = null;
+  if (team === "blue") bluelatestOne.value = null;
+
+  const viewportMode = props.stableShotEffect
+    ? await updateTargetRect()
+    : false;
+
+  if (requestGeneration !== shotEffectRequestGeneration) {
+    if (pendingShotEffect.value?.generation === requestGeneration) {
+      pendingShotEffect.value = null;
+    }
+    return;
+  }
+  pendingShotEffect.value = null;
+  triggerShotEffect(team, shot, index, viewportMode);
 }

 function completeShotEffect(key) {
@@ -168,35 +220,67 @@ function shakeTarget() {
  });
 }

-function updateTargetSize() {
-  nextTick(() => {
-    const query = instance?.proxy
-      ? uni.createSelectorQuery().in(instance.proxy)
-      : uni.createSelectorQuery();
+function hasValidTargetRect(rect = targetRect.value) {
+  return (
+    Number.isFinite(Number(rect?.left)) &&
+    Number.isFinite(Number(rect?.top)) &&
+    Number(rect?.width) > 0 &&
+    Number(rect?.height) > 0
+  );
+}

-    query
-      .select(".target")
-      .boundingClientRect((rect) => {
-        const width = Number(rect?.width);
-        const height = Number(rect?.height);
-        if (!Number.isFinite(width) || !Number.isFinite(height)) return;
-        if (width <= 0 || height <= 0) return;
-        targetSize.value = { width, height };
-      })
-      .exec();
+async function updateTargetRect() {
+  await nextTick();
+
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (rect) => {
+      if (settled) return;
+      settled = true;
+
+      const isValid = hasValidTargetRect(rect);
+      if (isValid) {
+        targetRect.value = {
+          left: Number(rect.left),
+          top: Number(rect.top),
+          width: Number(rect.width),
+          height: Number(rect.height),
+        };
+      }
+      resolve(isValid);
+    };
+
+    try {
+      const query = instance?.proxy
+        ? uni.createSelectorQuery().in(instance.proxy)
+        : uni.createSelectorQuery();
+
+      query
+        .select(".target")
+        .boundingClientRect()
+        .exec((result) => finish(Array.isArray(result) ? result[0] : null));
+    } catch {
+      finish(null);
+    }
  });
 }

 function handleWindowResize() {
-  updateTargetSize();
+  void updateTargetRect();
 }

 function shouldHideRedHit(index) {
-  return !!hiddenRedLatestKey.value && index === props.scores.length - 1;
+  return (
+    (!!hiddenRedLatestKey.value || pendingShotEffect.value?.team === "red") &&
+    index === props.scores.length - 1
+  );
 }

 function shouldHideBlueHit(index) {
-  return !!hiddenBlueLatestKey.value && index === props.blueScores.length - 1;
+  return (
+    (!!hiddenBlueLatestKey.value || pendingShotEffect.value?.team === "blue") &&
+    index === props.blueScores.length - 1
+  );
 }

 watch(
@@ -205,14 +289,18 @@ watch(
    if (newLen === oldLen + 1) {
      const latestShot = props.scores[newLen - 1];
      if (shouldPlayShotEffect(latestShot)) {
-        triggerShotEffect("red", latestShot, newLen - 1);
-      } else {
+        void prepareShotEffect("red", latestShot, newLen - 1);
+      } else if (props.enableShotEffect) {
+        shotEffectRequestGeneration += 1;
+        pendingShotEffect.value = null;
        showShotTip("red", latestShot);
      }
      return;
    }

    if (newLen < oldLen) {
+      shotEffectRequestGeneration += 1;
+      pendingShotEffect.value = null;
      latestOne.value = null;
      hiddenRedLatestKey.value = "";
      if (shotEffect.value?.team === "red") shotEffect.value = null;
@@ -226,14 +314,18 @@ watch(
    if (newLen === oldLen + 1) {
      const latestShot = props.blueScores[newLen - 1];
      if (shouldPlayShotEffect(latestShot)) {
-        triggerShotEffect("blue", latestShot, newLen - 1);
-      } else {
+        void prepareShotEffect("blue", latestShot, newLen - 1);
+      } else if (props.enableShotEffect) {
+        shotEffectRequestGeneration += 1;
+        pendingShotEffect.value = null;
        showShotTip("blue", latestShot);
      }
      return;
    }

    if (newLen < oldLen) {
+      shotEffectRequestGeneration += 1;
+      pendingShotEffect.value = null;
      bluelatestOne.value = null;
      hiddenBlueLatestKey.value = "";
      if (shotEffect.value?.team === "blue") shotEffect.value = null;
@@ -338,15 +430,30 @@ function getExperienceTipStyle(shot) {
  );
 }
 const simulShoot = async () => {
-  if (device.value.deviceId) await simulShootAPI(device.value.deviceId);
+  if (device.value.deviceId) {
+    await simulShootAPI(
+      device.value.deviceId,
+      undefined,
+      undefined,
+      props.targetType
+    );
+  }
 };
 const simulShoot2 = async () => {
  if (device.value.deviceId) {
    const r1 = Math.random() > 0.5 ? 0.01 : 0.02;
-    await simulShootAPI(device.value.deviceId, r1, r1);
+    await simulShootAPI(device.value.deviceId, r1, r1, props.targetType);
  }
 };

+const openAim = async () => {
+  await laserAimAPI();
+};
+
+const closeAim = async () => {
+  await laserCloseAPI();
+};
+
 const env = computed(() => {
  const accountInfo = uni.getAccountInfoSync();
  return accountInfo.miniProgram.envVersion;
@@ -384,11 +491,13 @@ async function onReceiveMessage(message) {

 onMounted(() => {
  uni.$on("socket-inbox", onReceiveMessage);
-  updateTargetSize();
+  void updateTargetRect();
  if (uni.onWindowResize) uni.onWindowResize(handleWindowResize);
 });

 onBeforeUnmount(() => {
+  shotEffectRequestGeneration += 1;
+  pendingShotEffect.value = null;
  if (timer.value) {
    clearTimeout(timer.value);
    timer.value = null;
@@ -433,8 +542,7 @@ onBeforeUnmount(() => {
        v-if="latestOne"
        class="round-tip fade-in-out"
        :style="getRoundTipStyle(latestOne)"
-        >{{ latestOne.ringX ? "X" : latestOne.ring || "未上靶"
-        }}<text v-if="latestOne.ring">环</text>
+        >{{ getRoundText(latestOne) }}
      </view>
      <view
        v-if="
@@ -451,8 +559,7 @@ onBeforeUnmount(() => {
        v-if="bluelatestOne"
        class="round-tip fade-in-out"
        :style="getRoundTipStyle(bluelatestOne)"
-        >{{ bluelatestOne.ringX ? "X" : bluelatestOne.ring || "未上靶"
-        }}<text v-if="bluelatestOne.ring">环</text></view
+        >{{ getRoundText(bluelatestOne) }}</view
      >
      <block v-for="(bow, index) in scores" :key="index">
        <image
@@ -496,17 +603,34 @@ onBeforeUnmount(() => {
        </view>
      </block>
      <BowShotEffect
+        v-if="!shotEffect || !shotEffect.viewportMode"
        :shot="shotEffect && shotEffect.shot"
        :playKey="shotEffect ? shotEffect.key : ''"
        :targetRadius="safeTargetRadius"
-        :targetWidth="targetSize.width"
-        :targetHeight="targetSize.height"
+        :targetLeft="targetRect.left"
+        :targetTop="targetRect.top"
+        :targetWidth="targetRect.width"
+        :targetHeight="targetRect.height"
        :hitOffsetPx="currentHitRadiusPx"
        @impact="shakeTarget"
        @complete="completeShotEffect"
      />
-      <image src="../static/bow-target.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/bow-target.png" mode="widthFix" />
    </view>
+    <BowShotEffect
+      v-if="shotEffect && shotEffect.viewportMode"
+      :shot="shotEffect.shot"
+      :playKey="shotEffect.key"
+      :targetRadius="safeTargetRadius"
+      :targetLeft="targetRect.left"
+      :targetTop="targetRect.top"
+      :targetWidth="targetRect.width"
+      :targetHeight="targetRect.height"
+      :hitOffsetPx="currentHitRadiusPx"
+      :viewportMode="true"
+      @impact="shakeTarget"
+      @complete="completeShotEffect"
+    />
    <view class="footer">
      <PointSwitcher
        :onChange="(val) => (pMode = val)"
@@ -516,6 +640,8 @@ onBeforeUnmount(() => {
    <view class="simul" v-if="env !== 'release'">
      <button @click="simulShoot">模拟</button>
      <button @click="simulShoot2">射箭</button>
+      <button @click="openAim">开瞄</button>
+      <button @click="closeAim">关瞄</button>
    </view>
  </view>
 </template>
@@ -1,13 +1,15 @@
 <script setup>
-import { ref, computed, onMounted, onBeforeUnmount } from "vue";
+import { ref } from "vue";
 import { onShow } from "@dcloudio/uni-app";
 import AppBackground from "@/components/AppBackground.vue";
 import Header from "@/components/Header.vue";
 import ScreenHint from "@/components/ScreenHint.vue";
 import BackToGame from "@/components/BackToGame.vue";
+import DeviceChargingDialog from "@/components/DeviceChargingDialog.vue";
 import {laserAimAPI, getBattleAPI, matchGameAPI} from "@/apis";
 import { capsuleHeight, debounce } from "@/util";
-import AudioManager from "@/audioManager";
+import { returnToBattle } from "@/utils/matchReturn";
+const emit = defineEmits(["scrolltolower"]);
 const props = defineProps({
  title: {
    type: String,
@@ -25,6 +27,10 @@ const props = defineProps({
    type: Boolean,
    default: true,
  },
+  usePageScroll: {
+    type: Boolean,
+    default: false,
+  },
  isHome: {
    type: Boolean,
    default: false,
@@ -41,6 +47,10 @@ const props = defineProps({
    type: Boolean,
    default: true,
  },
+  headerClass: {
+    type: String,
+    default: "",
+  },
  titleStyle: {
    type: [String, Object, Array],
    default: () => ({}),
@@ -49,14 +59,19 @@ const props = defineProps({
    type: Boolean,
    default: true,
  },
+  loading: {
+    type: Boolean,
+    default: false,
+  },
+  loadingText: {
+    type: String,
+    default: "",
+  },
 });
 const isIOS = uni.getDeviceInfo().osName === "ios";
 const showHint = ref(false);
 const hintType = ref(0);
 const isLoading = ref(false);
-const audioInitProgress = ref(1);
-const audioProgress = ref(0);
-const audioTimer = ref(null);

 const showGlobalHint = (type) => {
  hintType.value = type;
@@ -67,49 +82,21 @@ const hideGlobalHint = () => {
  showHint.value = false;
 };

-const restart = () => {
-  uni.restartMiniProgram({
-    path: "/pages/index",
-  });
-};
-
-const checkAudioProgress = async () => {
-  return new Promise((resolve, reject) => {
-    try {
-      audioInitProgress.value = AudioManager.getLoadProgress();
-      if (audioInitProgress.value === 1) return resolve();
-      audioTimer.value = setInterval(() => {
-        audioProgress.value = AudioManager.getLoadProgress();
-        if (audioProgress.value === 1) {
-          setTimeout(() => {
-            audioInitProgress.value = 1;
-          }, 200);
-          clearInterval(audioTimer.value);
-          resolve();
-        }
-      }, 200);
-    } catch (err) {
-      reject(err);
-    }
-  });
-};
-
-const audioFinalProgress = computed(() => {
-  const left = 1 - audioInitProgress.value;
-  return Math.max(0, (audioProgress.value - audioInitProgress.value) / left);
-});
-
-onBeforeUnmount(() => {
-  if (audioTimer.value) clearInterval(audioTimer.value);
-});
-
 onShow(() => {
  uni.$showHint = showGlobalHint;
  uni.$hideHint = hideGlobalHint;
-  uni.$checkAudio = checkAudioProgress;
  showHint.value = false;
 });

+const navigateTo = (url) =>
+  new Promise((resolve, reject) => {
+    uni.navigateTo({
+      url,
+      success: resolve,
+      fail: reject,
+    });
+  });
+
 const backToGame = debounce(async () => {
  if (isLoading.value) return; // 防止重复点击

@@ -117,16 +104,7 @@ const backToGame = debounce(async () => {
    isLoading.value = true;
    const result = await getBattleAPI();
    if (result && result.matchId) {
-      await checkAudioProgress();
-      if (result.mode <= 3) {
-        uni.navigateTo({
-          url: `/pages/team-battle/index?battleId=${result.matchId}`,
-        });
-      } else {
-        uni.navigateTo({
-          url: `/pages/melee-battle?battleId=${result.matchId}`,
-        });
-      }
+      await returnToBattle(result, navigateTo);
    }
  } catch (error) {
    console.error("获取当前游戏失败:", error);
@@ -154,21 +132,38 @@ const goCalibration = async () => {
 <template>
  <view :style="{ paddingTop: capsuleHeight + 'px' }">
    <AppBackground :type="bgType" :bgColor="bgColor" />
+    <slot v-if="$slots.header" name="header"></slot>
    <Header
-      v-if="!isHome"
+      v-else-if="!isHome"
+      :class="headerClass"
      :title="title"
      :onBack="onBack"
      :whiteBackArrow="whiteBackArrow"
      :titleStyle="titleStyle"
+      :style="
+        usePageScroll
+          ? {
+              position: 'sticky',
+              top: capsuleHeight + 'px',
+              zIndex: 10,
+            }
+          : undefined
+      "
    />
    <BackToGame v-if="showBackToGame" />
+    <view v-if="usePageScroll">
+      <slot></slot>
+    </view>
    <scroll-view
+      v-else
      :scroll-y="scroll"
      :enhanced="true"
      :bounces="false"
      :show-scrollbar="false"
+      :lower-threshold="120"
+      @scrolltolower="emit('scrolltolower')"
      :style="{
-        height: `calc(100vh - ${capsuleHeight + (isHome ? 0 : 50)}px - ${
+        height: `calc(100vh - ${capsuleHeight + (($slots.header || !isHome) ? 50 : 0)}px - ${
          $slots.bottom && showBottom ? (isIOS ? '75px' : '65px') : '0px'
        })`,
      }"
@@ -224,24 +219,19 @@ const goCalibration = async () => {
        </view>
      </view>
    </ScreenHint>
-    <view v-if="audioInitProgress < 1" class="audio-progress">
+    <view v-if="loading" class="audio-progress">
      <image
        src="https://static.shelingxingqiu.com/attachment/2025-11-26/deihtj15xjwcz3c1tx.png"
        mode="widthFix"
      />
      <view>
-        <view :style="{ width: `${audioFinalProgress * 100}%` }">
-          <!-- <image
-            src="https://static.shelingxingqiu.com/attachment/2025-11-24/degu91a7si77sg9jqv.png"
-            mode="widthFix"
-          /> -->
-        </view>
+        <view :style="{ width: '100%' }"></view>
      </view>
      <view>
-        <text>若加载时间过长，请</text>
-        <button hover-class="none" @click="restart">点击这里重启</button>
+        <text>{{ loadingText || "加载中..." }}</text>
      </view>
    </view>
+    <DeviceChargingDialog />
  </view>
 </template>

@@ -283,6 +273,7 @@ const goCalibration = async () => {
  color: #666;
  opacity: 0.6;
 }
+
 .audio-progress {
  z-index: 999;
  width: 100vw;
@@ -296,11 +287,13 @@ const goCalibration = async () => {
  align-items: center;
  justify-content: center;
 }
+
 .audio-progress > image:nth-child(1) {
  width: 140rpx;
  height: 150rpx;
  margin-bottom: 20rpx;
 }
+
 .audio-progress > view:nth-child(2) {
  width: 380rpx;
  height: 6rpx;
@@ -311,34 +304,24 @@ const goCalibration = async () => {
  align-items: flex-start;
  justify-content: flex-start;
 }
+
 .audio-progress > view:nth-child(2) > view {
-  background: #ffe431;
+  width: 100%;
  min-height: 6rpx;
+  background: #ffe431;
  border-radius: 4rpx;
-  display: flex;
-  align-items: center;
-  justify-content: flex-end;
-  transition: width 0.5s ease;
-}
-.audio-progress > view:nth-child(2) > view > image {
-  width: 46rpx;
-  height: 26rpx;
 }
+
 .audio-progress > view:nth-child(3) {
  display: flex;
  align-items: center;
  justify-content: center;
 }
+
 .audio-progress > view:nth-child(3) > text {
  font-size: 22rpx;
  color: #a2a2a2;
  text-align: center;
  line-height: 32rpx;
 }
-.audio-progress > view:nth-child(3) > button {
-  font-size: 22rpx;
-  color: #ffe431;
-  line-height: 32rpx;
-  padding: 20rpx 0;
-}
 </style>
@@ -36,6 +36,7 @@ const createRoom = debounce(async () => {
  }
  if (loading.value === true) return;
  loading.value = true;
+  let keepLoading = false;
  let size = 2;
  if (battleMode.value === 2) size = 10;
  if (battleMode.value === 3) size = 4;
@@ -49,14 +50,18 @@ const createRoom = debounce(async () => {
    if (result.number) {
      props.onConfirm();
      await joinRoomAPI(result.number);
+      keepLoading = true;
      uni.navigateTo({
        url: "/pages/battle-room?roomNumber=" + result.number + "&target=" + targetMode.value,
+        fail: () => {
+          loading.value = false;
+        },
      });
    }
  } catch (error) {
    console.log(error);
  } finally {
-    loading.value = false;
+    if (!keepLoading) loading.value = false;
  }
 });
 </script>
@@ -64,7 +69,7 @@ const createRoom = debounce(async () => {
  <view class="container">
    <view class="target-options-header">
      <view class="target-options-header-line-left"></view>
-      <image class="target-options-header-title-img" src="../static/choose-battle-mode.png" mode="widthFix" />
+      <image class="target-options-header-title-img" src="https://static.shelingxingqiu.com/shootmini/static/choose-battle-mode.png" mode="widthFix" />
      <view class="target-options-header-line-right"></view>
    </view>
    <view class="create-options">
@@ -112,7 +117,7 @@ const createRoom = debounce(async () => {
        <text>40厘米全环靶</text>
      </view>
    </view>
-    <SButton :onClick="() => $clickSound(createRoom)">创建房间</SButton>
+    <SButton :disabled="loading" :onClick="() => { $clickSound(); return createRoom(); }">创建房间</SButton>
  </view>
 </template>

@@ -0,0 +1,22 @@
+<script setup>
+import { storeToRefs } from "pinia";
+import ModalDialog from "@/components/ModalDialog.vue";
+import useStore from "@/store";
+
+const chargingNotice =
+  "检测到智能弓箭已开始充电，为保护电池，设备即将自动关机。\n(注意:此时拔出充电线将会重启设备。)";
+
+const store = useStore();
+const { deviceChargingDialogVisible } = storeToRefs(store);
+const { hideDeviceChargingDialog } = store;
+</script>
+
+<template>
+  <ModalDialog
+    :show="deviceChargingDialogVisible"
+    :content="chargingNotice"
+    :show-cancel="false"
+    confirm-text="我知道了"
+    :on-confirm="hideDeviceChargingDialog"
+  />
+</template>
@@ -12,13 +12,13 @@ defineProps({
 const bubbleTypes = [
  "../static/long-bubble.png",
  "../static/long-bubble-middle.png",
-  "../static/long-bubble-tall.png",
+  "https://static.shelingxingqiu.com/shootmini/static/long-bubble-tall.png",
 ];
 </script>

 <template>
  <view class="container">
-    <image src="../static/shooter.png" mode="widthFix" />
+    <image src="https://static.shelingxingqiu.com/shootmini/static/shooter.png" mode="widthFix" />
    <view>
      <image
        v-if="!noBg"
@@ -125,6 +125,8 @@ onBeforeUnmount(() => {
    <view
      :style="[{ color: whiteBackArrow ? '#fff' : '#000' }, titleStyle]"
    >
+      <slot v-if="$slots.title" name="title"></slot>
+      <template v-else>
      <view
        v-if="currentPage === 'pages/point-book'"
        class="user-header"
@@ -190,6 +192,7 @@ onBeforeUnmount(() => {
          >
        </view>
      </block>
+      </template>
    </view>
    <view v-if="pointBook" class="point-book-info">
      <text>{{ pointBook.bowType.name }}</text>
@@ -2,7 +2,11 @@
 import { ref, watch, onMounted, onBeforeUnmount } from "vue";
 import audioManager from "@/audioManager";
 import { MESSAGETYPESV2 } from "@/constants";
-import { getDirectionText } from "@/util";
+import {
+  getDirectionText,
+  getInvalidShotAudioKey,
+  getInvalidShotText,
+} from "@/util";

 import useStore from "@/store";
 import { storeToRefs } from "pinia";
@@ -88,10 +92,10 @@ async function onReceiveMessage(message) {
    currentRoundEnded.value = true;
  } else if (type === MESSAGETYPESV2.InvalidShot) {
    uni.showToast({
-      title: "距离不足，无效",
+      title: getInvalidShotText(shootData),
      icon: "none",
    });
-    audioManager.play("射击无效");
+    audioManager.play(getInvalidShotAudioKey(shootData));
  }
 }

@@ -105,7 +105,7 @@ onBeforeUnmount(() => {
 <template>
  <view class="matching">
    <image
-      src="../static/matching-bg.png"
+      src="https://static.shelingxingqiu.com/shootmini/static/matching-bg.png"
      mode="widthFix"
      class="matching-bg"
    />
@@ -52,19 +52,19 @@ const handleConfirm = () => {
    <view class="modal-wrap scale-in">
      <image
        class="dialog-light"
-        src="../static/common/dialog-light.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/common/dialog-light.png"
        mode="widthFix"
      />
      <image
        class="dialog-icon"
-        src="../static/common/dialog-icon.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/common/dialog-icon.png"
        mode="widthFix"
      />

      <view class="dialog-panel">
        <image
          class="dialog-bg"
-          src="../static/common/dialog-bg.png"
+          src="https://static.shelingxingqiu.com/shootmini/static/common/dialog-bg.png"
          mode="scaleToFill"
        />
        <view class="dialog-content">
@@ -19,7 +19,7 @@ const rowCount = new Array(6).fill(0);
 const getRingText = (arrow) => {
  if (!arrow) return "-";
  if (arrow.ringX && arrow.ring) return "X环";
-  return arrow.ring ? `${arrow.ring}环` : "-";
+  return `${Number(arrow.ring) || 0}环`;
 };
 const isMember = (player = {}) => player.vip === true || player.sVip === true;

@@ -20,13 +20,22 @@ const props = defineProps({
    default: false,
  },
 });
+
+const isMember = (player = {}) => player.vip === true || player.sVip === true;
+
+const getMemberNicknameClass = (player = {}) => [
+  "member-nickname",
+  player.vip === true && player.sVip !== true ? "member-nickname--vip" : "",
+  player.sVip === true ? "member-nickname--svip" : "",
+];
+
 const seats = new Array(props.total).fill(1);
 </script>

 <template>
  <view class="players">
    <view v-for="(_, index) in seats" :key="index">
-      <image src="../static/player-bg.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/player-bg.png" mode="widthFix" />
      <view v-if="players[index] && players[index].name" class="avatar">
        <Avatar
          :src="players[index].avatar || '../static/user-icon.png'"
@@ -40,10 +49,27 @@ const seats = new Array(props.total).fill(1);
      <view v-else class="player-unknow">
        <image src="../static/question-mark.png" mode="widthFix" />
      </view>
-      <text v-if="players[index] && players[index].name">{{
-        players[index].name
-      }}</text>
-      <text v-else :style="{ color: '#fff9' }">虚位以待</text>
+      <view
+        v-if="players[index] && players[index].name && isMember(players[index])"
+        :class="['player-seat-name', ...getMemberNicknameClass(players[index])]"
+      >
+        <text class="member-nickname__text">{{ players[index].name }}</text>
+        <text
+          v-if="players[index].sVip === true"
+          class="member-nickname__shine"
+        >
+          {{ players[index].name }}
+        </text>
+      </view>
+      <text
+        v-else-if="players[index] && players[index].name"
+        class="player-seat-name"
+      >
+        {{ players[index].name }}
+      </text>
+      <text v-else class="player-seat-name" :style="{ color: '#fff9' }">
+        虚位以待
+      </text>
      <view v-if="index === 0" class="founder">管理员</view>
      <!-- <image
        :src="`../static/player-${index + 1}.png`"
@@ -108,7 +134,7 @@ const seats = new Array(props.total).fill(1);
  height: 28rpx;
  line-height: 28rpx;
 }
-.players > view > text:nth-child(3) {
+.player-seat-name {
  width: 20vw;
  white-space: nowrap;
  overflow: hidden;
@@ -65,7 +65,7 @@ onMounted(() => {
      </view>
    </view>
    <view class="right-part">
-      <image src="../static/bow-target.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/bow-target.png" mode="widthFix" />
      <view class="arrow-amount">
        <text>{{ data.actualTotalRing }}</text>
        <text>/</text>
@@ -93,7 +93,7 @@ onMounted(async () => {

 <template>
  <view class="container">
-    <image src="../static/donate.png" mode="widthFix" />
+    <image src="https://static.shelingxingqiu.com/shootmini/static/donate.png" mode="widthFix" />
    <text>感谢您对我们公益项目的支持！</text>
    <view class="amounts">
      <button
@@ -1,5 +1,5 @@
 <script setup>
-import { ref, watch, onMounted, onBeforeUnmount } from "vue";
+import { ref, watch } from "vue";
 const props = defineProps({
  rowCount: {
    type: Number,
@@ -26,45 +26,39 @@ const items = ref(new Array(props.total).fill(9));
 const width = ref(92);
 const itemWidth = ref(0);
 const bgImages = [
-  "../static/complete-light1.png",
-  "../static/complete-light2.png",
+  "https://static.shelingxingqiu.com/shootmini/static/complete-light1.png",
+  "https://static.shelingxingqiu.com/shootmini/static/complete-light2.png",
 ];
-const bgIndex = ref(0);
 watch(
  () => props.total,
  (newValue) => {
    items.value = new Array(newValue).fill(9);
  }
 );
-const timer = ref(null);
-onMounted(() => {
-  timer.value = setInterval(() => {
-    bgIndex.value = bgIndex.value === 0 ? 1 : 0;
-  }, 200);
-});
-onBeforeUnmount(() => {
-  if (timer.value) {
-    clearInterval(timer.value);
-  }
-});
 </script>
 <template>
  <view class="container">
-    <image
-      v-if="total > 0 && arrows.length === total && completeEffect"
-      :src="bgImages[bgIndex]"
-      class="complete-light"
-      :style="{
-        width: `calc(${(100 / (rowCount + 2)) * rowCount}vw + ${
-          (100 / (total * 2)) * (rowCount * 2 + (total === 12 ? 8 : 24))
-        }px)`,
-        height: `calc(${(100 / (rowCount + 2)) * (total / rowCount)}vw + ${
-          (100 / (total * 2)) *
-          ((total / rowCount) * 2 + (total === 12 ? 7 : 24))
-        }px)`,
-        top: `${total === 12 ? -2 : -3}vw`,
-      }"
-    />
+    <template v-if="total > 0 && arrows.length === total && completeEffect">
+      <image
+        v-for="(image, index) in bgImages"
+        :key="image"
+        :src="image"
+        :class="[
+          'complete-light',
+          index === 0 ? 'complete-light--first' : 'complete-light--second',
+        ]"
+        :style="{
+          width: `calc(${(100 / (rowCount + 2)) * rowCount}vw + ${
+            (100 / (total * 2)) * (rowCount * 2 + (total === 12 ? 8 : 24))
+          }px)`,
+          height: `calc(${(100 / (rowCount + 2)) * (total / rowCount)}vw + ${
+            (100 / (total * 2)) *
+            ((total / rowCount) * 2 + (total === 12 ? 7 : 24))
+          }px)`,
+          top: `${total === 12 ? -2 : -3}vw`,
+        }"
+      />
+    </template>
    <view
      v-for="(_, index) in items"
      :key="index"
@@ -121,4 +115,30 @@ onBeforeUnmount(() => {
 .complete-light {
  position: absolute;
 }
+.complete-light--first {
+  animation: complete-light-first 400ms steps(1, end) infinite;
+}
+.complete-light--second {
+  animation: complete-light-second 400ms steps(1, end) infinite;
+}
+@keyframes complete-light-first {
+  0%,
+  49.9% {
+    opacity: 1;
+  }
+  50%,
+  100% {
+    opacity: 0;
+  }
+}
+@keyframes complete-light-second {
+  0%,
+  49.9% {
+    opacity: 0;
+  }
+  50%,
+  100% {
+    opacity: 1;
+  }
+}
 </style>
@@ -5,13 +5,19 @@ const props = defineProps({
    default: () => [],
  },
 });
-const getSum = (a, b, c) => {
-  const sum = (Number(a) || 0) + (Number(b) || 0) + (Number(c) || 0);
-  return sum > 0 ? sum + "环" : "-";
+const getSum = (...arrows) => {
+  const recordedArrows = arrows.filter(Boolean);
+  if (!recordedArrows.length) return "-";
+  const sum = recordedArrows.reduce(
+    (total, arrow) => total + (Number(arrow.ring) || 0),
+    0
+  );
+  return `${sum}环`;
 };
 const roundsName = ["第一轮", "第二轮", "第三轮", "第四轮"];
-const getShowText = (arrow = {}) => {
-  return arrow.ring ? (arrow.ringX ? "X" : arrow.ring + "环") : "-";
+const getShowText = (arrow) => {
+  if (!arrow) return "-";
+  return arrow.ringX ? "X" : `${Number(arrow.ring) || 0}环`;
 };
 </script>
 <template>
@@ -57,19 +57,22 @@ onMounted(() => {
 });

 const getRing = (arrow) => {
+  if (!arrow) return "-";
  if (arrow.ringX) return "X";
-  return arrow.ring ? arrow.ring : "-";
+  return Number(arrow.ring) || 0;
 };

 const arrows = computed(() => {
-  const data = new Array(props.total).fill({ ring: 0 });
+  const data = new Array(props.total).fill(null);
  (props.result.details || []).forEach((arrow, index) => {
    data[index] = arrow;
  });
  return data;
 });

-const validArrows = computed(() => arrows.value.filter((a) => !!a.ring).length);
+const validArrows = computed(
+  () => arrows.value.filter((a) => Number(a?.ring) > 0).length
+);
 const isMember = computed(() => user.value.vip === true || user.value.sVip === true);
 const openCoachComment = () => {
  if (!isMember.value) return;
@@ -81,7 +84,7 @@ const openCoachComment = () => {
  <view class="container">
    <view :class="['container-header', showPanel ? 'scale-in' : 'scale-out']">
      <image :src="tipSrc" mode="widthFix" />
-      <image src="../static/finish-frame.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/finish-frame.png" mode="widthFix" />
      <text
        >完成<text class="gold-text">{{ validArrows }}</text
        >箭，获得<text class="gold-text">{{ validArrows }}</text
@@ -27,22 +27,22 @@ const getContentHeight = () => {
    <view class="scale-in" :style="{ height: getContentHeight() }">
      <image
        v-if="mode === 'normal'"
-        src="../static/screen-hint-bg.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/screen-hint-bg.png"
        mode="widthFix"
      />
      <image
        v-if="mode === 'tall'"
-        src="../static/coach-comment.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/coach-comment.png"
        mode="widthFix"
      />
      <image
        v-if="mode === 'square'"
-        src="../static/prompt-bg-square.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/prompt-bg-square.png"
        mode="widthFix"
      />
      <image
        v-if="mode === 'small'"
-        src="../static/finish-frame.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/finish-frame.png"
        mode="widthFix"
      />
      <slot />
@@ -20,7 +20,7 @@ const props = defineProps({
 <template>
  <view class="container" :style="{ display: show ? 'flex' : 'none' }">
    <view class="scale-in">
-      <image src="../static/point-book-tip-bg.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/point-book-tip-bg.png" mode="widthFix" />
      <slot />
    </view>
    <IconButton
@@ -2,7 +2,11 @@
 import { ref, watch, onMounted, onBeforeUnmount, computed } from "vue";
 import audioManager from "@/audioManager";
 import { MESSAGETYPESV2 } from "@/constants";
-import { getDirectionText } from "@/util";
+import {
+  getDirectionText,
+  getInvalidShotAudioKey,
+  getInvalidShotText,
+} from "@/util";

 import useStore from "@/store";
 import { storeToRefs } from "pinia";
@@ -46,6 +50,10 @@ const props = defineProps({
    type: Function,
    default: () => {},
  },
+  endAudioKey: {
+    type: String,
+    default: "比赛结束",
+  },
 });

 const barColor = ref("#fed847");
@@ -144,29 +152,33 @@ async function onReceiveMessage(msg) {
    halfTime.value = false;
    audioManager.play(audioKey);
  } else if (msg.type === MESSAGETYPESV2.BattleEnd) {
-    audioManager.play("比赛结束", false);
+    audioManager.play(props.endAudioKey, false);
  } else if (msg.type === MESSAGETYPESV2.ShootResult) {
    let arrow = {};
    if (msg.details && Array.isArray(msg.details)) {
      arrow = msg.details[msg.details.length - 1];
    } else {
-      if (msg.shootData.playerId !== user.value.id) return;
+      if (!msg.shootData || String(msg.shootData.playerId) !== String(user.value.id)) return;
      if (msg.shootData) arrow = msg.shootData;
    }
    let key = [];
    key.push(arrow.ring ? `${arrow.ringX ? "X" : arrow.ring}环` : "未上靶");
-    if (arrow.angle !== null)
+    if (arrow.angle)
      key.push(`向${getDirectionText(arrow.angle)}调整`);
+    const shouldPlayTententen =
+      arrow.threeConsecutive10Rings === true ||
+      msg.shootData?.threeConsecutive10Rings === true;
+    if (!props.melee && shouldPlayTententen) key.push("tententen");
    audioManager.play(key, false);
  } else if (msg.type === MESSAGETYPESV2.HalfRest) {
    halfTime.value = true;
    audioManager.play("中场休息");
  } else if (msg.type === MESSAGETYPESV2.InvalidShot) {
    uni.showToast({
-      title: "距离不足，无效",
+      title: getInvalidShotText(msg.shootData),
      icon: "none",
    });
-    audioManager.play("射击无效");
+    audioManager.play(getInvalidShotAudioKey(msg.shootData));
  }
 }

@@ -191,7 +203,7 @@ onBeforeUnmount(() => {
 <template>
  <view class="container" :style="{ display: show ? 'block' : 'none' }">
    <view>
-      <image src="../static/shooter.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/shooter.png" mode="widthFix" />
      <text>{{ tipContent }}</text>
      <button hover-class="none" @click="updateSound">
        <image
@@ -32,6 +32,10 @@ const props = defineProps({
    type: Function,
    default: () => {},
  },
+  onSuccess: {
+    type: Function,
+    default: () => {},
+  },
 });
 const agree = ref(false);
 const phone = ref("");
@@ -127,6 +131,7 @@ async function doLogin() {
      clearDevice();
    }
    props.onClose();
+    await props.onSuccess();
  } catch (error) {
    console.log("login error", error);
  } finally {
@@ -0,0 +1,652 @@
+<script setup>
+import {
+  computed,
+  getCurrentInstance,
+  nextTick,
+  onBeforeUnmount,
+  onMounted,
+  ref,
+  watch,
+} from "vue";
+
+const defaultCanvasSize = 300;
+const defaultRingCount = 10;
+const highlightRevealProgressFrames = [0.08, 0.2, 0.38, 0.6, 0.82, 1];
+const highlightRevealFrameInterval = 60;
+
+const props = defineProps({
+  // canvas 唯一标识；不传时组件内部自动生成，避免多个靶面 canvas-id 冲突。
+  canvasId: {
+    type: String,
+    default: "",
+  },
+  // 业务坐标半径，例如 20 表示命中点坐标范围为 -20 到 20。
+  // 当前组件主要用它参与重绘判断，外层命中点定位也应使用同一半径。
+  coordinateRadius: {
+    type: Number,
+    default: 20,
+  },
+  // 是否显示靶心十字辅助线。
+  showCrosshair: {
+    type: Boolean,
+    default: false,
+  },
+  // 是否显示环数文字。
+  showRingLabels: {
+    type: Boolean,
+    default: true,
+  },
+  // 从正上方开始顺时针等分的区域数量。
+  sectorCount: {
+    type: Number,
+    default: 0,
+  },
+  // 当前高亮区域，范围为 1 到 sectorCount。
+  activeSector: {
+    type: Number,
+    default: 0,
+  },
+  // 指定环数，1 到 10；无效值表示高亮整个区域。
+  activeRing: {
+    type: Number,
+    default: 0,
+  },
+  // 每次变化时以固定低帧数重新展开当前高亮扇区；默认关闭。
+  highlightRefreshToken: {
+    type: Number,
+    default: 0,
+  },
+  showSectorLabels: {
+    type: Boolean,
+    default: false,
+  },
+  // 只绘制透明高亮层，不绘制完整靶纸；用于叠加在靶纸图片上。
+  highlightOnly: {
+    type: Boolean,
+    default: false,
+  },
+  // 外部指定 canvas 绘制尺寸；用于让高亮层跟随靶图真实显示区域。
+  canvasWidth: {
+    type: Number,
+    default: 0,
+  },
+  canvasHeight: {
+    type: Number,
+    default: 0,
+  },
+  // 靶纸样式覆盖配置，例如环数、环色、环线颜色、环数字体等。
+  targetStyleConfig: {
+    type: Object,
+    default: () => ({}),
+  },
+  // 十字辅助线样式覆盖配置。
+  crosshairStyle: {
+    type: Object,
+    default: () => ({}),
+  },
+  // 区域分割线样式覆盖配置。
+  sectorStyle: {
+    type: Object,
+    default: () => ({}),
+  },
+  // 区域数字样式覆盖配置。
+  sectorLabelStyle: {
+    type: Object,
+    default: () => ({}),
+  },
+  // 高亮样式覆盖配置。
+  highlightStyle: {
+    type: Object,
+    default: () => ({}),
+  },
+});
+
+const instance = getCurrentInstance();
+const localCanvasId = `target-canvas-${Math.random().toString(36).slice(2, 10)}`;
+const currentCanvasId = computed(() => props.canvasId || localCanvasId);
+const lastDrawKey = ref("");
+const canvasSize = ref({
+  width: defaultCanvasSize,
+  height: defaultCanvasSize,
+});
+let drawRequestGeneration = 0;
+let highlightAnimationGeneration = 0;
+let highlightAnimationTimer = null;
+let mountDrawTimer = null;
+
+// 完整靶纸默认样式，调用方可以通过 targetStyleConfig 局部覆盖。
+const defaultTargetStyleConfig = {
+  ringCount: defaultRingCount,
+  ringColors: {
+    1: "#f8f8f3",
+    2: "#f8f8f3",
+    3: "#595959",
+    4: "#595959",
+    5: "#24aee0",
+    6: "#24aee0",
+    7: "#ff1f35",
+    8: "#ff1f35",
+    9: "#f7d34a",
+    10: "#f7d34a",
+  },
+  ringLineColor: "rgba(150, 150, 150, 0.55)",
+  ringLineWidthRatio: 0.0022,
+  centerDotColor: "#ffffff",
+  centerDotRadiusRatio: 0.0048,
+  ringLabelFontRatio: 0.032,
+  ringLabelDarkColor: "#111111",
+  ringLabelLightColor: "#ffffff",
+};
+
+// 十字辅助线默认样式。
+const defaultCrosshairStyle = {
+  color: "rgba(20, 20, 20, 0.38)",
+  lineWidthRatio: 0.0025,
+};
+
+// 顺时针等分线默认样式。
+const defaultSectorStyle = {
+  color: "rgba(255, 255, 255, 0.82)",
+  lineWidthRatio: 0.004,
+};
+
+// 区域数字默认样式。
+const defaultSectorLabelStyle = {
+  color: "#ffffff",
+  backgroundColor: "rgba(0, 0, 0, 0.62)",
+  fontSizeRatio: 0.075,
+  radiusRatio: 0.76,
+  badgeRadiusRatio: 0.07,
+};
+
+// 高亮区域默认样式。
+const defaultHighlightStyle = {
+  color: "rgba(255, 228, 0, 0.6)",
+  strokeColor: "rgba(254, 216, 71, 0.82)",
+  lineWidthRatio: 0.003,
+};
+
+// 合并默认靶纸样式和外部传入样式，ringColors 单独深合并。
+const mergeTargetStyleConfig = () => ({
+  ...defaultTargetStyleConfig,
+  ...props.targetStyleConfig,
+  ringColors: {
+    ...defaultTargetStyleConfig.ringColors,
+    ...(props.targetStyleConfig?.ringColors || {}),
+  },
+});
+
+// 统一把外部传入值转成有效数字，非法值使用 fallback。
+const getNumber = (value, fallback = 0) => {
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) ? numberValue : fallback;
+};
+
+// 获取指定环数的填充色，兼容数字 key 和字符串 key。
+const getRingColor = (ring, config) => {
+  return config.ringColors?.[ring] || config.ringColors?.[String(ring)] || "#ffffff";
+};
+
+const getPositiveInteger = (value) => {
+  const numberValue = Number(value);
+  return Number.isInteger(numberValue) && numberValue > 0 ? numberValue : 0;
+};
+
+// 正上方作为第一区起始边界，Canvas 角度递增方向即为顺时针。
+const getSectorAngles = (sector, sectorCount) => {
+  const count = getPositiveInteger(sectorCount);
+  const index = getPositiveInteger(sector);
+  if (!count || !index || index > count) return null;
+
+  const step = (Math.PI * 2) / count;
+  const startAngle = -Math.PI / 2 + (index - 1) * step;
+  return {
+    startAngle,
+    endAngle: startAngle + step,
+    middleAngle: startAngle + step / 2,
+  };
+};
+
+// 绘制实心圆，靶纸环区和中心点都会用到。
+const drawCircle = (ctx, centerX, centerY, radius, fillColor) => {
+  ctx.beginPath();
+  ctx.arc(centerX, centerY, radius, 0, Math.PI * 2);
+  ctx.setFillStyle(fillColor);
+  ctx.fill();
+};
+
+// 绘制环形扇区，用于按象限高亮指定环数。
+const drawAnnularSector = (
+  ctx,
+  centerX,
+  centerY,
+  innerRadius,
+  outerRadius,
+  startAngle,
+  endAngle,
+  fillColor,
+  strokeColor = "",
+  lineWidth = 0
+) => {
+  ctx.beginPath();
+  ctx.arc(centerX, centerY, outerRadius, startAngle, endAngle);
+
+  if (innerRadius > 0) {
+    ctx.arc(centerX, centerY, innerRadius, endAngle, startAngle, true);
+  } else {
+    ctx.lineTo(centerX, centerY);
+  }
+
+  ctx.closePath();
+  ctx.setFillStyle(fillColor);
+  ctx.fill();
+
+  if (strokeColor && lineWidth > 0) {
+    ctx.setStrokeStyle(strokeColor);
+    ctx.setLineWidth(lineWidth);
+    ctx.stroke();
+  }
+};
+
+// 从外到内绘制完整靶纸色环。
+const drawTargetRings = (ctx, centerX, centerY, targetRadius, config) => {
+  for (let ring = 1; ring <= config.ringCount; ring += 1) {
+    const radius = targetRadius * ((config.ringCount + 1 - ring) / config.ringCount);
+    drawCircle(ctx, centerX, centerY, radius, getRingColor(ring, config));
+  }
+};
+
+// 高亮后端指定区域；activeRing 有效时只高亮该区域内的单个环。
+const drawSectorHighlight = (
+  ctx,
+  centerX,
+  centerY,
+  targetRadius,
+  config,
+  revealProgress = 1
+) => {
+  const angles = getSectorAngles(props.activeSector, props.sectorCount);
+  if (!angles) return;
+
+  const safeRevealProgress = Math.min(
+    Math.max(getNumber(revealProgress, 1), 0),
+    1
+  );
+  if (safeRevealProgress <= 0) return;
+
+  const ring = getPositiveInteger(props.activeRing);
+  const hasActiveRing = ring >= 1 && ring <= config.ringCount;
+  const innerRadius = hasActiveRing
+    ? targetRadius * ((config.ringCount - ring) / config.ringCount)
+    : 0;
+  const outerRadius = hasActiveRing
+    ? targetRadius * ((config.ringCount + 1 - ring) / config.ringCount)
+    : targetRadius;
+  const style = {
+    ...defaultHighlightStyle,
+    ...props.highlightStyle,
+  };
+
+  drawAnnularSector(
+    ctx,
+    centerX,
+    centerY,
+    innerRadius,
+    outerRadius,
+    angles.startAngle,
+    angles.startAngle +
+      (angles.endAngle - angles.startAngle) * safeRevealProgress,
+    style.color,
+    style.strokeColor,
+    Math.max(1, targetRadius * style.lineWidthRatio)
+  );
+};
+
+// 从正上方开始顺时针绘制所有区域边界。
+const drawSectorLines = (ctx, centerX, centerY, targetRadius) => {
+  const count = getPositiveInteger(props.sectorCount);
+  if (!count) return;
+
+  const style = {
+    ...defaultSectorStyle,
+    ...props.sectorStyle,
+  };
+  const step = (Math.PI * 2) / count;
+
+  ctx.beginPath();
+  for (let index = 0; index < count; index += 1) {
+    const angle = -Math.PI / 2 + index * step;
+    ctx.moveTo(centerX, centerY);
+    ctx.lineTo(
+      centerX + Math.cos(angle) * targetRadius,
+      centerY + Math.sin(angle) * targetRadius
+    );
+  }
+  ctx.setStrokeStyle(style.color);
+  ctx.setLineWidth(Math.max(1, targetRadius * style.lineWidthRatio));
+  ctx.stroke();
+};
+
+// 绘制各环之间的分割线。
+const drawRingLines = (ctx, centerX, centerY, targetRadius, config) => {
+  const lineWidth = Math.max(1, targetRadius * config.ringLineWidthRatio);
+
+  ctx.setStrokeStyle(config.ringLineColor);
+  ctx.setLineWidth(lineWidth);
+
+  for (let index = 1; index <= config.ringCount; index += 1) {
+    const radius = targetRadius * (index / config.ringCount);
+    ctx.beginPath();
+    ctx.arc(centerX, centerY, radius, 0, Math.PI * 2);
+    ctx.stroke();
+  }
+};
+
+// 绘制靶心十字辅助线。
+const drawCrosshair = (ctx, centerX, centerY, targetRadius) => {
+  if (!props.showCrosshair) {
+    return;
+  }
+
+  const style = {
+    ...defaultCrosshairStyle,
+    ...props.crosshairStyle,
+  };
+
+  ctx.beginPath();
+  ctx.moveTo(centerX - targetRadius, centerY);
+  ctx.lineTo(centerX + targetRadius, centerY);
+  ctx.moveTo(centerX, centerY - targetRadius);
+  ctx.lineTo(centerX, centerY + targetRadius);
+  ctx.setStrokeStyle(style.color);
+  ctx.setLineWidth(Math.max(1, targetRadius * style.lineWidthRatio));
+  ctx.stroke();
+};
+
+// 绘制环数文字。
+const drawRingLabels = (ctx, centerX, centerY, targetRadius, config) => {
+  if (!props.showRingLabels) {
+    return;
+  }
+
+  const ringWidth = targetRadius / config.ringCount;
+  const fontSize = Math.max(10, targetRadius * config.ringLabelFontRatio);
+
+  ctx.setFontSize(fontSize);
+  ctx.setTextAlign("center");
+  ctx.setTextBaseline("middle");
+
+  for (let ring = config.ringCount; ring >= 1; ring -= 1) {
+    const y = centerY + (config.ringCount - ring + 0.45) * ringWidth;
+    const color = ring <= 2 ? config.ringLabelDarkColor : config.ringLabelLightColor;
+    ctx.setFillStyle(color);
+    ctx.fillText(String(ring), centerX, y);
+  }
+};
+
+// 在每个区域中线位置绘制编号，编号层始终位于高亮和分割线之上。
+const drawSectorLabels = (ctx, centerX, centerY, targetRadius) => {
+  const count = getPositiveInteger(props.sectorCount);
+  if (!props.showSectorLabels || !count) return;
+
+  const style = {
+    ...defaultSectorLabelStyle,
+    ...props.sectorLabelStyle,
+  };
+  const labelRadius = targetRadius * style.radiusRatio;
+  const badgeRadius = Math.max(10, targetRadius * style.badgeRadiusRatio);
+
+  ctx.setFontSize(Math.max(11, targetRadius * style.fontSizeRatio));
+  ctx.setTextAlign("center");
+  ctx.setTextBaseline("middle");
+
+  for (let sector = 1; sector <= count; sector += 1) {
+    const angles = getSectorAngles(sector, count);
+    const x = centerX + Math.cos(angles.middleAngle) * labelRadius;
+    const y = centerY + Math.sin(angles.middleAngle) * labelRadius;
+    drawCircle(ctx, x, y, badgeRadius, style.backgroundColor);
+    ctx.setFillStyle(style.color);
+    ctx.fillText(String(sector), x, y);
+  }
+};
+
+// 生成本次绘制状态的唯一 key，用于避免相同内容重复 draw。
+const getDrawKey = (width, height) => {
+  return JSON.stringify({
+    width,
+    height,
+    coordinateRadius: props.coordinateRadius,
+    showCrosshair: props.showCrosshair,
+    showRingLabels: props.showRingLabels,
+    sectorCount: props.sectorCount,
+    activeSector: props.activeSector,
+    activeRing: props.activeRing,
+    showSectorLabels: props.showSectorLabels,
+    targetStyleConfig: props.targetStyleConfig,
+    crosshairStyle: props.crosshairStyle,
+    sectorStyle: props.sectorStyle,
+    sectorLabelStyle: props.sectorLabelStyle,
+    highlightStyle: props.highlightStyle,
+    highlightOnly: props.highlightOnly,
+  });
+};
+
+// 主绘制入口：根据 highlightOnly 决定画完整靶纸，还是只画透明高亮层。
+const drawTarget = ({ force = false, highlightProgress = 1 } = {}) => {
+  const width = Math.max(getNumber(canvasSize.value.width, defaultCanvasSize), 1);
+  const height = Math.max(getNumber(canvasSize.value.height, defaultCanvasSize), 1);
+  const drawKey = getDrawKey(width, height);
+
+  if (!force && drawKey === lastDrawKey.value) {
+    return;
+  }
+
+  const size = Math.min(width, height);
+  const centerX = width / 2;
+  const centerY = height / 2;
+  const targetRadius = size / 2;
+  const config = mergeTargetStyleConfig();
+  const ctx = uni.createCanvasContext(currentCanvasId.value, instance?.proxy);
+
+  ctx.clearRect(0, 0, width, height);
+
+  if (!props.highlightOnly) {
+    drawTargetRings(ctx, centerX, centerY, targetRadius, config);
+  }
+
+  drawSectorHighlight(
+    ctx,
+    centerX,
+    centerY,
+    targetRadius,
+    config,
+    highlightProgress
+  );
+
+  if (!props.highlightOnly) {
+    drawRingLines(ctx, centerX, centerY, targetRadius, config);
+    drawCircle(
+      ctx,
+      centerX,
+      centerY,
+      Math.max(1, targetRadius * config.centerDotRadiusRatio),
+      config.centerDotColor
+    );
+    drawCrosshair(ctx, centerX, centerY, targetRadius);
+    drawRingLabels(ctx, centerX, centerY, targetRadius, config);
+  }
+
+  // 高亮先画，等分线和编号后画，避免高亮覆盖区域边界。
+  drawSectorLines(ctx, centerX, centerY, targetRadius);
+  drawSectorLabels(ctx, centerX, centerY, targetRadius);
+
+  ctx.draw();
+  lastDrawKey.value = highlightProgress >= 1 ? drawKey : "";
+};
+
+const cancelHighlightAnimation = () => {
+  highlightAnimationGeneration += 1;
+  if (highlightAnimationTimer) {
+    clearTimeout(highlightAnimationTimer);
+    highlightAnimationTimer = null;
+  }
+};
+
+// 固定 6 帧展开黄色扇区，避免对原生 canvas 节点做缩放导致低端机错位。
+const runHighlightRevealAnimation = () => {
+  cancelHighlightAnimation();
+  const generation = highlightAnimationGeneration;
+  let frameIndex = 0;
+
+  const drawNextFrame = () => {
+    if (generation !== highlightAnimationGeneration) return;
+
+    drawTarget({
+      force: true,
+      highlightProgress: highlightRevealProgressFrames[frameIndex],
+    });
+    frameIndex += 1;
+
+    if (frameIndex < highlightRevealProgressFrames.length) {
+      highlightAnimationTimer = setTimeout(
+        drawNextFrame,
+        highlightRevealFrameInterval
+      );
+    } else {
+      highlightAnimationTimer = null;
+    }
+  };
+
+  drawNextFrame();
+};
+
+const setCanvasSizeAndDraw = async (
+  width,
+  height,
+  { animateHighlight = false, requestGeneration } = {}
+) => {
+  canvasSize.value = {
+    width: width > 0 ? width : defaultCanvasSize,
+    height: height > 0 ? height : width || defaultCanvasSize,
+  };
+
+  await nextTick();
+  if (requestGeneration !== drawRequestGeneration) return;
+
+  const canAnimateHighlight =
+    animateHighlight &&
+    props.highlightOnly &&
+    !!getSectorAngles(props.activeSector, props.sectorCount);
+
+  if (canAnimateHighlight) {
+    runHighlightRevealAnimation();
+  } else {
+    cancelHighlightAnimation();
+    drawTarget();
+  }
+};
+
+// 读取 canvas 实际渲染尺寸后再绘制，保证小程序真机尺寸和坐标一致。
+const measureAndDraw = ({ animateHighlight = false } = {}) => {
+  const requestGeneration = ++drawRequestGeneration;
+  const propWidth = Math.round(getNumber(props.canvasWidth, 0));
+  const propHeight = Math.round(getNumber(props.canvasHeight, 0));
+
+  if (propWidth > 0 && propHeight > 0) {
+    setCanvasSizeAndDraw(propWidth, propHeight, {
+      animateHighlight,
+      requestGeneration,
+    });
+    return;
+  }
+
+  const query = uni.createSelectorQuery().in(instance?.proxy);
+
+  query
+    .select(`#${currentCanvasId.value}`)
+    .boundingClientRect(async (rect) => {
+      if (requestGeneration !== drawRequestGeneration) return;
+
+      const width = Math.round(getNumber(rect?.width, defaultCanvasSize));
+      const height = Math.round(getNumber(rect?.height, width || defaultCanvasSize));
+
+      await setCanvasSizeAndDraw(width, height, {
+        animateHighlight,
+        requestGeneration,
+      });
+    })
+    .exec();
+};
+
+// 等待 Vue 完成 DOM 更新后重新测量和绘制。
+const scheduleDraw = async ({ animateHighlight = false } = {}) => {
+  await nextTick();
+  measureAndDraw({ animateHighlight });
+};
+
+watch(
+  () => [
+    props.coordinateRadius,
+    props.showCrosshair,
+    props.showRingLabels,
+    props.sectorCount,
+    props.activeSector,
+    props.activeRing,
+    props.highlightRefreshToken,
+    props.showSectorLabels,
+    props.highlightOnly,
+    props.canvasWidth,
+    props.canvasHeight,
+    props.targetStyleConfig,
+    props.crosshairStyle,
+    props.sectorStyle,
+    props.sectorLabelStyle,
+    props.highlightStyle,
+  ],
+  (currentValues, previousValues = []) => {
+    const refreshTokenIndex = 6;
+    const refreshToken = Number(currentValues[refreshTokenIndex]);
+    const previousRefreshToken = Number(previousValues[refreshTokenIndex]);
+    const animateHighlight =
+      Number.isFinite(refreshToken) &&
+      refreshToken > 0 &&
+      refreshToken !== previousRefreshToken;
+
+    return scheduleDraw({ animateHighlight });
+  },
+  {
+    deep: true,
+  }
+);
+
+onMounted(() => {
+  mountDrawTimer = setTimeout(measureAndDraw, 30);
+});
+
+onBeforeUnmount(() => {
+  drawRequestGeneration += 1;
+  cancelHighlightAnimation();
+  if (mountDrawTimer) {
+    clearTimeout(mountDrawTimer);
+    mountDrawTimer = null;
+  }
+});
+</script>
+
+<template>
+  <canvas
+    :id="currentCanvasId"
+    class="target-canvas"
+    :canvas-id="currentCanvasId"
+    :width="canvasSize.width"
+    :height="canvasSize.height"
+  />
+</template>
+
+<style scoped>
+.target-canvas {
+  display: block;
+  width: 100%;
+  height: 100%;
+}
+</style>
@@ -1,12 +1,17 @@
 <script setup>
 import { ref, watch } from "vue";
 import SButton from "@/components/SButton.vue";
+import audioManager from "@/audioManager";

 const props = defineProps({
  show: {
    type: Boolean,
    default: false,
  },
+  clickSound: {
+    type: Boolean,
+    default: false,
+  },
  onClose: {
    type: Function,
    default: () => {},
@@ -39,7 +44,19 @@ watch(
  {}
 );

+const playClickSound = () => {
+  if (props.clickSound) {
+    audioManager.play("点击按钮");
+  }
+};
+
+const handleSelectTarget = (target) => {
+  playClickSound();
+  selectedTarget.value = target;
+};
+
 const handleConfirm = () => {
+  playClickSound();
  props.onConfirm(selectedTarget.value);
  props.onClose();
 };
@@ -70,14 +87,14 @@ const handleConfirm = () => {
      <view class="target-options">
        <view
          :class="{ 'target-btn': true, 'target-choosen': selectedTarget === 1 }"
-          @click="() => (selectedTarget = 1)"
+          @click="handleSelectTarget(1)"
        >
          <text>20厘米全环靶</text>
        </view>
        <view style="width: 30rpx"></view>
        <view
          :class="{ 'target-btn': true, 'target-choosen': selectedTarget === 2 }"
-          @click="() => (selectedTarget = 2)"
+          @click="handleSelectTarget(2)"
        >
          <text>40厘米全环靶</text>
        </view>
@@ -194,4 +211,4 @@ const handleConfirm = () => {
  color: #fed847;
  border: 4rpx solid #fed847;
 }
-</style>
+</style>
@@ -6,10 +6,16 @@ import Avatar from "@/components/Avatar.vue";
 import audioManager from "@/audioManager";
 import { simulShootAPI } from "@/apis";
 import { MESSAGETYPESV2 } from "@/constants";
+import {
+  getDistanceCheckAudioKey,
+  getDistanceCheckText,
+  getShootValidation,
+} from "@/util";
 import useStore from "@/store";
 import { storeToRefs } from "pinia";
 const store = useStore();
 const { user, device } = storeToRefs(store);
+const emit = defineEmits(["passed"]);
 const props = defineProps({
  guide: {
    type: Boolean,
@@ -23,18 +29,50 @@ const props = defineProps({
    type: Number,
    default: 15,
  },
+  targetType: {
+    type: [Number, String],
+    default: 40,
+  },
+  autoStart: {
+    type: Boolean,
+    default: false,
+  },
 });
 const arrow = ref({});
 const distance = ref(0);
+const statusText = ref("");
 const showsimul = ref(false);
 const count = ref(props.count);
 const timer = ref(null);
+const autoStartPending = ref(false);
+const autoStartTriggered = ref(false);
+let autoStartTimer = null;
+const DISTANCE_PASSED_AUDIO_KEY = "站距合格，靶纸正确";
+const AUTO_START_TIMEOUT_MS = 6000;
+
+const clearAutoStartTimer = () => {
+  if (!autoStartTimer) return;
+  clearTimeout(autoStartTimer);
+  autoStartTimer = null;
+};
+
+const triggerAutoStart = () => {
+  if (!autoStartPending.value || autoStartTriggered.value) return;
+  clearAutoStartTimer();
+  autoStartPending.value = false;
+  autoStartTriggered.value = true;
+  emit("passed");
+};
+
+const onAudioEnded = (key) => {
+  if (key === DISTANCE_PASSED_AUDIO_KEY) triggerAutoStart();
+};

 const updateTimer = (value) => {
  count.value = Math.round(value);
 };
 onMounted(() => {
-  audioManager.play("请射箭测试距离");
+  audioManager.play("请射箭！测试站距与靶纸");
  if (props.isBattle) {
    timer.value = setInterval(() => {
      count.value -= 1;
@@ -42,23 +80,43 @@ onMounted(() => {
    }, 1000);
  }
  uni.$on("update-timer", updateTimer);
+  uni.$on("audioEnded", onAudioEnded);
 });
 onBeforeUnmount(() => {
  if (timer.value) clearInterval(timer.value);
+  clearAutoStartTimer();
  uni.$off("update-timer", updateTimer);
+  uni.$off("audioEnded", onAudioEnded);
 });

 async function onReceiveMessage(msg) {
  if (Array.isArray(msg)) return;
  if (msg.type === MESSAGETYPESV2.TestDistance) {
-    distance.value = Number((msg.shootData.distance / 100).toFixed(2));
-    if (distance.value >= 5) audioManager.play("距离合格");
-    else audioManager.play("距离不足");
+    if (autoStartPending.value || autoStartTriggered.value) return;
+    const rawDistance = Number(msg.shootData?.distance ?? msg.shootData?.dst);
+    distance.value = Number.isFinite(rawDistance)
+      ? Number((rawDistance / 100).toFixed(2))
+      : 0;
+    statusText.value = getDistanceCheckText(msg.shootData);
+    const audioKey = getDistanceCheckAudioKey(msg.shootData);
+    const validation = getShootValidation(msg.shootData);
+    if (props.autoStart && validation.distanceOk && validation.targetOk) {
+      autoStartPending.value = true;
+      autoStartTimer = setTimeout(triggerAutoStart, AUTO_START_TIMEOUT_MS);
+    }
+    audioManager.play(audioKey);
  }
 }

 const simulShoot = async () => {
-  if (device.value.deviceId) await simulShootAPI(device.value.deviceId);
+  if (device.value.deviceId) {
+    await simulShootAPI(
+      device.value.deviceId,
+      undefined,
+      undefined,
+      props.targetType
+    );
+  }
 };

 onMounted(() => {
@@ -96,13 +154,12 @@ onBeforeUnmount(() => {
        模拟射箭
      </button>
      <view class="warnning-text">
-        <block v-if="distance > 0">
-          <text>当前距离{{ distance }}米</text>
-          <text v-if="distance >= 5">已达到距离要求</text>
-          <text v-else>请调整站位</text>
+        <block v-if="statusText">
+          <text v-if="distance > 0">当前距离{{ distance }}米</text>
+          <text>{{ statusText }}</text>
        </block>
        <block v-else>
-          <text>请射箭，测试站距</text>
+          <text>请射箭，测试站距与靶纸</text>
        </block>
      </view>
      <view class="user-row">
@@ -111,9 +168,9 @@ onBeforeUnmount(() => {
      </view>
    </view>
    <view v-if="isBattle" class="ready-timer">
-      <image src="../static/test-tip.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/test-tip.png" mode="widthFix" />
      <view v-if="count >= 0">
-        <text>具体正式比赛还有</text>
+        <text>距离正式比赛还有</text>
        <text>{{ count }}</text>
        <text>秒</text>
      </view>
@@ -9,11 +9,13 @@ const props = defineProps({
 const show = ref(false);
 const count = ref(props.countdown);
 const timer = ref(null);
+const showTimer = ref(null);
 const updateTimer = (value) => {
  count.value = Math.round(value);
 };
 onMounted(() => {
-  setTimeout(() => {
+  showTimer.value = setTimeout(() => {
+    showTimer.value = null;
    show.value = true;
    timer.value = setInterval(() => {
      if (count.value === 0) {
@@ -27,7 +29,10 @@ onMounted(() => {
  uni.$on("update-timer", updateTimer);
 });
 onBeforeUnmount(() => {
+  if (showTimer.value) clearTimeout(showTimer.value);
+  showTimer.value = null;
  if (timer.value) clearInterval(timer.value);
+  timer.value = null;
  uni.$off("update-timer", updateTimer);
 });
 </script>
@@ -0,0 +1,171 @@
+<script setup>
+import { computed } from "vue";
+
+const MAX_VISIBLE_SCORE_CARDS = 60;
+
+const props = defineProps({
+  arrows: {
+    type: Array,
+    default: () => [],
+  },
+  total: {
+    type: Number,
+    default: 0,
+  },
+  trainingType: {
+    type: String,
+    default: "",
+  },
+  recordMode: {
+    type: Boolean,
+    default: false,
+  },
+});
+
+const getDisplayText = (arrow = {}) => {
+  if (!arrow) return "";
+  if (!arrow.ring) return props.trainingType === "stability" ? "-" : "0";
+  return arrow.ringX ? "X" : String(arrow.ring);
+};
+
+const isFailed = (arrow = {}) => {
+  if (!arrow) return false;
+  if (
+    props.recordMode &&
+    props.trainingType !== "precision" &&
+    props.trainingType !== "rhythm" &&
+    props.trainingType !== "stability"
+  ) {
+    return false;
+  }
+  return arrow.ok !== true;
+};
+
+const hiddenScoreCount = computed(() =>
+  props.recordMode
+    ? 0
+    : Math.max(props.arrows.length - MAX_VISIBLE_SCORE_CARDS, 0)
+);
+
+const displayArrows = computed(() => {
+  const list = props.recordMode
+    ? [...props.arrows]
+    : props.arrows.slice(-MAX_VISIBLE_SCORE_CARDS);
+  // total 是达标箭数，不是实际射箭上限；训练中始终预留下一箭空框。
+  if (!props.recordMode) list.push(null);
+  return list;
+});
+</script>
+
+<template>
+  <view v-if="displayArrows.length" class="score-panel">
+    <text v-if="hiddenScoreCount" class="score-window-tip">
+      已省略前 {{ hiddenScoreCount }} 支，仅显示最近
+      {{ MAX_VISIBLE_SCORE_CARDS }} 支
+    </text>
+    <view class="score-grid">
+      <view
+        v-for="(arrow, index) in displayArrows"
+        :key="index"
+        class="score-card"
+      >
+        <image
+          class="score-card-bg"
+          :src="
+            isFailed(arrow)
+              ? 'https://static.shelingxingqiu.com/shootmini/static/training-difficulty-design/block-gray.png'
+              : 'https://static.shelingxingqiu.com/shootmini/static/training-difficulty-design/block-gold.png'
+          "
+        />
+        <image
+          v-if="trainingType === 'precision' && arrow"
+          class="score-result-icon"
+          :src="
+            arrow.ok === true
+              ? 'https://static.shelingxingqiu.com/shootmini/static/training-difficulty-design/gou.png'
+              : 'https://static.shelingxingqiu.com/shootmini/static/training-difficulty-design/cha.png'
+          "
+          mode="aspectFit"
+        />
+        <text
+          v-else
+          class="score-value"
+          :class="{ 'score-value--low': isFailed(arrow) }"
+        >
+          {{ getDisplayText(arrow) }}
+        </text>
+      </view>
+    </view>
+  </view>
+</template>
+
+<style scoped lang="scss">
+.score-panel {
+  width: 100%;
+  padding: 30rpx 40rpx 0 40rpx;
+  box-sizing: border-box;
+}
+
+.score-grid {
+  display: flex;
+  flex-wrap: wrap;
+}
+
+.score-window-tip {
+  display: block;
+  margin-bottom: 18rpx;
+  color: rgba(255, 255, 255, 0.6);
+  font-size: 22rpx;
+  line-height: 1.4;
+}
+
+.score-card {
+  position: relative;
+  width: 100rpx;
+  height: 56rpx;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  overflow: hidden;
+  margin-right: 14rpx;
+  margin-bottom: 14rpx;
+}
+
+.score-card:nth-child(6n) {
+  margin-right: 0;
+}
+
+.score-card-bg {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100rpx;
+  height: 56rpx;
+}
+
+.score-result-icon {
+  position: relative;
+  z-index: 1;
+  width: 30rpx;
+  height: 30rpx;
+}
+
+.score-value {
+  position: relative;
+  z-index: 1;
+  min-width: 28rpx;
+  text-align: center;
+  font-size: 34rpx;
+  line-height: 1;
+  font-weight: 700;
+  font-style: italic;
+  color: #f6e3b2;
+  text-shadow: 0 2rpx 0 rgba(36, 36, 48, 0.5);
+  margin-left: -10rpx;
+}
+
+.score-value--low {
+  color: #cfcfcf;
+  text-shadow: 0 2rpx 0 rgba(0, 0, 0, 0.5);
+}
+</style>
@@ -10,6 +10,10 @@ const props = defineProps({
    type: Boolean,
    default: false,
  },
+  fullNickname: {
+    type: Boolean,
+    default: false,
+  },
  onSignin: {
    type: Function,
    default: () => {},
@@ -61,7 +65,13 @@ watch(
 </script>

 <template>
-  <view class="container" :style="{ width: containerWidth }">
+  <view
+    :class="[
+      'container',
+      fullNickname ? 'container--full-nickname' : '',
+    ]"
+    :style="{ width: containerWidth }"
+  >
    <block v-if="user.id">
      <Avatar
        :rankLvl="user.rankLvl"
@@ -83,11 +93,11 @@ watch(
              user.nickName
            }}</text>
          </view>
-          <image
+          <!-- <image
            class="user-name-image"
            src="../static/vip1.png"
            mode="widthFix"
-          />
+          /> -->
        </view>
        <view class="user-stats">
          <text class="level-tag level-tag-first">段位积分</text>
@@ -165,6 +175,19 @@ watch(
  max-width: 180rpx;
 }

+.container--full-nickname .user-details {
+  flex: 1;
+  min-width: 0;
+}
+
+.container--full-nickname .user-name {
+  width: 100%;
+}
+
+.container--full-nickname .user-name .member-nickname {
+  max-width: 80%;
+}
+
 .user-name .member-nickname__text,
 .user-name .member-nickname__shine {
  font-size: 13px;
@@ -54,23 +54,23 @@ onBeforeUnmount(() => {
    <view v-if="showRank" class="up-rank">
      <image :src="user.avatar || '../static/user-icon.png'" mode="widthFix" />
      <image :src="nextRankImage" mode="widthFix" />
-      <image class="bg-effect" src="../static/shining-bg.png" mode="widthFix" />
+      <image class="bg-effect" src="https://static.shelingxingqiu.com/shootmini/static/shining-bg.png" mode="widthFix" />
      <image
        class="bg-effect"
-        src="../static/gold-shining.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/gold-shining.png"
        mode="widthFix"
      />
    </view>
    <view v-if="showGrade" class="up-grade">
      <image
        class="scale-in"
-        src="../static/user-upgrade.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/user-upgrade.png"
        mode="widthFix"
      />
-      <image class="bg-effect" src="../static/shining-bg.png" mode="widthFix" />
+      <image class="bg-effect" src="https://static.shelingxingqiu.com/shootmini/static/shining-bg.png" mode="widthFix" />
      <image
        class="bg-effect"
-        src="../static/gold-shining.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/gold-shining.png"
        mode="widthFix"
      />
    </view>
@@ -1,6 +1,7 @@
 export const MESSAGETYPES = {
  ShootSyncMeArrowID: parseInt("0x789b6b0d"), // 2023451405
  ShootSyncMePracticeID: parseInt("0xD88AE05E"), // 3632980062
+  ShootSyncBattleCreateMatchLinkID: parseInt("0xF86FF466"), // 2538869862
  WaitForAllReady: parseInt("0x615C13BE"), // 1633424318
  AllReady: parseInt("0x1CCB49FD"), // 483084797
  MeleeAllReady: parseInt("0x37132BD5"), // 924003285
@@ -28,6 +29,7 @@ export const MESSAGETYPES = {
  DeviceOnline: 4168086626,
  DeviceOffline: 4168086627,
  SomeoneIsReady: 4168086628,
+  DeviceCharging: 4168086631, // 设备充电中
 };

 export const MESSAGETYPESV2 = {
@@ -53,6 +53,253 @@
    "quickapp" : {},
    "mp-weixin" : {
        "appid" : "wxa8f5989dcd45cc23",
+        "packOptions" : {
+            "ignore" : [
+                {
+                    "type" : "file",
+                    "value" : "static/common/dialog-light.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/common/dialog-bg.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/common/dialog-icon.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/prompt-bg-square.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/coach-comment.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/screen-hint-bg.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/red-team-win.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/blue-team-win.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/my-grow.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/gold-shining.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/bow-target.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/matching-bg.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/versus.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/point-champion.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/my-practise.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/shining-bg.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/donate.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/friend-battle.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/user-upgrade.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/finish-frame.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/vip/svip-jian.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/battle-header.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/battle-header-melee.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/player-bg.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/mvp-blue.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/finish-tip.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/2unfinish-tip.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/have-no-device.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/device-icon.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/unfinish-tip.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/test-tip.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/mvp-red.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/vip/svip-lie.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/mvp-tip.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/rank/battle-choose.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/back-to-game-bg.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/complete-light1.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/complete-light2.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/title-2v2.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/tab-bg.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/scan.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/choose-battle-mode.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/shooter.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/my-growth.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/juezhanbang.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/title-3v3.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/point-book-tip-bg.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/reward-us.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/rank/star.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/tab-point-book.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/pk-icon.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/first-try.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/row-yellow-bg.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/room-notfound-title.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/title-mvp.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/long-bubble-tall.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/battle-result.png"
+                },
+                {
+                    "type" : "file",
+                    "value" : "static/tab-mall.png"
+                },
+                {
+                    "type" : "folder",
+                    "value" : "static/training-home"
+                },
+                {
+                    "type" : "folder",
+                    "value" : "static/training-difficulty-design"
+                }
+            ]
+        },
+        "optimization" : {
+            "subPackages" : true
+        },
        "setting" : {
            "urlCheck" : false,
            "minified" : true,
@@ -1,11 +1,14 @@
 {
  "pages": [
-    {
-      "path": "pages/index"
-    },
-    {
-      "path": "pages/friend-battle"
-    },
+    {
+      "path": "pages/index"
+    },
+    {
+      "path": "pages/org-bind"
+    },
+    {
+      "path": "pages/friend-battle"
+    },
    {
      "path": "pages/point-book"
    },
@@ -30,9 +33,6 @@
        "navigationBarTitleText": ""
      }
    },
-    {
-      "path": "pages/team-battle/index"
-    },
    {
      "path": "pages/melee-battle"
    },
@@ -69,24 +69,9 @@
    {
      "path": "pages/user"
    },
-    {
-      "path": "pages/member/orders"
-    },
-    {
-      "path": "pages/member/order-detail"
-    },
-    {
-      "path": "pages/member/be-vip"
-    },
-    {
-      "path": "pages/member/vip-intro"
-    },
-    {
-      "path": "pages/member/agreement"
-    },
-    {
-      "path": "pages/grade-intro"
-    },
+    {
+      "path": "pages/grade-intro"
+    },
    {
      "path": "pages/rank-intro"
    },
@@ -117,9 +102,6 @@
    {
      "path": "pages/match-detail"
    },
-    {
-      "path": "pages/team-battle/team-bow-data"
-    },
    {
      "path": "pages/melee-bow-data"
    },
@@ -150,5 +132,82 @@
      "^uni-(.*)": "@dcloudio/uni-ui/lib/uni-$1/uni-$1.vue"
    }
  },
-  "subPackages": []
+  "subPackages": [
+    {
+      "root": "pages/coin",
+      "pages": [
+        {
+          "path": "index"
+        },
+        {
+          "path": "rules"
+        },
+        {
+          "path": "earning-records"
+        },
+        {
+          "path": "exchange-records"
+        },
+        {
+          "path": "nearby-stores"
+        },
+        {
+          "path": "product-detail"
+        }
+      ]
+    },
+    {
+      "root": "pages/device",
+      "pages": [
+        {
+          "path": "unbind-device"
+        }
+      ]
+    },
+    {
+      "root": "pages/member",
+      "pages": [
+        {
+          "path": "orders"
+        },
+        {
+          "path": "order-detail"
+        },
+        {
+          "path": "be-vip"
+        },
+        {
+          "path": "vip-intro"
+        },
+        {
+          "path": "agreement"
+        }
+      ]
+    },
+    {
+      "root": "pages/team-battle",
+      "pages": [
+        {
+          "path": "index"
+        },
+        {
+          "path": "team-bow-data"
+        }
+      ]
+    },
+    {
+      "root": "pages/training",
+      "pages": [
+        {
+          "path": "index"
+        },
+        {
+          "path": "difficulty"
+        },
+        {
+          "path": "practise-one"
+        }
+      ]
+    }
+  ]
 }
@@ -9,17 +9,23 @@ const playAudio = (key) => {
  audioManager.play(key);
 };

+const onAudioLoaded = (key) => {
+  loaded.value = {
+    ...loaded.value,
+    [key]: true,
+  };
+};
+
 onMounted(() => {
  const loadedAudioKeys = uni.getStorageSync("loadedAudioKeys") || {};
  loaded.value = loadedAudioKeys;

-  uni.$on("audioLoaded", (key) => {
-    loaded.value[key] = true;
-  });
+  uni.$on("audioLoaded", onAudioLoaded);
+  void audioManager.initAudios();
 });

 onBeforeUnmount(() => {
-  uni.$off("audioLoaded");
+  uni.$off("audioLoaded", onAudioLoaded);
 });
 </script>

@@ -40,8 +46,10 @@ onBeforeUnmount(() => {
      </view>
      <view v-for="key in Object.keys(audioFils)" :key="key">
        <text>{{ key }}</text>
-        <text v-if="!loaded[key]">未加载</text>
-        <button v-else hover-class="none" @click="playAudio(key)">播放</button>
+        <text>{{ loaded[key] ? "已加载" : "未加载" }}</text>
+        <button hover-class="none" @click="playAudio(key)">
+          {{ loaded[key] ? "播放" : "加载并播放" }}
+        </button>
      </view>
    </view>
  </Container>
@@ -3,6 +3,7 @@ import { ref, computed, onMounted } from "vue";
 import { onLoad } from "@dcloudio/uni-app";
 import Avatar from "@/components/Avatar.vue";
 import UserUpgrade from "@/components/UserUpgrade.vue";
+import DeviceChargingDialog from "@/components/DeviceChargingDialog.vue";
 import { getBattleAPI } from "@/apis";
 import { topThreeColors, getBattleResultTips } from "@/constants";
 import audioManager from "@/audioManager";
@@ -82,7 +83,7 @@ const checkBowData = () => {
  <view class="container">
    <block v-if="data.mode <= 3">
      <view class="header-team" :style="{ marginTop: '25%' }">
-        <image src="../static/battle-result.png" mode="widthFix" />
+        <image src="https://static.shelingxingqiu.com/shootmini/static/battle-result.png" mode="widthFix" />
        <view class="header-solo" v-if="data.mode === 1">
          <text
            :style="{
@@ -107,7 +108,7 @@ const checkBowData = () => {
      </view>
      <view class="header-mvp" v-if="data.mode === 2 || data.mode === 3">
        <image
-          :src="`../static/${data.winTeam === 1 ? 'blue' : 'red'}-team-win.png`"
+          :src="`https://static.shelingxingqiu.com/shootmini/static/${data.winTeam === 1 ? 'blue' : 'red'}-team-win.png`"
          mode="widthFix"
        />
        <view
@@ -117,8 +118,8 @@ const checkBowData = () => {
            }deg)`,
          }"
        >
-          <view v-if="data.mvp && data.mvp.totalRings">
-            <image src="../static/title-mvp.png" mode="widthFix" />
+          <view v-if="data.mvp && data.mvp.player_match_result.total_ring">
+            <image src="https://static.shelingxingqiu.com/shootmini/static/title-mvp.png" mode="widthFix" />
            <text
              >斩获<text
                :style="{
@@ -127,7 +128,7 @@ const checkBowData = () => {
                  margin: '0 3px',
                  fontWeight: '600',
                }"
-                >{{ data.mvp.totalRings }}</text
+                >{{ data.mvp.player_match_result.total_ring }}</text
              >环</text
            >
          </view>
@@ -153,7 +154,7 @@ const checkBowData = () => {
        </view>
      </view>
      <view class="battle-winner">
-        <image src="../static/shining-bg.png" mode="widthFix" />
+        <image src="https://static.shelingxingqiu.com/shootmini/static/shining-bg.png" mode="widthFix" />
        <image
          :src="ifWin ? '../static/you-win.png' : '../static/you-lost.png'"
          mode="widthFix"
@@ -173,7 +174,7 @@ const checkBowData = () => {
    <block v-else>
      <view class="header-melee">
        <view />
-        <image src="../static/battle-result.png" mode="widthFix" />
+        <image src="https://static.shelingxingqiu.com/shootmini/static/battle-result.png" mode="widthFix" />
        <view />
      </view>
      <view
@@ -248,7 +249,7 @@ const checkBowData = () => {
      class="battle-e"
      :style="{ marginTop: data.mode > 3 ? '20px' : '20vw' }"
    >
-      <image src="../static/row-yellow-bg.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/row-yellow-bg.png" mode="widthFix" />
      <view class="team-avatar">
        <Avatar
          :src="user.avatar"
@@ -287,6 +288,7 @@ const checkBowData = () => {
      <view @click="exit">返回</view>
    </view>
    <UserUpgrade />
+    <DeviceChargingDialog />
  </view>
 </template>

@@ -1,6 +1,6 @@
 <script setup>
 import { ref, onMounted, computed, onBeforeUnmount } from "vue";
-import { onShow, onLoad, onShareAppMessage } from "@dcloudio/uni-app";
+import { onShow, onHide, onLoad, onShareAppMessage } from "@dcloudio/uni-app";
 import Container from "@/components/Container.vue";
 import PlayerSeats from "@/components/PlayerSeats.vue";
 import GuideTwo from "@/components/GuideTwo.vue";
@@ -14,12 +14,14 @@ import {
  chooseTeamAPI,
  getReadyAPI,
  kickPlayerAPI,
+  getBattleAPI,
 } from "@/apis";
-import { isLimitError } from "@/util";
+import { debounce, isLimitError } from "@/util";
 import { MESSAGETYPES, MESSAGETYPESV2 } from "@/constants";
 import useStore from "@/store";
 import { storeToRefs } from "pinia";
 import audioManager from "@/audioManager";
+import { returnToBattle } from "@/utils/matchReturn";
 const store = useStore();
 const { user } = storeToRefs(store);

@@ -31,6 +33,20 @@ const players = ref([]);
 const blueTeam = ref([]);
 const redTeam = ref([]);

+const isMember = (player = {}) => player.vip === true || player.sVip === true;
+
+const getMemberNicknameClass = (player = {}) => [
+  "member-nickname",
+  player.vip === true && player.sVip !== true ? "member-nickname--vip" : "",
+  player.sVip === true ? "member-nickname--svip" : "",
+];
+
+const normalizeRoomPlayer = (member = {}) => ({
+  ...(member.userInfo || {}),
+  vip: member.vip ?? member.userInfo?.vip,
+  sVip: member.sVip ?? member.userInfo?.sVip,
+});
+
 /**
 * 根据对战类型和房间人数动态生成页面标题
 * battleType=1: 组队对战；count 2/4/6 分别对应 1v1/2v2/3v3
@@ -59,17 +75,152 @@ const allReady = ref(false);
 const timer = ref(null);
 const goBattle = ref(false);
 const showLimitModal = ref(false);
+const readySubmitting = ref(false);
+const navigationPending = ref(false);
+let pageMounted = false;
+let pageVisible = false;
+let foregroundGeneration = 0;
+const MATCH_INFO_RETRY_DELAY_MS = 500;
 /** 从结算页返回时为 true，跳过进场靶纸语音 */
 const skipTargetAudio = ref(false);

+const wait = (delay) =>
+  new Promise((resolve) => {
+    setTimeout(resolve, delay);
+  });
+
+const isCurrentForeground = (generation) =>
+  pageMounted &&
+  pageVisible &&
+  generation === foregroundGeneration &&
+  !navigationPending.value;
+
+const redirectOnce = (url) =>
+  new Promise((resolve, reject) => {
+    if (navigationPending.value) {
+      resolve(false);
+      return;
+    }
+
+    navigationPending.value = true;
+    uni.redirectTo({
+      url,
+      success: resolve,
+      fail: (error) => {
+        navigationPending.value = false;
+        goBattle.value = false;
+        reject(error);
+      },
+    });
+  });
+
+async function queryCurrentBattle(generation) {
+  try {
+    return await getBattleAPI();
+  } catch (error) {
+    await wait(MATCH_INFO_RETRY_DELAY_MS);
+    if (!isCurrentForeground(generation)) throw error;
+    return getBattleAPI();
+  }
+}
+
+async function returnToCurrentBattle(battle) {
+  if (!battle?.matchId || navigationPending.value) return false;
+
+  goBattle.value = true;
+  try {
+    const returned = await returnToBattle(battle, redirectOnce);
+    if (!returned) goBattle.value = false;
+    return returned;
+  } catch (error) {
+    goBattle.value = false;
+    throw error;
+  }
+}
+
+async function reconcileBattleRoom(generation) {
+  let battle = null;
+  try {
+    battle = await queryCurrentBattle(generation);
+  } catch (error) {
+    if (!isCurrentForeground(generation)) return;
+    console.log("resume room match info error", error);
+    uni.showToast({
+      title: "比赛状态查询失败，请重试",
+      icon: "none",
+    });
+    return;
+  }
+
+  if (!isCurrentForeground(generation)) return;
+  if (battle?.matchId) {
+    try {
+      await returnToCurrentBattle(battle);
+    } catch (error) {
+      console.log("return to room battle error", error);
+      uni.showToast({
+        title: "进入比赛失败，请重试",
+        icon: "none",
+      });
+    }
+    return;
+  }
+
+  let roomStarted = false;
+  try {
+    roomStarted = await refreshRoomData();
+  } catch (error) {
+    if (isCurrentForeground(generation)) {
+      console.log("refresh room data error", error);
+    }
+    return;
+  }
+
+  if (!isCurrentForeground(generation) || !roomStarted) return;
+
+  await wait(MATCH_INFO_RETRY_DELAY_MS);
+  if (!isCurrentForeground(generation)) return;
+
+  try {
+    battle = await queryCurrentBattle(generation);
+  } catch (error) {
+    if (!isCurrentForeground(generation)) return;
+    console.log("retry room match info error", error);
+    uni.showToast({
+      title: "比赛状态查询失败，请重试",
+      icon: "none",
+    });
+    return;
+  }
+
+  if (!isCurrentForeground(generation)) return;
+  if (battle?.matchId) {
+    try {
+      await returnToCurrentBattle(battle);
+    } catch (error) {
+      console.log("return to room battle error", error);
+      uni.showToast({
+        title: "进入比赛失败，请重试",
+        icon: "none",
+      });
+    }
+    return;
+  }
+
+  uni.showToast({
+    title: "比赛正在创建，请稍候",
+    icon: "none",
+  });
+}
+
 /**
 * 从服务端刷新当前房间数据，更新成员列表、准备状态等信息
 * 仅在 roomNumber 有效且房间未开始时执行
 */
 async function refreshRoomData() {
-  if (!roomNumber.value) return;
+  if (!roomNumber.value) return false;
  const result = await getRoomAPI(roomNumber.value);
-  if (result.started) return;
+  if (result.started) return true;
  room.value = result;
  // 加入者通过 API 返回的 targetType 字段同步靶纸尺寸，并持久化到本地缓存
  if (result.targetType) {
@@ -94,13 +245,16 @@ async function refreshRoomData() {
    return false;
  });
  members.some((m) => {
-    if (m.userInfo.id === result.creator) {
+    const player = normalizeRoomPlayer(m);
+    if (player.id === result.creator) {
      owner.value = {
-        id: m.userInfo.id,
-        name: m.userInfo.name,
-        avatar: m.userInfo.avatar,
-        rankLvl: m.userInfo.rankLvl,
-        ready: !!m.userInfo.state,
+        id: player.id,
+        name: player.name,
+        avatar: player.avatar,
+        rankLvl: player.rankLvl,
+        vip: player.vip,
+        sVip: player.sVip,
+        ready: !!player.state,
      };
      return true;
    }
@@ -108,13 +262,16 @@ async function refreshRoomData() {
  });
  if (result.battleType === 1 && result.count === 2) {
    result.members.forEach((m) => {
-      if (m.userInfo.id !== owner.value.id) {
+      const player = normalizeRoomPlayer(m);
+      if (player.id !== owner.value.id) {
        opponent.value = {
-          id: m.userInfo.id,
-          name: m.userInfo.name,
-          avatar: m.userInfo.avatar,
-          rankLvl: m.userInfo.rankLvl,
-          ready: !!m.userInfo.state,
+          id: player.id,
+          name: player.name,
+          avatar: player.avatar,
+          rankLvl: player.rankLvl,
+          vip: player.vip,
+          sVip: player.sVip,
+          ready: !!player.state,
        };
      }
    });
@@ -124,12 +281,12 @@ async function refreshRoomData() {
      (m) => m.userInfo.id === result.creator
    );
    if (ownerIndex !== -1) {
-      players.value.push(result.members[ownerIndex].userInfo);
+      players.value.push(normalizeRoomPlayer(result.members[ownerIndex]));
    } else {
      players.value.push({});
    }
    result.members.forEach((m, index) => {
-      if (ownerIndex !== index) players.value.push(m.userInfo);
+      if (ownerIndex !== index) players.value.push(normalizeRoomPlayer(m));
    });
  } else {
    players.value = new Array(result.count).fill({});
@@ -137,19 +294,25 @@ async function refreshRoomData() {
  }
  if (timer.value) clearInterval(timer.value);
  // timer.value = setTimeout(refreshRoomData, 2000);
+  return false;
 }

-const getReady = async () => {
+const getReady = debounce(async () => {
+  if (readySubmitting.value) return;
+  readySubmitting.value = true;
  try {
    await getReadyAPI(roomNumber.value);
+    ready.value = true;
  } catch (error) {
    if (isLimitError(error)) {
      showLimitModal.value = true;
      return;
    }
    console.log("room ready error", error);
+  } finally {
+    readySubmitting.value = false;
  }
-};
+});

 const closeLimitModal = () => {
  showLimitModal.value = false;
@@ -166,11 +329,12 @@ const refreshMembers = (members = []) => {
  blueTeam.value = [];
  redTeam.value = [];
  members.forEach((m, index) => {
-    players.value[index] = { ...m.userInfo, groupType: m.groupType };
+    const player = { ...normalizeRoomPlayer(m), groupType: m.groupType };
+    players.value[index] = player;
    if (m.groupType === 1) {
-      blueTeam.value.push({ ...m.userInfo, groupType: 1 });
+      blueTeam.value.push({ ...player, groupType: 1 });
    } else if (m.groupType === 2) {
-      redTeam.value.push({ ...m.userInfo, groupType: 2 });
+      redTeam.value.push({ ...player, groupType: 2 });
    }
  });
  for (let i = 0; i < room.value.count / 2; i++) {
@@ -212,17 +376,22 @@ async function onReceiveMessage(message) {
      }
    });
  } else if (message.type === MESSAGETYPESV2.AboutToStart) {
+    if (navigationPending.value) return;
+    const matchId = message.matchId || message.id;
+    if (!matchId) return;
    goBattle.value = true;
+    let url = "";
    if (message.mode <= 3) {
      uni.setStorageSync("blue-team", message.teams[1].players || []);
      uni.setStorageSync("red-team", message.teams[2].players || []);
-      uni.redirectTo({
-        url: "/pages/team-battle/index?battleId=" + message.matchId,
-      });
+      url = "/pages/team-battle/index?battleId=" + matchId;
    } else {
-      uni.redirectTo({
-        url: "/pages/melee-battle?battleId=" + message.matchId,
-      });
+      url = "/pages/melee-battle?battleId=" + matchId;
+    }
+    try {
+      await redirectOnce(url);
+    } catch (error) {
+      console.log("redirect to room battle error", error);
    }
  }
 }
@@ -317,7 +486,15 @@ onShareAppMessage(() => {
 */
 onShow(() => {
  goBattle.value = false;
-  refreshRoomData();
+  navigationPending.value = false;
+  pageVisible = true;
+  const generation = ++foregroundGeneration;
+  if (pageMounted) void reconcileBattleRoom(generation);
+});
+
+onHide(() => {
+  pageVisible = false;
+  foregroundGeneration += 1;
 });

 /**
@@ -341,6 +518,10 @@ onLoad(async (options) => {
    const stored = uni.getStorageSync(`targetSize_${roomNumber.value}`);
    if (stored) targetSize.value = stored;
  }
+  if (pageMounted && pageVisible) {
+    const generation = ++foregroundGeneration;
+    void reconcileBattleRoom(generation);
+  }
 });

 /**
@@ -352,6 +533,8 @@ onMounted(() => {
    keepScreenOn: true,
  });
  uni.$on("socket-inbox", onReceiveMessage);
+  pageMounted = true;
+  if (pageVisible) void reconcileBattleRoom(foregroundGeneration);
  // 页面加载完成 1 秒后根据靶纸尺寸播报对应语音；从结算页返回时跳过
  setTimeout(() => {
    if (!skipTargetAudio.value) {
@@ -362,6 +545,9 @@ onMounted(() => {
 });

 onBeforeUnmount(() => {
+  pageMounted = false;
+  pageVisible = false;
+  foregroundGeneration += 1;
  uni.setKeepScreenOn({
    keepScreenOn: false,
  });
@@ -389,18 +575,36 @@ onBeforeUnmount(() => {
          <view v-if="owner.id" class="player" :style="{ transform: 'translateY(-60px)' }">
            <Avatar :src="owner.avatar" :size="60" />
            <text>管理员</text>
-            <text>{{ owner.name }}</text>
+            <view
+              v-if="isMember(owner)"
+              :class="['room-player-name', ...getMemberNicknameClass(owner)]"
+            >
+              <text class="member-nickname__text">{{ owner.name }}</text>
+              <text v-if="owner.sVip === true" class="member-nickname__shine">
+                {{ owner.name }}
+              </text>
+            </view>
+            <text v-else class="room-player-name">{{ owner.name }}</text>
          </view>
          <view v-else class="no-player" :style="{ transform: 'translateY(-60px)' }">
            <image src="../static/question-mark.png" mode="widthFix" />
          </view>
-          <image src="../static/versus.png" mode="widthFix" />
+          <image src="https://static.shelingxingqiu.com/shootmini/static/versus.png" mode="widthFix" />
          <view v-if="opponent.id" class="player" :style="{ transform: 'translateY(60px)' }">
            <Avatar :src="opponent.avatar" :size="60" />
            <text class="ready" :style="{ opacity: opponent.ready ? 1 : 0 }">
              已准备
            </text>
-            <text>{{ opponent.name }}</text>
+            <view
+              v-if="isMember(opponent)"
+              :class="['room-player-name', ...getMemberNicknameClass(opponent)]"
+            >
+              <text class="member-nickname__text">{{ opponent.name }}</text>
+              <text v-if="opponent.sVip === true" class="member-nickname__shine">
+                {{ opponent.name }}
+              </text>
+            </view>
+            <text v-else class="room-player-name">{{ opponent.name }}</text>
            <button v-if="owner.id === user.id" hover-class="none" class="remove-player"
              @click="() => removePlayer(opponent)">
              <image src="../static/close-white.png" mode="widthFix" />
@@ -414,8 +618,8 @@ onBeforeUnmount(() => {
      <block v-if="room.battleType === 1 && room.count >= 4">
        <view class="all-players">
          <image src="https://static.shelingxingqiu.com/attachment/2025-08-13/dc0x1p59iab6cvbhqc.png" mode="widthFix" />
-          <image v-if="room.count === 4" src="../static/title-2v2.png" mode="widthFix" />
-          <image v-if="room.count === 6" src="../static/title-3v3.png" mode="widthFix" />
+          <image v-if="room.count === 4" src="https://static.shelingxingqiu.com/shootmini/static/title-2v2.png" mode="widthFix" />
+          <image v-if="room.count === 6" src="https://static.shelingxingqiu.com/shootmini/static/title-3v3.png" mode="widthFix" />
          <view>
            <view v-for="(item, index) in players" :key="index">
              <Avatar v-if="item.id" :src="item.avatar" :size="36" />
@@ -434,8 +638,17 @@ onBeforeUnmount(() => {
              <button hover-class="none" v-if="item.id === user.id" @click="chooseTeam(0)">
                <image src="../static/close-grey.png" mode="widthFix" />
              </button>
-              <text class="truncate">{{ item.name || "我要加入" }}</text>
-              <view v-if="item.id">
+              <view
+                v-if="item.id && isMember(item)"
+                :class="['team-player-name', 'truncate', ...getMemberNicknameClass(item)]"
+              >
+                <text class="member-nickname__text">{{ item.name }}</text>
+                <text v-if="item.sVip === true" class="member-nickname__shine">
+                  {{ item.name }}
+                </text>
+              </view>
+              <text v-else class="truncate">{{ item.name || "我要加入" }}</text>
+              <view v-if="item.id" class="team-player-avatar">
                <Avatar :src="item.avatar" :size="36" />
                <text :style="{ opacity: !!item.state ? 1 : 0 }">已准备</text>
              </view>
@@ -446,14 +659,23 @@ onBeforeUnmount(() => {
          </view>
          <view>
            <view v-for="(item, index) in blueTeam" :key="index" class="choose-side-right-item">
-              <view v-if="item.id">
+              <view v-if="item.id" class="team-player-avatar">
                <Avatar :src="item.avatar" :size="36" />
                <text :style="{ opacity: !!item.state ? 1 : 0 }">已准备</text>
              </view>
              <button v-else hover-class="none" @click="chooseTeam(1)">
                <image src="../static/add-grey.png" mode="widthFix" />
              </button>
-              <text class="truncate">{{ item.name || "我要加入" }}</text>
+              <view
+                v-if="item.id && isMember(item)"
+                :class="['team-player-name', 'truncate', ...getMemberNicknameClass(item)]"
+              >
+                <text class="member-nickname__text">{{ item.name }}</text>
+                <text v-if="item.sVip === true" class="member-nickname__shine">
+                  {{ item.name }}
+                </text>
+              </view>
+              <text v-else class="truncate">{{ item.name || "我要加入" }}</text>
              <button hover-class="none" v-if="item.id === user.id" @click="chooseTeam(0)">
                <image src="../static/close-grey.png" mode="widthFix" />
              </button>
@@ -465,7 +687,10 @@ onBeforeUnmount(() => {
      <PlayerSeats v-if="room.battleType === 2" :total="room.count || 10" :players="players"
        :removePlayer="removePlayer" :isOwner="owner.id === user.id" />
      <view>
-        <SButton :disabled="!canClick" :onClick="() => $clickSound(getReady)">
+        <SButton
+          :disabled="!canClick || readySubmitting"
+          :onClick="() => { $clickSound(); return getReady(); }"
+        >
          {{
            allReady.value
              ? "即将进入对局..."
@@ -584,11 +809,12 @@ onBeforeUnmount(() => {
  position: relative;
 }

-.player>text:nth-child(3) {
+.room-player-name {
  margin-top: 6rpx;
 }

-.player>text {
+.player>text,
+.room-player-name {
  max-width: 100px;
  white-space: nowrap;
  overflow: hidden;
@@ -596,6 +822,12 @@ onBeforeUnmount(() => {
  text-align: center;
 }

+.room-player-name .member-nickname__text,
+.room-player-name .member-nickname__shine {
+  font-size: 14px;
+  text-align: center;
+}
+
 .player .ready {
  background-color: #2c261fb3 !important;
  border: 1rpx solid #a3793f66 !important;
@@ -843,12 +1075,18 @@ onBeforeUnmount(() => {
 }

 .choose-side-left-item>text,
-.choose-side-right-item>text {
+.choose-side-right-item>text,
+.team-player-name {
  margin: 10px;
  max-width: 100px;
  font-size: 14px;
 }

+.team-player-name .member-nickname__text,
+.team-player-name .member-nickname__shine {
+  font-size: 14px;
+}
+
 .choose-side-left-item>button:first-child,
 .choose-side-right-item>button:last-child {
  position: absolute;
@@ -885,15 +1123,13 @@ onBeforeUnmount(() => {
  width: 18px;
 }

-.choose-side-left-item>view,
-.choose-side-right-item>view {
+.team-player-avatar {
  display: flex;
  flex-direction: column;
  align-items: center;
 }

-.choose-side-left-item>view>text,
-.choose-side-right-item>view>text {
+.team-player-avatar>text {
  font-size: 16rpx;
  border-radius: 20rpx;
  line-height: 26rpx;
@@ -1,9 +1,10 @@
 <script setup>
 import { ref, onMounted, onBeforeUnmount } from "vue";
+import { onShow, onHide } from "@dcloudio/uni-app";
 import Container from "@/components/Container.vue";
 import SButton from "@/components/SButton.vue";

-import { laserAimAPI, laserCloseAPI } from "@/apis";
+import { aimRenewAPI, laserAimAPI, laserCloseAPI } from "@/apis";
 import { MESSAGETYPES } from "@/constants";
 // import audioManager from "@/audioManager";

@@ -23,8 +24,56 @@ const guides = [
 ];

 const done = ref(true);
+let aimRenewTimer = null;
+let pageMounted = false;
+let pageVisible = false;
+let aimSessionVersion = 0;
+
+const stopAimRenew = () => {
+  if (!aimRenewTimer) return;
+  clearInterval(aimRenewTimer);
+  aimRenewTimer = null;
+};
+
+const startAimRenew = () => {
+  stopAimRenew();
+  aimRenewTimer = setInterval(() => {
+    aimRenewAPI();
+  }, 1000);
+};
+
+const openAimSession = async (sessionVersion) => {
+  try {
+    await laserAimAPI();
+  } catch (error) {
+    return;
+  }
+
+  if (
+    !pageMounted ||
+    !pageVisible ||
+    sessionVersion !== aimSessionVersion
+  ) {
+    void laserCloseAPI().catch(() => {});
+    return;
+  }
+
+  startAimRenew();
+};
+
+const stopAimSession = (closeLaser = true) => {
+  const wasVisible = pageVisible;
+  pageVisible = false;
+  aimSessionVersion += 1;
+  stopAimRenew();
+
+  if (closeLaser && wasVisible) {
+    void laserCloseAPI().catch(() => {});
+  }
+};

 const onComplete = async () => {
+  stopAimSession(false);
  await laserCloseAPI();
  uni.navigateBack();
 };
@@ -39,14 +88,26 @@ function onReceiveMessage(messages = []) {
  });
 }

-onMounted(async () => {
-  uni.$on("socket-inbox", onReceiveMessage);
-  await laserAimAPI();
+onShow(() => {
+  pageVisible = true;
+  const sessionVersion = ++aimSessionVersion;
+  if (pageMounted) void openAimSession(sessionVersion);
 });

-onBeforeUnmount(async () => {
+onHide(() => {
+  stopAimSession();
+});
+
+onMounted(() => {
+  uni.$on("socket-inbox", onReceiveMessage);
+  pageMounted = true;
+  if (pageVisible) void openAimSession(aimSessionVersion);
+});
+
+onBeforeUnmount(() => {
+  pageMounted = false;
+  stopAimSession();
  uni.$off("socket-inbox", onReceiveMessage);
-  await laserCloseAPI();
 });
 </script>

@@ -0,0 +1,76 @@
+<script setup>
+defineProps({
+  cumulative: {
+    type: [Number, String],
+    default: 0,
+  },
+  available: {
+    type: [Number, String],
+    default: 0,
+  },
+});
+</script>
+
+<template>
+  <view class="balance-panel">
+    <view class="balance-list">
+      <view class="balance-item">
+        <text class="balance-item__label">累计金币：</text>
+        <text class="balance-item__value">{{ cumulative }}</text>
+      </view>
+      <view class="balance-list__line" />
+      <view class="balance-item">
+        <text class="balance-item__label">可兑换金币：</text>
+        <text class="balance-item__value">{{ available }}</text>
+      </view>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.balance-panel {
+  width: 100%;
+  padding: 8rpx 28rpx 0;
+  box-sizing: border-box;
+}
+
+.balance-list {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 706rpx;
+  height: 60rpx;
+  margin-top: 0;
+  border: 2rpx solid rgba(255, 217, 71, 0.25);
+  border-radius: 12rpx;
+  box-sizing: border-box;
+  background-color: rgba(255, 217, 71, 0.06);
+}
+
+.balance-item {
+  width: auto;
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  justify-content: center;
+}
+
+.balance-item__label {
+  color: #ffffff;
+  font-size: 24rpx;
+  line-height: 34rpx;
+}
+
+.balance-item__value {
+  color: #ffd947;
+  font-size: 30rpx;
+  line-height: 42rpx;
+}
+
+.balance-list__line {
+  width: 2rpx;
+  height: 28rpx;
+  background-color: rgba(255, 255, 255, 0.5);
+  margin: 0 22rpx;
+}
+</style>
@@ -0,0 +1,37 @@
+<script setup>
+defineProps({
+  text: {
+    type: String,
+    default: "暂无金币获取记录。",
+  },
+});
+</script>
+
+<template>
+  <view class="empty-state">
+    <image
+      src="https://static.shelingxingqiu.com/shootmini/static/coin/empty-coin-record.png"
+      mode="aspectFit"
+    />
+    <text>{{ text }}</text>
+  </view>
+</template>
+
+<style scoped>
+.empty-state {
+  width: 100%;
+  padding-top: 280rpx;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  color: #ffffff;
+  font-size: 26rpx;
+  line-height: 36rpx;
+}
+
+.empty-state > image {
+  width: 162rpx;
+  height: 190rpx;
+  margin-bottom: 26rpx;
+}
+</style>
@@ -0,0 +1,86 @@
+<script setup>
+import Header from "@/components/Header.vue";
+
+const props = defineProps({
+  title: {
+    type: String,
+    default: "",
+  },
+  subtitle: {
+    type: String,
+    default: "",
+  },
+  onBack: {
+    type: Function,
+    default: null,
+  },
+});
+</script>
+
+<template>
+  <view class="coin-header">
+    <Header title="" :onBack="onBack">
+      <template #title>
+        <view class="coin-header__title-group">
+          <text
+            :class="[
+              'coin-header__title',
+              subtitle ? 'coin-header__title--with-subtitle' : '',
+            ]"
+          >
+            {{ title }}
+          </text>
+          <text v-if="subtitle" class="coin-header__subtitle">
+            {{ subtitle }}
+          </text>
+        </view>
+      </template>
+    </Header>
+  </view>
+</template>
+
+<style scoped>
+.coin-header {
+  position: sticky;
+  top: 0;
+  z-index: 20;
+  width: 100%;
+  height: 50px;
+  display: flex;
+  align-items: center;
+  flex-shrink: 0;
+}
+
+.coin-header__title-group {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  width: 430rpx;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  transform: translate(-50%, -50%);
+  text-align: center;
+}
+
+.coin-header__title {
+  color: #e7ba80;
+  font-size: 30rpx;
+  line-height: 42rpx;
+  font-weight: 500;
+  white-space: nowrap;
+}
+
+.coin-header__title--with-subtitle {
+  font-size: 28rpx;
+}
+
+.coin-header__subtitle {
+  color: #ffffff;
+  font-size: 20rpx;
+  line-height: 28rpx;
+  font-weight: 400;
+  white-space: nowrap;
+}
+</style>
@@ -0,0 +1,50 @@
+<script setup>
+defineProps({
+  menus: {
+    type: Array,
+    default: () => [],
+  },
+});
+
+const emit = defineEmits(["select"]);
+</script>
+
+<template>
+  <view class="quick-menu">
+    <view
+      v-for="item in menus"
+      :key="item.key"
+      class="quick-menu__item"
+      @click="emit('select', item)"
+    >
+      <image class="quick-menu__icon" :src="item.icon" mode="aspectFit" />
+      <text>{{ item.label }}</text>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.quick-menu {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  width: 100%;
+  padding: 26rpx 46rpx 30rpx;
+  box-sizing: border-box;
+}
+
+.quick-menu__item {
+  width: 142rpx;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  color: #fae6bc;
+  font-size: 24rpx;
+  line-height: 34rpx;
+}
+
+.quick-menu__icon {
+  width: 116rpx;
+  height: 116rpx;
+}
+</style>
@@ -0,0 +1,188 @@
+<script setup>
+defineProps({
+  records: {
+    type: Array,
+    default: () => [],
+  },
+  mode: {
+    type: String,
+    default: "earning",
+  },
+});
+</script>
+
+<template>
+  <view
+    class="record-table"
+    :class="{ 'record-table--exchange': mode === 'exchange' }"
+  >
+    <view class="record-table__header">
+      <template v-if="mode === 'exchange'">
+        <text>兑换内容</text>
+        <text>兑换类型</text>
+        <text>时间</text>
+        <text>金币使用</text>
+      </template>
+      <template v-else>
+        <text>时间</text>
+        <text>类型</text>
+        <text>金币获取</text>
+      </template>
+    </view>
+    <view
+      v-for="item in records"
+      :key="item.id"
+      class="record-table__row"
+    >
+      <template v-if="mode === 'exchange'">
+        <text class="record-table__exchange-content">{{ item.content }}</text>
+        <text class="record-table__exchange-type">{{ item.type }}</text>
+        <view class="record-table__time record-table__exchange-time">
+          <text>{{ item.date }}</text>
+          <text>{{ item.time }}</text>
+        </view>
+        <text class="record-table__amount record-table__exchange-amount">
+          {{ item.amount }}
+        </text>
+      </template>
+      <template v-else>
+        <view class="record-table__time">
+          <text>{{ item.date }}</text>
+          <text>{{ item.time }}</text>
+        </view>
+        <text class="record-table__type">{{ item.type }}</text>
+        <text class="record-table__amount">{{ item.amount }}</text>
+      </template>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.record-table {
+  width: 670rpx;
+  margin: 20rpx auto 0;
+  box-sizing: border-box;
+  border: 2rpx solid rgba(255, 255, 255, 0.35);
+}
+
+.record-table__header,
+.record-table__row {
+  display: flex;
+  align-items: center;
+}
+
+.record-table__header {
+  height: 66rpx;
+  color: #ffffff;
+  font-size: 24rpx;
+  line-height: 34rpx;
+}
+
+.record-table__header > text {
+  height: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  box-sizing: border-box;
+  border-right: 2rpx solid rgba(255, 255, 255, 0.35);
+}
+
+.record-table__header > text:nth-child(1),
+.record-table__time {
+  width: 182rpx;
+  flex: 0 0 182rpx;
+}
+
+.record-table__header > text:nth-child(2),
+.record-table__type {
+  width: 304rpx;
+  flex: 0 0 304rpx;
+}
+
+.record-table__header > text:nth-child(3),
+.record-table__amount {
+  width: 180rpx;
+  flex: 0 0 180rpx;
+  border-right: none;
+}
+
+.record-table__row {
+  height: 86rpx;
+  border-top: 2rpx solid rgba(255, 255, 255, 0.35);
+  color: #ffffff;
+  font-size: 24rpx;
+  line-height: 34rpx;
+}
+
+.record-table__row > view,
+.record-table__row > text {
+  height: 100%;
+  box-sizing: border-box;
+  border-right: 2rpx solid rgba(255, 255, 255, 0.35);
+}
+
+.record-table__time {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+}
+
+.record-table__time > text:last-child {
+  color: #ffffff;
+  font-size: 24rpx;
+  line-height: 34rpx;
+}
+
+.record-table__type {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: #ffffff;
+}
+
+.record-table__row > .record-table__amount {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: #ffffff;
+  text-align: center;
+  font-size: 24rpx;
+  border-right: none;
+}
+
+.record-table__exchange-content,
+.record-table__exchange-type {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0 8rpx;
+  color: #ffffff;
+  text-align: center;
+}
+
+.record-table--exchange .record-table__header > text:nth-child(1),
+.record-table__exchange-content {
+  width: 286rpx;
+  flex: 0 0 286rpx;
+}
+
+.record-table--exchange .record-table__header > text:nth-child(2),
+.record-table__exchange-type {
+  width: 110rpx;
+  flex: 0 0 110rpx;
+}
+
+.record-table--exchange .record-table__header > text:nth-child(3),
+.record-table__exchange-time {
+  width: 160rpx;
+  flex: 0 0 160rpx;
+}
+
+.record-table--exchange .record-table__header > text:nth-child(4),
+.record-table__exchange-amount {
+  width: 110rpx;
+  flex: 0 0 110rpx;
+  border-right: none;
+}
+</style>
@@ -0,0 +1,54 @@
+<script setup>
+const emit = defineEmits(["authorize"]);
+</script>
+
+<template>
+  <view class="location-state">
+    <image
+      src="https://static.shelingxingqiu.com/shootmini/static/coin/location-permission.png"
+      mode="aspectFit"
+    />
+    <text>授权获取你的定位，以便推荐附近门店。</text>
+    <button hover-class="none" @click="emit('authorize')">立即授权</button>
+  </view>
+</template>
+
+<style scoped>
+.location-state {
+  width: 100%;
+  padding-top: 190rpx;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  color: #ffffff;
+  font-size: 32rpx;
+  line-height: 44rpx;
+  font-weight: 600;
+}
+
+.location-state > image {
+  width: 168rpx;
+  height: 190rpx;
+  margin-bottom: 52rpx;
+}
+
+.location-state > button {
+  width: 360rpx;
+  height: 72rpx;
+  margin-top: 44rpx;
+  padding: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: 36rpx;
+  background-color: #ffd947;
+  color: #22222e;
+  font-size: 26rpx;
+  line-height: 72rpx;
+  font-weight: 500;
+}
+
+.location-state > button::after {
+  border: none;
+}
+</style>
@@ -0,0 +1,56 @@
+<script setup>
+defineProps({
+  variant: {
+    type: String,
+    default: "gold",
+  },
+});
+</script>
+
+<template>
+  <view class="exchange-notice" :class="`exchange-notice--${variant}`">
+    <image
+      src="https://static.shelingxingqiu.com/shootmini/static/coin/icon-notice.png"
+      mode="aspectFit"
+    />
+    <text>暂不支持线上兑换，请前往线下门店进行兑换。</text>
+  </view>
+</template>
+
+<style scoped>
+.exchange-notice {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 504rpx;
+  height: 40rpx;
+  margin: 0 auto;
+  padding: 0 16rpx;
+  box-sizing: border-box;
+  color: rgba(255, 255, 255, 0.65);
+  font-size: 20rpx;
+  line-height: 28rpx;
+  border-radius: 24rpx;
+}
+
+.exchange-notice--gold {
+  border: 2rpx solid rgba(255, 217, 71, 0.28);
+  background-color: rgba(255, 217, 71, 0.05);
+}
+
+.exchange-notice--red {
+  width: 492rpx;
+  height: 44rpx;
+  margin: 0 0 0 40rpx;
+  border: none;
+  background-color: rgba(255, 96, 96, 0.3);
+  color: #ffffff;
+}
+
+.exchange-notice > image {
+  width: 24rpx;
+  height: 24rpx;
+  margin-right: 8rpx;
+  flex-shrink: 0;
+}
+</style>
@@ -0,0 +1,90 @@
+<script setup>
+import { computed, ref } from "vue";
+
+const DEFAULT_PRODUCT_IMAGE =
+  "https://static.shelingxingqiu.com/shootmini/static/coin/product-hero-item.png";
+const props = defineProps({
+  images: {
+    type: Array,
+    default: () => [],
+  },
+});
+
+const current = ref(0);
+const slideImages = computed(() => {
+  const images = props.images.filter(
+    (image) => typeof image === "string" && image.trim()
+  );
+  return images.length ? images : [DEFAULT_PRODUCT_IMAGE];
+});
+
+const onChange = (event) => {
+  current.value = event.detail.current;
+};
+</script>
+
+<template>
+  <view class="hero-swiper">
+    <swiper class="hero-swiper__body" :duration="260" @change="onChange">
+      <swiper-item v-for="(image, index) in slideImages" :key="index">
+        <view class="hero-swiper__item">
+          <image
+            class="hero-swiper__background"
+            src="https://static.shelingxingqiu.com/shootmini/static/coin/product-hero-bg.png"
+            mode="scaleToFill"
+          />
+          <image class="hero-swiper__product" :src="image" mode="aspectFit" />
+        </view>
+      </swiper-item>
+    </swiper>
+    <view class="hero-swiper__dots">
+      <view
+        v-for="(_, index) in slideImages"
+        :key="index"
+        class="hero-swiper__dot"
+        :class="{ 'hero-swiper__dot--active': current === index }"
+      />
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.hero-swiper,
+.hero-swiper__body,
+.hero-swiper__item {
+  position: relative;
+  width: 750rpx;
+  height: 750rpx;
+}
+
+.hero-swiper__background,
+.hero-swiper__product {
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 100%;
+  height: 100%;
+}
+
+.hero-swiper__dots {
+  position: absolute;
+  left: 0;
+  bottom: 20rpx;
+  width: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.hero-swiper__dot {
+  width: 12rpx;
+  height: 12rpx;
+  margin: 0 6rpx;
+  border-radius: 50%;
+  background-color: rgba(34, 34, 46, 0.55);
+}
+
+.hero-swiper__dot--active {
+  background-color: #ffd947;
+}
+</style>
@@ -0,0 +1,97 @@
+<script setup>
+import { computed } from "vue";
+
+const DEFAULT_PRODUCT_IMAGE =
+  "https://static.shelingxingqiu.com/shootmini/static/coin/product-hero-bg.png";
+
+const props = defineProps({
+  product: {
+    type: Object,
+    required: true,
+  },
+});
+
+const productImage = computed(() => {
+  const image = props.product?.image;
+  return typeof image === "string" && image.trim()
+    ? image
+    : DEFAULT_PRODUCT_IMAGE;
+});
+</script>
+
+<template>
+  <view class="product-card">
+    <view class="product-card__image-wrap">
+      <image class="product-card__image" :src="productImage" mode="aspectFit" />
+    </view>
+    <text class="product-card__name">{{ product.name }}</text>
+    <view class="product-card__footer">
+      <text>{{ product.cost }}金币</text>
+      <text class="product-card__divider">|</text>
+      <text>剩余{{ product.stock }}个</text>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.product-card {
+  width: 336rpx;
+  height: 418rpx;
+  padding: 10rpx 10rpx 14rpx;
+  box-sizing: border-box;
+  border: 2rpx solid rgba(255, 217, 71, 0.1);
+  border-radius: 12rpx;
+  background-color: rgba(84, 67, 29, 0.2);
+  overflow: hidden;
+}
+
+.product-card__image-wrap {
+  position: relative;
+  width: 312rpx;
+  height: 312rpx;
+  overflow: hidden;
+  border-radius: 12rpx;
+}
+
+.product-card__image {
+  display: block;
+  width: 100%;
+  height: 100%;
+}
+
+.product-card__name {
+  display: block;
+  margin-top: 12rpx;
+  color: #fff0c9;
+  font-size: 26rpx;
+  line-height: 36rpx;
+  font-weight: 600;
+  text-align: center;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.product-card__footer {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin-top: 4rpx;
+  color: rgba(255, 255, 255, 0.85);
+  font-size: 22rpx;
+  line-height: 32rpx;
+}
+
+.product-card__footer > text:first-child {
+  color: #ffffff;
+}
+
+.product-card__footer > text:last-child {
+  color: rgba(255, 255, 255, 0.78);
+}
+
+.product-card__divider {
+  margin: 0 10rpx;
+  color: rgba(255, 255, 255, 0.45);
+}
+</style>
@@ -0,0 +1,69 @@
+<script setup>
+const props = defineProps({
+  store: {
+    type: Object,
+    required: true,
+  },
+});
+
+const emit = defineEmits(["select"]);
+
+const selectStore = () => {
+  emit("select", props.store);
+};
+</script>
+
+<template>
+  <view class="store-card" hover-class="none" @click="selectStore">
+    <image class="store-card__photo" :src="store.image" mode="aspectFill" />
+    <text class="store-card__name">{{ store.name }}</text>
+    <view class="store-card__info">
+      <view class="store-card__row">
+        <text>地址：{{ store.address }}</text>
+      </view>
+      <view class="store-card__row">
+        <text>电话：{{ store.phone }}</text>
+      </view>
+      <view class="store-card__row">
+        <text>营业时间：{{ store.hours }}</text>
+      </view>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.store-card {
+  width: 650rpx;
+  margin: 22rpx auto 0;
+  box-sizing: border-box;
+}
+
+.store-card__photo {
+  width: 650rpx;
+  height: 324rpx;
+  border-radius: 20rpx;
+}
+
+.store-card__name {
+  display: block;
+  margin-top: 24rpx;
+  margin-left: 10rpx;
+  color: #ffffff;
+  font-size: 32rpx;
+  line-height: 44rpx;
+  font-weight: 500;
+}
+
+.store-card__info {
+  width: 584rpx;
+  margin-top: 12rpx;
+  margin-left: 10rpx;
+}
+
+.store-card__row {
+  margin-top: 0;
+  color: #ffffff;
+  font-size: 24rpx;
+  line-height: 40rpx;
+}
+</style>
@@ -0,0 +1,22 @@
+export const quickMenus = [
+  {
+    key: "rules",
+    label: "金币规则",
+    icon: "https://static.shelingxingqiu.com/shootmini/static/coin/icon-rules.png",
+  },
+  {
+    key: "earningRecords",
+    label: "获取明细",
+    icon: "https://static.shelingxingqiu.com/shootmini/static/coin/icon-earning-records.png",
+  },
+  {
+    key: "exchangeRecords",
+    label: "兑换记录",
+    icon: "https://static.shelingxingqiu.com/shootmini/static/coin/icon-exchange-records.png",
+  },
+  {
+    key: "nearbyStores",
+    label: "附近门店",
+    icon: "https://static.shelingxingqiu.com/shootmini/static/coin/icon-nearby-store.png",
+  },
+];
@@ -0,0 +1,130 @@
+<script setup>
+import { computed, ref } from "vue";
+import { onLoad } from "@dcloudio/uni-app";
+import Container from "@/components/Container.vue";
+import CoinHeader from "./components/CoinHeader.vue";
+import CoinRecordList from "./components/CoinRecordList.vue";
+import CoinEmptyState from "./components/CoinEmptyState.vue";
+import { getGoldLogAPI } from "@/apis";
+
+const PAGE_SIZE = 20;
+const storeId = ref("");
+const earningRecords = ref([]);
+const page = ref(0);
+const total = ref(0);
+const loading = ref(false);
+const noMore = ref(false);
+const loaded = ref(false);
+const showEmpty = computed(() => loaded.value && !earningRecords.value.length);
+
+const formatRecord = (item = {}) => {
+  const [date = "", time = ""] = String(item.createdAt || "").split(" ");
+  const amount = Number(item.amount) || 0;
+  return {
+    id: item.id,
+    date,
+    time,
+    type: item.remark || item.typeDesc || "-",
+    amount: amount > 0 ? `+${amount}` : String(amount),
+  };
+};
+
+// 实际接口返回 totalCount/pageCount/pageSize，同时兼容接口文档中的旧字段。
+const updatePaginationState = (result, list, nextPage) => {
+  const currentPage = Number(result?.page) || nextPage;
+  const pageCount = Number(result?.pageCount);
+  const totalCount = Number(result?.totalCount ?? result?.total);
+  const responsePageSize = Number(result?.pageSize ?? result?.perPage) || PAGE_SIZE;
+
+  page.value = currentPage;
+  total.value = Number.isFinite(totalCount) ? totalCount : 0;
+
+  if (Number.isFinite(pageCount) && pageCount >= 0) {
+    noMore.value = currentPage >= pageCount;
+    return;
+  }
+  if (Number.isFinite(totalCount) && totalCount >= 0) {
+    noMore.value = earningRecords.value.length >= totalCount;
+    return;
+  }
+  noMore.value = list.length < responsePageSize;
+};
+
+const loadRecords = async ({ reset = false } = {}) => {
+  if (loading.value || (!reset && noMore.value)) return;
+
+  const nextPage = reset ? 1 : page.value + 1;
+  loading.value = true;
+  if (reset) noMore.value = false;
+
+  try {
+    const result = await getGoldLogAPI({
+      page: nextPage,
+      pageSize: PAGE_SIZE,
+      type: 1,
+      storeId: storeId.value,
+    });
+    const list = Array.isArray(result?.list) ? result.list : [];
+    const mappedList = list.map(formatRecord);
+    earningRecords.value = reset
+      ? mappedList
+      : earningRecords.value.concat(mappedList);
+    updatePaginationState(result, list, nextPage);
+  } catch (error) {
+    if (reset) {
+      earningRecords.value = [];
+      page.value = 0;
+    }
+    console.error("加载金币获取明细失败", error);
+  } finally {
+    loading.value = false;
+    loaded.value = true;
+  }
+};
+
+onLoad((options = {}) => {
+  const currentStoreId = String(options.storeId || "");
+  if (!/^\d+$/.test(currentStoreId) || Number(currentStoreId) <= 0) {
+    uni.redirectTo({
+      url: "/pages/coin/nearby-stores",
+    });
+    return;
+  }
+
+  storeId.value = currentStoreId;
+  loadRecords({ reset: true });
+});
+</script>
+
+<template>
+  <Container :bgType="6" :isHome="true" @scrolltolower="loadRecords">
+    <template #header>
+      <CoinHeader title="金币获取明细" />
+    </template>
+    <view class="records-page">
+      <CoinEmptyState v-if="showEmpty" />
+      <CoinRecordList v-else :records="earningRecords" />
+      <view
+        v-if="loading || (noMore && earningRecords.length)"
+        class="records-page__status"
+      >
+        <text>{{ loading ? "加载中..." : "没有更多了" }}</text>
+      </view>
+    </view>
+  </Container>
+</template>
+
+<style scoped>
+.records-page {
+  width: 100%;
+  min-height: 100%;
+}
+
+.records-page__status {
+  padding: 24rpx 0 32rpx;
+  color: rgba(255, 255, 255, 0.6);
+  font-size: 24rpx;
+  line-height: 34rpx;
+  text-align: center;
+}
+</style>
@@ -0,0 +1,130 @@
+<script setup>
+import { computed, ref } from "vue";
+import { onLoad } from "@dcloudio/uni-app";
+import Container from "@/components/Container.vue";
+import CoinHeader from "./components/CoinHeader.vue";
+import CoinRecordList from "./components/CoinRecordList.vue";
+import CoinEmptyState from "./components/CoinEmptyState.vue";
+import { getGoldLogAPI } from "@/apis";
+
+const PAGE_SIZE = 20;
+const storeId = ref("");
+const exchangeRecords = ref([]);
+const page = ref(0);
+const total = ref(0);
+const loading = ref(false);
+const noMore = ref(false);
+const loaded = ref(false);
+const showEmpty = computed(() => loaded.value && !exchangeRecords.value.length);
+
+const formatRecord = (item = {}) => {
+  const [date = "", time = ""] = String(item.createdAt || "").split(" ");
+  return {
+    id: item.id,
+    content: item.remark || "-",
+    type: item.typeDesc || "-",
+    date,
+    time,
+    amount: String(Number(item.amount) || 0),
+  };
+};
+
+// 实际接口返回 totalCount/pageCount/pageSize，同时兼容接口文档中的旧字段。
+const updatePaginationState = (result, list, nextPage) => {
+  const currentPage = Number(result?.page) || nextPage;
+  const pageCount = Number(result?.pageCount);
+  const totalCount = Number(result?.totalCount ?? result?.total);
+  const responsePageSize = Number(result?.pageSize ?? result?.perPage) || PAGE_SIZE;
+
+  page.value = currentPage;
+  total.value = Number.isFinite(totalCount) ? totalCount : 0;
+
+  if (Number.isFinite(pageCount) && pageCount >= 0) {
+    noMore.value = currentPage >= pageCount;
+    return;
+  }
+  if (Number.isFinite(totalCount) && totalCount >= 0) {
+    noMore.value = exchangeRecords.value.length >= totalCount;
+    return;
+  }
+  noMore.value = list.length < responsePageSize;
+};
+
+const loadRecords = async ({ reset = false } = {}) => {
+  if (loading.value || (!reset && noMore.value)) return;
+
+  const nextPage = reset ? 1 : page.value + 1;
+  loading.value = true;
+  if (reset) noMore.value = false;
+
+  try {
+    const result = await getGoldLogAPI({
+      page: nextPage,
+      pageSize: PAGE_SIZE,
+      type: 2,
+      storeId: storeId.value,
+    });
+    const list = Array.isArray(result?.list) ? result.list : [];
+    const mappedList = list.map(formatRecord);
+    exchangeRecords.value = reset
+      ? mappedList
+      : exchangeRecords.value.concat(mappedList);
+    updatePaginationState(result, list, nextPage);
+  } catch (error) {
+    if (reset) {
+      exchangeRecords.value = [];
+      page.value = 0;
+    }
+    console.error("加载金币兑换记录失败", error);
+  } finally {
+    loading.value = false;
+    loaded.value = true;
+  }
+};
+
+onLoad((options = {}) => {
+  const currentStoreId = String(options.storeId || "");
+  if (!/^\d+$/.test(currentStoreId) || Number(currentStoreId) <= 0) {
+    uni.redirectTo({
+      url: "/pages/coin/nearby-stores",
+    });
+    return;
+  }
+
+  storeId.value = currentStoreId;
+  loadRecords({ reset: true });
+});
+</script>
+
+<template>
+  <Container :bgType="6" :isHome="true" @scrolltolower="loadRecords">
+    <template #header>
+      <CoinHeader title="金币兑换记录" />
+    </template>
+    <view class="records-page">
+      <CoinEmptyState v-if="showEmpty" text="暂无金币兑换记录。" />
+      <CoinRecordList v-else mode="exchange" :records="exchangeRecords" />
+      <view
+        v-if="loading || (noMore && exchangeRecords.length)"
+        class="records-page__status"
+      >
+        <text>{{ loading ? "加载中..." : "没有更多了" }}</text>
+      </view>
+    </view>
+  </Container>
+</template>
+
+<style scoped>
+.records-page {
+  width: 100%;
+  min-height: 100%;
+}
+
+.records-page__status {
+  padding: 24rpx 0 32rpx;
+  color: rgba(255, 255, 255, 0.6);
+  font-size: 24rpx;
+  line-height: 34rpx;
+  text-align: center;
+}
+</style>
@@ -0,0 +1,216 @@
+<script setup>
+import { ref } from "vue";
+import { onLoad } from "@dcloudio/uni-app";
+import Container from "@/components/Container.vue";
+import CoinHeader from "./components/CoinHeader.vue";
+import CoinBalancePanel from "./components/CoinBalancePanel.vue";
+import CoinQuickMenu from "./components/CoinQuickMenu.vue";
+import OfflineExchangeNotice from "./components/OfflineExchangeNotice.vue";
+import RewardProductCard from "./components/RewardProductCard.vue";
+import { getGiftListAPI, getMyGoldAPI } from "@/apis";
+import { quickMenus } from "./data";
+
+const PAGE_SIZE = 20;
+const coinSummary = ref({
+  cumulative: 0,
+  available: 0,
+});
+const selectedStoreId = ref("");
+const selectedStoreName = ref("");
+const rewardProducts = ref([]);
+const productPage = ref(0);
+const productTotal = ref(0);
+const productLoading = ref(false);
+const productNoMore = ref(false);
+
+const loadCoinSummary = async () => {
+  try {
+    const result = await getMyGoldAPI(selectedStoreId.value);
+    coinSummary.value = {
+      cumulative: Number(result?.totalGold) || 0,
+      available: Number(result?.usableGold) || 0,
+    };
+  } catch (error) {
+    console.error("加载金币统计失败", error);
+  }
+};
+
+const loadProducts = async ({ reset = false } = {}) => {
+  if (productLoading.value || (!reset && productNoMore.value)) return;
+
+  const nextPage = reset ? 1 : productPage.value + 1;
+  productLoading.value = true;
+  if (reset) productNoMore.value = false;
+
+  try {
+    const result = await getGiftListAPI({
+      page: nextPage,
+      pageSize: PAGE_SIZE,
+      storeId: selectedStoreId.value,
+    });
+    const list = Array.isArray(result?.list) ? result.list : [];
+    const mappedList = list.map((item) => ({
+      id: item.id,
+      name: item.name || "",
+      cost: Number(item.coin_price) || 0,
+      stock: Number(item.stock) || 0,
+      image: item.cover_image || "",
+    }));
+
+    rewardProducts.value = reset
+      ? mappedList
+      : rewardProducts.value.concat(mappedList);
+    productPage.value = Number(result?.page) || nextPage;
+    const pageCount = Number(result?.pageCount ?? result?.page_count);
+    const totalCount = Number(result?.totalCount ?? result?.total);
+    const responsePageSize =
+      Number(result?.pageSize ?? result?.page_size) || PAGE_SIZE;
+    productTotal.value = Number.isFinite(totalCount) ? totalCount : 0;
+
+    if (Number.isFinite(pageCount) && pageCount >= 0) {
+      productNoMore.value = productPage.value >= pageCount;
+    } else if (Number.isFinite(totalCount) && totalCount >= 0) {
+      productNoMore.value = rewardProducts.value.length >= totalCount;
+    } else {
+      productNoMore.value = list.length < responsePageSize;
+    }
+  } catch (error) {
+    if (reset) {
+      rewardProducts.value = [];
+      productPage.value = 0;
+    }
+    console.error("加载礼品列表失败", error);
+  } finally {
+    productLoading.value = false;
+  }
+};
+
+const menuRoutes = {
+  rules: "/pages/coin/rules",
+  earningRecords: "/pages/coin/earning-records",
+  exchangeRecords: "/pages/coin/exchange-records",
+};
+
+const buildStorePageUrl = (path, extraQuery = "") => {
+  const query = [
+    `storeId=${encodeURIComponent(selectedStoreId.value)}`,
+    `storeName=${encodeURIComponent(selectedStoreName.value)}`,
+    extraQuery,
+  ]
+    .filter(Boolean)
+    .join("&");
+  return `${path}?${query}`;
+};
+
+const decodeRouteText = (value = "") => {
+  const text = String(value);
+  try {
+    return decodeURIComponent(text.replace(/\+/g, " "));
+  } catch (error) {
+    console.error("门店名称解码失败", error);
+    return text;
+  }
+};
+
+const onMenuSelect = (menu) => {
+  if (menu.key === "nearbyStores") {
+    uni.redirectTo({
+      url: "/pages/coin/nearby-stores",
+    });
+    return;
+  }
+
+  const url = menuRoutes[menu.key];
+  if (!url) {
+    uni.showToast({
+      title: "功能开发中",
+      icon: "none",
+    });
+    return;
+  }
+  uni.navigateTo({
+    url: buildStorePageUrl(url),
+  });
+};
+
+const toProductDetail = (product) => {
+  uni.navigateTo({
+    url: buildStorePageUrl(
+      "/pages/coin/product-detail",
+      `id=${encodeURIComponent(product.id)}`
+    ),
+  });
+};
+
+onLoad((options = {}) => {
+  const storeId = String(options.storeId || "");
+  if (!/^\d+$/.test(storeId) || Number(storeId) <= 0) {
+    uni.redirectTo({
+      url: "/pages/coin/nearby-stores",
+    });
+    return;
+  }
+
+  selectedStoreId.value = storeId;
+  selectedStoreName.value = decodeRouteText(options.storeName);
+  loadCoinSummary();
+  loadProducts({ reset: true });
+});
+</script>
+
+<template>
+  <Container :bgType="6" :isHome="true" @scrolltolower="loadProducts">
+    <template #header>
+      <CoinHeader title="我的金币" :subtitle="selectedStoreName" />
+    </template>
+    <view class="coin-page">
+      <CoinBalancePanel
+        :cumulative="coinSummary.cumulative"
+        :available="coinSummary.available"
+      />
+      <CoinQuickMenu :menus="quickMenus" @select="onMenuSelect" />
+      <OfflineExchangeNotice />
+      <view class="reward-section">
+        <view class="reward-grid">
+          <view
+            v-for="product in rewardProducts"
+            :key="product.id"
+            class="reward-grid__item"
+            @click="toProductDetail(product)"
+          >
+            <RewardProductCard :product="product" />
+          </view>
+        </view>
+      </view>
+    </view>
+  </Container>
+</template>
+
+<style scoped>
+.coin-page {
+  width: 100%;
+  min-height: 100%;
+  padding-bottom: 40rpx;
+  box-sizing: border-box;
+}
+
+.reward-section {
+  padding: 20rpx 28rpx 40rpx;
+  box-sizing: border-box;
+}
+
+.reward-grid {
+  display: flex;
+  flex-wrap: wrap;
+}
+
+.reward-grid__item {
+  width: 336rpx;
+  margin-right: 22rpx;
+  margin-bottom: 20rpx;
+}
+
+.reward-grid__item:nth-child(2n) {
+  margin-right: 0;
+}
+</style>
@@ -0,0 +1,167 @@
+<script setup>
+import { ref } from "vue";
+import { onLoad } from "@dcloudio/uni-app";
+import Container from "@/components/Container.vue";
+import CoinHeader from "./components/CoinHeader.vue";
+import LocationPermissionState from "./components/LocationPermissionState.vue";
+import StoreCard from "./components/StoreCard.vue";
+import { getNearbyStoresAPI } from "@/apis";
+
+const PAGE_SIZE = 20;
+const DEFAULT_STORE_IMAGE =
+  "https://static.shelingxingqiu.com/shootmini/static/coin/store-photo.png";
+const showPermissionState = ref(false);
+const stores = ref([]);
+const location = ref(null);
+const page = ref(0);
+const total = ref(0);
+const loading = ref(false);
+const noMore = ref(false);
+const loaded = ref(false);
+
+const getCurrentLocation = () =>
+  new Promise((resolve, reject) => {
+    uni.getLocation({
+      type: "gcj02",
+      success: resolve,
+      fail: reject,
+    });
+  });
+
+const mapStore = (item = {}) => ({
+  id: item.id,
+  name: item.name || "",
+  address: item.address || "",
+  phone: item.phone || "",
+  hours: item.businessHours || "",
+  image: item.coverImage || DEFAULT_STORE_IMAGE,
+});
+
+const loadStores = async ({ reset = false } = {}) => {
+  if (!location.value || loading.value || (!reset && noMore.value)) return;
+
+  const nextPage = reset ? 1 : page.value + 1;
+  loading.value = true;
+  if (reset) noMore.value = false;
+
+  try {
+    const result = await getNearbyStoresAPI({
+      ...location.value,
+      page: nextPage,
+      pageSize: PAGE_SIZE,
+    });
+    const list = Array.isArray(result?.list) ? result.list : [];
+    const mappedList = list.map(mapStore);
+    stores.value = reset ? mappedList : stores.value.concat(mappedList);
+    page.value = Number(result?.page) || nextPage;
+    const pageCount = Number(result?.pageCount);
+    const totalCount = Number(result?.totalCount ?? result?.total);
+    const responsePageSize = Number(result?.pageSize) || PAGE_SIZE;
+    total.value = Number.isFinite(totalCount) ? totalCount : 0;
+
+    if (Number.isFinite(pageCount) && pageCount >= 0) {
+      noMore.value = page.value >= pageCount;
+    } else if (Number.isFinite(totalCount) && totalCount >= 0) {
+      noMore.value = stores.value.length >= totalCount;
+    } else {
+      noMore.value = list.length < responsePageSize;
+    }
+  } catch (error) {
+    if (reset) {
+      stores.value = [];
+      page.value = 0;
+    }
+    console.error("加载附近门店失败", error);
+  } finally {
+    loading.value = false;
+    loaded.value = true;
+  }
+};
+
+const locateAndLoadStores = async () => {
+  try {
+    const position = await getCurrentLocation();
+    location.value = {
+      longitude: position.longitude,
+      latitude: position.latitude,
+    };
+    showPermissionState.value = false;
+    await loadStores({ reset: true });
+  } catch (error) {
+    showPermissionState.value = true;
+    loaded.value = true;
+    console.error("获取定位失败", error);
+  }
+};
+
+const authorizeLocation = () => {
+  uni.openSetting({
+    success: locateAndLoadStores,
+    fail: locateAndLoadStores,
+  });
+};
+
+// 选择门店后替换当前页面，返回时直接回到进入金币模块前的页面。
+const selectStore = (store) => {
+  const storeId = String(store?.id || "");
+  if (!/^\d+$/.test(storeId) || Number(storeId) <= 0) {
+    uni.showToast({
+      title: "门店信息无效",
+      icon: "none",
+    });
+    return;
+  }
+
+  const storeName = encodeURIComponent(store?.name || "");
+  uni.redirectTo({
+    url: `/pages/coin/index?storeId=${encodeURIComponent(storeId)}&storeName=${storeName}`,
+  });
+};
+
+onLoad(locateAndLoadStores);
+</script>
+
+<template>
+  <Container :bgType="6" :isHome="true" @scrolltolower="loadStores">
+    <template #header>
+      <CoinHeader title="附近门店" />
+    </template>
+    <view class="stores-page">
+      <LocationPermissionState
+        v-if="showPermissionState"
+        @authorize="authorizeLocation"
+      />
+      <template v-else>
+        <StoreCard
+          v-for="store in stores"
+          :key="store.id"
+          :store="store"
+          @select="selectStore"
+        />
+        <text v-if="loaded && !stores.length" class="stores-page__more">
+          附近暂无门店~
+        </text>
+        <text v-else-if="noMore" class="stores-page__more">没有更多门店了~</text>
+      </template>
+    </view>
+  </Container>
+</template>
+
+<style scoped>
+.stores-page {
+  width: 100%;
+  min-height: 100%;
+  padding-bottom: 54rpx;
+  box-sizing: border-box;
+}
+
+.stores-page__more {
+  display: block;
+  width: 650rpx;
+  margin: 26rpx auto 0;
+  color: rgba(255, 255, 255, 0.72);
+  font-size: 26rpx;
+  line-height: 36rpx;
+  text-align: left;
+}
+</style>
@@ -0,0 +1,144 @@
+<script setup>
+import { ref } from "vue";
+import { onLoad } from "@dcloudio/uni-app";
+import Container from "@/components/Container.vue";
+import CoinHeader from "./components/CoinHeader.vue";
+import ProductHeroSwiper from "./components/ProductHeroSwiper.vue";
+import OfflineExchangeNotice from "./components/OfflineExchangeNotice.vue";
+import { getGiftDetailAPI } from "@/apis";
+
+const productDetail = ref({
+  name: "",
+  coinPrice: 0,
+  stock: 0,
+  images: [],
+  descriptions: [],
+});
+
+const loadProductDetail = async (id) => {
+  try {
+    const result = await getGiftDetailAPI(id);
+    const images = Array.isArray(result?.images)
+      ? result.images
+          .slice()
+          .sort((first, second) =>
+            (Number(first?.sort_order) || 0) - (Number(second?.sort_order) || 0)
+          )
+          .map((item) => item?.image_url)
+          .filter(Boolean)
+      : [];
+
+    productDetail.value = {
+      ...productDetail.value,
+      name: result?.name || "",
+      coinPrice: Number(result?.coin_price) || 0,
+      stock: Number(result?.stock) || 0,
+      images,
+      descriptions: result?.description
+        ? String(result.description).split(/\r?\n/).filter(Boolean)
+        : [],
+    };
+  } catch (error) {
+    console.error("加载礼品详情失败", error);
+  }
+};
+
+onLoad((options = {}) => {
+  const id = Number(options.id);
+  if (!Number.isInteger(id) || id <= 0) {
+    uni.showToast({
+      title: "商品参数无效",
+      icon: "none",
+    });
+    return;
+  }
+
+  loadProductDetail(id);
+});
+</script>
+
+<template>
+  <Container :bgType="6" :isHome="true">
+    <template #header>
+      <CoinHeader title="商品详情" />
+    </template>
+    <view class="product-detail">
+      <ProductHeroSwiper
+        :images="productDetail.images"
+      />
+      <view class="product-detail__summary">
+        <text class="product-detail__name">{{ productDetail.name }}</text>
+        <view class="product-detail__balance">
+          <text>金币：</text>
+          <text class="product-detail__amount">{{ productDetail.coinPrice }}</text>
+          <text>（剩余{{ productDetail.stock }}个）</text>
+        </view>
+      </view>
+      <OfflineExchangeNotice variant="red" />
+      <view class="product-detail__content">
+        <text
+          v-for="(description, index) in productDetail.descriptions"
+          :key="index"
+          class="product-detail__paragraph"
+        >
+          {{ description }}
+        </text>
+      </view>
+    </view>
+  </Container>
+</template>
+
+<style scoped>
+.product-detail {
+  width: 100%;
+  min-height: 100%;
+  padding-bottom: 60rpx;
+  box-sizing: border-box;
+  background-color: #22222e;
+}
+
+.product-detail__summary {
+  padding: 30rpx 40rpx 20rpx;
+  display: flex;
+  flex-direction: column;
+}
+
+.product-detail__name {
+  color: #ffd947;
+  font-size: 52rpx;
+  line-height: 74rpx;
+  font-weight: 500;
+}
+
+.product-detail__balance {
+  display: flex;
+  align-items: baseline;
+  margin-top: 10rpx;
+  color: rgba(255, 255, 255, 0.75);
+  font-size: 24rpx;
+  line-height: 34rpx;
+}
+
+.product-detail__amount {
+  margin-right: 6rpx;
+  color: #ffffff;
+  font-size: 36rpx;
+  line-height: 50rpx;
+  font-weight: 500;
+}
+
+.product-detail__content {
+  padding: 38rpx 40rpx 60rpx;
+  box-sizing: border-box;
+  border-bottom: 2rpx solid rgba(255, 217, 71, 0.05);
+}
+
+.product-detail__paragraph {
+  display: block;
+  margin-bottom: 20rpx;
+  color: rgba(255, 255, 255, 0.75);
+  font-size: 26rpx;
+  line-height: 40rpx;
+  text-align: justify;
+}
+</style>
@@ -0,0 +1,133 @@
+<script setup>
+import { computed, ref } from "vue";
+import { onLoad } from "@dcloudio/uni-app";
+import Container from "@/components/Container.vue";
+import CoinHeader from "./components/CoinHeader.vue";
+import CoinEmptyState from "./components/CoinEmptyState.vue";
+import { getStoreGoldRuleListAPI } from "@/apis";
+
+const PAGE_SIZE = 20;
+const storeId = ref("");
+const coinRules = ref([]);
+const page = ref(0);
+const loading = ref(false);
+const noMore = ref(false);
+const loaded = ref(false);
+const showEmpty = computed(() => loaded.value && !coinRules.value.length);
+
+const updatePaginationState = (result, list, nextPage) => {
+  const currentPage = Number(result?.page) || nextPage;
+  const pageCount = Number(result?.pageCount ?? result?.page_count);
+  const totalCount = Number(result?.totalCount ?? result?.total);
+  const responsePageSize =
+    Number(result?.pageSize ?? result?.page_size) || PAGE_SIZE;
+
+  page.value = currentPage;
+  if (Number.isFinite(pageCount) && pageCount >= 0) {
+    noMore.value = currentPage >= pageCount;
+    return;
+  }
+  if (Number.isFinite(totalCount) && totalCount >= 0) {
+    noMore.value = coinRules.value.length >= totalCount;
+    return;
+  }
+  noMore.value = list.length < responsePageSize;
+};
+
+const loadRules = async ({ reset = false } = {}) => {
+  if (loading.value || (!reset && noMore.value)) return;
+
+  const nextPage = reset ? 1 : page.value + 1;
+  loading.value = true;
+  if (reset) noMore.value = false;
+
+  try {
+    const result = await getStoreGoldRuleListAPI({
+      storeId: storeId.value,
+      page: nextPage,
+      pageSize: PAGE_SIZE,
+    });
+    const list = Array.isArray(result?.list) ? result.list : [];
+    const mappedList = list.map((item) => ({
+      id: item.id,
+      content: item.content || "",
+    }));
+
+    coinRules.value = reset ? mappedList : coinRules.value.concat(mappedList);
+    updatePaginationState(result, list, nextPage);
+  } catch (error) {
+    if (reset) {
+      coinRules.value = [];
+      page.value = 0;
+    }
+    console.error("加载金币规则失败", error);
+  } finally {
+    loading.value = false;
+    loaded.value = true;
+  }
+};
+
+onLoad((options = {}) => {
+  const currentStoreId = String(options.storeId || "");
+  if (!/^\d+$/.test(currentStoreId) || Number(currentStoreId) <= 0) {
+    uni.redirectTo({
+      url: "/pages/coin/nearby-stores",
+    });
+    return;
+  }
+
+  storeId.value = currentStoreId;
+  loadRules({ reset: true });
+});
+</script>
+
+<template>
+  <Container :bgType="6" :isHome="true" @scrolltolower="loadRules">
+    <template #header>
+      <CoinHeader title="金币规则" />
+    </template>
+    <view class="rules-page">
+      <CoinEmptyState v-if="showEmpty" text="暂无金币规则。" />
+      <template v-else>
+        <view
+          v-for="rule in coinRules"
+          :key="rule.id"
+          class="rules-page__item"
+        >
+          <rich-text class="rules-page__content" :nodes="rule.content" />
+        </view>
+      </template>
+      <view v-if="loading" class="rules-page__status">
+        <text>加载中...</text>
+      </view>
+    </view>
+  </Container>
+</template>
+
+<style scoped>
+.rules-page {
+  width: 100%;
+  padding: 28rpx 38rpx 60rpx;
+  box-sizing: border-box;
+}
+
+.rules-page__item {
+  margin-bottom: 26rpx;
+  color: rgba(255, 255, 255, 0.88);
+  font-size: 28rpx;
+  line-height: 52rpx;
+  text-align: justify;
+}
+
+.rules-page__content {
+  display: block;
+}
+
+.rules-page__status {
+  padding: 12rpx 0 20rpx;
+  color: rgba(255, 255, 255, 0.6);
+  font-size: 24rpx;
+  line-height: 34rpx;
+  text-align: center;
+}
+</style>
@@ -1,6 +1,7 @@
 <script setup>
 import { ref, onMounted } from "vue";
 import SButton from "@/components/SButton.vue";
+import DeviceChargingDialog from "@/components/DeviceChargingDialog.vue";

 import { capsuleHeight } from "@/util";

@@ -55,6 +56,7 @@ const onScrollView = (e) => {
        />
      </view>
    </scroll-view>
+    <DeviceChargingDialog />
  </view>
 </template>

@@ -0,0 +1,156 @@
+<script setup>
+import { ref } from "vue";
+import { onLoad } from "@dcloudio/uni-app";
+import Container from "@/components/Container.vue";
+import ModalDialog from "@/components/ModalDialog.vue";
+import SButton from "@/components/SButton.vue";
+import { unbindDeviceByQrcodeIdAPI } from "@/apis";
+
+const deviceQrcodeId = ref("");
+const showConfirmDialog = ref(false);
+const isSubmitting = ref(false);
+const isTestEnvironment = ref(false);
+
+// 提交前移除用户输入中的所有空白字符，兼容复制粘贴的设备编号。
+const normalizeDeviceQrcodeId = () =>
+  String(deviceQrcodeId.value ?? "").replace(/\s+/g, "");
+
+const getEnvVersion = () => {
+  try {
+    return uni.getAccountInfoSync?.().miniProgram?.envVersion || "develop";
+  } catch (error) {
+    console.error("获取小程序环境失败", error);
+    return "develop";
+  }
+};
+
+const validateDeviceQrcodeId = () => {
+  const normalizedId = normalizeDeviceQrcodeId();
+  deviceQrcodeId.value = normalizedId;
+  const numericId = Number(normalizedId);
+
+  if (!/^\d+$/.test(normalizedId) || !Number.isSafeInteger(numericId) || numericId <= 0) {
+    uni.showToast({
+      title: "请输入正确的设备编号",
+      icon: "none",
+    });
+    return null;
+  }
+
+  return numericId;
+};
+
+const openConfirmDialog = () => {
+  if (!isTestEnvironment.value || validateDeviceQrcodeId() === null) return;
+  showConfirmDialog.value = true;
+};
+
+const closeConfirmDialog = () => {
+  if (isSubmitting.value) return;
+  showConfirmDialog.value = false;
+};
+
+const confirmUnbind = async () => {
+  if (isSubmitting.value) return;
+  const id = validateDeviceQrcodeId();
+  if (id === null) {
+    showConfirmDialog.value = false;
+    return;
+  }
+
+  isSubmitting.value = true;
+  try {
+    await unbindDeviceByQrcodeIdAPI(id);
+    showConfirmDialog.value = false;
+    deviceQrcodeId.value = "";
+    uni.showToast({
+      title: "解绑成功",
+      icon: "success",
+    });
+  } catch (error) {
+    console.error("测试解绑设备失败", error);
+  } finally {
+    isSubmitting.value = false;
+  }
+};
+
+onLoad(() => {
+  if (getEnvVersion() !== "release") {
+    isTestEnvironment.value = true;
+    return;
+  }
+
+  uni.showToast({
+    title: "该功能仅用于测试环境",
+    icon: "none",
+  });
+  setTimeout(() => {
+    uni.navigateBack();
+  }, 1200);
+});
+</script>
+
+<template>
+  <Container title="解绑设备" :scroll="false">
+    <view v-if="isTestEnvironment" class="unbind-page">
+      <view class="unbind-form">
+        <input
+          v-model="deviceQrcodeId"
+          class="device-input"
+          type="number"
+          placeholder="请输入设备编号"
+          placeholder-class="device-input-placeholder"
+        />
+        <SButton
+          width="100%"
+          :rounded="40"
+          :onClick="openConfirmDialog"
+        >解绑</SButton>
+      </view>
+    </view>
+  </Container>
+
+  <ModalDialog
+    :show="showConfirmDialog"
+    content="是否解绑该设备（仅用于测试环境）"
+    cancelText="取消"
+    confirmText="解绑"
+    :onCancel="closeConfirmDialog"
+    :onConfirm="confirmUnbind"
+  />
+</template>
+
+<style scoped lang="scss">
+.unbind-page {
+  display: flex;
+  width: 100%;
+  height: 100%;
+  padding: 0 72rpx;
+  box-sizing: border-box;
+  align-items: center;
+  justify-content: center;
+}
+
+.unbind-form {
+  display: flex;
+  width: 100%;
+  flex-direction: column;
+  gap: 36rpx;
+}
+
+.device-input {
+  width: 100%;
+  height: 88rpx;
+  padding: 0 32rpx;
+  box-sizing: border-box;
+  color: #ffffff;
+  font-size: 28rpx;
+  background: rgba(255, 255, 255, 0.12);
+  border: 2rpx solid rgba(255, 255, 255, 0.28);
+  border-radius: 44rpx;
+}
+
+:deep(.device-input-placeholder) {
+  color: rgba(255, 255, 255, 0.55);
+}
+</style>
@@ -15,19 +15,24 @@ import BubbleTip from "@/components/BubbleTip.vue";
 import audioManager from "@/audioManager";
 import {
  createPractiseAPI,
-  startPractiseAPI,
-  endPractiseAPI,
  getPractiseAPI,
+  startPractiseAPI,
  laserAimAPI,
  laserCloseAPI,
 } from "@/apis";
+import { connectMatchWebSocket, closeMatchWebSocket } from "@/matchWebsocket";
 import { sharePractiseData } from "@/canvas";
-import { wxShare, debounce } from "@/util";
+import {
+  wxShare,
+  debounce,
+  getDistanceCheckAudioKey,
+  getShootValidation,
+} from "@/util";
 import { MESSAGETYPESV2 } from "@/constants";
 import useStore from "@/store";
 import { storeToRefs } from "pinia";
 const store = useStore();
-const { user } = storeToRefs(store);
+const { user, device } = storeToRefs(store);
 const scores = ref([]);
 const isSvip = ref(false);
 const step = ref(0);
@@ -50,6 +55,7 @@ const showGuide = ref(false);
 const laserActive = ref(false);
 const guideSwiperIndex = ref(0);
 const sharing = ref(false);
+const RESULT_TIP_CDN = "https://static.shelingxingqiu.com/shootmini/static";

 const guideImages = [
  "https://static.shelingxingqiu.com/shootmini/static/target.png",
@@ -104,27 +110,60 @@ const closeCalibrationLaser = async () => {
 };

 const createPractise = async (arrows) => {
-  const result = await createPractiseAPI(arrows, 1);
+  closeMatchWebSocket({ reason: "practice-recreate" });
+  const result = await createPractiseAPI(
+    arrows,
+    120,
+    2,
+    device.value.deviceId
+  );
  if (result) practiseId.value = result.id;
+  if (!result?.serverAddr) {
+    uni.showToast({
+      title: "练习连接信息异常，请重试",
+      icon: "none",
+    });
+    return null;
+  }
+  connectMatchWebSocket({
+    serverAddr: result.serverAddr,
+    matchId: result.id,
+    userId: user.value.id,
+  });
+  return result;
 };

-const onOver = async () => {
-  practiseResult.value = await getPractiseAPI(practiseId.value);
+const onOver = async (message) => {
+  practiseResult.value = Array.isArray(message?.details)
+    ? message
+    : await getPractiseAPI(practiseId.value);
  start.value = false;
 };

+const beginPractise = async () => {
+  if (!practiseId.value) {
+    uni.showToast({
+      title: "练习未创建，请重试",
+      icon: "none",
+    });
+    return false;
+  }
+  await startPractiseAPI(practiseId.value);
+  return true;
+};
+
 async function onReceiveMessage(msg) {
  if (msg.type === MESSAGETYPESV2.ShootResult) {
    isSvip.value = msg.sVip === true;
-    scores.value = msg.details;
+    scores.value = Array.isArray(msg.details) ? msg.details : scores.value;
  } else if (msg.type === MESSAGETYPESV2.BattleEnd) {
-    setTimeout(onOver, 1500);
+    setTimeout(() => onOver(msg), 1500);
  } else if (msg.type === MESSAGETYPESV2.TestDistance && step.value === 3) {
-    if (msg.shootData.distance / 100 >= 5) {
-      audioManager.play("距离合格");
-      btnDisabled.value = false;
-      showGuide.value = true;
-    } else audioManager.play("距离不足");
+    const result = getShootValidation(msg.shootData);
+    const isQualified = result.distanceOk && result.targetOk;
+    audioManager.play(getDistanceCheckAudioKey(msg.shootData));
+    btnDisabled.value = !isQualified;
+    showGuide.value = isQualified;
  }
  // messages.forEach((msg) => {
  //   if (msg.constructor === MESSAGETYPES.ShootSyncMeArrowID) {
@@ -158,6 +197,7 @@ const onClickShare = debounce(async () => {
 });

 onMounted(() => {
+  void audioManager.warmCommon();
  uni.setKeepScreenOn({
    keepScreenOn: true,
  });
@@ -173,7 +213,7 @@ onBeforeUnmount(async () => {
  uni.$off("share-image", onClickShare);
  await closeCalibrationLaser();
  audioManager.stopAll();
-  endPractiseAPI();
+  closeMatchWebSocket({ reason: "practice-leave" });
 });

 const nextStep = async () => {
@@ -196,15 +236,20 @@ const nextStep = async () => {
    btnDisabled.value = true;
    step.value = 3;
    title.value = "-感知距离";
-    const result = await createPractiseAPI(total, 120);
-    if (result) practiseId.value = result.id;
+    const result = await createPractise(total);
+    if (!result) {
+      btnDisabled.value = false;
+      step.value = 2;
+      return;
+    }
  } else if (step.value === 3) {
    showGuide.value = false;
    step.value = 4;
    title.value = "-小试牛刀";
  } else if (step.value === 4) {
    title.value = "小试牛刀";
-    await startPractiseAPI();
+    const result = await beginPractise();
+    if (!result) return;
    scores.value = [];
    isSvip.value = false;
    step.value = 5;
@@ -235,10 +280,16 @@ const onClose = async () => {
    scores.value = [];
    isSvip.value = false;
    step.value = 4;
-    const result = await createPractiseAPI(total, 120);
-    if (result) practiseId.value = result.id;
+    await createPractise(total);
  }
 };
+
+const getResultTipSrc = (result = {}) => {
+  const validCount = (result.details || []).filter(
+    (arrow) => arrow.x !== -30 && arrow.y !== -30
+  ).length;
+  return `${RESULT_TIP_CDN}/${validCount < total ? "un" : ""}finish-tip.png`;
+};
 </script>

 <template>
@@ -333,7 +384,7 @@ const onClose = async () => {
        <text>请完成以上步骤校准智能弓</text>
      </view>
      <ShootProgress v-if="step === 5" tips="请开始连续射箭" :start="start" />
-      <TestDistance v-if="step === 3" :guide="false" />
+      <TestDistance v-if="step === 3" :guide="false" :targetType="40" />
      <view
        class="user-row"
        v-if="step === 5"
@@ -348,6 +399,8 @@ const onClose = async () => {
        :totalRound="step === 5 ? total : 0"
        :scores="scores"
        :isSvip="isSvip"
+        :targetType="40"
+        stable-shot-effect
      />
      <ScorePanel
        v-if="step === 5"
@@ -361,13 +414,7 @@ const onClose = async () => {
        :total="total"
        :onClose="onClose"
        :result="practiseResult"
-        :tipSrc="`../static/${
-          practiseResult.details.filter(
-            (arrow) => arrow.x !== -30 && arrow.y !== -30
-          ).length < total
-            ? 'un'
-            : ''
-        }finish-tip.png`"
+        :tipSrc="getResultTipSrc(practiseResult)"
      />
      <canvas class="share-canvas" id="shareCanvas" type="2d"></canvas>
    </view>
@@ -27,6 +27,8 @@ const data = ref({});
 const showOverlay = ref(false);
 /** 自动关闭覆盖层的计时器 */
 const overlayTimer = ref(null);
+const overlayDelayTimer = ref(null);
+let loadGeneration = 0;
 /** 控制经验条是否执行进场动画（弹窗关闭后才置 true，避免动画被遮挡） */
 const showExpAnim = ref(false);

@@ -83,6 +85,13 @@ const mvpPlayer = computed(() => {
  return null;
 });

+const mvpTotalRing = computed(
+  () =>
+    mvpPlayer.value?.playerMatchResult?.totalRing ??
+    mvpPlayer.value?.totalRing ??
+    0
+);
+
 /**
 * MVP 玩家所在队伍编号（1=蓝队，2=红队）
 * 通过比对 mvpPlayer.id 与 blueTeamPlayers 确定，用于选择背景图（mvp-blue / mvp-red）
@@ -175,9 +184,11 @@ function getMeleeAvatarBorderColor(rank) {
 // ---- 生命周期 ----

 onLoad(async (options) => {
+  const currentLoadId = ++loadGeneration;
  if (!options.battleId) return;

  const result = await getBattleAPI(options.battleId);
+  if (currentLoadId !== loadGeneration) return;
  data.value = result;

  // 从 teams 各队伍的 players 中找到当前用户，解析经验进度条所需字段
@@ -219,7 +230,8 @@ onLoad(async (options) => {
  }

  // 数据加载完成后延迟 1 秒再显示激励弹窗，避免进场时画面太杂
-  setTimeout(() => {
+  overlayDelayTimer.value = setTimeout(() => {
+    overlayDelayTimer.value = null;
    showOverlay.value = true;
    // 弹窗显示后 2.5 秒自动关闭
    overlayTimer.value = setTimeout(() => {
@@ -229,7 +241,15 @@ onLoad(async (options) => {
 });

 onBeforeUnmount(() => {
-  if (overlayTimer.value) clearTimeout(overlayTimer.value);
+  loadGeneration += 1;
+  if (overlayDelayTimer.value) {
+    clearTimeout(overlayDelayTimer.value);
+    overlayDelayTimer.value = null;
+  }
+  if (overlayTimer.value) {
+    clearTimeout(overlayTimer.value);
+    overlayTimer.value = null;
+  }
 });

 // ---- 方法 ----
@@ -404,14 +424,14 @@ function goBack() {
        <!-- 背景图：蓝队用 mvp-blue.png，红队用 mvp-red.png（平行四边形渐变切图） -->
        <image
          class="mvp-bg"
-          :src="mvpTeam === 1 ? '../static/mvp-blue.png' : '../static/mvp-red.png'"
+          :src="mvpTeam === 1 ? 'https://static.shelingxingqiu.com/shootmini/static/mvp-blue.png' : 'https://static.shelingxingqiu.com/shootmini/static/mvp-red.png'"
          mode="scaleToFill"
        />
        <!-- 左：MVP 标题图 + 斩获环数 -->
        <view class="mvp-info">
-          <image class="mvp-badge" src="../static/mvp-tip.png" mode="widthFix" />
+          <image class="mvp-badge" src="https://static.shelingxingqiu.com/shootmini/static/mvp-tip.png" mode="widthFix" />
          <view class="mvp-rings">
-            斩获<text class="mvp-rings-num">{{ mvpPlayer.totalRing }}</text>环
+            斩获<text class="mvp-rings-num">{{ mvpTotalRing }}</text>环
          </view>
        </view>
        <!-- 右：MVP 头像 + 名字，边框颜色跟随 MVP 所在队伍 -->
@@ -439,7 +459,7 @@ function goBack() {
        <!-- 本场战绩标题：装饰横线 + 标题图 + 装饰横线 -->
        <view class="melee-title">
          <view class="melee-title-line" />
-          <image class="melee-title-img" src="../static/battle-result.png" mode="scaleToFill" />
+          <image class="melee-title-img" src="https://static.shelingxingqiu.com/shootmini/static/battle-result.png" mode="scaleToFill" />
          <view class="melee-title-line" />
        </view>

@@ -27,6 +27,7 @@ const data = ref({});
 const roomID = ref("");
 const loading = ref(false);
 const showLimitModal = ref(false);
+const createRoomLoading = ref(false);
 const isSVip = computed(() => user.value.sVip === true);
 const isVip = computed(() => user.value.vip === true && !isSVip.value);
 const challengeLimitText = computed(() =>
@@ -45,6 +46,8 @@ const enterRoom = debounce(async (number) => {
    showModal.value = true;
    return;
  }
+  loading.value = true;
+  let keepLoading = false;
  try {
    const room = await getRoomAPI(number);
    if (!room.number) {
@@ -63,24 +66,33 @@ const enterRoom = debounce(async (number) => {
        return;
      }
    }
-    loading.value = true;
+    keepLoading = true;
    uni.navigateTo({
      url: "/pages/battle-room?roomNumber=" + number,
+      fail: () => {
+        loading.value = false;
+      },
    });
  } finally {
-    loading.value = false;
+    if (!keepLoading) loading.value = false;
  }
 });
-const onCreateRoom = async () => {
+const onCreateRoom = debounce(async () => {
+  if (createRoomLoading.value) return;
  if (!canEenter(user.value, device.value, online.value)) return;
-  const countData = await loadDailyCount();
-  if (isLimitReached(countData.challenge)) {
-    showLimitModal.value = true;
-    return;
+  createRoomLoading.value = true;
+  try {
+    const countData = await loadDailyCount();
+    if (isLimitReached(countData.challenge)) {
+      showLimitModal.value = true;
+      return;
+    }
+    warnning.value = "";
+    showModal.value = true;
+  } finally {
+    createRoomLoading.value = false;
  }
-  warnning.value = "";
-  showModal.value = true;
-};
+});

 const closeLimitModal = () => {
  showLimitModal.value = false;
@@ -116,6 +128,7 @@ const goMyRecord = () => {
  });
 };
 onShow(async () => {
+  loading.value = false;
  if (user.value.id) {
    const [result] = await Promise.all([
      getBattleDataAPI(),
@@ -196,10 +209,10 @@ onLoad(async (options) => {
      </view>
      <view class="create-room">
        <image src="https://static.shelingxingqiu.com/attachment/2025-07-15/dbcejys872iyun92h6.png" mode="widthFix" />
-        <image src="../static/room-notfound-title.png" mode="widthFix" />
+        <image src="https://static.shelingxingqiu.com/shootmini/static/room-notfound-title.png" mode="widthFix" />
        <view>
          <image :src="user.avatar" mode="widthFix" />
-          <image src="../static/versus.png" mode="widthFix" />
+          <image src="https://static.shelingxingqiu.com/shootmini/static/versus.png" mode="widthFix" />
          <view>
            <image src="../static/question-mark.png" mode="widthFix" />
          </view>
@@ -208,7 +221,12 @@ onLoad(async (options) => {
          <view v-if="challengeLimitText" class="pp-text">
            {{ challengeLimitText }}
          </view>
-          <SButton width="80%" :rounded="30" :onClick="() => $clickSound(onCreateRoom)">
+          <SButton
+            width="80%"
+            :rounded="30"
+            :disabled="createRoomLoading"
+            :onClick="() => { $clickSound(); return onCreateRoom(); }"
+          >
            创建约战房
          </SButton>
        </view>
@@ -1,5 +1,5 @@
 <script setup>
-import {onMounted, onUnmounted, ref} from "vue";
+import {onMounted, onUnmounted, ref, watch} from "vue";
 import {onShareAppMessage, onShareTimeline, onShow} from "@dcloudio/uni-app";
 import Container from "@/components/Container.vue";
 import AppFooter from "@/components/AppFooter.vue";
@@ -52,20 +52,41 @@ const otaInfo = ref({
  forceUpdate: false,
 });
 const isStartingOta = ref(false);
+let isCheckingOta = false;
+let otaCheckQueuedForOnline = false;
 let otaProgressTimer = null;
 let otaStatusTimer = null;
 let otaTimeoutTimer = null;
+let otaResultTimer = null;
+let otaStatusPollCount = 0;
+let otaUpdateRunId = 0;
+// 首页 OTA 轮询采用请求次数和总时长双重兜底，避免更新中状态长期卡住。
+const OTA_TASK_STATUS_POLL_INTERVAL = 2000;
+const OTA_TASK_STATUS_MAX_POLL_COUNT = 15;
+const OTA_TASK_STATUS_TIMEOUT = 30000;

 // 清理首页 OTA 更新定时器，避免弹窗关闭或页面卸载后继续轮询。
 const clearOtaUpdateTimers = () => {
  clearInterval(otaProgressTimer);
  clearTimeout(otaStatusTimer);
  clearTimeout(otaTimeoutTimer);
+  clearTimeout(otaResultTimer);
  otaProgressTimer = null;
  otaStatusTimer = null;
  otaTimeoutTimer = null;
+  otaResultTimer = null;
+  otaStatusPollCount = 0;
 };

+// 使当前 OTA 运行失效，确保旧请求返回后不会继续轮询或覆盖新状态。
+const invalidateOtaUpdateRun = () => {
+  otaUpdateRunId += 1;
+  clearOtaUpdateTimers();
+};
+
+const isOtaUpdateRunActive = (runId) =>
+  runId === otaUpdateRunId && otaState.value === "update_progress";
+
 // 启动首页 OTA 本地进度动画，最终成功失败以后端任务状态为准。
 const startOtaProgressAnimation = () => {
  clearInterval(otaProgressTimer);
@@ -91,21 +112,51 @@ const applyOtaVersionInfo = (versionInfo) => {

 // 检查当前设备盒子是否存在可升级版本。
 const checkOtaUpdate = async () => {
-  let versionInfo;
+  if (isCheckingOta || otaVisible.value) return;
+  isCheckingOta = true;
+
  try {
-    versionInfo = await getHardwareBoxVersionAPI();
-  } catch (err) {
+    let deviceStatus;
+    try {
+      deviceStatus = await getDeviceBatteryAPI();
+    } catch (err) {
+      return;
+    }
+    if (deviceStatus?.online !== true || otaVisible.value) return;
+
+    let versionInfo;
+    try {
+      versionInfo = await getHardwareBoxVersionAPI();
+    } catch (err) {
+      return;
+    }
+    if (!versionInfo?.needUpdate || otaVisible.value) return;
+    applyOtaVersionInfo(versionInfo);
+
+    const dismissedAt = uni.getStorageSync("ota_dismissed_at");
+    const now = Date.now();
+    if (!otaInfo.value.forceUpdate && dismissedAt && now - dismissedAt < 24 * 60 * 60 * 1000) return;
+    otaState.value = "new_version";
+    otaVisible.value = true;
+  } finally {
+    isCheckingOta = false;
+    const shouldRecheckForOnline = otaCheckQueuedForOnline;
+    otaCheckQueuedForOnline = false;
+    if (shouldRecheckForOnline && !otaVisible.value) {
+      void checkOtaUpdate();
+    }
+  }
+};
+
+// 设备由 WS 通知上线时补查 OTA；已显示任何 OTA 弹窗时保留当前流程和结果。
+watch(online, (nextOnline, previousOnline) => {
+  if (previousOnline !== false || nextOnline !== true || otaVisible.value) return;
+  if (isCheckingOta) {
+    otaCheckQueuedForOnline = true;
    return;
  }
-  if (!versionInfo?.needUpdate) return;
-  applyOtaVersionInfo(versionInfo);
-
-  const dismissedAt = uni.getStorageSync("ota_dismissed_at");
-  const now = Date.now();
-  if (!otaInfo.value.forceUpdate && dismissedAt && now - dismissedAt < 24 * 60 * 60 * 1000) return;
-  otaState.value = "new_version";
-  otaVisible.value = true;
-};
+  void checkOtaUpdate();
+});

 // 拼接 OTA WiFi 页参数，让未连 WiFi 的设备继续使用同一份版本信息。
 const getOtaWifiUrl = () => {
@@ -125,61 +176,78 @@ const handleOtaDismiss = () => {
 };

 // 将首页 OTA 直连更新流程标记为失败。
-const failHomeOtaUpdate = () => {
-  clearOtaUpdateTimers();
+const failHomeOtaUpdate = (runId) => {
+  if (!isOtaUpdateRunActive(runId)) return;
+  invalidateOtaUpdateRun();
  isStartingOta.value = false;
  otaState.value = "update_failure";
  otaVisible.value = true;
 };

 // 将首页 OTA 直连更新流程标记为成功。
-const completeHomeOtaUpdate = () => {
-  clearOtaUpdateTimers();
+const completeHomeOtaUpdate = (runId) => {
+  if (!isOtaUpdateRunActive(runId)) return;
+  invalidateOtaUpdateRun();
  isStartingOta.value = false;
  otaProgress.value = 100;
-  setTimeout(() => {
+  const completedRunId = otaUpdateRunId;
+  otaResultTimer = setTimeout(() => {
+    otaResultTimer = null;
+    if (completedRunId !== otaUpdateRunId) return;
    otaState.value = "update_success";
    otaVisible.value = true;
  }, 300);
 };

 // 轮询首页直接发起的 OTA 更新任务状态。
-const pollHomeOtaTaskStatus = (taskId) => {
-  clearTimeout(otaStatusTimer);
-  otaStatusTimer = setTimeout(async () => {
-    try {
-      const taskStatus = await getHardwareBoxTaskStatusAPI(taskId);
-      const status = Number(taskStatus?.status);
-      if (status === 2) {
-        completeHomeOtaUpdate();
-        return;
-      }
-      if (status === 3) {
-        failHomeOtaUpdate();
-        return;
-      }
-      if (status === 0 || status === 1) {
-        pollHomeOtaTaskStatus(taskId);
-        return;
-      }
-      failHomeOtaUpdate();
-    } catch (err) {
-      failHomeOtaUpdate();
+const pollHomeOtaTaskStatus = async (taskId, runId) => {
+  if (!isOtaUpdateRunActive(runId)) return;
+
+  otaStatusPollCount += 1;
+  try {
+    const taskStatus = await getHardwareBoxTaskStatusAPI(taskId);
+    if (!isOtaUpdateRunActive(runId)) return;
+
+    const status = Number(taskStatus?.status);
+    if (status === 2) {
+      completeHomeOtaUpdate(runId);
+      return;
    }
-  }, 3000);
+    if (status === 3) {
+      failHomeOtaUpdate(runId);
+      return;
+    }
+    if (status === 0 || status === 1) {
+      if (otaStatusPollCount >= OTA_TASK_STATUS_MAX_POLL_COUNT) {
+        failHomeOtaUpdate(runId);
+        return;
+      }
+      otaStatusTimer = setTimeout(() => {
+        otaStatusTimer = null;
+        if (!isOtaUpdateRunActive(runId)) return;
+        void pollHomeOtaTaskStatus(taskId, runId);
+      }, OTA_TASK_STATUS_POLL_INTERVAL);
+      return;
+    }
+    failHomeOtaUpdate(runId);
+  } catch (err) {
+    if (!isOtaUpdateRunActive(runId)) return;
+    failHomeOtaUpdate(runId);
+  }
 };

 // 设备盒子已连 WiFi 时，从首页直接传空 WiFi 信息发起 OTA 更新。
 const startHomeOtaUpdate = async () => {
+  invalidateOtaUpdateRun();
+  const runId = otaUpdateRunId;
  otaState.value = "update_progress";
  otaVisible.value = true;
  otaProgress.value = 0;
  startOtaProgressAnimation();
  otaTimeoutTimer = setTimeout(() => {
-    if (otaState.value === "update_progress") {
-      failHomeOtaUpdate();
-    }
-  }, 5 * 60 * 1000);
+    if (!isOtaUpdateRunActive(runId)) return;
+    failHomeOtaUpdate(runId);
+  }, OTA_TASK_STATUS_TIMEOUT);

  try {
    const updateResult = await sendHardwareBoxUpdateAPI({
@@ -188,13 +256,15 @@ const startHomeOtaUpdate = async () => {
      wifiPassword: "",
      resourceUrl: otaInfo.value.resourceUrl,
    });
+    if (!isOtaUpdateRunActive(runId)) return;
    if (!updateResult?.taskId) {
-      failHomeOtaUpdate();
+      failHomeOtaUpdate(runId);
      return;
    }
-    pollHomeOtaTaskStatus(updateResult.taskId);
+    void pollHomeOtaTaskStatus(updateResult.taskId, runId);
  } catch (err) {
-    failHomeOtaUpdate();
+    if (!isOtaUpdateRunActive(runId)) return;
+    failHomeOtaUpdate(runId);
  }
 };

@@ -240,6 +310,7 @@ const handleOtaDone = () => {

 // 处理 OTA 更新失败后的重试按钮，重新走立即更新判断流程。
 const handleOtaRetry = () => {
+  invalidateOtaUpdateRun();
  handleOtaUpdate();
 };

@@ -256,11 +327,6 @@ const toPage = async (path) => {
    showModal.value = true;
    return;
  }
-  // if (path === "/pages/first-try") {
-  // if (canEenter(user.value, device.value, online.value, path)) {
-  //   await uni.$checkAudio();
-  // }
-  // }
  uni.navigateTo({url: path});
 };

@@ -356,7 +422,7 @@ onMounted(async () => {
 });

 onUnmounted(() => {
-  clearOtaUpdateTimers();
+  invalidateOtaUpdateRun();
 });

 onShareAppMessage(() => {
@@ -423,7 +489,7 @@ onShareTimeline(() => {
              <text v-else-if="online">设备在线</text>
            </block>
            <image
-                src="../static/first-try.png"
+                src="https://static.shelingxingqiu.com/shootmini/static/first-try.png"
                mode="widthFix"
                @click="() => toPage('/pages/first-try')"
            />
@@ -433,11 +499,12 @@ onShareTimeline(() => {
            </BubbleTip>
          </view>
          <view class="play-card">
-            <view @click="$clickSound(() => toPage('/pages/practise'))">
-              <image src="../static/my-practise.png" mode="widthFix"/>
+            <!-- toPage('/pages/practise') -->
+            <view @click="$clickSound(() => toPage('/pages/training/index'))">
+              <image src="https://static.shelingxingqiu.com/shootmini/static/my-practise.png" mode="widthFix"/>
            </view>
            <view @click="$clickSound(() => toPage('/pages/friend-battle'))">
-              <image src="../static/friend-battle.png" mode="widthFix"/>
+              <image src="https://static.shelingxingqiu.com/shootmini/static/friend-battle.png" mode="widthFix"/>
            </view>
          </view>
        </view>
@@ -452,7 +519,7 @@ onShareTimeline(() => {
              hover-class="none"
          ></button>
          <view class="ranking-players" @click="toRankListPage">
-            <img src="../static/juezhanbang.png" mode="widthFix"/>
+            <img src="https://static.shelingxingqiu.com/shootmini/static/juezhanbang.png" mode="widthFix"/>
            <view class="divide-line"></view>
            <view class="player-avatars">
              <view
@@ -486,7 +553,7 @@ onShareTimeline(() => {
          </view>
          <view class="my-data">
            <view @click="() => toPage('/pages/my-growth')">
-              <image src="../static/my-growth.png" mode="widthFix"/>
+              <image src="https://static.shelingxingqiu.com/shootmini/static/my-growth.png" mode="widthFix"/>
            </view>
            <view @click="() => toPage('/pages/ranking')">
              <view>
@@ -515,6 +582,7 @@ onShareTimeline(() => {
      </view>
      <Signin :show="showModal" :onClose="() => (showModal = false)"/>
    </view>
+    <view class="foot-space"></view>
    <AppFooter/>
  </Container>
 </template>
@@ -522,9 +590,12 @@ onShareTimeline(() => {
 <style scoped>
 .container {
  width: 100%;
-  height: calc(100% - 120px);
+  /* height: calc(100% + 240rpx); */
+}
+.foot-space{
+  width: 100%;
+  height: 200rpx;
 }
-
 .feature-grid {
  width: 100%;
  display: flex;
@@ -684,7 +755,7 @@ onShareTimeline(() => {

 .my-data > view:nth-child(2) {
  width: 68%;
-  font-size: 12px;
+  font-size: 24rpx;
  color: #fff6;
  display: flex;
  justify-content: space-between;
@@ -13,10 +13,10 @@ const data = ref({
  rounds: [],
 });
 const players = ref([]);
+const isLoading = ref(true);
+const loadError = ref("");

-onLoad(async (options) => {
-  if (!options.battleId) return;
-  battleId.value = options.battleId || "60510101693403136";
+const loadBattle = async () => {
  const result = await getBattleAPI(battleId.value);
  data.value = result;
  if (result.mode > 3) {
@@ -62,6 +62,32 @@ onLoad(async (options) => {

    players.value = [...rankedPlayers, ...unrankedPlayers];
  }
+
+  // 数据和派生列表均已就绪后再关闭占位，避免空壳闪烁。
+  isLoading.value = false;
+};
+
+const requestBattle = () => {
+  if (!battleId.value) return;
+
+  isLoading.value = true;
+  loadError.value = "";
+  loadBattle().catch((error) => {
+    console.error("加载比赛详情失败:", error);
+    loadError.value = "赛况加载失败";
+    isLoading.value = false;
+  });
+};
+
+onLoad((options) => {
+  if (!options.battleId) {
+    loadError.value = "缺少比赛信息";
+    isLoading.value = false;
+    return;
+  }
+
+  battleId.value = options.battleId;
+  requestBattle();
 });

 const checkBowData = (selected) => {
@@ -80,6 +106,17 @@ const checkBowData = (selected) => {
 <template>
  <Container title="详情">
    <view class="container">
+      <view v-if="isLoading" class="page-state">
+        <text>赛况加载中...</text>
+      </view>
+      <view
+        v-else-if="loadError"
+        class="page-state page-state--error"
+        @click="requestBattle"
+      >
+        <text>{{ loadError }}</text>
+        <text v-if="battleId" class="retry-text">点击重新加载</text>
+      </view>
      <BattleHeader
        v-if="data.mode <= 3"
        :winner="data.winTeam"
@@ -165,6 +202,22 @@ const checkBowData = (selected) => {
  width: 100%;
  height: 100%;
 }
+.page-state {
+  min-height: 60vh;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  color: rgba(255, 255, 255, 0.6);
+  font-size: 26rpx;
+}
+.page-state--error {
+  color: rgba(255, 255, 255, 0.72);
+}
+.retry-text {
+  margin-top: 16rpx;
+  color: #fed847;
+}
 .score-header,
 .score-row {
  display: flex;
@@ -4,20 +4,27 @@ import { onLoad, onShow, onHide } from "@dcloudio/uni-app";
 import Container from "@/components/Container.vue";
 import Matching from "@/components/Matching.vue";
 import ModalDialog from "@/components/ModalDialog.vue";
+import audioManager from "@/audioManager";
 import { matchGameAPI, getBattleAPI } from "@/apis";
 import { MESSAGETYPESV2 } from "@/constants";
 import { isLimitError } from "@/util";
+import { returnToBattle } from "@/utils/matchReturn";

 const gameType = ref(0);
 const teamSize = ref(0);
 const onComplete = ref(null);
 const showLimitModal = ref(false);
+const navigationPending = ref(false);
+let pageMounted = false;
+let pageVisible = false;
+let foregroundGeneration = 0;

 /** 匹配超时计时器，用于检测 WS 消息丢失或真正超时 */
 const matchTimeoutTimer = ref(null);

 /** 匹配超时阈值（ms），后端设置 15s 匹配，前端预留 5s 冗余 */
 const MATCH_TIMEOUT_MS = 20 * 1000;
+const MATCH_INFO_RETRY_DELAY_MS = 500;

 /** 清除超时计时器 */
 const clearMatchTimeout = () => {
@@ -27,21 +34,110 @@ const clearMatchTimeout = () => {
  }
 };

+const wait = (delay) =>
+  new Promise((resolve) => {
+    setTimeout(resolve, delay);
+  });
+
+const isCurrentForeground = (generation) =>
+  pageMounted &&
+  pageVisible &&
+  generation === foregroundGeneration &&
+  !navigationPending.value;
+
+const redirectOnce = (url) =>
+  new Promise((resolve, reject) => {
+    if (navigationPending.value) {
+      resolve(false);
+      return;
+    }
+
+    navigationPending.value = true;
+    clearMatchTimeout();
+    uni.redirectTo({
+      url,
+      success: resolve,
+      fail: (error) => {
+        navigationPending.value = false;
+        reject(error);
+      },
+    });
+  });
+
+async function queryCurrentBattle(generation) {
+  try {
+    return await getBattleAPI();
+  } catch (error) {
+    await wait(MATCH_INFO_RETRY_DELAY_MS);
+    if (!isCurrentForeground(generation)) throw error;
+    return getBattleAPI();
+  }
+}
+
+async function returnToCurrentBattle(battle) {
+  if (!battle?.matchId || navigationPending.value) return false;
+  return returnToBattle(battle, redirectOnce);
+}
+
+async function reconcileMatchingPage(generation) {
+  clearMatchTimeout();
+
+  let battle = null;
+  try {
+    battle = await queryCurrentBattle(generation);
+  } catch (error) {
+    if (!isCurrentForeground(generation)) return;
+    console.log("resume match info error", error);
+    uni.showToast({
+      title: "比赛状态查询失败，请重试",
+      icon: "none",
+    });
+    return;
+  }
+
+  if (!isCurrentForeground(generation)) return;
+  if (battle?.matchId) {
+    try {
+      await returnToCurrentBattle(battle);
+    } catch (error) {
+      console.log("return to current match error", error);
+      uni.showToast({
+        title: "进入比赛失败，请重试",
+        icon: "none",
+      });
+    }
+    return;
+  }
+
+  if (!gameType.value || !teamSize.value) return;
+
+  try {
+    await matchGameAPI(true, gameType.value, teamSize.value);
+    if (!isCurrentForeground(generation)) return;
+    matchTimeoutTimer.value = setTimeout(handleMatchTimeout, MATCH_TIMEOUT_MS);
+  } catch (error) {
+    if (!isCurrentForeground(generation)) return;
+    clearMatchTimeout();
+    if (isLimitError(error)) {
+      showLimitModal.value = true;
+      return;
+    }
+    uni.navigateBack();
+  }
+}
+
 /**
 * 超时处理：查询后端是否已分配对局
 * - 有对局 → WS 消息丢失场景，自动跳入
 * - 无对局 → 真正超时，提示用户并返回大厅
 */
 const handleMatchTimeout = async () => {
+  if (!pageVisible || navigationPending.value) return;
  try {
    const battle = await getBattleAPI();
    if (battle && battle.matchId) {
      uni.showToast({ title: "匹配成功，正在进入...", icon: "none" });
-      if (battle.mode <= 3) {
-        uni.redirectTo({ url: `/pages/team-battle/index?battleId=${battle.matchId}` });
-      } else {
-        uni.redirectTo({ url: `/pages/melee-battle?battleId=${battle.matchId}` });
-      }
+      await returnToCurrentBattle(battle);
    } else {
      uni.showToast({ title: "匹配超时，请重试", icon: "none" });
      try {
@@ -79,6 +175,8 @@ const goVipPage = () => {
 * - 取消失败（后端已分配对局但 WS 未到达）→ 查询并跳入当前对局
 */
 async function cancelMatch() {
+  if (navigationPending.value) return;
+  foregroundGeneration += 1;
  clearMatchTimeout();
  try {
    if (gameType.value && teamSize.value) {
@@ -90,11 +188,7 @@ async function cancelMatch() {
    try {
      const battle = await getBattleAPI();
      if (battle && battle.matchId) {
-        if (battle.mode <= 3) {
-          uni.redirectTo({ url: `/pages/team-battle/index?battleId=${battle.matchId}` });
-        } else {
-          uni.redirectTo({ url: `/pages/melee-battle?battleId=${battle.matchId}` });
-        }
+        await returnToCurrentBattle(battle);
      } else {
        uni.navigateBack();
      }
@@ -109,18 +203,21 @@ async function onReceiveMessage(msg) {
    onComplete.value = () => {}
  }
  if (msg.type === MESSAGETYPESV2.AboutToStart) {
+    if (navigationPending.value) return;
    // 收到开始消息，清除超时计时器
    clearMatchTimeout();
    // 使用后端下发的 mode 字段判断跳转目标，与好友约战（battle-room.vue）保持一致
    // mode <= 3 为团队对抗，mode > 3 为大乱斗，覆盖全部 gameType（1~5），不再遗漏
-    if (msg.mode <= 3) {
-      uni.redirectTo({
-        url: `/pages/team-battle/index?battleId=${msg.id}`,
-      });
-    } else {
-      uni.redirectTo({
-        url: `/pages/melee-battle?battleId=${msg.id}`,
-      });
+    const matchId = msg.matchId || msg.id;
+    if (!matchId) return;
+    const url =
+      msg.mode <= 3
+        ? `/pages/team-battle/index?battleId=${matchId}`
+        : `/pages/melee-battle?battleId=${matchId}`;
+    try {
+      await redirectOnce(url);
+    } catch (error) {
+      console.log("redirect to matched battle error", error);
    }
  }
 }
@@ -130,17 +227,27 @@ onLoad(async (options) => {
    gameType.value = options.gameType;
    teamSize.value = options.teamSize;
  }
+  if (pageMounted && pageVisible) {
+    const generation = ++foregroundGeneration;
+    void reconcileMatchingPage(generation);
+  }
 });

 onMounted(() => {
+  void audioManager.warmCommon();
  uni.setKeepScreenOn({
    keepScreenOn: true,
  });
  uni.$on("socket-inbox", onReceiveMessage);
  uni.$on("cancelMatching", cancelMatch);
+  pageMounted = true;
+  if (pageVisible) void reconcileMatchingPage(foregroundGeneration);
 });

 onBeforeUnmount(() => {
+  pageMounted = false;
+  pageVisible = false;
+  foregroundGeneration += 1;
  clearMatchTimeout();
  uni.setKeepScreenOn({
    keepScreenOn: false,
@@ -149,26 +256,18 @@ onBeforeUnmount(() => {
  uni.$off("cancelMatching", cancelMatch);
 });

-onShow(async () => {
-  if (gameType.value && teamSize.value) {
-    try {
-      await matchGameAPI(true, gameType.value, teamSize.value);
-      // 启动超时计时器，防止 WS 消息丢失或长时间无对手导致用户卡死
-      clearMatchTimeout();
-      matchTimeoutTimer.value = setTimeout(handleMatchTimeout, MATCH_TIMEOUT_MS);
-    } catch (error) {
-      clearMatchTimeout();
-      if (isLimitError(error)) {
-        showLimitModal.value = true;
-        return;
-      }
-      uni.navigateBack();
-    }
-  }
+onShow(() => {
+  pageVisible = true;
+  navigationPending.value = false;
+  const generation = ++foregroundGeneration;
+  clearMatchTimeout();
+  if (pageMounted) void reconcileMatchingPage(generation);
 });

 onHide(() => {
-
+  pageVisible = false;
+  foregroundGeneration += 1;
+  clearMatchTimeout();
 });
 </script>

@@ -8,12 +8,20 @@ import BattleHeader from "@/components/BattleHeader.vue";
 import PlayerScore from "@/components/PlayerScore.vue";
 import SButton from "@/components/SButton.vue";
 import Avatar from "@/components/Avatar.vue";
+import BowPower from "@/components/BowPower.vue";
 import ScreenHint from "@/components/ScreenHint.vue";
 import TestDistance from "@/components/TestDistance.vue";
 import SModal from "@/components/SModal.vue";
 import audioManager from "@/audioManager";
 import { getBattleAPI, laserCloseAPI } from "@/apis";
+import {
+  closeMatchWebSocket,
+  connectMatchWebSocket,
+  MATCH_WS_AUDIO_ACK_EVENT,
+  MATCH_WS_STATE_EVENT,
+} from "@/matchWebsocket";
 import { MESSAGETYPESV2 } from "@/constants";
+import { takeMatchReturnSnapshot } from "@/utils/matchReturn";
 import useStore from "@/store";
 import { storeToRefs } from "pinia";
 const store = useStore();
@@ -21,6 +29,7 @@ const { user, online } = storeToRefs(store);
 const title = ref("");
 const start = ref(null);
 const battleId = ref("");
+const targetType = ref(20);
 /** 对战模式：1=好友约战 2=排位赛，用于结算页跳转判断 */
 const way = ref(0);
 const currentRound = ref(1);
@@ -30,13 +39,24 @@ const playersSorted = ref([]);
 const playersScores = ref([]);
 const halfTimeTip = ref(false);
 const halfRest = ref(false);
+const DEFAULT_READY_TIME = 15;
 const HALF_REST_SECONDS = 20;
+const MATCH_READY_SNAPSHOT_PREFIX = "match-ready-snapshot:";
+const MATCH_STATUS_BY_TEXT = {
+  MATCH_STATUS_READY: 0,
+  MATCH_STATUS_STARTED: 1,
+  MATCH_STATUS_END: 2,
+  MATCH_STATUS_TIMEOUT: 3,
+  MATCH_STATUS_UNEXPECTEDLY: 4,
+};
 const halfRestRemain = ref(HALF_REST_SECONDS);
+const readyTime = ref(DEFAULT_READY_TIME);
 let halfRestTimer = null;
 /** 控制设备离线提示弹窗的显示状态 */
 const showOfflineModal = ref(false);
-/** 记录每位玩家当前半场连续 10 环及以上次数，key 为 playerId，用于触发 tententen 音效 */
-const xRingStreaks = ref({});
+let battleEnded = false;
+let skipNextRestoreOnShow = false;
+let restoreGeneration = 0;

 function clearHalfRestCountdown() {
  if (halfRestTimer) {
@@ -45,6 +65,12 @@ function clearHalfRestCountdown() {
  }
 }

+function leaveHalfRest() {
+  clearHalfRestCountdown();
+  halfTimeTip.value = false;
+  halfRest.value = false;
+}
+
 function getHalfRestSeconds(battleInfo) {
  const remainCandidates = [
    battleInfo?.halfRestRemain,
@@ -60,13 +86,24 @@ function getHalfRestSeconds(battleInfo) {
    }
  }

-  const endTime = Number(battleInfo?.halfRestEndTime ?? battleInfo?.restEndTime);
-  if (!Number.isFinite(endTime) || endTime <= 0) return HALF_REST_SECONDS;
+  const timeoutTime = normalizeTimestamp(battleInfo?.timeoutTime);
+  if (timeoutTime) {
+    const elapsedSeconds = Math.max(0, (Date.now() - timeoutTime) / 1000);
+    return Math.max(
+      0,
+      Math.min(HALF_REST_SECONDS, Math.ceil(HALF_REST_SECONDS - elapsedSeconds))
+    );
+  }

-  const timestamp = endTime < 1e12 ? endTime * 1000 : endTime;
-  const diffSeconds = (timestamp - Date.now()) / 1000;
-  if (diffSeconds > 0 && diffSeconds <= HALF_REST_SECONDS) {
-    return Math.ceil(diffSeconds);
+  const endTime = normalizeTimestamp(
+    battleInfo?.halfRestEndTime ?? battleInfo?.restEndTime
+  );
+  if (endTime) {
+    const diffSeconds = (endTime - Date.now()) / 1000;
+    return Math.max(
+      0,
+      Math.min(HALF_REST_SECONDS, Math.ceil(diffSeconds))
+    );
  }

  return HALF_REST_SECONDS;
@@ -74,7 +111,14 @@ function getHalfRestSeconds(battleInfo) {

 function startHalfRestCountdown(seconds = HALF_REST_SECONDS) {
  clearHalfRestCountdown();
-  halfRestRemain.value = Math.max(0, Math.ceil(Number(seconds) || HALF_REST_SECONDS));
+  const secondsValue = Number(seconds);
+  const normalizedSeconds = Number.isFinite(secondsValue)
+    ? secondsValue
+    : HALF_REST_SECONDS;
+  halfRestRemain.value = Math.max(
+    0,
+    Math.min(HALF_REST_SECONDS, Math.ceil(normalizedSeconds))
+  );

  if (halfRestRemain.value <= 0) return;

@@ -93,6 +137,112 @@ const currentPlayer = computed(() =>
 );
 const isCurrentUserSvip = computed(() => currentPlayer.value?.sVip === true);

+function getReadySnapshotKey(matchId) {
+  return `${MATCH_READY_SNAPSHOT_PREFIX}${String(matchId || "")}`;
+}
+
+function normalizeBattleInfo(battleInfo) {
+  if (!battleInfo || typeof battleInfo !== "object") return battleInfo;
+
+  const statusText = battleInfo.statusText || battleInfo.status_text;
+  if (
+    (battleInfo.status === undefined ||
+      battleInfo.status === null ||
+      battleInfo.status === "") &&
+    MATCH_STATUS_BY_TEXT[statusText] !== undefined
+  ) {
+    return {
+      ...battleInfo,
+      status: MATCH_STATUS_BY_TEXT[statusText],
+    };
+  }
+
+  return battleInfo;
+}
+
+function normalizeTimestamp(value) {
+  const numberValue = Number(value || 0);
+  if (!numberValue) return 0;
+  return numberValue < 1000000000000 ? numberValue * 1000 : numberValue;
+}
+
+function getReadyTime(battleInfo) {
+  const value = Number(battleInfo?.readyTime);
+  return Number.isFinite(value) && value > 0 ? value : DEFAULT_READY_TIME;
+}
+
+function getReadyRemainingSeconds(battleInfo) {
+  const total = getReadyTime(battleInfo);
+  const countdownStartTime = normalizeTimestamp(battleInfo?.countdownStartTime);
+  if (!countdownStartTime) return total;
+
+  const elapsed = Math.max(0, (Date.now() - countdownStartTime) / 1000);
+  console.log('11111111111111111111111111111',  total, countdownStartTime,  Math.max(0, (Date.now() - countdownStartTime) / 1000))
+  return Math.max(0, total - elapsed);
+}
+
+function hasKnownStatus(battleInfo) {
+  return !(
+    battleInfo?.status === undefined ||
+    battleInfo?.status === null ||
+    battleInfo?.status === ""
+  );
+}
+
+function hasStartedSnapshot(battleInfo) {
+  if (hasKnownStatus(battleInfo)) return Number(battleInfo.status) !== 0;
+
+  const current = battleInfo?.current || {};
+  return !!(
+    current.playerId ||
+    current.startTime ||
+    current.round ||
+    (Array.isArray(battleInfo?.rounds) && battleInfo.rounds.length)
+  );
+}
+
+function takeReadySnapshot(matchId) {
+  const key = getReadySnapshotKey(matchId);
+  const snapshot = uni.getStorageSync(key);
+  if (snapshot) uni.removeStorageSync(key);
+  return normalizeBattleInfo(snapshot);
+}
+
+function reconnectMatchServer(battleInfo) {
+  const status = Number(battleInfo?.status);
+  if ([2, 4].includes(status)) return;
+  if (!battleInfo?.serverAddr) return;
+
+  connectMatchWebSocket({
+    serverAddr: battleInfo.serverAddr,
+    matchId: battleInfo.matchId || battleId.value,
+    userId: user.value.id,
+    mode: battleInfo.mode,
+  });
+}
+
+function closeBattleServer(reason) {
+  if (battleEnded) return;
+  closeMatchWebSocket({ reason });
+}
+
+function notifyMatchAudioAck(message) {
+  if (
+    message?.sequence === undefined ||
+    message?.sequence === null ||
+    message?.sequence === ""
+  ) {
+    return;
+  }
+
+  uni.$emit(MATCH_WS_AUDIO_ACK_EVENT, {
+    matchId: message.matchId || battleId.value,
+    sequence: message.sequence,
+    matchWsType: message.matchWsType,
+    matchWsTypeName: message.matchWsTypeName,
+  });
+}
+
 /**
 * 监听设备在线状态，大乱斗比赛进行中设备离线时弹窗提示用户
 */
@@ -103,7 +253,13 @@ watch(online, (newVal, oldVal) => {
 });

 function recoverData(battleInfo, { force = false } = {}) {
+  battleInfo = normalizeBattleInfo(battleInfo);
  if (!battleInfo) return;
+  const nextTargetType = Number(battleInfo.targetType ?? battleInfo.target_type);
+  if ([20, 40].includes(nextTargetType)) targetType.value = nextTargetType;
+  if (battleInfo.status !== undefined) {
+    battleEnded = [2, 4].includes(Number(battleInfo.status));
+  }
  try {
    if (battleInfo.way === 1) title.value = "好友约战 - 大乱斗";
    if (battleInfo.way === 2) title.value = "排位赛 - 大乱斗";
@@ -121,19 +277,27 @@ function recoverData(battleInfo, { force = false } = {}) {
      players.value = []; 
    }
    
-    start.value = battleInfo.status !== 0;
+    if (hasKnownStatus(battleInfo)) {
+      start.value = battleInfo.status !== 0;
+    } else if (!hasStartedSnapshot(battleInfo)) {
+      if (start.value !== true) start.value = false;
+      return;
+    } else {
+      start.value = true;
+    }

    if (battleInfo.status === 0) {
-      const readyRemain = (Date.now() - (battleInfo.createTime || Date.now())) / 1000;
-      if (readyRemain > 0 && readyRemain < 15) {
-        setTimeout(() => uni.$emit("update-timer", 15 - readyRemain - 0.2), 200);
-      }
+      readyTime.value = getReadyTime(battleInfo);
+      setTimeout(() => {
+        uni.$emit("update-timer", getReadyRemainingSeconds(battleInfo));
+      }, 200);
      return;
    }

+    const rounds = Array.isArray(battleInfo.rounds) ? battleInfo.rounds : [];
    tips.value =
-      (battleInfo.rounds.length !== 2 ? "上" : "下") + "半场：请先射6箭";
-    playersScores.value = battleInfo.rounds.map((r) => ({ ...r.shoots }));
+      (rounds.length !== 2 ? "上" : "下") + "半场：请先射6箭";
+    playersScores.value = rounds.map((r) => ({ ...r.shoots }));
    const totals = {};
    players.value.forEach((p) => {
      const total = playersScores.value.reduce((acc, round) => {
@@ -155,8 +319,10 @@ function recoverData(battleInfo, { force = false } = {}) {
      }, 200);
      return;
    }
+    leaveHalfRest();
    if (force) {
-      const remain = (Date.now() - (battleInfo.current?.startTime || Date.now())) / 1000;
+      const ackTime = normalizeTimestamp(battleInfo.current?.ackTime);
+      const remain = ackTime ? Math.max(0, (Date.now() - ackTime) / 1000) : 0;
      console.log(`当前轮已进行${remain}秒`);
      if (remain > 0 && remain < 90) {
        setTimeout(() => {
@@ -169,8 +335,65 @@ function recoverData(battleInfo, { force = false } = {}) {
  }
 }

+async function restoreLatestBattle() {
+  if (!battleId.value) return;
+
+  const currentRestoreId = ++restoreGeneration;
+  let result = null;
+  try {
+    result = normalizeBattleInfo(await getBattleAPI(battleId.value));
+  } catch (err) {
+    console.log("restore latest melee battle failed:", err);
+    return;
+  }
+  if (currentRestoreId !== restoreGeneration || !result) return;
+
+  if (result.status === 2) {
+    battleEnded = true;
+    uni.showToast({
+      title: "比赛已结束",
+      icon: "none",
+    });
+    uni.navigateBack({
+      delta: 2,
+    });
+    return;
+  }
+
+  reconnectMatchServer(result);
+  recoverData(result, { force: true });
+}
+
+function onMatchSocketState(event) {
+  if (event?.state !== "open" || event?.reconnected !== true) return;
+  if (
+    event.matchId &&
+    battleId.value &&
+    String(event.matchId) !== String(battleId.value)
+  ) {
+    return;
+  }
+  restoreLatestBattle();
+}
+
 onLoad(async (options) => {
-  if (options.battleId) battleId.value = options.battleId;
+  targetType.value = 20;
+  const returnSnapshot = options.fromReturn ? takeMatchReturnSnapshot() : null;
+  skipNextRestoreOnShow = false;
+  if (returnSnapshot?.matchId) battleId.value = returnSnapshot.matchId;
+  else if (options.battleId) battleId.value = options.battleId;
+  if (returnSnapshot) {
+    skipNextRestoreOnShow = true;
+    reconnectMatchServer(returnSnapshot);
+    recoverData(returnSnapshot, { force: true });
+    return;
+  }
+  const readySnapshot = takeReadySnapshot(battleId.value);
+  if (readySnapshot?.status === 0) {
+    skipNextRestoreOnShow = true;
+    reconnectMatchServer(readySnapshot);
+    recoverData(readySnapshot);
+  }
  // uni.enableAlertBeforeUnload({
  //   message: "离开比赛可能导致比赛失败，是否继续？",
  //   success: (res) => {
@@ -179,68 +402,26 @@ onLoad(async (options) => {
  // });
 });

-/**
- * 检测指定玩家连续 10 环及以上是否达到 3 箭，达到则在环数播报入队后追加 tententen 音效
- * @param {number|string} playerId - 本次射手的 ID（大乱斗中 ShootResult 保留 playerId）
- * @param {boolean} isTenPlusRingShot - 本次射击是否为 10 环及以上
- */
-function isTenPlusRing(shot) {
-  return !!(shot?.ringX || Number(shot?.ring) >= 10);
-}
-
-function checkAndPlayTententen(playerId, isTenPlusRingShot) {
-  if (!playerId) return;
-  const id = parseInt(playerId);
-  if (isTenPlusRingShot) {
-    xRingStreaks.value[id] = (xRingStreaks.value[id] || 0) + 1;
-    // 同一玩家连续 3 箭均为 10 环及以上，追加到环数音效队列尾部播放
-    if (xRingStreaks.value[id] >= 3) {
-      xRingStreaks.value[id] = 0;
-      // nextTick 确保 HeaderProgress 的环数播报已入队后再追加 tententen，避免播放顺序颠倒
-      nextTick(() => audioManager.play("tententen", false));
-    }
-  } else {
-    // 低于 10 环或未上靶则重置该玩家的连续计数
-    xRingStreaks.value[id] = 0;
-  }
-}
-
 async function onReceiveMessage(msg) {
  if (Array.isArray(msg)) return;
-  if (msg.type === MESSAGETYPESV2.BattleStart) {
-    clearHalfRestCountdown();
-    halfTimeTip.value = false;
-    halfRest.value = false;
+  if (msg.type === MESSAGETYPESV2.AboutToStart) {
+    recoverData(msg);
+  } else if (msg.type === MESSAGETYPESV2.BattleStart) {
+    leaveHalfRest();
    recoverData(msg);
  } else if (msg.type === MESSAGETYPESV2.ShootResult) {
-    // 更新前快照各玩家本轮已射箭数，用于事后识别本次射手
-    const curRound = playersScores.value[playersScores.value.length - 1] || {};
-    const prevCounts = {};
-    for (const pid of Object.keys(curRound)) {
-      prevCounts[pid] = (curRound[pid] || []).length;
-    }
    recoverData(msg);
-    // 对比更新后数据找出箭数增加的玩家（即本次射手），并读取其最新箭的 ring 数据
-    const newRound = playersScores.value[playersScores.value.length - 1] || {};
-    let shooterId = null;
-    let isTenPlusRingShot = false;
-    for (const pid of Object.keys(newRound)) {
-      const newLen = (newRound[pid] || []).length;
-      if (newLen > (prevCounts[pid] || 0)) {
-        shooterId = parseInt(pid);
-        const shot = newRound[pid][newLen - 1];
-        isTenPlusRingShot = isTenPlusRing(shot);
-        break;
-      }
+    if (msg.shootData?.threeConsecutive10Rings === true) {
+      nextTick(() => audioManager.play("tententen", false));
    }
-    // 检测同一玩家连续三箭 10 环及以上，触发 tententen 音效
-    checkAndPlayTententen(shooterId, isTenPlusRingShot);
  } else if (msg.type === MESSAGETYPESV2.HalfRest) {
    halfTimeTip.value = true;
    halfRest.value = true;
    tips.value = "准备下半场";
-    startHalfRestCountdown();
+    startHalfRestCountdown(getHalfRestSeconds(msg));
  } else if (msg.type === MESSAGETYPESV2.BattleEnd) {
+    battleEnded = true;
+    notifyMatchAudioAck(msg);
    setTimeout(() => {
      // 全部跳转到新结算页
      uni.redirectTo({
@@ -254,33 +435,31 @@ onMounted(async () => {
    keepScreenOn: true,
  });
  uni.$on("socket-inbox", onReceiveMessage);
+  uni.$on(MATCH_WS_STATE_EVENT, onMatchSocketState);
  await laserCloseAPI();
 });
 onBeforeUnmount(() => {
  uni.setKeepScreenOn({
    keepScreenOn: false,
  });
+  restoreGeneration += 1;
  clearHalfRestCountdown();
  uni.$off("socket-inbox", onReceiveMessage);
+  uni.$off(MATCH_WS_STATE_EVENT, onMatchSocketState);
+  closeBattleServer("melee-battle-unmount");
  audioManager.stopAll();
 });

-onShow(async () => {
-  if (battleId.value) {
-    const result = await getBattleAPI(battleId.value);
-    if (!result) return;
-    if (result.status === 2) {
-      uni.showToast({
-        title: "比赛已结束",
-        icon: "none",
-      });
-      uni.navigateBack({
-        delta: 2,
-      });
-    } else {
-      recoverData(result, { force: true });
-    }
+onHide(() => {
+  closeBattleServer("melee-battle-hide");
+});
+
+onShow(() => {
+  if (skipNextRestoreOnShow) {
+    skipNextRestoreOnShow = false;
+    return;
  }
+  restoreLatestBattle();
 });
 </script>

@@ -288,7 +467,13 @@ onShow(async () => {
  <Container :title="title" :bgType="1">
    <view class="container">
      <BattleHeader v-if="!start" :players="players" />
-      <TestDistance v-if="start === false" :guide="false" :isBattle="true" />
+      <TestDistance
+        v-if="start === false"
+        :guide="false"
+        :isBattle="true"
+        :count="readyTime"
+        :targetType="targetType"
+      />
      <ShootProgress
        :show="start"
        :start="start && !halfRest"
@@ -310,7 +495,9 @@ onShow(async () => {
        :totalRound="12"
        :scores="playersScores.map((r) => r[user.id]).flat()"
        :isSvip="isCurrentUserSvip"
+        :targetType="targetType"
        :stop="halfRest"
+        stable-shot-effect
      />
      <view :style="{ paddingBottom: '20px' }">
        <PlayerScore
@@ -65,7 +65,7 @@ onLoad(async (options) => {
  <Container title="靶纸">
    <view class="container">
      <image
-        src="../static/battle-header-melee.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/battle-header-melee.png"
        mode="widthFix"
        :style="{ top: '-50rpx' }"
      />
@@ -35,7 +35,7 @@ const memberTypes = [
    heroBadge: "../../static/vip/normal-hero-badge.png",
    buttonClass: "activate-btn--normal",
    benefits: [
-      { label: "专属会员标识", icon: "../../static/vip/vip-badge.png" },
+      { label: "黄金昵称", icon: "../../static/vip/vip-badge.png" },
      { label: "教练点评", icon: "../../static/vip/vip-comment.png" },
      { label: "专享VIP客服", icon: "../../static/vip/vip-service.png" },
      { label: "排位赛\n每日+20次", icon: "../../static/vip/vip-rank.png" },
@@ -59,7 +59,7 @@ const memberTypes = [
      { label: "专属落点标识", icon: "../../static/vip/svip-point.png" },
      { label: "专属命中效果", icon: "../../static/vip/svip-hit.png" },
      { label: "专属射箭效果", icon: "../../static/vip/svip-arrow.png" },
-      { label: "专属会员标识", icon: "../../static/vip/svip-badge.png" },
+      { label: "炫彩昵称", icon: "../../static/vip/svip-badge.png" },
      { label: "教练点评", icon: "../../static/vip/svip-comment.png" },
      { label: "约战无限制", icon: "../../static/vip/svip-battle.png" },
      { label: "排位赛无限制", icon: "../../static/vip/svip-rank.png" },
@@ -80,8 +80,8 @@ import Container from "@/components/Container.vue";
            <view class="table-row">
              <text class="table-cell table-cell--feature">昵称美化</text>
              <text class="table-cell">无</text>
-              <text class="table-cell">专享</text>
-              <text class="table-cell">专享</text>
+              <text class="table-cell">黄金</text>
+              <text class="table-cell">炫彩</text>
            </view>
            <view class="table-row">
              <text class="table-cell table-cell--feature">专属客服</text>
@@ -1,25 +1,61 @@
 <script setup>
-import { ref } from "vue";
+import { computed, ref } from "vue";
 import { onLoad } from "@dcloudio/uni-app";
 import Container from "@/components/Container.vue";
 import Avatar from "@/components/Avatar.vue";
 import BowTarget from "@/components/BowTarget.vue";
-import ScorePanel from "@/components/ScorePanel.vue";
-import { getPractiseAPI } from "@/apis";
+import ScorePanel2 from "@/components/TrainingScorePanel.vue";
+import { getPractiseDetailAPI } from "@/apis";
 import useStore from "@/store";
 import { storeToRefs } from "pinia";
 const store = useStore();
 const { user } = storeToRefs(store);
 const arrows = ref([]);
 const isSvip = ref(false);
-const total = ref(0);
+const practiseDetail = ref({});
+
+const trainingType = computed(() =>
+  String(practiseDetail.value.trainingType || "").trim().toLowerCase()
+);
+const targetTypeText = computed(() => {
+  const targetType = Number(practiseDetail.value.targetType);
+  return targetType > 0 ? `${targetType}CM靶` : "";
+});
+const difficultyText = computed(() => {
+  const difficultyLevel = Number(practiseDetail.value.difficultyLevel);
+  return Number.isInteger(difficultyLevel) && difficultyLevel > 0
+    ? `LV${difficultyLevel}`
+    : "";
+});
+const totalRings = computed(() => {
+  const interpretationTotal = Number(
+    practiseDetail.value.interpretation?.totalRings
+  );
+  if (Number.isFinite(interpretationTotal)) return interpretationTotal;
+  return arrows.value.reduce(
+    (total, arrow) => total + (Number(arrow.ring) || 0),
+    0
+  );
+});
+
+const normalizeArrow = (arrow = {}) => ({
+  ...arrow,
+  ring: Number(arrow.ring) || 0,
+  ringX:
+    arrow.ringX === true ||
+    Number(arrow.ringX) === 1 ||
+    Number(arrow.ifX) === 1,
+  ok: arrow.ok === true || Number(arrow.ok) === 1,
+});

 onLoad(async (options) => {
  if (!options.id) return;
-  const result = await getPractiseAPI(options.id || 176);
-  arrows.value = result.details;
-  isSvip.value = result.sVip === true;
-  total.value = result.details.length;
+  const result = (await getPractiseDetailAPI(options.id)) || {};
+  practiseDetail.value = result;
+  arrows.value = Array.isArray(result.details)
+    ? result.details.map(normalizeArrow)
+    : [];
+  isSvip.value = result.sVip === true || user.value?.sVip === true;
 });
 </script>

@@ -35,22 +71,29 @@ onLoad(async (options) => {
          </view>
        </view>
      </view> -->
+      <view v-if="practiseDetail.id" class="practice-meta">
+        <text v-if="targetTypeText">{{ targetTypeText }}</text>
+        <text>{{ practiseDetail.trainingTypeText }}</text>
+        <text v-if="difficultyText">{{ difficultyText }}</text>
+      </view>
      <view :style="{ marginBottom: '20px' }">
-        <BowTarget :scores="arrows" :isSvip="isSvip" />
+        <BowTarget
+          :scores="arrows"
+          :isSvip="isSvip"
+          :enableShotEffect="false"
+        />
      </view>
      <view class="desc">
        <text>{{ arrows.length }}</text>
        <text>支箭，共</text>
-        <text>{{ arrows.reduce((a, b) => a + b.ring, 0) }}</text>
+        <text>{{ totalRings }}</text>
        <text>环</text>
      </view>
-      <ScorePanel
-        :completeEffect="false"
-        :rowCount="total === 12 ? 6 : 9"
-        :total="total"
+      <ScorePanel2
        :arrows="arrows"
-        :margin="arrows.length === 12 ? 4 : 1"
-        :fontSize="arrows.length === 12 ? 25 : 22"
+        :total="arrows.length"
+        :trainingType="trainingType"
+        recordMode
      />
    </view>
  </Container>
@@ -63,6 +106,20 @@ onLoad(async (options) => {
  justify-content: center;
  align-items: center;
 }
+.practice-meta {
+  width: 100%;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  color: #fff;
+  font-size: 26rpx;
+  font-weight: 600;
+  line-height: 40rpx;
+  padding: 16rpx 0;
+}
+.practice-meta > text + text {
+  margin-left: 24rpx;
+}
 .header {
  display: flex;
  justify-content: space-between;
@@ -161,7 +161,7 @@ onShow(async () => {
  <Container title="弓箭绑定">
    <view v-if="!device.deviceId" class="scan-code">
      <button hover-class="none" @click="$clickSound(handleScan)">
-        <image src="../static/scan.png" mode="widthFix" />
+        <image src="https://static.shelingxingqiu.com/shootmini/static/scan.png" mode="widthFix" />
      </button>
      <button hover-class="none" @click="showTip = true">
        <text>扫</text>
@@ -172,7 +172,7 @@ onShow(async () => {
      <text>射灵智能弓箭，三模传感系统与独创靶环算法，</text>
      <text>毫秒级在线实时对战，让你拥有全球约战的乐趣！</text>
      <button hover-class="none" @click="toDeviceIntroPage">
-        <image src="../static/have-no-device.png" mode="widthFix" />
+        <image src="https://static.shelingxingqiu.com/shootmini/static/have-no-device.png" mode="widthFix" />
      </button>
      <ScreenHint
        mode="square"
@@ -219,7 +219,7 @@ onShow(async () => {
        :style="{ marginBottom: calibration ? '250rpx' : '100rpx' }"
      >
        <view>
-          <image src="../static/device-icon.png" mode="widthFix" />
+          <image src="https://static.shelingxingqiu.com/shootmini/static/device-icon.png" mode="widthFix" />
          <text>{{ device.deviceName }}</text>
          <view class="calibration" v-if="calibration">
            <button hover-class="none" @click="goCalibration">
@@ -286,7 +286,7 @@ onShow(async () => {
    <view v-if="device.deviceId && !justBind" class="has-device">
      <view class="device-binded">
        <view>
-          <image src="../static/device-icon.png" mode="widthFix" />
+          <image src="https://static.shelingxingqiu.com/shootmini/static/device-icon.png" mode="widthFix" />
          <text>{{ device.deviceName }}</text>
          <view class="calibration">
            <button hover-class="none" @click="goCalibration">
@@ -16,6 +16,14 @@ const matchList = ref([]);
 const battleList = ref([]);
 const practiseList = ref([]);

+const formatPractiseTime = (value) => {
+  const normalizedTime = String(value || "").trim();
+  const matchedTime = normalizedTime.match(
+    /^(\d{4}-\d{2}-\d{2})[T\s](\d{2}:\d{2}:\d{2})/
+  );
+  return matchedTime ? `${matchedTime[1]} ${matchedTime[2]}` : normalizedTime;
+};
+
 const toMatchDetail = (id) => {
  uni.navigateTo({
    url: `/pages/match-detail?battleId=${id}`,
@@ -81,7 +89,7 @@ onLoad((options) => {
  <Container title="我的成长脚印" :scroll="false">
    <view class="tabs">
      <view
-        v-for="(rankType, index) in ['排位赛', '好友约战', '个人练习']"
+        v-for="(rankType, index) in ['排位赛', '好友约战', '个人训练']"
        :key="index"
        :style="{
          color: index === selectedIndex ? '#000' : '#fff',
@@ -153,8 +161,8 @@ onLoad((options) => {
              @click="() => getPractiseDetail(item.id)"
            >
              <text
-                >{{ item.completed_arrows === 36 ? "耐力挑战" : "单组练习" }}
-                {{ item.createTime }}</text
+                >{{ item.trainingTypeText }}
+                {{ formatPractiseTime(item.createTime) }}</text
              >
              <image src="../static/back.png" mode="widthFix" />
            </view>
@@ -0,0 +1,306 @@
+<script setup>
+import { computed, ref } from "vue";
+import { onLoad } from "@dcloudio/uni-app";
+import Signin from "@/components/Signin.vue";
+import SButton from "@/components/SButton.vue";
+import Avatar from "@/components/Avatar.vue";
+import AppBackground from "@/components/AppBackground.vue";
+import DeviceChargingDialog from "@/components/DeviceChargingDialog.vue";
+import { tempBindOrgAPI } from "@/apis";
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+
+const store = useStore();
+const { user } = storeToRefs(store);
+
+const scene = ref("");
+const status = ref("idle");
+const errorMessage = ref("");
+const showSignin = ref(false);
+const binding = ref(false);
+const bindInfo = ref({});
+
+const successInfo = computed(() => {
+  const result = bindInfo.value || {};
+
+  return {
+    avatar: user.value.avatar,
+    nickName: user.value.nickName || "--",
+    mobile: result.mobile || "--",
+    storeName: result.storeName || "--",
+  };
+});
+
+const getToken = () => {
+  try {
+    const env = uni.getAccountInfoSync().miniProgram.envVersion;
+    return uni.getStorageSync(`${env}_token`);
+  } catch (error) {
+    return "";
+  }
+};
+
+const openSignin = () => {
+  showSignin.value = true;
+};
+
+const closeSignin = () => {
+  showSignin.value = false;
+};
+
+const bindOrg = async () => {
+  if (binding.value || !scene.value) return;
+
+  if (!getToken()) {
+    status.value = "login";
+    return;
+  }
+
+  binding.value = true;
+  status.value = "binding";
+  errorMessage.value = "";
+  bindInfo.value = {};
+
+  try {
+    const result = (await tempBindOrgAPI(scene.value)) || {};
+    if (result.success !== true) {
+      status.value = "failed";
+      errorMessage.value = result.msg || "授权登录失败，请稍后重试。";
+      return;
+    }
+
+    bindInfo.value = result;
+    status.value = "success";
+  } catch (error) {
+    if (error?.type === "AUTH_INVALID") {
+      status.value = "login";
+      errorMessage.value = "登录已失效，请重新登录后完成绑定。";
+    } else {
+      status.value = "failed";
+      errorMessage.value = error?.message || "网络异常，请稍后重试。";
+    }
+  } finally {
+    binding.value = false;
+  }
+};
+
+const handleLoginSuccess = async () => {
+  await bindOrg();
+};
+
+const goHome = () => {
+  uni.reLaunch({ url: "/pages/index" });
+};
+
+onLoad((options) => {
+  try {
+    const value = decodeURIComponent(String(options?.scene || ""));
+    if (!/^org_\d+$/.test(value)) {
+      status.value = "invalid";
+      return;
+    }
+
+    scene.value = value;
+    if (getToken()) {
+      void bindOrg();
+    } else {
+      status.value = "login";
+    }
+  } catch (error) {
+    status.value = "invalid";
+  }
+});
+</script>
+
+<template>
+  <view class="page">
+    <AppBackground :type="6" bgColor="#20202c" />
+
+    <view class="content">
+      <text class="title">登录门店Pad端</text>
+
+      <view
+        v-if="status === 'idle' || status === 'binding'"
+        class="state message-state"
+      >
+        <text class="state-title">正在授权登录</text>
+        <text class="description">正在登录门店Pad端，请稍候……</text>
+      </view>
+
+      <view v-else-if="status === 'login'" class="state login-state">
+        <image
+          class="login-icon"
+          src="../static/org-bind/login-icon.png"
+          mode="aspectFit"
+        />
+        <text class="login-title">{{
+          errorMessage || "请先登录小程序"
+        }}</text>
+        <SButton width="600rpx" :rounded="22" :onClick="openSignin">
+          <text>微信授权登录</text>
+        </SButton>
+      </view>
+
+      <view v-else-if="status === 'success'" class="state success-state">
+        <view class="avatar-wrap">
+          <Avatar
+            :src="successInfo.avatar"
+            :size="176"
+            sizeUnit="rpx"
+            imageMode="aspectFill"
+          />
+          <image
+            class="success-badge"
+            src="../static/org-bind/green-gou.png"
+            mode="aspectFit"
+          />
+        </view>
+        <text class="success-title">已成功授权登录射灵星球门店Pad端。</text>
+        <view class="account-info">
+          <text>登录账号：{{ successInfo.nickName }}</text>
+          <text>手机号：{{ successInfo.mobile }}</text>
+          <text>登录门店：{{ successInfo.storeName }}</text>
+          <text class="warm-tip">
+            温馨提示：离开门店时候记得在Pad退出登录哦！
+          </text>
+        </view>
+        <view class="success-action">
+          <SButton width="600rpx" :rounded="22" :onClick="goHome">
+            <text>回到首页</text>
+          </SButton>
+        </view>
+      </view>
+
+      <view v-else-if="status === 'failed'" class="state message-state">
+        <text class="state-title">授权登录失败</text>
+        <text class="description">{{ errorMessage }}</text>
+        <SButton width="600rpx" :rounded="22" :onClick="bindOrg">
+          <text>重新登录</text>
+        </SButton>
+      </view>
+
+      <view v-else class="state message-state">
+        <text class="state-title">二维码无效</text>
+        <text class="description">请重新扫描门店Pad端上的小程序码。</text>
+      </view>
+    </view>
+
+    <Signin
+      :show="showSignin"
+      :onClose="closeSignin"
+      :onSuccess="handleLoginSuccess"
+    />
+    <DeviceChargingDialog />
+  </view>
+</template>
+
+<style scoped lang="scss">
+.page {
+  box-sizing: border-box;
+  width: 100%;
+  min-height: 100vh;
+  padding: calc(var(--status-bar-height) + 64rpx) 48rpx 80rpx;
+  color: #fff;
+}
+
+.content {
+  position: relative;
+  z-index: 1;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+
+.title {
+  color: #d8ad69;
+  font-size: 30rpx;
+  font-weight: 500;
+}
+
+.state {
+  width: 100%;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+
+.login-state,
+.success-state {
+  margin-top: 320rpx;
+}
+
+.message-state {
+  margin-top: 240rpx;
+}
+
+.login-icon {
+  width: 176rpx;
+  height: 176rpx;
+  border-radius: 50%;
+}
+
+.login-title {
+  width: 600rpx;
+  margin: 28rpx 0 60rpx;
+  font-size: 40rpx;
+  font-weight: 500;
+  text-align: center;
+}
+
+.avatar-wrap {
+  position: relative;
+}
+
+.success-badge {
+  position: absolute;
+  right: -2rpx;
+  bottom: 4rpx;
+  width: 40rpx;
+  height: 40rpx;
+}
+
+.success-title {
+  width: 572rpx;
+  margin-top: 28rpx;
+  color: #fed847;
+  font-size: 34rpx;
+  font-weight: 500;
+  line-height: 48rpx;
+}
+
+.account-info {
+  box-sizing: border-box;
+  width: 572rpx;
+  margin-top: 20rpx;
+  display: flex;
+  flex-direction: column;
+  color: #FFFFFF;
+  font-size: 28rpx;
+  line-height: 52rpx;
+}
+
+.warm-tip {
+  margin-top: 40rpx;
+  color: #b8b8bd;
+  font-size: 24rpx;
+  line-height: 40rpx;
+}
+
+.success-action {
+  margin-top: 64rpx;
+}
+
+.state-title {
+  font-size: 38rpx;
+  font-weight: 600;
+}
+
+.description {
+  max-width: 600rpx;
+  margin: 32rpx 0 64rpx;
+  color: #b8b8b8;
+  font-size: 28rpx;
+  line-height: 1.8;
+  text-align: center;
+}
+</style>
@@ -5,6 +5,7 @@ import SButton from "@/components/SButton.vue";
 import BowTargetEdit from "@/components/BowTargetEdit.vue";
 import ScreenHint2 from "@/components/ScreenHint2.vue";
 import RingBarChart from "@/components/RingBarChart.vue";
+import DeviceChargingDialog from "@/components/DeviceChargingDialog.vue";
 import { getPointBookDetailAPI, getPointBookConfigAPI } from "@/apis";

 const selectedIndex = ref(0);
@@ -238,6 +239,7 @@ const targetTypeName = computed(() => {
        </block>
      </view>
    </ScreenHint2>
+    <DeviceChargingDialog />
  </view>
 </template>

@@ -44,7 +44,7 @@ onMounted(async () => {
  <Container :bgType="5" bgColor="#F5F5F5" :whiteBackArrow="false">
    <view class="top-part">
      <view>
-        <image src="../static/point-champion.png" mode="widthFix" />
+        <image src="https://static.shelingxingqiu.com/shootmini/static/point-champion.png" mode="widthFix" />
        <image
          :src="list[0] && list[0].avatar ? list[0].avatar : ''"
          mode="widthFix"
@@ -348,7 +348,7 @@ onShareTimeline(() => {
      />
      <view class="heat-map">
        <image
-          :src="bowTargetSrc || '../static/bow-target.png'"
+          :src="bowTargetSrc || 'https://static.shelingxingqiu.com/shootmini/static/bow-target.png'"
          mode="widthFix"
        />
        <image
@@ -374,7 +374,7 @@ onShareTimeline(() => {
      </view>
      <view class="reward" v-if="data.totalArrow">
        <button hover-class="none" @click="showTip = true">
-          <image src="../static/reward-us.png" mode="widthFix" />
+          <image src="https://static.shelingxingqiu.com/shootmini/static/reward-us.png" mode="widthFix" />
        </button>
      </view>
      <RingBarChart :data="data.ringRate" v-if="user.id" />
@@ -1,6 +1,6 @@
 <script setup>
-import { ref, onMounted, onBeforeUnmount, nextTick } from "vue";
-import { onLoad } from "@dcloudio/uni-app";
+import { computed, ref, nextTick, onMounted, onBeforeUnmount } from "vue";
+import { onHide, onLoad, onShow } from "@dcloudio/uni-app";
 import Container from "@/components/Container.vue";
 import ShootProgress from "@/components/ShootProgress.vue";
 import BowTarget from "@/components/BowTarget.vue";
@@ -15,10 +15,18 @@ import audioManager from "@/audioManager";

 import {
  createPractiseAPI,
-  startPractiseAPI,
  endPractiseAPI,
+  getCurrentPractiseAPI,
  getPractiseAPI,
+  startPractiseAPI,
 } from "@/apis";
+import {
+  connectMatchWebSocket,
+  closeMatchWebSocket,
+  setMatchAppHideResumable,
+  MATCH_WS_PRACTICE_SYNC_EVENT,
+  MATCH_WS_STATE_EVENT,
+} from "@/matchWebsocket";
 import { sharePractiseData } from "@/canvas";
 import { wxShare, debounce } from "@/util";
 import { MESSAGETYPESV2, roundsName } from "@/constants";
@@ -26,20 +34,34 @@ import { MESSAGETYPESV2, roundsName } from "@/constants";
 import useStore from "@/store";
 import { storeToRefs } from "pinia";
 const store = useStore();
-const { user } = storeToRefs(store);
+const { user, device } = storeToRefs(store);

 const start = ref(false);
+const practiceStarting = ref(false);
 const scores = ref([]);
 const isSvip = ref(false);
 const total = 12;
-/** 当前练习中连续 10 环及以上计数，用于触发 tententen 音效 */
-const xRingStreak = ref(0);
 const practiseResult = ref({});
 const practiseId = ref("");
+const serverAddr = ref("");
 const showGuide = ref(false);
 const tips = ref("");
 const targetType = ref(1);
+const simulatorTargetType = computed(() =>
+  [2, 40].includes(Number(targetType.value)) ? 40 : 20
+);
 const sharing = ref(false);
+const exiting = ref(false);
+const hiddenWhileActive = ref(false);
+const resumeInFlight = ref(false);
+const foregroundResumeSyncPending = ref(false);
+const pageVisible = ref(true);
+const appHideResumable = ref(false);
+const restoringSnapshot = ref(false);
+let practiceSyncTimer = null;
+let waitingPracticeSync = false;
+const PRACTICE_SYNC_TIMEOUT_MS = 5000;
+const RESULT_TIP_CDN = "https://static.shelingxingqiu.com/shootmini/static";

 onLoad((options) => {
  if (options.target) {
@@ -47,58 +69,137 @@ onLoad((options) => {
  }
 });

-const onReady = async () => {
-  await startPractiseAPI();
-  scores.value = [];
-  isSvip.value = false;
-  xRingStreak.value = 0; // 新一局开始，重置 X 环连续计数
-  start.value = true;
-  audioManager.play("练习开始");
+const setPracticeAppHideResumable = (enabled) => {
+  appHideResumable.value = enabled === true;
+  setMatchAppHideResumable(appHideResumable.value);
 };

-const onOver = async () => {
-  practiseResult.value = await getPractiseAPI(practiseId.value);
+const clearPracticeSyncTimer = () => {
+  if (!practiceSyncTimer) return;
+  clearTimeout(practiceSyncTimer);
+  practiceSyncTimer = null;
+};
+
+const cancelPracticeSyncWait = () => {
+  waitingPracticeSync = false;
+  clearPracticeSyncTimer();
+};
+
+const startPracticeSyncTimer = () => {
+  clearPracticeSyncTimer();
+  waitingPracticeSync = true;
+  practiceSyncTimer = setTimeout(() => {
+    practiceSyncTimer = null;
+    if (!waitingPracticeSync) return;
+
+    waitingPracticeSync = false;
+    foregroundResumeSyncPending.value = false;
+    hiddenWhileActive.value = false;
+    closeMatchWebSocket({
+      reason: "legacy-practice-resume-timeout",
+      sendLeave: false,
+    });
+    uni.showToast({
+      title: "训练重连失败，请重试",
+      icon: "none",
+    });
+  }, PRACTICE_SYNC_TIMEOUT_MS);
+};
+
+const connectPracticeServer = () => {
+  const latestServerAddr = String(serverAddr.value || "").trim();
+  if (!practiseId.value || !latestServerAddr) return false;
+
+  cancelPracticeSyncWait();
+  closeMatchWebSocket({
+    reason: "legacy-practice-switch",
+    sendLeave: false,
+  });
+  connectMatchWebSocket({
+    serverAddr: latestServerAddr,
+    matchId: practiseId.value,
+    userId: user.value.id,
+    requestPracticeInfoOnOpen: true,
+    appHideResumable: true,
+  });
+  setPracticeAppHideResumable(true);
+  return true;
+};
+
+const createPractise = async () => {
+  closeMatchWebSocket({ reason: "practice-recreate" });
+  const result = await createPractiseAPI(
+    total,
+    120,
+    targetType.value,
+    device.value.deviceId
+  );
+  if (result?.id) practiseId.value = result.id;
+  if (!result?.serverAddr) {
+    uni.showToast({
+      title: "练习连接信息异常，请重试",
+      icon: "none",
+    });
+    return null;
+  }
+  serverAddr.value = result.serverAddr;
+  connectPracticeServer();
+  return result;
+};
+
+const beginPractise = async () => {
+  if (!practiseId.value) {
+    uni.showToast({
+      title: "练习未创建，请重试",
+      icon: "none",
+    });
+    return false;
+  }
+  await startPractiseAPI(practiseId.value);
+  return true;
+};
+
+const onReady = async () => {
+  if (practiceStarting.value || start.value) return;
+  practiceStarting.value = true;
+  try {
+    const result = await beginPractise();
+    if (!result) return;
+    scores.value = [];
+    isSvip.value = false;
+    start.value = true;
+    audioManager.play("练习开始");
+  } finally {
+    practiceStarting.value = false;
+  }
+};
+
+const onOver = async (message) => {
+  setPracticeAppHideResumable(false);
+  hiddenWhileActive.value = false;
+  foregroundResumeSyncPending.value = false;
+  cancelPracticeSyncWait();
+  practiseResult.value = Array.isArray(message?.details)
+    ? message
+    : await getPractiseAPI(practiseId.value);
  start.value = false;
 };

-/**
- * 检测连续 10 环及以上是否达到 3 箭，达到则播放 tententen 音效
- * @param {boolean} isTenPlusRingShot - 本次射击是否为 10 环及以上
- */
-function isTenPlusRing(shot) {
-  return !!(shot?.ringX || Number(shot?.ring) >= 10);
-}
-
-function checkAndPlayTententen(isTenPlusRingShot) {
-  if (isTenPlusRingShot) {
-    xRingStreak.value += 1;
-    // 连续 3 箭均为 10 环及以上，在环数播报入队后追加 tententen，避免播放顺序颠倒
-    if (xRingStreak.value >= 3) {
-      xRingStreak.value = 0;
-      nextTick(() => audioManager.play("tententen", false));
-    }
-  } else {
-    // 低于 10 环或未上靶则重置连续计数
-    xRingStreak.value = 0;
-  }
-}
-
 async function onReceiveMessage(msg) {
  if (msg.type === MESSAGETYPESV2.ShootResult) {
-    const prevLen = scores.value.length;
    isSvip.value = msg.sVip === true;
-    scores.value = msg.details;
-    // 有新箭时取最后一箭判断是否 10 环及以上并检测连续计数
-    if (scores.value.length > prevLen) {
-      const latestArrow = scores.value[scores.value.length - 1];
-      checkAndPlayTententen(isTenPlusRing(latestArrow));
-    }
+    scores.value = Array.isArray(msg.details) ? msg.details : scores.value;
  } else if (msg.type === MESSAGETYPESV2.BattleEnd) {
-    // setTimeout(onOver, 1500);
+    setPracticeAppHideResumable(false);
+    hiddenWhileActive.value = false;
+    foregroundResumeSyncPending.value = false;
+    cancelPracticeSyncWait();
+    setTimeout(() => onOver(msg), 1500);
  }
 }

 async function onComplete() {
+  setPracticeAppHideResumable(false);
  const validArrows = (practiseResult.value.details || []).filter(
    (a) => a.x !== -30 && a.y !== -30
  );
@@ -106,16 +207,176 @@ async function onComplete() {
    uni.navigateBack();
  } else {
    practiseId.value = "";
+    serverAddr.value = "";
    practiseResult.value = {};
    start.value = false;
    scores.value = [];
    isSvip.value = false;
-    xRingStreak.value = 0; // 重新开始练习，重置 X 环连续计数
-    const result = await createPractiseAPI(total, 120);
-    if (result) practiseId.value = result.id;
+    await createPractise();
  }
 }

+async function exitPractise() {
+  if (exiting.value) return;
+  exiting.value = true;
+  setPracticeAppHideResumable(false);
+  hiddenWhileActive.value = false;
+  foregroundResumeSyncPending.value = false;
+  cancelPracticeSyncWait();
+
+  try {
+    if (practiseId.value && !practiseResult.value?.details) {
+      await endPractiseAPI(practiseId.value);
+    }
+  } catch (error) {
+    console.error("Failed to stop practice", error);
+  } finally {
+    uni.navigateBack();
+  }
+}
+
+const stopMissingCurrentPracticeAndExit = async () => {
+  if (exiting.value) return;
+
+  const localPractiseId = practiseId.value;
+  exiting.value = true;
+  setPracticeAppHideResumable(false);
+  hiddenWhileActive.value = false;
+  foregroundResumeSyncPending.value = false;
+  cancelPracticeSyncWait();
+
+  try {
+    if (localPractiseId) {
+      await endPractiseAPI(localPractiseId);
+    }
+  } catch (error) {
+    console.error("Failed to stop missing current practice", error);
+  } finally {
+    closeMatchWebSocket({ reason: "legacy-practice-current-missing" });
+    practiseId.value = "";
+    serverAddr.value = "";
+    practiseResult.value = {};
+    start.value = false;
+    scores.value = [];
+    isSvip.value = false;
+    uni.showToast({
+      title: "训练已结束，请重新进入",
+      icon: "none",
+    });
+    uni.navigateBack();
+  }
+};
+
+const resumeCurrentPractice = async () => {
+  if (
+    resumeInFlight.value ||
+    !hiddenWhileActive.value ||
+    !appHideResumable.value ||
+    exiting.value
+  ) {
+    return;
+  }
+
+  resumeInFlight.value = true;
+  try {
+    let currentPractice;
+    try {
+      currentPractice = await getCurrentPractiseAPI();
+    } catch (error) {
+      if (!pageVisible.value || exiting.value) return;
+      console.error("Failed to get current practice", error);
+      await stopMissingCurrentPracticeAndExit();
+      return;
+    }
+
+    if (!pageVisible.value || !hiddenWhileActive.value || exiting.value) return;
+
+    const latestPractiseId = currentPractice?.id;
+    const latestServerAddr = String(currentPractice?.serverAddr || "").trim();
+    if (
+      currentPractice === null ||
+      !latestPractiseId ||
+      !latestServerAddr
+    ) {
+      await stopMissingCurrentPracticeAndExit();
+      return;
+    }
+
+    practiseId.value = latestPractiseId;
+    serverAddr.value = latestServerAddr;
+    foregroundResumeSyncPending.value = true;
+    if (!connectPracticeServer()) {
+      foregroundResumeSyncPending.value = false;
+      await stopMissingCurrentPracticeAndExit();
+    }
+  } finally {
+    resumeInFlight.value = false;
+  }
+};
+
+const onMatchSocketState = (event = {}) => {
+  if (event.state !== "open") return;
+  if (
+    event.matchId &&
+    String(event.matchId) !== String(practiseId.value)
+  ) {
+    return;
+  }
+  startPracticeSyncTimer();
+};
+
+const onPracticeInfoSync = async (payload = {}) => {
+  const responsePractiseId = String(
+    payload.matchId || payload.practiceInfo?.id || ""
+  );
+  if (
+    !responsePractiseId ||
+    responsePractiseId !== String(practiseId.value)
+  ) {
+    return;
+  }
+
+  const snapshot = payload.practiceInfo;
+  if (!snapshot || typeof snapshot !== "object") return;
+
+  cancelPracticeSyncWait();
+  foregroundResumeSyncPending.value = false;
+  hiddenWhileActive.value = false;
+
+  restoringSnapshot.value = true;
+  await nextTick();
+  try {
+    scores.value = Array.isArray(snapshot.details) ? snapshot.details : [];
+    isSvip.value = snapshot.sVip === true;
+
+    const status = Number(snapshot.status);
+    if (status === 1) {
+      start.value = false;
+    } else if (status === 2) {
+      start.value = true;
+    }
+  } finally {
+    restoringSnapshot.value = false;
+    await nextTick();
+  }
+
+  const timeLimit = Number(snapshot.timeLimit);
+  const duration = Number(snapshot.duration);
+  if (Number(snapshot.status) === 2 && Number.isFinite(timeLimit) && timeLimit > 0) {
+    uni.$emit(
+      "update-remain",
+      Math.max(0, timeLimit - (Number.isFinite(duration) ? duration : 0))
+    );
+  }
+};
+
+const getResultTipSrc = (result = {}) => {
+  const validCount = (result.details || []).filter(
+    (arrow) => arrow.x !== -30 && arrow.y !== -30
+  ).length;
+  return `${RESULT_TIP_CDN}/${validCount < total ? "un" : ""}finish-tip.png`;
+};
+
 const onClickShare = debounce(async () => {
  if (sharing.value) return;
  sharing.value = true;
@@ -132,33 +393,50 @@ const onClickShare = debounce(async () => {
  }
 });

-function onAudioEnded(s) {
-  if (s.indexOf("比赛结束") >= 0) {
-    onOver()
+onHide(() => {
+  pageVisible.value = false;
+  if (
+    !appHideResumable.value ||
+    exiting.value ||
+    !practiseId.value ||
+    practiseResult.value?.details
+  ) {
+    return;
  }
-}
+
+  hiddenWhileActive.value = true;
+});
+
+onShow(async () => {
+  pageVisible.value = true;
+  await resumeCurrentPractice();
+});

 onMounted(async () => {
+  void audioManager.warmCommon();
  // audioManager.play("第一轮");
  uni.setKeepScreenOn({
    keepScreenOn: true,
  });
  uni.$on("socket-inbox", onReceiveMessage);
+  uni.$on(MATCH_WS_PRACTICE_SYNC_EVENT, onPracticeInfoSync);
+  uni.$on(MATCH_WS_STATE_EVENT, onMatchSocketState);
  uni.$on("share-image", onClickShare);
-  uni.$on("audioEnded", onAudioEnded);
-  const result = await createPractiseAPI(total, 120, targetType.value);
-  if (result) practiseId.value = result.id;
+  await createPractise();
 });

 onBeforeUnmount(() => {
+  setPracticeAppHideResumable(false);
+  cancelPracticeSyncWait();
  uni.setKeepScreenOn({
    keepScreenOn: false,
  });
  uni.$off("socket-inbox", onReceiveMessage);
+  uni.$off(MATCH_WS_PRACTICE_SYNC_EVENT, onPracticeInfoSync);
+  uni.$off(MATCH_WS_STATE_EVENT, onMatchSocketState);
  uni.$off("share-image", onClickShare);
-  uni.$off("audioEnded", onAudioEnded);
  audioManager.stopAll();
-  endPractiseAPI();
+  closeMatchWebSocket({ reason: "practice-leave" });
 });
 </script>

@@ -167,9 +445,15 @@ onBeforeUnmount(() => {
    :bgType="1"
    title="个人单组练习"
    :showBottom="!start && !scores.length"
+    :onBack="exitPractise"
  >
    <view>
-      <TestDistance v-if="!start && !practiseResult.id" />
+      <TestDistance
+        v-if="!start && !practiseResult.id"
+        :targetType="simulatorTargetType"
+        :autoStart="true"
+        @passed="onReady"
+      />
      <block v-else>
        <ShootProgress
          :tips="`${
@@ -181,6 +465,7 @@ onBeforeUnmount(() => {
          }`"
          :start="start"
          :onStop="onOver"
+          end-audio-key="练习结束"
        />
        <view class="user-row">
          <Avatar :src="user.avatar" :size="35" />
@@ -191,10 +476,13 @@ onBeforeUnmount(() => {
          <BowPower />
        </view>
        <BowTarget
+          v-if="!restoringSnapshot"
          :totalRound="start ? total / 4 : 0"
          :currentRound="scores.length % 3"
          :scores="scores"
          :isSvip="isSvip"
+          :targetType="simulatorTargetType"
+          stable-shot-effect
        />
        <ScorePanel2 :arrows="scores" />
        <ScoreResult
@@ -203,13 +491,7 @@ onBeforeUnmount(() => {
          :total="total"
          :onClose="onComplete"
          :result="practiseResult"
-          :tipSrc="`../static/${
-            practiseResult.details.filter(
-              (arrow) => arrow.x !== -30 && arrow.y !== -30
-            ).length < total
-              ? 'un'
-              : ''
-          }finish-tip.png`"
+          :tipSrc="getResultTipSrc(practiseResult)"
        />
        <canvas class="share-canvas" id="shareCanvas" type="2d"></canvas>
      </block>
@@ -1,5 +1,6 @@
 <script setup>
-import { ref, onMounted, onBeforeUnmount, nextTick } from "vue";
+import { computed, ref, nextTick, onMounted, onBeforeUnmount } from "vue";
+import { onHide, onLoad, onShow } from "@dcloudio/uni-app";
 import Container from "@/components/Container.vue";
 import ShootProgress from "@/components/ShootProgress.vue";
 import BowTarget from "@/components/BowTarget.vue";
@@ -14,31 +15,52 @@ import audioManager from "@/audioManager";

 import {
  createPractiseAPI,
-  startPractiseAPI,
  endPractiseAPI,
+  getCurrentPractiseAPI,
  getPractiseAPI,
+  startPractiseAPI,
 } from "@/apis";
+import {
+  connectMatchWebSocket,
+  closeMatchWebSocket,
+  setMatchAppHideResumable,
+  MATCH_WS_PRACTICE_SYNC_EVENT,
+  MATCH_WS_STATE_EVENT,
+} from "@/matchWebsocket";
 import { sharePractiseData } from "@/canvas";
 import { wxShare, debounce } from "@/util";
 import { MESSAGETYPESV2 } from "@/constants";

 import useStore from "@/store";
 import { storeToRefs } from "pinia";
-import {onLoad} from "@dcloudio/uni-app";
 const store = useStore();
-const { user } = storeToRefs(store);
+const { user, device } = storeToRefs(store);

 const start = ref(false);
+const practiceStarting = ref(false);
 const scores = ref([]);
 const isSvip = ref(false);
 const total = 36;
-/** 当前练习中连续 10 环及以上计数，用于触发 tententen 音效 */
-const xRingStreak = ref(0);
 const practiseResult = ref({});
 const practiseId = ref("");
+const serverAddr = ref("");
 const showGuide = ref(false);
 const targetType = ref(1);
+const simulatorTargetType = computed(() =>
+  [2, 40].includes(Number(targetType.value)) ? 40 : 20
+);
 const sharing = ref(false);
+const exiting = ref(false);
+const hiddenWhileActive = ref(false);
+const resumeInFlight = ref(false);
+const foregroundResumeSyncPending = ref(false);
+const pageVisible = ref(true);
+const appHideResumable = ref(false);
+const restoringSnapshot = ref(false);
+let practiceSyncTimer = null;
+let waitingPracticeSync = false;
+const PRACTICE_SYNC_TIMEOUT_MS = 5000;
+const RESULT_TIP_CDN = "https://static.shelingxingqiu.com/shootmini/static";

 onLoad((options) => {
  if (options.target) {
@@ -46,54 +68,132 @@ onLoad((options) => {
  }
 });

-const onReady = async () => {
-  await startPractiseAPI();
-  scores.value = [];
-  isSvip.value = false;
-  xRingStreak.value = 0; // 新一局开始，重置 X 环连续计数
-  start.value = true;
-  audioManager.play("练习开始");
+const setPracticeAppHideResumable = (enabled) => {
+  appHideResumable.value = enabled === true;
+  setMatchAppHideResumable(appHideResumable.value);
 };

-const onOver = async () => {
-  practiseResult.value = await getPractiseAPI(practiseId.value);
+const clearPracticeSyncTimer = () => {
+  if (!practiceSyncTimer) return;
+  clearTimeout(practiceSyncTimer);
+  practiceSyncTimer = null;
+};
+
+const cancelPracticeSyncWait = () => {
+  waitingPracticeSync = false;
+  clearPracticeSyncTimer();
+};
+
+const startPracticeSyncTimer = () => {
+  clearPracticeSyncTimer();
+  waitingPracticeSync = true;
+  practiceSyncTimer = setTimeout(() => {
+    practiceSyncTimer = null;
+    if (!waitingPracticeSync) return;
+
+    waitingPracticeSync = false;
+    foregroundResumeSyncPending.value = false;
+    hiddenWhileActive.value = false;
+    closeMatchWebSocket({
+      reason: "legacy-practice-resume-timeout",
+      sendLeave: false,
+    });
+    uni.showToast({
+      title: "训练重连失败，请重试",
+      icon: "none",
+    });
+  }, PRACTICE_SYNC_TIMEOUT_MS);
+};
+
+const connectPracticeServer = () => {
+  const latestServerAddr = String(serverAddr.value || "").trim();
+  if (!practiseId.value || !latestServerAddr) return false;
+
+  cancelPracticeSyncWait();
+  closeMatchWebSocket({
+    reason: "legacy-practice-switch",
+    sendLeave: false,
+  });
+  connectMatchWebSocket({
+    serverAddr: latestServerAddr,
+    matchId: practiseId.value,
+    userId: user.value.id,
+    requestPracticeInfoOnOpen: true,
+    appHideResumable: true,
+  });
+  setPracticeAppHideResumable(true);
+  return true;
+};
+
+const createPractise = async () => {
+  closeMatchWebSocket({ reason: "practice-recreate" });
+  const result = await createPractiseAPI(
+    total,
+    3600,
+    targetType.value,
+    device.value.deviceId
+  );
+  if (result?.id) practiseId.value = result.id;
+  if (!result?.serverAddr) {
+    uni.showToast({
+      title: "练习连接信息异常，请重试",
+      icon: "none",
+    });
+    return null;
+  }
+  serverAddr.value = result.serverAddr;
+  connectPracticeServer();
+  return result;
+};
+
+const beginPractise = async () => {
+  if (!practiseId.value) {
+    uni.showToast({
+      title: "练习未创建，请重试",
+      icon: "none",
+    });
+    return false;
+  }
+  await startPractiseAPI(practiseId.value);
+  return true;
+};
+
+const onReady = async () => {
+  if (practiceStarting.value || start.value) return;
+  practiceStarting.value = true;
+  try {
+    const result = await beginPractise();
+    if (!result) return;
+    scores.value = [];
+    isSvip.value = false;
+    start.value = true;
+    audioManager.play("练习开始");
+  } finally {
+    practiceStarting.value = false;
+  }
+};
+
+const onOver = async (message) => {
+  setPracticeAppHideResumable(false);
+  hiddenWhileActive.value = false;
+  foregroundResumeSyncPending.value = false;
+  cancelPracticeSyncWait();
+  practiseResult.value = Array.isArray(message?.details)
+    ? message
+    : await getPractiseAPI(practiseId.value);
  start.value = false;
 };

-/**
- * 检测连续 10 环及以上是否达到 3 箭，达到则播放 tententen 音效
- * @param {boolean} isTenPlusRingShot - 本次射击是否为 10 环及以上
- */
-function isTenPlusRing(shot) {
-  return !!(shot?.ringX || Number(shot?.ring) >= 10);
-}
-
-function checkAndPlayTententen(isTenPlusRingShot) {
-  if (isTenPlusRingShot) {
-    xRingStreak.value += 1;
-    // 连续 3 箭均为 10 环及以上，在环数播报入队后追加 tententen，避免播放顺序颠倒
-    if (xRingStreak.value >= 3) {
-      xRingStreak.value = 0;
-      nextTick(() => audioManager.play("tententen", false));
-    }
-  } else {
-    // 低于 10 环或未上靶则重置连续计数
-    xRingStreak.value = 0;
-  }
-}
-
 async function onReceiveMessage(msg) {
  if (msg.type === MESSAGETYPESV2.ShootResult) {
-    const prevLen = scores.value.length;
    isSvip.value = msg.sVip === true;
-    scores.value = msg.details;
-    // 有新箭时取最后一箭判断是否 10 环及以上并检测连续计数
-    if (scores.value.length > prevLen) {
-      const latestArrow = scores.value[scores.value.length - 1];
-      checkAndPlayTententen(isTenPlusRing(latestArrow));
-    }
+    scores.value = Array.isArray(msg.details) ? msg.details : scores.value;
  } else if (msg.type === MESSAGETYPESV2.BattleEnd) {
-    setTimeout(onOver, 1500);
+    setPracticeAppHideResumable(false);
+    hiddenWhileActive.value = false;
+    foregroundResumeSyncPending.value = false;
+    cancelPracticeSyncWait();
+    setTimeout(() => onOver(msg), 1500);
  }
  // messages.forEach((msg) => {
  //   if (msg.constructor === MESSAGETYPES.ShootSyncMeArrowID) {
@@ -114,6 +214,7 @@ async function onReceiveMessage(msg) {
 }

 async function onComplete() {
+  setPracticeAppHideResumable(false);
  const validArrows = (practiseResult.value.details || []).filter(
    (a) => a.x !== -30 && a.y !== -30
  );
@@ -121,16 +222,176 @@ async function onComplete() {
    uni.navigateBack();
  } else {
    practiseId.value = "";
+    serverAddr.value = "";
    practiseResult.value = {};
    start.value = false;
    scores.value = [];
    isSvip.value = false;
-    xRingStreak.value = 0; // 重新开始练习，重置 X 环连续计数
-    const result = await createPractiseAPI(total, 3600);
-    if (result) practiseId.value = result.id;
+    await createPractise();
  }
 }

+async function exitPractise() {
+  if (exiting.value) return;
+  exiting.value = true;
+  setPracticeAppHideResumable(false);
+  hiddenWhileActive.value = false;
+  foregroundResumeSyncPending.value = false;
+  cancelPracticeSyncWait();
+
+  try {
+    if (practiseId.value && !practiseResult.value?.details) {
+      await endPractiseAPI(practiseId.value);
+    }
+  } catch (error) {
+    console.error("Failed to stop practice", error);
+  } finally {
+    uni.navigateBack();
+  }
+}
+
+const stopMissingCurrentPracticeAndExit = async () => {
+  if (exiting.value) return;
+
+  const localPractiseId = practiseId.value;
+  exiting.value = true;
+  setPracticeAppHideResumable(false);
+  hiddenWhileActive.value = false;
+  foregroundResumeSyncPending.value = false;
+  cancelPracticeSyncWait();
+
+  try {
+    if (localPractiseId) {
+      await endPractiseAPI(localPractiseId);
+    }
+  } catch (error) {
+    console.error("Failed to stop missing current practice", error);
+  } finally {
+    closeMatchWebSocket({ reason: "legacy-practice-current-missing" });
+    practiseId.value = "";
+    serverAddr.value = "";
+    practiseResult.value = {};
+    start.value = false;
+    scores.value = [];
+    isSvip.value = false;
+    uni.showToast({
+      title: "训练已结束，请重新进入",
+      icon: "none",
+    });
+    uni.navigateBack();
+  }
+};
+
+const resumeCurrentPractice = async () => {
+  if (
+    resumeInFlight.value ||
+    !hiddenWhileActive.value ||
+    !appHideResumable.value ||
+    exiting.value
+  ) {
+    return;
+  }
+
+  resumeInFlight.value = true;
+  try {
+    let currentPractice;
+    try {
+      currentPractice = await getCurrentPractiseAPI();
+    } catch (error) {
+      if (!pageVisible.value || exiting.value) return;
+      console.error("Failed to get current practice", error);
+      await stopMissingCurrentPracticeAndExit();
+      return;
+    }
+
+    if (!pageVisible.value || !hiddenWhileActive.value || exiting.value) return;
+
+    const latestPractiseId = currentPractice?.id;
+    const latestServerAddr = String(currentPractice?.serverAddr || "").trim();
+    if (
+      currentPractice === null ||
+      !latestPractiseId ||
+      !latestServerAddr
+    ) {
+      await stopMissingCurrentPracticeAndExit();
+      return;
+    }
+
+    practiseId.value = latestPractiseId;
+    serverAddr.value = latestServerAddr;
+    foregroundResumeSyncPending.value = true;
+    if (!connectPracticeServer()) {
+      foregroundResumeSyncPending.value = false;
+      await stopMissingCurrentPracticeAndExit();
+    }
+  } finally {
+    resumeInFlight.value = false;
+  }
+};
+
+const onMatchSocketState = (event = {}) => {
+  if (event.state !== "open") return;
+  if (
+    event.matchId &&
+    String(event.matchId) !== String(practiseId.value)
+  ) {
+    return;
+  }
+  startPracticeSyncTimer();
+};
+
+const onPracticeInfoSync = async (payload = {}) => {
+  const responsePractiseId = String(
+    payload.matchId || payload.practiceInfo?.id || ""
+  );
+  if (
+    !responsePractiseId ||
+    responsePractiseId !== String(practiseId.value)
+  ) {
+    return;
+  }
+
+  const snapshot = payload.practiceInfo;
+  if (!snapshot || typeof snapshot !== "object") return;
+
+  cancelPracticeSyncWait();
+  foregroundResumeSyncPending.value = false;
+  hiddenWhileActive.value = false;
+
+  restoringSnapshot.value = true;
+  await nextTick();
+  try {
+    scores.value = Array.isArray(snapshot.details) ? snapshot.details : [];
+    isSvip.value = snapshot.sVip === true;
+
+    const status = Number(snapshot.status);
+    if (status === 1) {
+      start.value = false;
+    } else if (status === 2) {
+      start.value = true;
+    }
+  } finally {
+    restoringSnapshot.value = false;
+    await nextTick();
+  }
+
+  const timeLimit = Number(snapshot.timeLimit);
+  const duration = Number(snapshot.duration);
+  if (Number(snapshot.status) === 2 && Number.isFinite(timeLimit) && timeLimit > 0) {
+    uni.$emit(
+      "update-remain",
+      Math.max(0, timeLimit - (Number.isFinite(duration) ? duration : 0))
+    );
+  }
+};
+
+const getResultTipSrc = (result = {}) => {
+  const validCount = (result.details || []).filter(
+    (arrow) => arrow.x !== -30 && arrow.y !== -30
+  ).length;
+  return `${RESULT_TIP_CDN}/${validCount < total ? "2un" : ""}finish-tip.png`;
+};
+
 const onClickShare = debounce(async () => {
  if (sharing.value) return;
  sharing.value = true;
@@ -147,24 +408,49 @@ const onClickShare = debounce(async () => {
  }
 });

+onHide(() => {
+  pageVisible.value = false;
+  if (
+    !appHideResumable.value ||
+    exiting.value ||
+    !practiseId.value ||
+    practiseResult.value?.details
+  ) {
+    return;
+  }
+
+  hiddenWhileActive.value = true;
+});
+
+onShow(async () => {
+  pageVisible.value = true;
+  await resumeCurrentPractice();
+});
+
 onMounted(async () => {
+  void audioManager.warmCommon();
  uni.setKeepScreenOn({
    keepScreenOn: true,
  });
  uni.$on("socket-inbox", onReceiveMessage);
+  uni.$on(MATCH_WS_PRACTICE_SYNC_EVENT, onPracticeInfoSync);
+  uni.$on(MATCH_WS_STATE_EVENT, onMatchSocketState);
  uni.$on("share-image", onClickShare);
-  const result = await createPractiseAPI(total, 3600, targetType.value);
-  if (result) practiseId.value = result.id;
+  await createPractise();
 });

 onBeforeUnmount(() => {
+  setPracticeAppHideResumable(false);
+  cancelPracticeSyncWait();
  uni.setKeepScreenOn({
    keepScreenOn: false,
  });
  uni.$off("socket-inbox", onReceiveMessage);
+  uni.$off(MATCH_WS_PRACTICE_SYNC_EVENT, onPracticeInfoSync);
+  uni.$off(MATCH_WS_STATE_EVENT, onMatchSocketState);
  uni.$off("share-image", onClickShare);
  audioManager.stopAll();
-  endPractiseAPI();
+  closeMatchWebSocket({ reason: "practice-leave" });
 });
 </script>

@@ -173,15 +459,22 @@ onBeforeUnmount(() => {
    :bgType="1"
    title="日常耐力挑战"
    :showBottom="!start && !scores.length"
+    :onBack="exitPractise"
  >
    <view>
-      <TestDistance v-if="!start && !practiseResult.id" />
+      <TestDistance
+        v-if="!start && !practiseResult.id"
+        :targetType="simulatorTargetType"
+        :autoStart="true"
+        @passed="onReady"
+      />
      <block v-else>
        <ShootProgress
          :tips="`请连续射${total}支箭`"
          :start="start"
          :total="3600"
          :onStop="onOver"
+          end-audio-key="练习结束"
        />
        <view class="user-row">
          <Avatar :src="user.avatar" :size="35" />
@@ -192,10 +485,12 @@ onBeforeUnmount(() => {
          <BowPower />
        </view>
        <BowTarget
+          v-if="!restoringSnapshot"
          :currentRound="scores.length"
          :totalRound="start ? total : 0"
          :scores="scores"
          :isSvip="isSvip"
+          :targetType="simulatorTargetType"
        />
        <ScorePanel
          v-if="start"
@@ -211,13 +506,7 @@ onBeforeUnmount(() => {
          :rowCount="9"
          :onClose="onComplete"
          :result="practiseResult"
-          :tipSrc="`../static/${
-            practiseResult.details.filter(
-              (arrow) => arrow.x !== -30 && arrow.y !== -30
-            ).length < total
-              ? '2un'
-              : ''
-          }finish-tip.png`"
+          :tipSrc="getResultTipSrc(practiseResult)"
        />
        <canvas class="share-canvas" id="shareCanvas" type="2d"></canvas>
      </block>
@@ -1,5 +1,61 @@
 <script setup>
 import Container from "@/components/Container.vue";
+
+const LEVEL_ICON_BASE_URL = "https://static.shelingxingqiu.com/levelicon";
+
+const rankRows = [
+  {
+    name: "倔强青铜",
+    levels: ["倔强青铜1", "倔强青铜2", "倔强青铜3"],
+    picNames: ["青铜1", "青铜2", "青铜3"],
+    score: "每个小段位需要满3颗星才能晋升到下一个段位，共9颗星。",
+  },
+  {
+    name: "秩序白银",
+    levels: ["秩序白银1", "秩序白银2", "秩序白银3"],
+    picNames: ["白银1", "白银2", "白银3"],
+    score: "每个小段位需要满3颗星才能晋升到下一个段位，共9颗星。",
+  },
+  {
+    name: "荣耀黄金",
+    levels: ["荣耀黄金1", "荣耀黄金2", "荣耀黄金3", "荣耀黄金4"],
+    picNames: ["黄金1", "黄金2", "黄金3", "黄金4"],
+    score: "每个小段位需要满4颗星才能晋升到下一个段位，共16颗星。",
+  },
+  {
+    name: "永恒钻石",
+    levels: ["永恒钻石1", "永恒钻石2", "永恒钻石3", "永恒钻石4", "永恒钻石5"],
+    picNames: ["钻石1", "钻石2", "钻石3", "钻石4", "钻石5"],
+    score: "每个小段位需要满5颗星才能晋升到下一个段位，共25颗星。",
+  },
+];
+
+const kingRankRows = [
+  { name: "最强王者", score: "0-9" },
+  { name: "非凡王者", score: "10-19" },
+  { name: "无双王者", score: "20-29" },
+  { name: "绝世王者", score: "30-39" },
+  { name: "至圣王者", score: "40-49" },
+  { name: "荣耀王者", score: "50-99" },
+  { name: "传奇王者", score: "100+" },
+];
+
+const meleeScoreTables = [
+  {
+    title: "5人大乱斗",
+    rankings: [1, 2, 3, 4, 5],
+    scores: [150, 75, 0, -100, -100],
+  },
+  {
+    title: "10人大乱斗",
+    rankings: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+    scores: [200, 125, 75, 0, 0, 0, -50, -100, -100, -100],
+  },
+];
+
+// 图片文件名与段位名称一致，统一在这里拼接远程地址。
+const getLevelIcon = (levelName) =>
+  `${LEVEL_ICON_BASE_URL}/${levelName}.png`;
 </script>

 <template>
@@ -22,25 +78,89 @@ import Container from "@/components/Container.vue";

          <view class="sub-section">
            <view class="sub-title">（一）基本规则</view>
-            <view class="rule-item">
-              <text class="rule-label">重一局：</text>
-              <text class="rule-value">+100积分</text>
+            <view class="rule-mode">
+              <view class="rule-mode-title">1V1、2V2、3V3对抗模式：</view>
+              <view class="rule-item">
+                <text class="rule-bullet">●</text>
+                <text class="rule-content"
+                  >每胜一局，胜方每人+100积分；每负一局，负方每人-100积分</text
+                >
+              </view>
+              <view class="rule-item">
+                <text class="rule-bullet">●</text>
+                <text class="rule-content"
+                  >2V2模式：胜方队伍中，总成绩最高且箭均成绩≥7环者，为本局MVP，额外获得40积分。</text
+                >
+              </view>
+              <view class="rule-item">
+                <text class="rule-bullet">●</text>
+                <text class="rule-content"
+                  >3V3模式：胜方队伍中，总成绩最高且箭均成绩≥7环者，为本局MVP，额外获得60积分。</text
+                >
+              </view>
+              <view class="rule-item">
+                <text class="rule-bullet">●</text>
+                <text class="rule-content"
+                  >在1V1/2V2/3V3三种模式中，连续获得五连胜（三类模式一起算），则从第五场开始，每场胜利可额外再加15分，直至结束连胜。（仅限对抗模式，不含大乱斗模式。）</text
+                >
+              </view>
            </view>
-            <view class="rule-item">
-              <text class="rule-label">输一局：</text>
-              <text class="rule-value">-100积分</text>
-            </view>
-            <view class="rule-item">
-              <text class="rule-label">全场MVP（2v2）：</text>
-              <text class="rule-value">额外+40积分</text>
-            </view>
-            <view class="rule-item">
-              <text class="rule-label">全场MVP（3v3）：</text>
-              <text class="rule-value">额外+60积分</text>
-            </view>
-            <view class="rule-item">
-              <text class="rule-label">五连胜：</text>
-              <text class="rule-value">每局额外+15积分</text>
+
+            <view class="rule-mode">
+              <view class="rule-mode-title">5人、10人大乱斗模式：</view>
+              <view class="rule-paragraph">
+                5人大乱斗和10人大乱斗按个人总环数成绩排序，排名从高到低依次设置系统默认奖励/扣除积分，默认初始排名和积分规则具体如下：
+              </view>
+
+              <view class="melee-score-table">
+                <view
+                  v-for="table in meleeScoreTables"
+                  :key="table.title"
+                  class="melee-table-section"
+                >
+                  <view class="melee-table-title">{{ table.title }}</view>
+                  <scroll-view
+                    class="melee-table-scroll"
+                    scroll-x
+                    :enhanced="true"
+                    :show-scrollbar="false"
+                  >
+                    <view
+                      :class="[
+                        'melee-table-body',
+                        table.rankings.length > 5
+                          ? 'melee-table-body--wide'
+                          : '',
+                      ]"
+                    >
+                      <view class="melee-table-row">
+                        <text class="melee-table-cell melee-table-label"
+                          >排名</text
+                        >
+                        <text
+                          v-for="ranking in table.rankings"
+                          :key="ranking"
+                          class="melee-table-cell"
+                        >
+                          {{ ranking }}
+                        </text>
+                      </view>
+                      <view class="melee-table-row">
+                        <text class="melee-table-cell melee-table-label"
+                          >积分</text
+                        >
+                        <text
+                          v-for="(score, index) in table.scores"
+                          :key="index"
+                          class="melee-table-cell"
+                        >
+                          {{ score }}
+                        </text>
+                      </view>
+                    </view>
+                  </scroll-view>
+                </view>
+              </view>
            </view>
          </view>

@@ -55,77 +175,57 @@ import Container from "@/components/Container.vue";
        <view class="section">
          <view class="title">三、（表格）</view>
          <view class="rank-table">
-            <view class="table-row">
-              <text>大段位</text>
-              <text>小段位</text>
-              <text>积分（100积分=1星）</text>
+            <view class="table-row table-header">
+              <text class="table-cell major-column">大段位</text>
+              <text class="table-cell minor-column">小段位</text>
+              <text class="table-cell score-column">积分（100积分=1星）</text>
            </view>
-            <view class="table-row">
-              <text>倔强青铜</text>
-              <view>
-                <text>青铜1*</text>
-                <text>青铜2*</text>
-                <text>青铜3*</text>
+
+            <view
+              v-for="rank in rankRows"
+              :key="rank.name"
+              class="table-row rank-group-row"
+            >
+              <view class="table-cell major-column major-rank-cell">
+                <image
+                  class="rank-icon"
+                  :src="getLevelIcon(rank.picNames[0])"
+                  mode="aspectFit"
+                  lazy-load
+                />
+                <text class="major-rank-name">{{ rank.name }}</text>
              </view>
-              <text>每个小段位需要满 3星才能晋升到下一个段位，共9颗星。</text>
-            </view>
-            <view class="table-row">
-              <text>秩序白银</text>
-              <view>
-                <text>白铜1*</text>
-                <text>白铜2*</text>
-                <text>白铜3*</text>
+
+              <view class="minor-column minor-rank-cell">
+                <text
+                  v-for="level in rank.levels"
+                  :key="level"
+                  class="table-cell minor-rank-item"
+                >
+                  {{ level }}
+                </text>
              </view>
-              <text>每个小段位需要满 3颗星才能晋升到下一个段位，共9颗星。</text>
+
+              <text class="table-cell score-column score-text">
+                {{ rank.score }}
+              </text>
            </view>
-            <view class="table-row">
-              <text>荣耀黄金</text>
-              <view>
-                <text>黄金1*</text>
-                <text>黄金2*</text>
-                <text>黄金3*</text>
-                <text>黄金4*</text>
+
+            <view
+              v-for="rank in kingRankRows"
+              :key="rank.name"
+              class="table-row king-rank-row"
+            >
+              <view class="table-cell king-rank-cell">
+                <image
+                  class="rank-icon"
+                  :src="getLevelIcon(rank.name)"
+                  mode="aspectFit"
+                  lazy-load
+                />
+                <text class="major-rank-name">{{ rank.name }}</text>
              </view>
-              <text>每个小段位需要满4颗星才能晋升到下一个段位，共16颗星。</text>
-            </view>
-            <view class="table-row">
-              <text>永恒钻石</text>
-              <view>
-                <text>钻石1*</text>
-                <text>钻石2*</text>
-                <text>钻石3*</text>
-                <text>钻石4*</text>
-                <text>钻石5*</text>
-              </view>
-              <text>每个小段位需要满5颗星才能晋升到下一个段位，共25颗星。</text>
-            </view>
-            <view class="table-row2">
-              <text>最强王者</text>
-              <text>0-9</text>
-            </view>
-            <view class="table-row2">
-              <text>非凡王者</text>
-              <text>10-19</text>
-            </view>
-            <view class="table-row2">
-              <text>无双王者</text>
-              <text>20-29</text>
-            </view>
-            <view class="table-row2">
-              <text>绝世王者</text>
-              <text>30-39</text>
-            </view>
-            <view class="table-row2">
-              <text>至圣王者</text>
-              <text>40-49</text>
-            </view>
-            <view class="table-row2">
-              <text>荣耀王者</text>
-              <text>50-99</text>
-            </view>
-            <view class="table-row2">
-              <text>传奇王者</text>
-              <text>100+</text>
+              <text class="table-cell king-score-cell">{{ rank.score }}</text>
            </view>
          </view>
        </view>
@@ -181,17 +281,103 @@ import Container from "@/components/Container.vue";

 .rule-item {
  display: flex;
-  margin-bottom: 8px;
-}
-
-.rule-label {
-  font-size: 14px;
+  align-items: flex-start;
+  margin-bottom: 16rpx;
+  font-size: 28rpx;
  color: #666666;
+  line-height: 1.7;
 }

-.rule-value {
-  font-size: 14px;
+.rule-mode {
+  margin-bottom: 24rpx;
+}
+
+.rule-mode:last-child {
+  margin-bottom: 0;
+}
+
+.rule-mode-title {
+  margin-bottom: 12rpx;
+  font-size: 28rpx;
  color: #333333;
+  font-weight: 600;
+  line-height: 1.6;
+}
+
+.rule-bullet {
+  flex-shrink: 0;
+  margin-right: 10rpx;
+  font-size: 20rpx;
+  line-height: 2.38;
+}
+
+.rule-content {
+  flex: 1;
+}
+
+.rule-paragraph {
+  font-size: 28rpx;
+  color: #666666;
+  line-height: 1.7;
+}
+
+.melee-score-table {
+  margin-top: 20rpx;
+  border: $uni-border;
+  color: #333333;
+  font-size: 26rpx;
+}
+
+.melee-table-section + .melee-table-section {
+  border-top: $uni-border;
+}
+
+.melee-table-title {
+  padding: 14rpx 16rpx;
+  background-color: #f5f6f7;
+  color: #e53935;
+  font-weight: 600;
+  border-bottom: $uni-border;
+}
+
+.melee-table-scroll {
+  width: 100%;
+  white-space: nowrap;
+}
+
+.melee-table-body {
+  width: 100%;
+}
+
+.melee-table-body--wide {
+  width: 900rpx;
+}
+
+.melee-table-row {
+  display: flex;
+}
+
+.melee-table-row + .melee-table-row {
+  border-top: $uni-border;
+}
+
+.melee-table-cell {
+  display: flex;
+  flex: 1;
+  align-items: center;
+  min-width: 0;
+  min-height: 72rpx;
+  padding: 10rpx 12rpx;
+  box-sizing: border-box;
+  border-left: $uni-border;
+}
+
+.melee-table-cell:first-child {
+  border-left: 0;
+}
+
+.melee-table-label {
+  flex: 0 0 86rpx;
 }

 .rank-table {
@@ -201,41 +387,94 @@ import Container from "@/components/Container.vue";
  width: calc(100vw - 20px);
 }

-.rank-table > view {
+.table-row {
  display: flex;
 }

-.rank-table > view > text:last-child {
-  margin-left: -1rpx;
-}
-
-.rank-table text {
+.table-cell {
  padding: 10rpx 20rpx;
  border: $uni-border;
  box-sizing: border-box;
-  display: inline-block;
  margin-top: -1rpx;
+  margin-left: -1rpx;
 }

-.table-row text {
+.major-column,
+.minor-column {
  width: 25%;
 }

-.table-row > view {
+.score-column {
+  width: 50%;
+}
+
+.table-header .table-cell {
+  display: flex;
+  align-items: center;
+}
+
+.major-rank-cell,
+.minor-rank-cell {
  display: flex;
  flex-direction: column;
-  width: 25%;
+  padding: 0;
 }

-.table-row > view > text {
+.minor-rank-item {
+  min-height: 70rpx;
+  box-sizing: border-box;
+}
+
+.major-rank-cell {
+  align-items: center;
+  justify-content: center;
+  padding: 12rpx 8rpx;
+}
+
+.rank-icon {
+  width: 120rpx;
+  height: 120rpx;
+  flex-shrink: 0;
+}
+
+.major-rank-name {
+  margin-top: 8rpx;
+  font-size: 24rpx;
+  line-height: 1.4;
+  text-align: center;
+}
+
+.minor-rank-item {
+  display: flex;
+  align-items: center;
+  justify-content: center;
  width: 100%;
+  margin-left: 0;
+  padding: 10rpx;
+  border-right: 0;
 }

-.table-row > text:nth-child(3) {
+.score-text {
+  display: flex;
+  align-items: center;
+  line-height: 1.6;
+}
+
+.king-rank-cell,
+.king-score-cell {
  width: 50%;
 }

-.table-row2 > text {
-  width: 50%;
+.king-rank-cell {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  min-height: 210rpx;
+}
+
+.king-score-cell {
+  display: flex;
+  align-items: center;
 }
 </style>
@@ -2,6 +2,7 @@
 import { computed, nextTick, onMounted, ref } from "vue";
 import { onLoad } from "@dcloudio/uni-app";
 import Avatar from "@/components/Avatar.vue";
+import DeviceChargingDialog from "@/components/DeviceChargingDialog.vue";
 import {
  getMvpRankList,
  getMyMvpRank,
@@ -524,6 +525,7 @@ const measureTabsMetrics = () => {
        {{ getRankUnit() }}
      </text>
    </view>
+    <DeviceChargingDialog />
  </view>
 </template>

@@ -126,7 +126,6 @@ const toMatchPage = async (gameType, teamSize) => {
    showLimitModal.value = true;
    return;
  }
-  await uni.$checkAudio();
  uni.navigateTo({
    url: `/pages/match-page?gameType=${gameType}&teamSize=${teamSize}`,
  });
@@ -328,8 +327,8 @@ onShow(async () => {
    <view class="battle-types-box">
      <view class="battle-types">
        <view class="first">
-          <image src="../static/rank/battle-choose.png" mode="widthFix" />
-          <image class="star" src="../static/rank/star.png" mode="widthFix" />
+          <image src="https://static.shelingxingqiu.com/shootmini/static/rank/battle-choose.png" mode="widthFix" />
+          <image class="star" src="https://static.shelingxingqiu.com/shootmini/static/rank/star.png" mode="widthFix" />
        </view>
        <image
          src="../static/rank/battle1v1.svg"
@@ -49,8 +49,6 @@ const battleWay = ref(0);
 const lastToSomeoneShootKey = ref("");
 /** 控制设备离线提示弹窗的显示状态 */
 const showOfflineModal = ref(false);
-/** 记录每位玩家当前轮连续 10 环及以上次数，key 为 playerId，用于触发 tententen 音效 */
-const xRingStreaks = ref({});

 /**
 * 监听设备在线状态，比赛进行中设备离线时弹窗提示用户
@@ -86,7 +84,7 @@ const recoverData = (battleInfo, {force = false, arrowOnly = false} = {}) => {
    start.value = battleInfo.status !== 0;

    if (battleInfo.status === 0) {
-      const readyRemain = (Date.now() - (battleInfo.createTime || Date.now())) / 1000;
+      const readyRemain = (Date.now() - (battleInfo.serverTime || Date.now())) / 1000;
      if (readyRemain > 0 && readyRemain < 15) {
        setTimeout(() => {
          uni.$emit("update-timer", 15 - readyRemain - 0.2);
@@ -233,31 +231,6 @@ function onNewRound(msg, prevRound) {
  }
 }

-/**
- * 检测指定射手连续 10 环及以上是否达到 3 箭，达到则在环数播报入队后追加 tententen 音效
- * @param {number} shooterId - 本次射手的 ID（取自 currentShooterId.value）
- * @param {boolean} isTenPlusRingShot - 本次射击是否为 10 环及以上
- */
-function isTenPlusRing(shot) {
-  return !!(shot?.ringX || Number(shot?.ring) >= 10);
-}
-
-function checkAndPlayTententen(shooterId, isTenPlusRingShot) {
-  if (!shooterId) return;
-  if (isTenPlusRingShot) {
-    xRingStreaks.value[shooterId] = (xRingStreaks.value[shooterId] || 0) + 1;
-    // 同一玩家连续 3 箭均为 10 环及以上，追加到环数音效队列尾部播放
-    if (xRingStreaks.value[shooterId] >= 3) {
-      xRingStreaks.value[shooterId] = 0;
-      // nextTick 确保 HeaderProgress 的环数播报已入队后再追加 tententen，避免播放顺序颠倒
-      nextTick(() => audioManager.play("tententen", false));
-    }
-  } else {
-    // 低于 10 环或未上靶则重置该玩家的连续计数
-    xRingStreaks.value[shooterId] = 0;
-  }
-}
-
 async function onReceiveMessage(msg) {
  if (Array.isArray(msg)) return;
  if (msg.type === MESSAGETYPESV2.BattleStart) {
@@ -272,9 +245,9 @@ async function onReceiveMessage(msg) {
  } else if (msg.type === MESSAGETYPESV2.ShootResult) {
    showRoundTip.value = false;
    recoverData(msg, {arrowOnly: true});
-    // 检测同一玩家连续三箭 10 环及以上，触发 tententen 音效
-    // currentShooterId 在 ToSomeoneShoot 时写入，ShootResult 不会覆盖，可靠识别本次射手
-    checkAndPlayTententen(currentShooterId.value, isTenPlusRing(msg.shootData));
+    if (msg.shootData?.threeConsecutive10Rings === true) {
+      nextTick(() => audioManager.play("tententen", false));
+    }
  } else if (msg.type === MESSAGETYPESV2.NewRound) {
    // 在进入延迟前先捕获当前轮次，供 onNewRound 使用，防止 800ms 内 ToSomeoneShoot 提前更新 currentRound 造成 Tip 展示错轮
    const prevRound = currentRound.value;
@@ -4,6 +4,7 @@ import { onShow } from "@dcloudio/uni-app";

 import { getBattleAPI, getUserGameState } from "@/apis";
 import { debounce } from "@/util";
+import { returnToBattle } from "@/utils/matchReturn";

 import useStore from "@/store";
 import { storeToRefs } from "pinia";
@@ -66,12 +67,7 @@ const onClick = debounce(async () => {
    loading.value = true;
    const result = await getBattleAPI();
    if (result && result.matchId) {
-      await uni.$checkAudio();
-      if (result.mode <= 3) {
-        await navigateOnce(`/pages/team-battle/index?battleId=${result.matchId}`);
-      } else {
-        await navigateOnce(`/pages/melee-battle?battleId=${result.matchId}`);
-      }
+      await returnToBattle(result, navigateOnce);
      return;
    }
    if (game.value.roomID) {
@@ -100,9 +96,9 @@ onBeforeUnmount(() => {
    class="back-to-game"
    @click="onClick"
  >
-    <image src="../../../static/back-to-game-bg.png" mode="widthFix" />
+    <image src="https://static.shelingxingqiu.com/shootmini/static/back-to-game-bg.png" mode="widthFix" />
    <block v-if="game.inBattle">
-      <image src="../../../static/pk-icon.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/pk-icon.png" mode="widthFix" />
      <text>返回进行中的对局</text>
    </block>
    <block v-else-if="game.roomID">
@@ -31,7 +31,7 @@ const normalRounds = computed(() => {
 <template>
  <view class="container">
    <view class="guide-row">
-      <image src="../../../static/shooter.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/shooter.png" mode="widthFix" />
      <view
        :style="{
          marginBottom: '10px',
@@ -42,7 +42,7 @@ const normalRounds = computed(() => {
      </view>
    </view>
    <view>
-      <image src="../../../static/battle-header-melee.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/battle-header-melee.png" mode="widthFix" />
      <text>蓝队({{ bluePoints }})</text>
      <text>红队({{ redPoints }})</text>
    </view>
@@ -41,7 +41,7 @@ const isMember = (player = {}) => player.vip === true || player.sVip === true;
  <view class="container" :style="{ paddingTop: showHeader ? '5px' : '0' }">
    <image
      v-if="showHeader"
-      :src="`../../../static/battle-header${players.length ? '-melee' : ''}.png`"
+      :src="`https://static.shelingxingqiu.com/shootmini/static/battle-header${players.length ? '-melee' : ''}.png`"
      mode="widthFix"
    />
    <view
@@ -151,6 +151,7 @@ const isMember = (player = {}) => player.vip === true || player.sVip === true;
 .container {
  width: 100%;
  position: relative;
+  z-index: 999;
  margin-bottom: 10px;
 }
 .container > image:first-child {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
zhangyi	74bfd7a327	update：优化赏金赛记录	2026-08-31 16:14:57 +08:00
zhangyi	bbfa35e871	update：优化个人训练	2026-08-28 11:12:28 +08:00
zhangyi	469487ba73	update：优化新手教程	2026-08-27 17:24:25 +08:00
zhangyi	b9bbaba77f	update：优化新版个人训练	2026-08-26 17:23:36 +08:00
zhangyi	11eeb98b74	update：图片更新	2026-08-26 15:36:45 +08:00
zhangyi	96b64e4187	update：新增稳定训练	2026-08-26 15:23:02 +08:00
zhangyi	45bc324f70	update：优化节奏训练结算	2026-08-25 18:00:14 +08:00
zhangyi	2eba5f87d7	update：优化记录	2026-08-25 17:49:44 +08:00
zhangyi	9a06dcf942	update：对接节奏训练	2026-08-25 17:36:54 +08:00
zhangyi	35e0ee3ca0	update：优化节奏训练	2026-08-24 16:35:56 +08:00
zhangyi	59fa317c5a	update: 优化个人训练	2026-08-21 15:38:01 +08:00
zhangyi	09756ae165	Merge branch 'feat-scene' into test	2026-08-20 18:09:06 +08:00
zhangyi	b89c003313	update：新增回到首页按钮	2026-08-20 18:08:49 +08:00
zhangyi	9dda58b19c	Merge branch 'feat-yuyin' into test	2026-08-20 17:57:33 +08:00
zhangyi	962596e510	update:优化精准射箭语音	2026-08-20 17:57:22 +08:00
zhangyi	8a2fbb0780	Merge branch 'feat-scene' into test	2026-08-20 17:14:11 +08:00
zhangyi	0c0a00f742	update: 优化机构金币相关	2026-08-20 17:13:36 +08:00
zhangyi	66fc7fa8eb	Merge branch 'feat-yuyin' into test	2026-08-20 16:56:47 +08:00
zhangyi	6363dda204	update: 语音优化	2026-08-20 16:56:34 +08:00
zhangyi	9f4fbbe4c9	Merge branch 'feat-scene' into test	2026-08-20 16:10:48 +08:00
zhangyi	45957d04b1	update：优化金币	2026-08-20 16:10:17 +08:00
zhangyi	42cfb5c3d8	update: 优化图片	2026-08-20 14:43:28 +08:00
zhangyi	844f72489e	Merge branch 'feat-scene' into test	2026-08-20 14:37:47 +08:00
zhangyi	d2571854bc	update: 对接金币相关	2026-08-20 14:37:08 +08:00
zhangyi	bb224c9f29	update:语音优化	2026-08-19 14:04:12 +08:00
zhangyi	82c360f1b1	Merge branch 'test' into feat-scene	2026-08-19 10:17:38 +08:00
zhangyi	63f3cada0f	update:暂存金币相关	2026-08-19 10:14:17 +08:00
chenlimao	75cfcd66ee	fix: OTA轮询次数改为15次	2026-08-18 13:57:49 +08:00
chenlimao	7955b37ec5	fix: 修复首页更新卡在更新中弹窗问题	2026-08-18 11:48:20 +08:00
chenlimao	9e6ad4cf50	feat: OTA 首页弹窗优化	2026-08-18 10:30:16 +08:00
chenlimao	6c55d32f90	chore: 依赖锁提交	2026-08-17 18:02:12 +08:00
zhangyi	d60c32506f	update:优化机构扫码页	2026-08-17 14:05:52 +08:00
zhangyi	63fb4ae85a	update:优化性能问题	2026-08-17 10:11:28 +08:00
zhangyi	2628a17b3f	update: 新增设备充电通知	2026-08-14 17:59:11 +08:00
zhangyi	e7f073ed7c	update:个人训练优化	2026-08-14 17:13:23 +08:00
zhangyi	d662db9465	Merge branch 'test' into feat-scene	2026-08-10 11:56:37 +08:00
zhangyi	23655102d3	update:设备解绑功能	2026-08-10 10:34:54 +08:00
zhangyi	fbb2076a77	Merge branch 'main' into feat-scene	2026-08-06 14:24:17 +08:00
zhangyi	8c96a4cb73	update:优化文字	2026-08-05 17:52:26 +08:00
zhangyi	6a78093d31	update: 优化	2026-08-05 17:38:34 +08:00
zhangyi	4835993639	update:大乱斗新增电量展示	2026-08-04 17:31:05 +08:00
zhangyi	3c45ef78ac	update: 修复飞行特效	2026-08-04 16:18:30 +08:00
zhangyi	ab70c8c78e	Merge branch 'feat-miao' into test	2026-08-03 16:59:30 +08:00
zhangyi	fac2576b65	update:新增调瞄通信，优化首页	2026-08-03 16:39:52 +08:00
zhangyi	360da2a1d7	update:本地域名优化	2026-08-03 14:26:00 +08:00
zhangyi	e96537b21b	update:优化边距	2026-07-31 16:26:08 +08:00
zhangyi	8c834d299b	update:个人训练新版新增靶型标志	2026-07-31 16:07:38 +08:00
zhangyi	b386990475	Merge branch 'main' into test	2026-07-31 14:55:45 +08:00
zhangyi	3ab1ad59bd	update:新增语音优化	2026-07-31 14:45:17 +08:00
zhangyi	cfdb169329	update:优化训练0环显示	2026-07-31 13:52:39 +08:00
zhangyi	4245a3f947	update:按钮特效优化	2026-07-31 11:16:34 +08:00
zhangyi	d6f914ca7e	update:新版优化练习结束语音	2026-07-31 10:56:41 +08:00
zhangyi	959244c03a	update:更新新版个人训练结束播报	2026-07-31 10:32:45 +08:00
zhangyi	3a51142bd3	Merge branch 'feat-audio2' into test	2026-07-31 10:28:40 +08:00
zhangyi	07dc8a250c	update:个人训练结束修改语音	2026-07-31 10:21:30 +08:00
zhangyi	f34800798d	update:新增机构扫码登录页	2026-07-31 09:42:59 +08:00
zhangyi	72fd8b134e	update:补充新版个人训练查看靶纸vip特效	2026-07-28 15:37:13 +08:00
zhangyi	30ab1c6775	update:优化个人训练字段	2026-07-27 17:45:07 +08:00
zhangyi	02f30e88ba	update:优化vip飞行特效	2026-07-27 16:55:56 +08:00
zhangyi	e6f11d3684	update:优化个人训练	2026-07-27 16:38:53 +08:00
zhangyi	c5618fb60b	update:新增个人训练重连机制，修复海报	2026-07-24 16:00:46 +08:00
zhangyi	f316d52cec	update:优化图片	2026-07-23 16:47:15 +08:00
zhangyi	d8d2f9e7e7	update；优化	2026-07-23 14:44:46 +08:00
zhangyi	ef499e1448	update:优化新版个人训练	2026-07-23 14:38:45 +08:00
zhangyi	c0d061d7d5	update:优化图片	2026-07-23 13:45:49 +08:00
zhangyi	dff210462f	update:优化个人训练图片	2026-07-23 11:01:55 +08:00
zhangyi	3c5754b3fd	update：对接个人训练改版	2026-07-23 09:44:58 +08:00
zhangyi	a78ab1daeb	Merge branch 'test' into feat-prac	2026-07-20 17:58:40 +08:00
zhangyi	886faa0007	update:新增匹配跳转幂等	2026-07-20 16:46:04 +08:00
zhangyi	b15c37cb4a	update:优化10人乱斗测距页	2026-07-17 18:26:14 +08:00
zhangyi	970a9874b4	Merge branch 'test'	2026-07-16 16:41:16 +08:00
zhangyi	f64a6b5c95	update:新增房间重连逻辑，优化tententen语音，修复mvp斩获环	2026-07-16 16:40:32 +08:00
zhangyi	621397e25d	update:优化比赛流程	2026-07-16 11:38:17 +08:00
zhangyi	fa7ad8f538	update:优化比赛结束	2026-07-15 16:57:48 +08:00
zhangyi	b8c5f3dd91	Merge branch 'test'	2026-07-15 15:23:57 +08:00
zhangyi	af7f70ba80	update:修改mvp字段	2026-07-15 15:22:31 +08:00
zhangyi	6d1a910051	Merge branch 'test'	2026-07-15 09:55:37 +08:00
zhangyi	1c7cf74eb9	update:优化段位介绍	2026-07-15 09:55:01 +08:00
zhangyi	e9023ecc9f	update:新增dist排除代码	2026-07-14 17:59:52 +08:00
zhangyi	080af14be8	update:语音加载优化，修复大乱斗未重连比赛服问题	2026-07-13 14:50:21 +08:00
zhangyi	1796d4aa40	update:房间新增vip特效	2026-07-10 18:13:41 +08:00
zhangyi	4b39107453	update：优化大乱斗断连	2026-07-10 17:49:42 +08:00
zhangyi	3e090e5b33	update:修复大乱斗	2026-07-10 16:45:03 +08:00
zhangyi	98ca638b63	update:新增比赛服断线重连机制	2026-07-10 15:11:45 +08:00
zhangyi	b5373bee31	update:新版本websocket	2026-07-10 13:57:09 +08:00
zhangyi	58a7bb2017	update:优化个人练习	2026-07-09 18:29:04 +08:00
zhangyi	82eedc3ab8	update:分包、对接个人练习	2026-07-09 17:53:29 +08:00
zhangyi	ac4d8dfb38	Merge branch 'test' into feat-websoc	2026-07-09 16:26:31 +08:00
zhangyi	725a3ddcb9	update:优化比赛	2026-07-09 16:15:27 +08:00
zhangyi	33187e0cc3	update；优化比赛服	2026-07-09 15:48:28 +08:00
zhangyi	bf6b87b59c	update:优化跳转	2026-07-09 14:43:25 +08:00
zhangyi	12729a1cef	update:修复日志和防抖	2026-07-09 14:35:48 +08:00
zhangyi	f8efe4c4a4	update：优化比赛	2026-07-09 11:43:06 +08:00
zhangyi	af07d09ab6	update:优化比赛队列	2026-07-08 18:18:27 +08:00
zhangyi	e0d976fcce	update:更新比赛服逻辑	2026-07-08 16:03:34 +08:00
zhangyi	01ac4f9c03	update:新增比赛服链接	2026-07-08 14:51:35 +08:00
zhangyi	095884d7fc	Merge branch 'fix-vip'	2026-07-06 11:16:52 +08:00
zhangyi	a7897af861	Merge branch 'fix-vip'	2026-07-06 09:38:15 +08:00
zhangyi	fd7c4b4bbf	update:优化图片	2026-07-03 17:50:55 +08:00
zhangyi	efb186d242	Merge branch 'test'	2026-07-03 17:49:40 +08:00
zhangyi	0bf4773400	Merge branch 'test' into feat-prac	2026-06-15 09:32:27 +08:00
zhangyi	4ce2e6a7c4	Merge branch 'fix-bug'	2026-06-15 09:31:27 +08:00
zhangyi	52c5b9504a	update:更新靶纸	2026-06-11 18:13:46 +08:00
zhangyi	022683aff1	Merge branch 'test' into feat-prac	2026-06-02 15:54:15 +08:00
zhangyi	72518fa17e	update:优化样式	2026-06-01 15:39:40 +08:00
zhangyi	f5497c534d	update:代码备份	2026-06-01 10:59:26 +08:00
zhangyi	b3fc11f1b1	update:代码备份	2026-05-29 17:46:52 +08:00
zhangyi	8b25a10d4c	Merge branch 'test' into feat-prac	2026-05-29 14:01:03 +08:00
zhangyi	0e82416800	Merge branch 'test' into feat-prac	2026-05-28 11:16:54 +08:00
zhangyi	e6d00e7ea9	Merge branch 'test' into feat-prac	2026-05-28 09:46:54 +08:00
zhangyi	18afba01ec	update:新增基础训练入口	2026-05-26 11:38:49 +08:00
zhangyi	2780d1a6df	update:代码备份	2026-05-26 10:23:31 +08:00
zhangyi	2a53f6739e	update:对接个人训练难度页	2026-05-26 09:33:28 +08:00
zhangyi	bae31add22	update:对接个人训练首页	2026-05-20 16:36:07 +08:00
zhangyi	465b9c8dc7	update:代码备份	2026-05-18 16:39:36 +08:00
zhangyi	3ff11df1d7	update:代码备份	2026-05-18 11:05:13 +08:00
zhangyi	21d8d0fbdb	update:代码备份	2026-05-18 09:20:07 +08:00
zhangyi	fc7149121b	update：优化	2026-05-15 10:23:59 +08:00
zhangyi	8061ddbed5	update：训练难度展示ui完成	2026-05-15 09:46:33 +08:00
zhangyi	bb50c7ca10	update:删除个人训练首页的无用组件	2026-05-13 10:54:15 +08:00
zhangyi	1bca5977c1	个人训练改版首页存档	2026-05-13 10:49:31 +08:00