update:补充新版个人训练查看靶纸vip特效

# Conflicts:
#	src/apis.js

.gitignore

@@ -10,9 +10,10 @@ lerna-debug.log*
 node_modules
 .history
 .github
+.claude
 openspec
 CLAUDE.md
-dosc
+docs
 .DS_Store
 dist
 *.local

.vscode/settings.json

@@ -1,3 +1,9 @@
 {
-    "i18n-ally.localesPaths": []
+  "i18n-ally.localesPaths": [],
+  "files.watcherExclude": {
+    "**/dist/**": true
+  },
+  "search.exclude": {
+    "**/dist/**": true
+  }
 }

AGENTS.md

@@ -0,0 +1,270 @@
+# AI Agent 企业级行为策略（Ultimate Edition）
+
+## 核心目标
+
+AI 应：
+
+* 像高级工程师一样思考
+* 保持智能
+* 保持上下文理解能力
+* 保持组件联动能力
+* 同时避免无意义 token 消耗
+
+目标不是限制 AI。
+
+目标是：
+
+* 智能
+* 克制
+* 稳定
+* 高效
+
+---
+
+# AI 工作模式
+
+默认采用：
+
+Think First
+Explore Second
+Modify Last
+
+即：
+
+1. 先理解需求
+2. 再推理可能相关文件
+3. 再最小化读取
+4. 最后修改代码
+
+禁止：
+
+* 无脑全项目扫描
+* 不经思考直接 grep
+* 无限递归读取
+
+---
+
+# 智能按需扫描（核心规则）
+
+允许 AI 自动：
+
+* 分析当前任务
+* 分析 import
+* 分析组件依赖
+* 分析 store 依赖
+* 分析 api 依赖
+* 分析 types 依赖
+* 分析 utils 依赖
+
+允许：
+
+* 自动读取直接依赖文件
+* 自动修复 import
+* 自动修复类型引用
+* 自动分析运行链路
+
+但必须：
+
+* 最小化扫描范围
+* 最小化 token 消耗
+* 禁止无限递归探索
+
+---
+
+# 扫描深度限制
+
+默认最大依赖深度：
+
+2 层
+
+例如：
+
+index.vue
+-> ProductCard.vue
+-> product.ts
+
+允许读取：
+
+* ProductCard.vue
+* product.ts
+
+禁止继续无限扫描。
+
+如果任务复杂：
+
+必须先输出分析计划，
+等待确认后再扩大扫描范围。
+
+---
+
+# AI 自由发挥边界
+
+允许：
+
+* 合理重构
+* 合理组件化
+* 合理优化结构
+* 合理优化样式
+* 合理优化复用
+* 合理修复低级问题
+* 合理修复 import
+* 合理修复类型错误
+
+禁止：
+
+* 为了炫技重构项目
+* 无意义抽象
+* 过度设计
+* 无意义拆分
+* 无意义新增依赖
+* 自动升级依赖
+
+---
+
+# Token 经济策略
+
+Token 应优先用于：
+
+* 推理
+* 架构理解
+* 业务逻辑
+* UI 结构优化
+* 类型安全
+* 组件联动
+
+禁止浪费在：
+
+* 全项目 grep
+* 重复读取
+* 重复输出
+* 重复解释
+* 输出完整项目
+* 输出未修改代码
+
+---
+
+# 页面生成规则（Figma / uni-app）
+
+允许：
+
+* 自动组件化
+* 自动布局优化
+* 自动结构优化
+* 自动提取公共组件
+
+优先：
+
+* flex 布局
+* 可维护性
+* uni-app 最佳实践
+* 低嵌套结构
+* 高复用结构
+
+禁止：
+
+* div 套 div
+* 全 absolute 页面
+* 垃圾 HTML
+* 无意义嵌套
+* 内联 style 泛滥
+
+---
+
+# uni-app 规则
+
+必须：
+
+* 使用 view/text/image
+* px 转 rpx
+* 使用 script setup
+* scoped scss
+* 兼容：
+
+  * H5
+  * 微信小程序
+  * App
+
+---
+
+# 大任务策略
+
+复杂任务：
+
+必须：
+
+1. 先分析
+2. 先规划
+3. 先输出方案
+4. 等待确认
+
+再：
+
+5. 编码
+
+禁止直接进入大规模代码生成。
+
+---
+
+# 修改策略
+
+优先：
+
+* diff 修改
+* 小范围 patch
+* 保持现有架构
+* 保持现有组件体系
+* 保持现有 API 结构
+
+允许：
+
+* 小范围智能优化
+
+禁止：
+
+* 全项目重构
+* 无关文件修改
+
+---
+
+# 高级工程师行为模式
+
+AI 应像高级工程师：
+
+* 先思考
+* 再探索
+* 再修改
+
+而不是：
+
+* 无脑扫描器
+* Token 消耗机器
+* 低级代码生成器
+
+AI 应主动：
+
+* 控制扫描范围
+* 控制输出长度
+* 控制修改范围
+* 控制复杂度
+
+同时保持：
+
+* 智能
+* 联动能力
+* 架构理解能力
+
+---
+
+# 默认输出规则
+
+默认：
+
+* 仅输出修改部分
+* 不重复未修改代码
+* 少解释
+* 优先 patch
+* 优先 diff
+* 写好中文注释
+
+除非用户明确要求：
+否则不要输出完整项目。

doc.md

@@ -0,0 +1,246 @@
+# 微信小程序多人协作分支管理规范
+
+## 一、分支结构
+
+```
+main (主分支/生产环境)
+  └── test (测试分支)
+        └── feature/xxx (个人开发分支)
+```
+
+| 分支 | 用途 | 稳定性 |
+|------|------|--------|
+| main | 生产环境代码 | 最高，仅接受测试通过的代码合并 |
+| test | 测试环境，用于体验版发布 | 中，需验证后合并到 main |
+| feature/xxx | 个人开发分支 | 低，按需命名，如 `feature/user-center` |
+
+---
+
+## 二、开发流程
+
+### 1. 开始开发
+
+```bash
+# 确保本地 main 最新
+git checkout main
+git pull origin main
+
+# 从 main 创建自己的开发分支
+git checkout -b feature/your-name-work
+```
+
+### 2. 开发阶段
+
+- 在个人分支上开发功能
+- 频繁提交，保持原子性提交
+- 定期 `git pull origin main` 同步主线变更，避免合并冲突累积
+
+```bash
+git add .
+git commit -m "feat: 完成xxx功能"
+```
+
+### 3. 合并到 test 分支
+
+```bash
+# 切换到 test
+git checkout test
+git pull origin test
+
+# 合并个人分支
+git merge feature/your-name-work
+
+# 推送 test 分支
+git push origin test
+```
+
+### 4. 打包上传体验版
+
+```bash
+# 执行打包
+npm run build
+```
+
+打包完成后：
+
+1. 打开 **微信开发者工具**
+2. 导入项目，选择 `dist/build/mp-weixin` 目录
+3. 在开发者工具中点击 **上传**
+4. 登录 [微信公众平台](https://mp.weixin.qq.com)
+5. 进入 **管理->版本管理**
+6. 找到刚上传的版本，点击 **选为体验版**
+
+---
+
+## 三、合并到 main 分支
+
+当 test 分支验证通过后，将其合并到 main：
+
+```bash
+git checkout main
+git pull origin main
+
+git merge origin/test
+
+git push origin main
+```
+
+---
+
+## 四、冲突处理
+
+合并时如有冲突，在个人分支解决后再合并：
+
+```bash
+git checkout feature/your-name-work
+git merge main
+# 解决冲突后
+git add .
+git commit -m "merge: 解决与main的冲突"
+git push origin feature/your-name-work
+
+# 重新合并到 test
+git checkout test
+git merge feature/your-name-work
+git push origin test
+```
+
+---
+
+## 五、注意事项
+
+1. **禁止直接向 main 和 test 分支提交代码**，必须通过合并
+2. **每次合并前先拉取最新代码**，避免覆盖他人改动
+3. **体验版发布前确认代码已提交**，避免遗漏
+4. **开发分支命名建议**：`feature/姓名-功能名`，如 `feature/zhangsan-login`
+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. 微信开发者工具中的主包、分包体积符合上传限制。

jsconfig.json

@@ -12,5 +12,6 @@
   },
   "vueCompilerOptions": {
     "plugins": ["@uni-helper/uni-types/volar-plugin"]
-  }
+  },
+  "exclude": ["node_modules", "dist"]
 }

package-lock.json

@@ -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",

package.json

@@ -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": {
@@ -25,6 +30,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"
   },

project.config.json

@@ -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": {

scripts/generate-match-schema.mjs

@@ -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;
+}

src/App.vue

@@ -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
@@ -21,7 +25,9 @@
 	} = storeToRefs(store);
 	const {
 		updateUser,
-		updateOnline
+		updateOnline,
+		clearSessionState,
+		clearDevice
 	} = store;
 
 	watch(
@@ -34,6 +40,9 @@
 				websocket.createWebSocket(token, onShootWsMsg);
 			}
 			if (!newVal) {
+				matchWebsocket.closeMatchWebSocket({
+					reason: "logout"
+				});
 				websocket.closeWebSocket();
 			}
 		}, {
@@ -46,25 +55,75 @@
 		updateUser(value);
 	}
 
+	function onSessionKickedOut() {
+		const env = uni.getAccountInfoSync().miniProgram.envVersion;
+		uni.removeStorageSync(`${env}_token`);
+		clearSessionState();
+		uni.showModal({
+			title: "提示",
+			content: "账号已在其他设备登录",
+			showCancel: false,
+		});
+	}
+
 	async function emitUpdateOnline() {
 		const data = await getDeviceBatteryAPI();
 		updateOnline(data.online);
 	}
 
+	function onDeviceBindInvalid() {
+		clearDevice();
+		uni.setStorageSync("calibration", false);
+	}
+
 	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);
+		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`
 		);
@@ -77,6 +136,14 @@
 	onHide(() => {
 		uni.$off("update-user", emitUpdateUser);
 		uni.$off("update-online", emitUpdateOnline);
+		uni.$off("session-kicked-out", onSessionKickedOut);
+		uni.$off("device-bind-invalid", onDeviceBindInvalid);
+		if (typeof uni.offNetworkStatusChange === "function") {
+			uni.offNetworkStatusChange(onNetworkStatusChange);
+		}
+		matchWebsocket.closeMatchWebSocket({
+			reason: "app-hide"
+		});
 		websocket.closeWebSocket();
 	});
 </script>
@@ -236,6 +303,69 @@
 		text-overflow: ellipsis;
 	}
 
+	.member-nickname {
+		position: relative;
+		display: inline-flex;
+		max-width: 100%;
+		overflow: hidden;
+	}
+
+	.member-nickname__text,
+	.member-nickname__shine {
+		display: block;
+		max-width: 100%;
+		white-space: nowrap;
+		overflow: hidden;
+		text-overflow: ellipsis;
+	}
+
+	.member-nickname--vip .member-nickname__text {
+		color: #E7BA80;
+	}
+
+	.member-nickname--svip .member-nickname__text {
+		background: linear-gradient(90deg, #ffb86c, #ff4fd8, #7c5cff, #35d6ff);
+		-webkit-background-clip: text;
+		background-clip: text;
+		color: transparent;
+	}
+
+	.member-nickname__shine {
+		position: absolute;
+		left: 0;
+		top: 0;
+		width: 100%;
+		height: 100%;
+		background: linear-gradient(
+			110deg,
+			transparent 0%,
+			transparent 38%,
+			rgba(255, 255, 255, 0.15) 45%,
+			rgba(255, 255, 255, 1) 50%,
+			rgba(255, 255, 255, 0.15) 55%,
+			transparent 62%,
+			transparent 100%
+		);
+		background-size: 220% 100%;
+		background-position: 120% 0;
+		-webkit-background-clip: text;
+		background-clip: text;
+		color: transparent;
+		pointer-events: none;
+		animation: memberNicknameShine 3.5s infinite ease-in-out;
+	}
+
+	@keyframes memberNicknameShine {
+		0%,
+		50% {
+			background-position: 120% 0;
+		}
+
+		100% {
+			background-position: -200% 0;
+		}
+	}
+
 	.modal {
 		height: 100%;
 		display: flex;

src/apis.js

@@ -1,3 +1,5 @@
+import { normalizeBattleApiResult } from "@/utils/matchAdapter";
+
 let BASE_URL = "https://api.shelingxingqiu.com/api/shoot"; // 默认正式版
 
 try {
@@ -6,8 +8,8 @@ try {
 
     switch (envVersion) {
         case "develop": // 开发版
-            BASE_URL = "http://localhost:8000/api/shoot";
-            // BASE_URL = "https://apitest.shelingxingqiu.com/api/shoot";
+            // BASE_URL = "http://192.168.1.2:8000/api/shoot";
+            BASE_URL = "https://apitest.shelingxingqiu.com/api/shoot";
             break;
         case "trial": // 体验版
             BASE_URL = "https://apitest.shelingxingqiu.com/api/shoot";
@@ -23,7 +25,9 @@ try {
     console.error("获取环境信息失败，使用默认正式环境", e);
 }
 
-function request(method, url, data = {}) {
+const ADDONS_BASE_URL = BASE_URL.replace(/\/api\/shoot$/, "/api/shoot");
+// 统一处理业务接口请求，包含登录态、业务错误和 WiFi 连接空响应兼容。
+function request(method, url, data = {}, baseUrl = BASE_URL) {
     const token = uni.getStorageSync(
         `${uni.getAccountInfoSync().miniProgram.envVersion}_token`
     );
@@ -31,21 +35,33 @@ function request(method, url, data = {}) {
     if (token) header.Authorization = `Bearer ${token || ""}`;
     return new Promise((resolve, reject) => {
         uni.request({
-            url: `${BASE_URL}${url}`,
+            url: `${baseUrl}${url}`,
             method,
             header,
             data,
             timeout: 10000,
             success: (res) => {
+                if (url === "/user/hardwareBox/connectWifi" && 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);
                     else if (message) {
+                        const error = {code, data, message};
                         if (message.indexOf("登录身份已失效") !== -1) {
+                            console.log('1111111111111111111,token失效')
                             uni.removeStorageSync(
                                 `${uni.getAccountInfoSync().miniProgram.envVersion}_token`
                             );
                             uni.$emit("update-user");
+                            reject({ type: "AUTH_INVALID", message });
+                            return;
+                        }
+                        if (message.indexOf("已达上限") !== -1) {
+                            reject(error);
+                            return;
                         }
                         if (message === "ROOM_FULL") {
                             resolve({full: true});
@@ -67,6 +83,15 @@ function request(method, url, data = {}) {
                             resolve({binded: true});
                             return;
                         }
+                        if (message === "BIND_FAILD") {
+                            uni.$emit("device-bind-invalid");
+                            uni.showToast({
+                                title: "设备绑定状态已失效，请重新绑定",
+                                icon: "none",
+                            });
+                            reject({type: "DEVICE_BIND_INVALID", message});
+                            return;
+                        }
                         if (message === "ERROR_ORDER_UNPAY") {
                             uni.showToast({
                                 title: "当前有未支付订单",
@@ -85,8 +110,10 @@ function request(method, url, data = {}) {
                             title: message,
                             icon: "none",
                         });
+                        reject(error);
+                        return;
                     }
-                    reject("");
+                    reject({code, data, message});
                 }
             },
             fail: (err) => {
@@ -155,6 +182,10 @@ export const getAppConfig = () => {
     return request("GET", "/index/appConfig");
 };
 
+export const getDailyCountAPI = () => {
+    return request("GET", "/index/dailyCount", {}, ADDONS_BASE_URL);
+};
+
 export const getHomeData = (seasonId) => {
     return request("GET", `/user/myHome?seasonId=${seasonId}`);
 };
@@ -231,12 +262,23 @@ 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) => {
@@ -330,9 +372,23 @@ export const createOrderAPI = (vipId) => {
         quanity: 1,
         tradeType: "mini",
         payType: "wxpay",
+        returnUrl: "",
+        remark: "",
+        mockTest: false,
     });
 };
 
+export const virtualPayOrderAPI = (vipId = 0, code = "") => {
+    return request("POST", "/user/virtualPay/createOrder", {
+        vipId,
+        code,
+    });
+};
+
+export const getOrderDetailAPI = (orderId) => {
+    return request("GET", `/user/order/detail?orderId=${encodeURIComponent(orderId)}`);
+};
+
 export const payOrderAPI = (id) => {
     return request("POST", "/user/order/pay", {
         id,
@@ -407,6 +463,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");
 };
@@ -445,6 +510,26 @@ export const getDeviceBatteryAPI = async () => {
     return request("GET", "/user/device/battery");
 };
 
+// 设备连接指定 WiFi，只下发 WiFi 凭证，不触发 OTA 升级。
+export const connectDeviceWifiAPI = async (ssid, password) => {
+    return request("POST", "/user/hardwareBox/connectWifi", {ssid, password});
+};
+
+// 获取硬件盒子版本信息，用于判断当前设备是否需要 OTA 升级。
+export const getHardwareBoxVersionAPI = async () => {
+    return request("GET", "/user/hardwareBox/version");
+};
+
+// 发送硬件盒子 OTA 更新指令，服务端会返回后续轮询使用的任务 ID。
+export const sendHardwareBoxUpdateAPI = async (data) => {
+    return request("POST", "/user/hardwareBox/sendUpdate", data);
+};
+
+// 根据任务 ID 获取硬件盒子 OTA 更新状态。
+export const getHardwareBoxTaskStatusAPI = async (taskId) => {
+    return request("GET", `/user/hardwareBox/taskStatus?taskId=${taskId}`);
+};
+
 export const addNoteAPI = async (id, remark) => {
     return request("POST", "/user/score/sheet/remark", {id, remark});
 };
@@ -457,6 +542,10 @@ export const getPhoneNumberAPI = (data) => {
     return request("POST", "/index/getPhone", data);
 };
 
+export const getPhoneNumberAPIv2 = (data) => {
+    return request("POST", "/index/getPhone/v2", data);
+};
+
 export const getPointBookRankListAPI = (page = 1) => {
     return request(
         "GET",
@@ -485,9 +574,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) => {
@@ -496,3 +586,63 @@ export const kickPlayerAPI = (number, userId) => {
         userId,
     });
 };
+
+// 获取赛季列表
+export const getSeasonList = () => {
+    return request("GET", "/index/season/list");
+};
+
+// 获取赛季统计
+export const getSeasonStats = (seasonId) => {
+    const data = {};
+    if (seasonId !== undefined && seasonId !== null) data.seasonId = seasonId;
+    return request("GET", "/index/season/stats", data);
+};
+
+//获取积分榜
+export const getScoreRankList = (seasonId, page, perPage) => {
+    return request("GET", "/index/score/rank/list", {
+		seasonId,
+		page,
+		perPage
+	});
+};
+
+// 获取10环排行榜
+export const getTenRingRankList = (seasonId, page, perPage) => {
+    return request("GET", "/index/tenRing/rank/list", {
+		seasonId,
+		page,
+		perPage
+	});
+};
+
+// 获取MVP排行榜
+export const getMvpRankList = (seasonId, page, perPage) => {
+    return request("GET", "/index/mvp/rank/list", {
+		seasonId,
+		page,
+		perPage
+	});
+};
+
+// 获取我的积分排名
+export const getMyScoreRank = (seasonId) => {
+    const data = {};
+    if (seasonId !== undefined && seasonId !== null) data.seasonId = seasonId;
+    return request("GET", "/index/myScoreRank", data);
+};
+
+// 获取我的MVP排名
+export const getMyMvpRank = (seasonId) => {
+    const data = {};
+    if (seasonId !== undefined && seasonId !== null) data.seasonId = seasonId;
+    return request("GET", "/index/myMvpRank", data);
+};
+
+// 获取我的10环排名
+export const getMyTenRingRank = (seasonId) => {
+    const data = {};
+    if (seasonId !== undefined && seasonId !== null) data.seasonId = seasonId;
+    return request("GET", "/index/myTenRingRank", data);
+};

src/audioManager.js

@@ -1,4 +1,11 @@
+export const AUDIO_INTERRUPTION_BEGIN_EVENT = "audio-interruption-begin";
+export const AUDIO_INTERRUPTION_END_EVENT = "audio-interruption-end";
+
 export const audioFils = {
+  tententen: "https://static.shelingxingqiu.com/shootmini/static/audio/tententen.mp3",
+  点击按钮: "https://static.shelingxingqiu.com/shootmini/static/audio/%E7%82%B9%E5%87%BB%E6%8C%89%E9%92%AE.mp3",
+  "20CM全环靶": "https://static.shelingxingqiu.com/shootmini/static/audio/20CM%E5%85%A8%E7%8E%AF%E9%9D%B6-%E6%97%A0%E6%95%88.mp3",
+  "40CM全环靶": "https://static.shelingxingqiu.com/shootmini/static/audio/40CM%E5%85%A8%E7%8E%AF%E9%9D%B6-%E6%97%A0%E6%95%88.mp3",
   // 激光已校准:
   //   "https://static.shelingxingqiu.com/attachment/2025-10-29/ddupaur1vdkyhzaqdc.mp3",
   胜利: "https://static.shelingxingqiu.com/attachment/2025-09-17/dcuo9yjp0kt5msvmvd.mp3",
@@ -33,10 +40,12 @@ export const audioFils = {
     "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutya59b6pu0ur4um.mp3",
   比赛开始:
     "https://static.shelingxingqiu.com/attachment/2025-09-17/dcuu5z3a3lumkutske.mp3",
+  下半场开始:
+    "https://static.shelingxingqiu.com/shootmini/static/audio/%E4%B8%8B%E5%8D%8A%E5%9C%BA%E5%BC%80%E5%A7%8B.mp3",
   请开始射击:
     "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutzdrl5u0iromqhf.mp3",
   射击无效:
-    "https://static.shelingxingqiu.com/attachment/2025-09-17/dcutya55ufiiw8oo55.mp3",
+    "https://static.shelingxingqiu.com/shootmini/static/audio/%E5%B0%84%E7%AE%AD%E6%97%A0%E6%95%88%E6%A3%80%E6%9F%A5%E8%B7%9D%E7%A6%BB%E5%92%8C%E9%9D%B6%E7%BA%B8.mp3",
   未上靶:
     "https://static.shelingxingqiu.com/attachment/2025-11-12/de6n45o3tsm1v4unam.mp3",
   "1环":
@@ -86,6 +95,28 @@ export const audioFils = {
 	"https://static.shelingxingqiu.com/shootaudio/%E5%91%BD%E4%B8%AD.mp3"
 };
 
+const AUDIO_LOAD_TIMEOUT_MS = 5000;
+const AUDIO_WARM_CONCURRENCY = 3;
+const AUDIO_WARM_RETRIES = 1;
+const AUDIO_WARM_PRIORITY_KEYS = [
+  "点击按钮",
+  "比赛开始",
+  "练习开始",
+  "请开始射击",
+  "轮到你了",
+  "比赛结束",
+  "射击无效",
+  "中场休息",
+  "下半场开始",
+  "决金箭轮",
+  "请蓝方射箭",
+  "请红方射箭",
+  "距离合格",
+  "距离不足",
+  "未上靶",
+  "X环",
+];
+
 // 版本控制日志函数
 function debugLog(...args) {
   // 获取当前环境信息
@@ -93,7 +124,7 @@ function debugLog(...args) {
   const envVersion = accountInfo.miniProgram.envVersion;
 
   // 只在体验版打印日志，正式版(release)和开发版(develop)不打印
-  if (envVersion === "trial") {
+  if (envVersion === "trial" || envVersion === "develop") {
     console.log(...args);
   }
 }
@@ -102,18 +133,15 @@ class AudioManager {
   constructor() {
     this.audioMap = new Map();
     this.currentPlayingKey = null;
-    this.maxRetries = 3;
-    // 多轮统一重试：最多重试的轮次与每轮间隔
-    this.maxRetryRounds = 10;
-    this.retryRoundIntervalMs = 1500;
     // 显式授权播放标记，防止 iOS 在设置 src 后误播
     this.allowPlayMap = new Map();
 
-    // 串行加载相关属性
-    this.audioKeys = [];
-    this.currentLoadingIndex = 0;
+    // 后台预热与单条加载状态
     this.isLoading = false;
-    this.loadingPromise = null;
+    this.loadingKeyPromises = new Map();
+    this.pendingPlayKeys = new Set();
+    this.cacheWritePromises = new Map();
+    this.warmAllPromise = null;
 
     // 连续播放队列相关属性
     this.sequenceQueue = [];
@@ -123,22 +151,55 @@ class AudioManager {
     // 防重复播放保护
     this.lastPlayKey = null;
     this.lastPlayAt = 0;
+    this.isInterrupted = false;
+    this.interruptedAt = 0;
+    this.interruptionFallbackMs = 5000;
+    this.playWatchdogMs = 8000;
+    this.playWatchdogTimers = new Map();
 
     // 静音开关
     this.isMuted = false;
     this.pendingPlayKey = null;
-    // 新增：就绪状态映射
     this.readyMap = new Map();
-    // 新增：首轮失败的音频集合与重试阶段标识
-    this.failedLoadKeys = new Set();
-    // 加载代数，用于 reloadAll 时作废旧的加载循环
+    // 加载代数，用于 reloadAll 时作废旧的异步加载
     this.loadGeneration = 0;
     // 本地路径缓存 Map: { url: localPath }
     this.localFileCache = uni.getStorageSync("audio_local_files") || {};
     // 启动时自动清理过期的缓存文件（URL 已不在 audioFils 中的文件）
     this.cleanObsoleteCache();
+    this.bindAudioInterruptionEvents();
+  }
 
-    this.initAudios();
+  bindAudioInterruptionEvents() {
+    if (this._audioInterruptionBound) return;
+    this._audioInterruptionBound = true;
+
+    const begin = () => {
+      if (this.isInterrupted) return;
+      this.isInterrupted = true;
+      this.interruptedAt = Date.now();
+      this.stopAll();
+      this.isSequenceRunning = false;
+      this.sequenceQueue = [];
+      this.sequenceIndex = 0;
+      this.pendingPlayKey = null;
+      uni.$emit(AUDIO_INTERRUPTION_BEGIN_EVENT);
+    };
+
+    const end = () => {
+      if (!this.isInterrupted) return;
+      this.isInterrupted = false;
+      this.interruptedAt = 0;
+      uni.$emit(AUDIO_INTERRUPTION_END_EVENT);
+      void this.reloadAll();
+    };
+
+    if (typeof uni?.onAudioInterruptionBegin === "function") {
+      uni.onAudioInterruptionBegin(begin);
+    }
+    if (typeof uni?.onAudioInterruptionEnd === "function") {
+      uni.onAudioInterruptionEnd(end);
+    }
   }
 
   // 清理不再使用的缓存文件
@@ -170,128 +231,122 @@ class AudioManager {
     }
   }
 
-  // 初始化音频（两阶段：首轮串行加载全部，次轮仅串行加载失败项一次）
-  initAudios() {
-    if (this.isLoading) {
-      debugLog("音频正在加载中，跳过重复初始化");
-      return this.loadingPromise;
-    }
-    debugLog("开始串行加载音频...");
-    this.isLoading = true;
-    this.audioKeys = Object.keys(audioFils);
-    this.currentLoadingIndex = 0;
-    this.failedLoadKeys.clear();
-
-    // 增加代数，使得旧的加载循环失效
-    this.loadGeneration = (this.loadGeneration || 0) + 1;
-    const currentGen = this.loadGeneration;
-
-    this.loadingPromise = new Promise((resolve) => {
-      const finalize = () => {
-        if (currentGen !== this.loadGeneration) return;
-        const runRounds = (round) => {
-          if (currentGen !== this.loadGeneration) return;
-          // 达到最大轮次或没有失败项，收尾
-          if (this.failedLoadKeys.size === 0 || round > this.maxRetryRounds) {
-            this.isLoading = false;
-            resolve();
-            return;
-          }
-
-          const retryKeys = Array.from(this.failedLoadKeys);
-          this.failedLoadKeys.clear();
-          debugLog(`开始第 ${round} 轮串行加载，共 ${retryKeys.length} 个`);
-
-          this.loadKeysSequentially(
-            retryKeys,
-            () => {
-              if (currentGen !== this.loadGeneration) return;
-              // 如仍有失败项，继续下一轮；否则结束
-              if (this.failedLoadKeys.size > 0 && round < this.maxRetryRounds) {
-                setTimeout(
-                  () => runRounds(round + 1),
-                  this.retryRoundIntervalMs
-                );
-              } else {
-                this.isLoading = false;
-                resolve();
-              }
-            },
-            currentGen
-          );
-        };
-
-        // 启动第 1 轮重试（如有失败项）
-        runRounds(1);
-      };
-      this.loadNextAudio(finalize, currentGen);
-    });
-    return this.loadingPromise;
+  getWarmupKeys() {
+    return Array.from(
+      new Set([...AUDIO_WARM_PRIORITY_KEYS, ...Object.keys(audioFils)])
+    );
   }
 
-  // 按自定义列表串行加载音频（避免并发过多）
-  loadKeysSequentially(keys, onComplete, gen) {
-    if (gen !== undefined && gen !== this.loadGeneration) return;
-    let idx = 0;
-    const list = Array.from(keys);
-    const next = () => {
-      if (gen !== undefined && gen !== this.loadGeneration) return;
-      if (idx >= list.length) {
-        if (onComplete) onComplete();
-        return;
-      }
-      const k = list[idx++];
+  ensureAudio(key) {
+    if (!audioFils[key]) return Promise.resolve(false);
+    if (this.readyMap.get(key) && this.audioMap.has(key)) {
+      return Promise.resolve(true);
+    }
 
-      // 已就绪的音频不再重载，避免把 ready 状态重置为 false
-      if (this.readyMap.get(k)) {
-        setTimeout(next, 50);
-        return;
-      }
+    const loadingPromise = this.loadingKeyPromises.get(key);
+    if (loadingPromise) return loadingPromise;
 
-      // 未就绪：已存在则重载；不存在则创建
-      if (this.audioMap.has(k)) {
-        this.retryLoadAudio(k);
-        setTimeout(next, 100);
-      } else {
-        this.createAudio(k, () => {
-          setTimeout(next, 100);
+    let promise;
+    promise = new Promise((resolve) => {
+      try {
+        this.createAudio(key, () => {
+          resolve(this.readyMap.get(key) === true && this.audioMap.has(key));
         });
-        return; // createAudio 内部会触发 next
+      } catch (error) {
+        debugLog(`音频 ${key} 创建失败`, error);
+        resolve(false);
+      }
+    }).finally(() => {
+      if (this.loadingKeyPromises.get(key) === promise) {
+        this.loadingKeyPromises.delete(key);
+      }
+    });
+    this.loadingKeyPromises.set(key, promise);
+    return promise;
+  }
+
+  async warmKeys(
+    keys,
+    { concurrency = AUDIO_WARM_CONCURRENCY, retries = AUDIO_WARM_RETRIES } = {}
+  ) {
+    const queue = Array.from(new Set(keys)).filter((key) => !!audioFils[key]);
+    if (!queue.length) return;
+
+    let index = 0;
+    const worker = async () => {
+      while (index < queue.length) {
+        const key = queue[index++];
+        let ready = await this.ensureAudio(key);
+        for (let attempt = 0; !ready && attempt < retries; attempt += 1) {
+          ready = await this.retryLoadAudio(key);
+        }
       }
     };
-    next();
+
+    const workerCount = Math.min(Math.max(1, concurrency), queue.length);
+    await Promise.all(Array.from({ length: workerCount }, () => worker()));
   }
 
-  // 串行加载下一个音频（首轮）
-  loadNextAudio(onComplete, gen) {
-    if (gen !== undefined && gen !== this.loadGeneration) return;
-    if (this.currentLoadingIndex >= this.audioKeys.length) {
-      debugLog("首轮加载遍历完成", this.currentLoadingIndex);
-      if (onComplete) onComplete();
+  warmButton() {
+    return this.warmKeys(["点击按钮"], { concurrency: 1, retries: 1 });
+  }
+
+  warmAll() {
+    if (this.warmAllPromise) return this.warmAllPromise;
+
+    debugLog("开始后台分级预热全部语音");
+    this.isLoading = true;
+    this.warmAllPromise = this.warmKeys(this.getWarmupKeys())
+      .catch((error) => {
+        debugLog("后台语音预热异常", error);
+      })
+      .finally(() => {
+        this.isLoading = false;
+        debugLog("后台语音预热结束", this.getLoadProgress());
+      });
+    return this.warmAllPromise;
+  }
+
+  // 保留旧入口兼容测试页或其他历史调用，实际行为改为非阻塞后台预热。
+  initAudios() {
+    return this.warmAll();
+  }
+
+  // 创建单个音频实例：缓存命中优先使用，未命中直接使用 CDN。
+  createAudio(key, callback) {
+    const src = audioFils[key];
+    const generation = this.loadGeneration;
+    let completed = false;
+
+    const complete = () => {
+      if (completed) return;
+      completed = true;
+      if (callback) callback();
+    };
+
+    if (!src) {
+      complete();
       return;
     }
-    const key = this.audioKeys[this.currentLoadingIndex];
-    debugLog(
-      `开始加载音频 ${this.currentLoadingIndex + 1}/${
-        this.audioKeys.length
-      }: ${key}`
-    );
-    this.createAudio(key, () => {
-      setTimeout(() => {
-        this.loadNextAudio(onComplete, gen);
-      }, 100);
-    });
-  }
 
-  // 创建单个音频实例（支持本地缓存）
-  createAudio(key, callback) {
-    this.currentLoadingIndex++;
-    const src = audioFils[key];
+    const existingAudio = this.audioMap.get(key);
+    if (existingAudio && !this.readyMap.get(key)) {
+      try {
+        existingAudio.destroy();
+      } catch (_) {}
+      this.audioMap.delete(key);
+    }
+
+    const isCurrentGeneration = () => generation === this.loadGeneration;
+
+    const setupAudio = (realSrc, resumeAfterReady = false) => {
+      if (!isCurrentGeneration()) {
+        complete();
+        return;
+      }
 
-    const setupAudio = (realSrc) => {
       const audio = uni.createInnerAudioContext();
       audio.autoplay = false;
-      audio.src = realSrc;
       try {
         if (typeof audio.volume === "number") {
           audio.volume = this.isMuted ? 0 : 1;
@@ -308,115 +363,185 @@ class AudioManager {
         }
       });
 
-      const loadTimeout = setTimeout(() => {
-        debugLog(`音频 ${key} 加载超时`);
-        this.recordLoadFailure(key);
+      let loadTimeout = null;
+      let readyHandled = false;
+      const clearLoadTimeout = () => {
+        if (!loadTimeout) return;
+        clearTimeout(loadTimeout);
+        loadTimeout = null;
+      };
+
+      const handleLoadFailure = (message) => {
+        if (this.audioMap.get(key) !== audio) return;
+        clearLoadTimeout();
+        debugLog(`音频 ${key} ${message}`);
+
+        const isLocalCache =
+          realSrc !== src && this.localFileCache[src] === realSrc;
+        const shouldResume =
+          this.allowPlayMap.get(key) === true || this.currentPlayingKey === key;
+        const shouldResumeDirectly = shouldResume && completed;
+
+        this.clearPlayWatchdog(key);
+        this.allowPlayMap.set(key, false);
+        if (this.currentPlayingKey === key) {
+          this.currentPlayingKey = null;
+        }
+        if (this.lastPlayKey === key) {
+          this.lastPlayKey = null;
+          this.lastPlayAt = 0;
+        }
+        this.readyMap.set(key, false);
+        this.audioMap.delete(key);
         try {
           audio.destroy();
         } catch (_) {}
-        if (callback) callback();
-      }, 10000);
+
+        if (isLocalCache && isCurrentGeneration()) {
+          debugLog(`本地缓存失效，立即切换 CDN: ${key}`);
+          delete this.localFileCache[src];
+          uni.setStorageSync("audio_local_files", this.localFileCache);
+          uni.removeSavedFile({ filePath: realSrc });
+          setupAudio(src, shouldResumeDirectly);
+          void this.cacheRemoteFile(src, key);
+          return;
+        }
+
+        this.finishPlayback(key, {
+          advanceSequence: true,
+          emitEnded: true,
+        });
+        complete();
+      };
+
+      loadTimeout = setTimeout(() => {
+        handleLoadFailure("加载超时");
+      }, AUDIO_LOAD_TIMEOUT_MS);
 
       audio.onCanplay(() => {
+        if (this.audioMap.get(key) !== audio) return;
+        if (readyHandled) return;
+        readyHandled = true;
+        if (!isCurrentGeneration()) {
+          clearLoadTimeout();
+          this.audioMap.delete(key);
+          try {
+            audio.destroy();
+          } catch (_) {}
+          complete();
+          return;
+        }
         if (!this.allowPlayMap.get(key)) {
           try {
             audio.pause();
           } catch (_) {}
         }
-        clearTimeout(loadTimeout);
+        clearLoadTimeout();
         this.readyMap.set(key, true);
-        this.failedLoadKeys.delete(key);
-        // debugLog(`音频 ${key} 已加载完成`, this.getLoadProgress());
         uni.$emit("audioLoaded", key);
         const loadedAudioKeys = uni.getStorageSync("loadedAudioKeys") || {};
         loadedAudioKeys[key] = true;
         uni.setStorageSync("loadedAudioKeys", loadedAudioKeys);
-        if (callback) callback();
+        complete();
+
+        if (resumeAfterReady) {
+          setTimeout(() => {
+            const isSequenceCurrent =
+              this.isSequenceRunning &&
+              this.sequenceQueue[this.sequenceIndex] === key;
+            if (isSequenceCurrent) this._playSingle(key, false);
+          }, 0);
+        }
       });
 
       audio.onError((res) => {
-        clearTimeout(loadTimeout);
-        debugLog(`音频 ${key} 加载失败：`, res.errMsg);
-        // 如果是本地文件加载失败，可能是文件损坏，清除缓存以便下次重新下载
-        if (realSrc !== src && this.localFileCache[src] === realSrc) {
-          debugLog(`本地缓存失效，移除记录: ${key}`);
-          delete this.localFileCache[src];
-          uni.setStorageSync("audio_local_files", this.localFileCache);
-          // 移除文件
-          uni.removeSavedFile({ filePath: realSrc });
-        }
-        this.recordLoadFailure(key);
-        this.audioMap.delete(key);
-        audio.destroy();
-        if (this.readyMap.get(key)) {
-          // 这里不要去除，不然检查进度的时候由于没有重新加载而进度卡住，等播放失败的时候会重新加载
-          // this.readyMap.set(key, false);
-        } else {
-          if (callback) callback();
-        }
+        handleLoadFailure(`加载失败：${res.errMsg || "unknown"}`);
       });
 
       audio.onEnded(() => {
-        if (this.currentPlayingKey === key) {
-          this.currentPlayingKey = null;
-        }
-        this.allowPlayMap.set(key, false);
-        this.onAudioEnded(key);
-        uni.$emit('audioEnded', key);
+        this.finishPlayback(key, {
+          advanceSequence: true,
+          emitEnded: true,
+        });
       });
 
       audio.onStop(() => {
-        if (this.currentPlayingKey === key) {
-          this.currentPlayingKey = null;
-        }
-        this.allowPlayMap.set(key, false);
+        this.finishPlayback(key);
       });
 
       this.audioMap.set(key, audio);
+      audio.src = realSrc;
     };
 
     // 检查是否有可用的本地缓存
     this.checkLocalFile(src).then((localPath) => {
+      if (!isCurrentGeneration()) {
+        complete();
+        return;
+      }
       if (localPath) {
         debugLog(`命中本地缓存: ${key}`);
         setupAudio(localPath);
       } else {
-        // 下载并尝试保存
-        uni.downloadFile({
-          url: src,
-          timeout: 20000,
-          success: (res) => {
-            if (res.tempFilePath) {
-              // 尝试保存文件到本地存储（持久化）
-              uni.getFileSystemManager().saveFile({
-                tempFilePath: res.tempFilePath,
-                success: (saveRes) => {
-                  const savedPath = saveRes.savedFilePath;
-                  this.localFileCache[src] = savedPath;
-                  uni.setStorageSync("audio_local_files", this.localFileCache);
-                  debugLog(`音频已缓存到本地: ${key}`);
-                  setupAudio(savedPath);
-                },
-                fail: (err) => {
-                  debugLog(
-                    `保存音频失败(可能空间不足)，使用临时文件: ${key}`,
-                    err
-                  );
-                  setupAudio(res.tempFilePath);
-                },
-              });
-            } else {
-              this.recordLoadFailure(key);
-              if (callback) callback();
-            }
-          },
-          fail: () => {
-            this.recordLoadFailure(key);
-            if (callback) callback();
-          },
-        });
+        setupAudio(src);
+        void this.cacheRemoteFile(src, key);
+      }
+    }).catch(() => {
+      setupAudio(src);
+      void this.cacheRemoteFile(src, key);
+    });
+  }
+
+  cacheRemoteFile(url, key) {
+    if (this.localFileCache[url]) return Promise.resolve(true);
+    const currentPromise = this.cacheWritePromises.get(url);
+    if (currentPromise) return currentPromise;
+
+    let promise;
+    promise = new Promise((resolve) => {
+      if (typeof uni.downloadFile !== "function") {
+        resolve(false);
+        return;
+      }
+
+      uni.downloadFile({
+        url,
+        timeout: 20000,
+        success: (res) => {
+          if (!res.tempFilePath) {
+            resolve(false);
+            return;
+          }
+
+          let fileSystemManager;
+          try {
+            fileSystemManager = uni.getFileSystemManager();
+          } catch (_) {
+            resolve(false);
+            return;
+          }
+
+          fileSystemManager.saveFile({
+            tempFilePath: res.tempFilePath,
+            success: (saveRes) => {
+              this.localFileCache[url] = saveRes.savedFilePath;
+              uni.setStorageSync("audio_local_files", this.localFileCache);
+              debugLog(`音频已后台缓存到本地: ${key}`);
+              resolve(true);
+            },
+            fail: () => resolve(false),
+          });
+        },
+        fail: () => resolve(false),
+      });
+    }).finally(() => {
+      if (this.cacheWritePromises.get(url) === promise) {
+        this.cacheWritePromises.delete(url);
       }
     });
+
+    this.cacheWritePromises.set(url, promise);
+    return promise;
   }
 
   // 检查本地文件是否有效
@@ -443,20 +568,138 @@ class AudioManager {
     });
   }
 
-  // 新增：记录失败（首轮与次轮都会用到）
-  recordLoadFailure(key) {
-    this.failedLoadKeys.add(key);
+  clearPlayWatchdog(key) {
+    const timer = this.playWatchdogTimers.get(key);
+    if (timer) {
+      clearTimeout(timer);
+      this.playWatchdogTimers.delete(key);
+    }
+  }
+
+  clearAllPlayWatchdogs() {
+    for (const timer of this.playWatchdogTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.playWatchdogTimers.clear();
+  }
+
+  startPlayWatchdog(key) {
+    this.clearPlayWatchdog(key);
+    const timer = setTimeout(() => {
+      if (this.currentPlayingKey !== key) return;
+      debugLog(`音频 ${key} 播放超时，跳过当前音频并继续队列`);
+      this.finishPlayback(key, {
+        advanceSequence: true,
+        emitEnded: true,
+        force: true,
+      });
+      this.reloadAudioKey(key);
+    }, this.playWatchdogMs);
+    this.playWatchdogTimers.set(key, timer);
+  }
+
+  finishPlayback(key, { advanceSequence = false, emitEnded = false, force = false } = {}) {
+    const wasCurrent = this.currentPlayingKey === key;
+    const isSequenceCurrent =
+      this.isSequenceRunning && this.sequenceQueue[this.sequenceIndex] === key;
+
+    this.clearPlayWatchdog(key);
+    this.allowPlayMap.set(key, false);
+
+    if (!force && !wasCurrent && !isSequenceCurrent) return false;
+
+    if (wasCurrent) {
+      this.currentPlayingKey = null;
+    }
+
+    if (advanceSequence && isSequenceCurrent) {
+      this.onAudioEnded(key);
+    }
+
+    if (emitEnded) {
+      uni.$emit("audioEnded", key);
+    }
+
+    return true;
+  }
+
+  recoverFromInterruptionIfStale(force = false) {
+    if (!this.isInterrupted) return false;
+    const interruptedFor = Date.now() - (this.interruptedAt || Date.now());
+    if (!force && interruptedFor < this.interruptionFallbackMs) return false;
+
+    debugLog("音频中断状态超时，执行兜底恢复");
+    this.isInterrupted = false;
+    this.interruptedAt = 0;
+    uni.$emit(AUDIO_INTERRUPTION_END_EVENT);
+    void this.reloadAll();
+    return true;
+  }
+
+  recoverIfStale(expectedKey) {
+    if (this.recoverFromInterruptionIfStale(true)) return;
+
+    const key =
+      expectedKey || this.currentPlayingKey || this.sequenceQueue[this.sequenceIndex];
+    if (!key) {
+      if (this.isSequenceRunning) {
+        this.sequenceQueue = [];
+        this.sequenceIndex = 0;
+        this.isSequenceRunning = false;
+      }
+      return;
+    }
+
+    const isStaleCurrent =
+      this.currentPlayingKey === key ||
+      (this.isSequenceRunning && this.sequenceQueue[this.sequenceIndex] === key);
+    if (!isStaleCurrent) return;
+
+    debugLog(`音频 ${key} 等待超时，执行轻量恢复`);
+    const audio = this.audioMap.get(key);
+    if (audio) {
+      try {
+        audio.stop();
+      } catch (_) {}
+    }
+    this.finishPlayback(key, {
+      advanceSequence: true,
+      emitEnded: true,
+      force: true,
+    });
+    this.reloadAudioKey(key);
+  }
+
+  reloadAudioKey(key) {
+    return this.retryLoadAudio(key);
   }
 
   // 重新加载音频
   retryLoadAudio(key) {
+    const loadingPromise = this.loadingKeyPromises.get(key);
+    if (loadingPromise) return loadingPromise;
+
+    this.clearPlayWatchdog(key);
     const oldAudio = this.audioMap.get(key);
-    if (oldAudio) oldAudio.destroy();
-    this.createAudio(key);
+    if (oldAudio) {
+      try {
+        oldAudio.destroy();
+      } catch (_) {}
+    }
+    this.audioMap.delete(key);
+    this.readyMap.set(key, false);
+    return this.ensureAudio(key);
   }
 
   // 播放指定音频或音频数组（数组则按顺序连续播放）
   play(input, interrupt = true) {
+    if (this.isInterrupted) {
+      this.recoverFromInterruptionIfStale();
+    }
+    if (this.isInterrupted) {
+      debugLog("音频处理中断状态，忽略播放请求");
+      return;
+    }
     // 统一规范化为队列
     let queue = [];
     if (Array.isArray(input)) {
@@ -508,12 +751,50 @@ class AudioManager {
     }
   }
 
+  waitForAudioAndPlay(key) {
+    if (this.pendingPlayKeys.has(key)) return;
+    this.pendingPlayKeys.add(key);
+
+    this.ensureAudio(key)
+      .then((ready) => {
+        const isSequenceCurrent =
+          this.isSequenceRunning && this.sequenceQueue[this.sequenceIndex] === key;
+        if (!isSequenceCurrent) return;
+
+        if (ready) {
+          this._playSingle(key, false);
+          return;
+        }
+
+        this.finishPlayback(key, {
+          advanceSequence: true,
+          emitEnded: true,
+          force: true,
+        });
+      })
+      .finally(() => {
+        this.pendingPlayKeys.delete(key);
+      });
+  }
+
   // 内部方法：播放单个 key
   _playSingle(key, forceStopAll = false) {
+    if (this.isInterrupted) {
+      this.recoverFromInterruptionIfStale();
+    }
+    if (this.isInterrupted) {
+      debugLog(`音频处理中断状态，跳过播放: ${key}`);
+      return;
+    }
     // 200ms 内的同 key 重复播放直接忽略，避免“比比赛开始”这类重复首音
     const now = Date.now();
     if (this.lastPlayKey === key && now - this.lastPlayAt < 250) {
       debugLog(`忽略快速重复播放: ${key}`);
+      this.finishPlayback(key, {
+        advanceSequence: true,
+        emitEnded: true,
+        force: true,
+      });
       return;
     }
 
@@ -527,7 +808,7 @@ class AudioManager {
     }
 
     const audio = this.audioMap.get(key);
-    if (audio) {
+    if (audio && this.readyMap.get(key)) {
       // 播放前确保遵循当前静音状态
       try {
         if (typeof audio.volume === "number") {
@@ -553,28 +834,24 @@ class AudioManager {
       // 显式授权播放并立即播放
       this.allowPlayMap.set(key, true);
 
-      audio.play();
+      try {
+        audio.play();
+      } catch (err) {
+        this.finishPlayback(key, {
+          advanceSequence: true,
+          emitEnded: true,
+          force: true,
+        });
+        debugLog(`音频 ${key} 播放调用失败`, err?.errMsg || err);
+        return;
+      }
       this.currentPlayingKey = key;
       this.lastPlayKey = key;
       this.lastPlayAt = Date.now();
+      this.startPlayWatchdog(key);
     } else {
-      debugLog(`音频 ${key} 不存在，尝试重新加载...`);
-      this.retryLoadAudio(key);
-      const handler = (loadedKey) => {
-        if (loadedKey === key) {
-          try {
-            uni.$off("audioLoaded", handler);
-          } catch (_) {}
-          // 再次校验是否存在且就绪
-          const a = this.audioMap.get(key);
-          if (a && this.readyMap.get(key)) {
-            this._playSingle(key, false);
-          }
-        }
-      };
-      try {
-        uni.$on("audioLoaded", handler);
-      } catch (_) {}
+      debugLog(`音频 ${key} 尚未就绪，按需加载后播放...`);
+      this.waitForAudioAndPlay(key);
     }
   }
 
@@ -600,6 +877,7 @@ class AudioManager {
   // 停止指定音频
   stop(key) {
     const audio = this.audioMap.get(key);
+    this.clearPlayWatchdog(key);
     if (audio) {
       audio.stop();
       this.allowPlayMap.set(key, false);
@@ -611,6 +889,7 @@ class AudioManager {
 
   // 停止所有音频
   stopAll() {
+    this.clearAllPlayWatchdogs();
     for (const [k, audio] of this.audioMap.entries()) {
       try {
         audio.stop();
@@ -665,9 +944,11 @@ class AudioManager {
     debugLog("本地音频缓存清理完成");
   }
 
-  // 手动重置并重新加载所有音频（用于卡住时恢复）
+  // 手动重置音频实例，并按之前的预热范围在后台恢复。
   reloadAll() {
-    debugLog("执行 reloadAll: 重置所有状态并重新加载");
+    debugLog("执行 reloadAll: 重置音频实例并后台恢复");
+    const shouldWarmAll = this.warmAllPromise !== null;
+    this.loadGeneration += 1;
 
     // 1. 停止所有播放
     this.stopAll();
@@ -682,8 +963,10 @@ class AudioManager {
 
     // 3. 重置状态
     this.readyMap.clear();
-    this.failedLoadKeys.clear();
     this.allowPlayMap.clear();
+    this.loadingKeyPromises.clear();
+    this.pendingPlayKeys.clear();
+    this.clearAllPlayWatchdogs();
     this.currentPlayingKey = null;
     this.sequenceQueue = [];
     this.sequenceIndex = 0;
@@ -693,13 +976,12 @@ class AudioManager {
     // 这里选择不自动全清，而是依赖 onError 里的单点清除。如果需要彻底重置，可取消注释：
     // this.clearCache();
 
-    // 4. 强制重置加载锁
+    // 4. 重置后台预热状态
     this.isLoading = false;
-    this.loadingPromise = null;
-    this.currentLoadingIndex = 0;
+    this.warmAllPromise = null;
 
-    // 5. 重新初始化 (initAudios 会自增 loadGeneration，从而终止之前的任何异步循环)
-    return this.initAudios();
+    // 5. 之前已启动过全量预热则继续全量恢复，否则只恢复按钮音效。
+    return shouldWarmAll ? this.warmAll() : this.warmButton();
   }
 }
 

src/canvas.js

@@ -456,23 +456,29 @@ export const generateShareImage = async (canvasId, data) => {
     // 2D 即时绘制，无需 ctx.draw()
   } catch (e) {
     console.error("generateShareImage 绘制失败:", e);
+    throw e;
   }
 };
 
 // 顶部导入与工具方法
 async function getCanvas2DContext(canvasId, targetWidth, targetHeight) {
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
     const query = uni.createSelectorQuery();
     query
       .select(`#${canvasId}`)
       .fields({ node: true, size: true })
       .exec((res) => {
-        const { node: canvas } = res[0] || {};
+        const canvasInfo = res && res[0];
+        const { node: canvas } = canvasInfo || {};
+        if (!canvas || typeof canvas.getContext !== "function") {
+          reject(new Error(`canvas ${canvasId} not found`));
+          return;
+        }
         const ctx = canvas.getContext("2d");
         const dpr = uni.getSystemInfoSync().pixelRatio || 1;
 
-        const w = targetWidth || res[0].width;
-        const h = targetHeight || res[0].height;
+        const w = targetWidth || canvasInfo.width;
+        const h = targetHeight || canvasInfo.height;
 
         canvas.width = w * dpr;
         canvas.height = h * dpr;
@@ -561,6 +567,7 @@ export const sharePointData = async (canvasId, data) => {
     // 2D 即时绘制，无需 ctx.draw()
   } catch (e) {
     console.error("generateShareImage 绘制失败:", e);
+    throw e;
   }
 };
 
@@ -628,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,
@@ -650,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,
@@ -699,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([
@@ -731,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);
@@ -778,6 +802,7 @@ export async function sharePractiseData(canvasId, type, user, data) {
     // 2D 模式下无需 ctx.draw()
   } catch (err) {
     console.log(err);
+    throw err;
   }
 }
 

src/components/AppBackground.vue

@@ -18,31 +18,31 @@ const props = defineProps({
     <image
       class="bg-image"
       v-if="type === 0"
-      src="../static/app-bg.png"
+      src="https://static.shelingxingqiu.com/shootmini/static/app-bg.png"
       mode="widthFix"
     />
     <image
       class="bg-image"
       v-if="type === 1"
-      src="../static/app-bg2.png"
+      src="https://static.shelingxingqiu.com/shootmini/static/app-bg2.png"
       mode="widthFix"
     />
     <image
       class="bg-image"
       v-if="type === 2"
-      src="../static/app-bg3.png"
+      src="https://static.shelingxingqiu.com/shootmini/static/app-bg3.png"
       :style="{ height: capsuleHeight + 50 + 'px' }"
     />
     <image
       class="bg-image"
       v-if="type === 3"
-      src="../static/app-bg4.png"
+      src="https://static.shelingxingqiu.com/shootmini/static/app-bg4.png"
       mode="widthFix"
     />
     <image
       class="bg-image"
       v-if="type === 4"
-      src="../static/app-bg5.png"
+      src="https://static.shelingxingqiu.com/shootmini/static/app-bg5.png"
       mode="widthFix"
     />
     <image
@@ -51,6 +51,42 @@ const props = defineProps({
       src="https://static.shelingxingqiu.com/attachment/2026-01-05/dfgf3b5kp459tfyn0f.png"
       mode="widthFix"
     />
+	<image
+	  class="bg-image"
+	  v-if="type === 6"
+	  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"
+	  src="https://static.shelingxingqiu.com/shootmini/static/vip/vip-bg.png"
+	  mode="widthFix"
+	/>
     <view class="bg-overlay" v-if="type === 0"></view>
   </view>
 </template>
@@ -67,7 +103,7 @@ const props = defineProps({
 
 .bg-image {
   width: 100%;
-  height: 100%;
+  /* height: 100%; */
 }
 
 .bg-overlay {

src/components/AppFooter.vue

@@ -1,14 +1,14 @@
 <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) {
   if (index === 0) {
     uni.navigateTo({
-      url: "/pages/be-vip",
+      url: "/pages/member/be-vip",
     });
   }
   if (index === 1) {
@@ -26,12 +26,12 @@ 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"
       class="tab-item"
-      @click="handleTabClick(index)"
+      @click="$clickSound(() => handleTabClick(index))"
       :style="{
         width: index === 1 ? '36%' : '20%',
       }"

src/components/Avatar.vue

@@ -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>

src/components/BackToGame.vue

@@ -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";
@@ -18,9 +19,15 @@ const props = defineProps({
   },
 });
 const loading = ref(false);
+const navigating = ref(false);
+
+/** 统一获取当前环境 token，用于守卫：无有效 token 时不发起接口请求 */
+const getToken = () =>
+  uni.getStorageSync(`${uni.getAccountInfoSync().miniProgram.envVersion}_token`);
 
 onShow(async () => {
-  if (user.value.id) {
+  navigating.value = false;
+  if (user.value.id && getToken()) {
     setTimeout(async () => {
       const state = await getUserGameState();
       updateGame(state.gaming, state.roomId);
@@ -33,35 +40,38 @@ watch(
   async (value) => {
     if (!value.id) {
       updateGame(false, "");
-    } else {
+    } else if (getToken()) {
+      // 有有效 token 时才查询在局状态，避免 token 失效时反复发起无效请求
       const state = await getUserGameState();
       updateGame(state.gaming, state.roomId);
     }
   }
 );
 
+const navigateOnce = (url) =>
+  new Promise((resolve, reject) => {
+    navigating.value = true;
+    uni.navigateTo({
+      url,
+      success: resolve,
+      fail: (error) => {
+        navigating.value = false;
+        reject(error);
+      },
+    });
+  });
+
 const onClick = debounce(async () => {
-  if (loading.value) return;
+  if (loading.value || navigating.value) return;
   try {
     loading.value = true;
     const result = await getBattleAPI();
     if (result && result.matchId) {
-      await uni.$checkAudio();
-      if (result.mode <= 3) {
-        uni.navigateTo({
-          url: `/pages/team-battle?battleId=${result.matchId}`,
-        });
-      } else {
-        uni.navigateTo({
-          url: `/pages/melee-battle?battleId=${result.matchId}`,
-        });
-      }
+      await returnToBattle(result, navigateOnce);
       return;
     }
     if (game.value.roomID) {
-      uni.navigateTo({
-        url: "/pages/battle-room?roomNumber=" + game.value.roomID,
-      });
+      await navigateOnce("/pages/battle-room?roomNumber=" + game.value.roomID);
     } else {
       updateGame(false, "");
     }
@@ -86,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">

src/components/BattleFooter.vue

@@ -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>

src/components/BattleHeader.vue

@@ -27,19 +27,27 @@ defineProps({
     default: true,
   },
 });
+
+const getMemberNicknameClass = (player = {}) => [
+  "member-nickname",
+  player.vip === true && player.sVip !== true ? "member-nickname--vip" : "",
+  player.sVip === true ? "member-nickname--svip" : "",
+];
+
+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
@@ -51,7 +59,16 @@ defineProps({
           }"
         >
           <Avatar :src="player.avatar" :rankLvl="player.rankLvl" :size="40" />
-          <text class="player-name">{{ player.name }}</text>
+          <view
+            v-if="isMember(player)"
+            :class="['player-name', ...getMemberNicknameClass(player)]"
+          >
+            <text class="member-nickname__text">{{ player.name }}</text>
+            <text v-if="player.sVip === true" class="member-nickname__shine">
+              {{ player.name }}
+            </text>
+          </view>
+          <text v-else class="player-name">{{ player.name }}</text>
         </view>
         <image
           v-if="winner === 1"
@@ -70,7 +87,16 @@ defineProps({
           }"
         >
           <Avatar :src="player.avatar" :rankLvl="player.rankLvl" :size="40" />
-          <text class="player-name">{{ player.name }}</text>
+          <view
+            v-if="isMember(player)"
+            :class="['player-name', ...getMemberNicknameClass(player)]"
+          >
+            <text class="member-nickname__text">{{ player.name }}</text>
+            <text v-if="player.sVip === true" class="member-nickname__shine">
+              {{ player.name }}
+            </text>
+          </view>
+          <text v-else class="player-name">{{ player.name }}</text>
         </view>
         <image
           v-if="winner === 2"
@@ -80,28 +106,45 @@ defineProps({
         />
       </view>
     </view>
-    <view
+    <!-- 大乱斗玩家列表：scroll-view 作为横向滚动容器 -->
+    <!-- 小程序中 scroll-view 不支持直接 display:flex，需内部 wrapper view 承载 flex 布局 -->
+    <!-- 仅当玩家 >5 人（内容溢出宽度）时才阻止冒泡，防止与外层 swiper 切换 tab 的手势冲突 -->
+    <scroll-view
       v-if="players.length"
       class="players-melee"
+      scroll-x
+      :show-scrollbar="false"
+      @touchmove="(e) => players.length > 5 && e.stopPropagation()"
       :style="{ paddingTop: showHeader ? '15px' : '0' }"
     >
-      <view
-        v-for="(player, index) in players"
-        :key="index"
-        :style="{
-          backgroundColor: meleeAvatarColors[index],
-          width: `${Math.max(100 / players.length, 18)}vw`,
-        }"
-      >
-        <Avatar
-          :src="player.avatar"
-          :rankLvl="showRank ? undefined : player.rankLvl"
-          :size="40"
-          :rank="showRank ? index + 1 : 0"
-        />
-        <text class="player-name">{{ player.name }}</text>
+      <view class="players-melee-inner">
+        <view
+          v-for="(player, index) in players"
+          :key="index"
+          :style="{
+            backgroundColor: meleeAvatarColors[index],
+            width: `${Math.max(100 / players.length, 18)}vw`,
+          }"
+        >
+          <Avatar
+            :src="player.avatar"
+            :rankLvl="showRank ? undefined : player.rankLvl"
+            :size="40"
+            :rank="showRank ? index + 1 : 0"
+          />
+          <view
+            v-if="isMember(player)"
+            :class="['player-name', ...getMemberNicknameClass(player)]"
+          >
+            <text class="member-nickname__text">{{ player.name }}</text>
+            <text v-if="player.sVip === true" class="member-nickname__shine">
+              {{ player.name }}
+            </text>
+          </view>
+          <text v-else class="player-name">{{ player.name }}</text>
+        </view>
       </view>
-    </view>
+    </scroll-view>
   </view>
 </template>
 
@@ -109,13 +152,15 @@ defineProps({
 .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;
@@ -144,24 +189,25 @@ defineProps({
   justify-content: center;
 }
 .players-melee {
-  display: flex;
   height: 80px;
   width: 100%;
-  overflow-x: auto;
+  white-space: nowrap;
 }
-.players-melee::-webkit-scrollbar {
-  width: 0;
-  height: 0;
-  color: transparent;
+/* 小程序 scroll-view 不支持直接 flex，通过内层 wrapper 承载横向排列 */
+.players-melee-inner {
+  display: inline-flex;
+  min-width: 100%;
+  height: 100%;
+  flex-wrap: nowrap;
 }
-.players-melee > view {
+.players-melee-inner > view {
   display: flex;
   flex-direction: column;
   align-items: center;
   justify-content: center;
   color: #fff9;
   font-size: 12px;
-  padding-top: 7px;
+  /* padding-top: 7px; */
   flex: 0 0 auto;
 }
 .player-name {
@@ -172,6 +218,13 @@ defineProps({
   text-overflow: ellipsis;
   text-align: center;
 }
+view.player-name {
+  justify-content: center;
+}
+.player-name .member-nickname__text,
+.player-name .member-nickname__shine {
+  font-size: 12px;
+}
 .left-winner-badge {
   position: absolute;
   width: 50px;

src/components/BowData.vue

@@ -1,4 +1,5 @@
 <script setup>
+import { computed } from "vue";
 import AppBackground from "@/components/AppBackground.vue";
 import Avatar from "@/components/Avatar.vue";
 import BowTarget from "@/components/BowTarget.vue";
@@ -8,6 +9,9 @@ import { storeToRefs } from "pinia";
 const store = useStore();
 const { user } = storeToRefs(store);
 
+const isSVip = computed(() => user.value.sVip === true);
+const isVip = computed(() => user.value.vip === true && user.value.sVip !== true);
+
 const props = defineProps({
   show: {
     type: Boolean,
@@ -35,7 +39,21 @@ const props = defineProps({
       <view>
         <Avatar :src="user.avatar" :rankLvl="user.rankLvl" :size="45" />
         <view>
-          <text>{{ user.nickName }}</text>
+          <view
+            v-if="isVip || isSVip"
+            :class="[
+              'bow-data-user-name',
+              'member-nickname',
+              isVip ? 'member-nickname--vip' : '',
+              isSVip ? 'member-nickname--svip' : '',
+            ]"
+          >
+            <text class="member-nickname__text">{{ user.nickName }}</text>
+            <text v-if="isSVip" class="member-nickname__shine">
+              {{ user.nickName }}
+            </text>
+          </view>
+          <text v-else>{{ user.nickName }}</text>
           <text>{{ user.lvlName }}</text>
         </view>
       </view>
@@ -44,7 +62,7 @@ const props = defineProps({
       </view>
     </view>
     <view :style="{ width: '100%', marginBottom: '20px' }">
-      <BowTarget :scores="arrows" />
+      <BowTarget :scores="arrows" :isSvip="isSVip" />
     </view>
     <view class="desc">
       <text>{{ arrows.length }}</text>
@@ -95,6 +113,13 @@ const props = defineProps({
   margin-left: 10px;
   color: #fff;
 }
+.bow-data-user-name {
+  max-width: 300rpx;
+}
+.bow-data-user-name .member-nickname__text,
+.bow-data-user-name .member-nickname__shine {
+  max-width: 300rpx;
+}
 .header > view:first-child > view:last-child > text:last-child {
   font-size: 10px;
   background-color: #5f51ff;

src/components/BowShotEffect.vue

@@ -0,0 +1,442 @@
+<script setup>
+import { computed, onBeforeUnmount, ref, watch } from "vue";
+
+const props = defineProps({
+  shot: {
+    type: Object,
+    default: null,
+  },
+  playKey: {
+    type: [String, Number],
+    default: "",
+  },
+  targetRadius: {
+    type: Number,
+    default: 20,
+  },
+  targetWidth: {
+    type: Number,
+    default: 0,
+  },
+  targetHeight: {
+    type: Number,
+    default: 0,
+  },
+  targetLeft: {
+    type: Number,
+    default: 0,
+  },
+  targetTop: {
+    type: Number,
+    default: 0,
+  },
+  hitOffsetPx: {
+    type: Number,
+    default: 0,
+  },
+});
+
+const emit = defineEmits(["complete", "impact"]);
+
+const phase = ref("idle");
+const activePlayKey = ref("");
+const animationKey = ref("");
+const impactEmitted = ref(false);
+const activeShot = 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);
+  return Number.isFinite(radius) && radius > 0 ? radius : 20;
+});
+
+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);
+  return Number.isFinite(x) && Number.isFinite(y);
+}
+
+const effectiveShot = computed(() => activeShot.value || props.shot);
+
+const shotPoint = computed(() => {
+  const x = Number(effectiveShot.value?.x);
+  const y = Number(effectiveShot.value?.y);
+  return {
+    x: Number.isFinite(x) ? x : 0,
+    y: Number.isFinite(y) ? y : 0,
+  };
+});
+
+const pointDirection = computed(() => {
+  const point = shotPoint.value;
+  const distance = Math.sqrt(point.x * point.x + point.y * point.y);
+  if (distance === 0) return null;
+
+  return {
+    x: point.x / distance,
+    y: point.y / distance,
+  };
+});
+
+const hitOffset = computed(() => {
+  const offset = Number(props.hitOffsetPx);
+  const safeOffset = Number.isFinite(offset) && offset > 0 ? offset : 0;
+  const direction = pointDirection.value;
+
+  return {
+    x: direction ? direction.x * safeOffset : 0,
+    y: direction ? -direction.y * safeOffset : 0,
+  };
+});
+
+const hitPercent = computed(() => {
+  const point = shotPoint.value;
+  const radius = safeTargetRadius.value;
+  const diameter = radius * 2;
+
+  return {
+    left: ((point.x + radius) / diameter) * 100,
+    top: ((radius - point.y) / diameter) * 100,
+  };
+});
+
+const flightPath = computed(() => {
+  const size = safeTargetSize.value;
+  const windowSize = getWindowSize();
+
+  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 = endY - startY;
+
+  return {
+    startX,
+    startY,
+    translateX: dx,
+    translateY: dy,
+    angle: Math.atan2(dx, -dy) * (180 / Math.PI),
+  };
+});
+
+function formatPxOffset(value) {
+  if (!value) return "";
+  const operator = value > 0 ? "+" : "-";
+  return ` ${operator} ${Math.abs(value)}px`;
+}
+
+function formatTargetPosition(percent, offset) {
+  const pxOffset = formatPxOffset(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),
+}));
+
+function getTargetTranslate(percent) {
+  const absPercent = Math.abs(percent);
+  const operator = percent >= 0 ? "-" : "+";
+  return `calc(${percent}vw ${operator} ${absPercent * 0.5}px)`;
+}
+
+const arrowMoveStyle = computed(() => {
+  const size = safeTargetSize.value;
+  const path = flightPath.value;
+  let x = getTargetTranslate(hitPercent.value.left - 50);
+  let y = getTargetTranslate(hitPercent.value.top - 114);
+
+  if (size.width && size.height) {
+    x = `${path.translateX}px`;
+    y = `${path.translateY}px`;
+  }
+
+  return {
+    "--shot-start-x": size.width ? `${path.startX}px` : "50%",
+    "--shot-start-y": size.height ? `${path.startY}px` : "114%",
+    "--shot-tx": x,
+    "--shot-ty": y,
+    "--shot-angle": `${path.angle}deg`,
+  };
+});
+
+function clearTimers() {
+  timers.forEach((timer) => clearTimeout(timer));
+  timers = [];
+}
+
+function queueTimer(callback, delay) {
+  const timer = setTimeout(callback, delay);
+  timers.push(timer);
+}
+
+function emitImpactOnce(playKey) {
+  if (phase.value === "idle" || activePlayKey.value !== playKey || impactEmitted.value) return;
+  impactEmitted.value = true;
+  emit("impact");
+}
+
+function finish(playKey) {
+  if (phase.value === "idle" || activePlayKey.value !== playKey) return;
+  clearTimers();
+  phase.value = "idle";
+  activePlayKey.value = "";
+  activeShot.value = null;
+  emit("complete", playKey);
+}
+
+function play() {
+  if (!props.playKey || !props.shot || !props.shot.ring || !hasShotPoint(props.shot)) {
+    return;
+  }
+
+  clearTimers();
+  activePlayKey.value = props.playKey;
+  animationKey.value = `${props.playKey}`;
+  impactEmitted.value = false;
+  activeShot.value = { ...props.shot };
+  phase.value = "playing";
+
+  queueTimer(() => {
+    emitImpactOnce(activePlayKey.value);
+  }, ARROW_IMPACT_MS);
+  queueTimer(() => {
+    finish(activePlayKey.value);
+  }, COMPLETE_FALLBACK_MS);
+}
+
+function handleArrowAnimationEnd() {
+  emitImpactOnce(activePlayKey.value);
+}
+
+function handleCrackAnimationEnd() {
+  finish(activePlayKey.value);
+}
+
+watch(
+  () => props.playKey,
+  () => {
+    play();
+  },
+  { immediate: true }
+);
+
+onBeforeUnmount(() => {
+  clearTimers();
+});
+</script>
+
+<template>
+  <view
+    v-show="isActive"
+    :class="['shot-effect', `shot-effect--${phase}`]"
+    :style="arrowMoveStyle"
+  >
+    <view
+      :key="`arrow-${animationKey}`"
+      class="shot-arrow-track"
+      @animationend="handleArrowAnimationEnd"
+    >
+      <image
+        class="shot-arrow"
+        src="https://static.shelingxingqiu.com/shootmini/static/vip/svip-jian.png"
+        mode="heightFix"
+      />
+    </view>
+    <view
+      :key="`flash-${animationKey}`"
+      class="shot-flash"
+      :style="crackStyle"
+    ></view>
+    <view
+      :key="`crack-anchor-${animationKey}`"
+      class="shot-crack-anchor"
+      :style="crackStyle"
+    >
+      <image
+        :key="`crack-${animationKey}`"
+        class="shot-crack"
+        src="https://static.shelingxingqiu.com/shootmini/static/vip/svip-lie.png"
+        mode="aspectFit"
+        @animationend="handleCrackAnimationEnd"
+      />
+    </view>
+  </view>
+</template>
+
+<style scoped lang="scss">
+.shot-effect {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  z-index: 9999;
+  pointer-events: none;
+  overflow: visible;
+  transform: translateZ(0);
+}
+
+.shot-arrow-track {
+  position: absolute;
+  left: var(--shot-start-x);
+  top: var(--shot-start-y);
+  width: 0;
+  height: 0;
+  opacity: 0;
+  transform: translate3d(0, 0, 0);
+  animation: none;
+  backface-visibility: hidden;
+  will-change: transform, opacity;
+}
+
+.shot-arrow {
+  position: absolute;
+  width: 248rpx;
+  height: 1186rpx;
+  left: 0;
+  top: 0;
+  opacity: 1;
+  transform-origin: 44.35% 3.04%;
+  transform: translate(-44.35%, -3.04%) rotate(var(--shot-angle));
+  backface-visibility: hidden;
+  will-change: transform;
+}
+
+.shot-effect--playing .shot-arrow-track {
+  animation: shot-arrow-fly 0.38s cubic-bezier(0.68, 0, 0.9, 0.62) forwards;
+}
+
+.shot-flash,
+.shot-crack-anchor {
+  position: absolute;
+  transform: translate(-50%, -50%);
+  backface-visibility: hidden;
+  will-change: transform, opacity;
+}
+
+.shot-flash {
+  width: 86rpx;
+  height: 86rpx;
+  border-radius: 50%;
+  border: 3rpx solid rgba(255, 236, 166, 0.9);
+  opacity: 0;
+  animation: none;
+}
+
+.shot-crack-anchor {
+  width: 750rpx;
+  height: 750rpx;
+}
+
+.shot-crack {
+  width: 100%;
+  height: 100%;
+  opacity: 0;
+  transform-origin: center center;
+  animation: none;
+  will-change: transform, opacity;
+}
+
+.shot-effect--playing .shot-flash {
+  animation: shot-flash 0.42s ease-out 0.32s forwards;
+}
+
+.shot-effect--playing .shot-crack {
+  animation: shot-crack-hit 0.52s ease-out 0.34s forwards;
+}
+
+@keyframes shot-arrow-fly {
+  0% {
+    opacity: 1;
+    transform: translate3d(0, 0, 0);
+  }
+  86% {
+    opacity: 1;
+    transform: translate3d(var(--shot-tx), var(--shot-ty), 0);
+  }
+  100% {
+    opacity: 0;
+    transform: translate3d(var(--shot-tx), var(--shot-ty), 0);
+  }
+}
+
+@keyframes shot-flash {
+  0% {
+    opacity: 0.95;
+    transform: translate(-50%, -50%) scale(0.2);
+  }
+  100% {
+    opacity: 0;
+    transform: translate(-50%, -50%) scale(1.9);
+  }
+}
+
+@keyframes shot-crack-hit {
+  0% {
+    opacity: 0;
+    transform: scale(0.55);
+  }
+  28% {
+    opacity: 1;
+    transform: scale(1.08);
+  }
+  56% {
+    opacity: 1;
+    transform: scale(1);
+  }
+  100% {
+    opacity: 0;
+    transform: scale(1.18);
+  }
+}
+</style>

src/components/BowTarget.vue

@@ -1,9 +1,18 @@
 <script setup>
-import { ref, watch, onMounted, onBeforeUnmount, computed } from "vue";
+import {
+  ref,
+  watch,
+  onMounted,
+  onBeforeUnmount,
+  computed,
+  nextTick,
+  getCurrentInstance,
+} from "vue";
 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();
@@ -26,67 +35,326 @@ const props = defineProps({
     type: Array,
     default: () => [],
   },
+  isSvip: {
+    type: Boolean,
+    default: false,
+  },
   mode: {
     type: String,
     default: "solo", // solo 单排，team 双排
   },
+  missAsZero: {
+    type: Boolean,
+    default: false,
+  },
   stop: {
     type: Boolean,
     default: false,
   },
+  targetRadius: {
+    type: Number,
+    default: 20,
+  },
+  hitRadiusPx: {
+    type: Number,
+    default: 2,
+  },
+  zoomHitRadiusPx: {
+    type: Number,
+    default: 5,
+  },
 });
 
 const pMode = ref(true);
 const latestOne = ref(null);
 const bluelatestOne = ref(null);
-const prevScores = ref([]);
-const prevBlueScores = ref([]);
 const timer = ref(null);
 const dirTimer = ref(null);
 const angle = ref(null);
 const circleColor = ref("");
+const shotEffect = ref(null);
+const hiddenRedLatestKey = ref("");
+const hiddenBlueLatestKey = ref("");
+const targetShaking = ref(false);
+const targetRect = ref({ left: 0, top: 0, width: 0, height: 0 });
+const shakeTimer = ref(null);
+const instance = getCurrentInstance();
+const ROUND_TIP_OFFSET_Y = -32;
+const EXPERIENCE_TIP_OFFSET_Y = -68;
 
-watch(
-  () => props.scores,
-  (newVal) => {
-    if (newVal.length - prevScores.value.length === 1) {
-      latestOne.value = newVal[newVal.length - 1];
-      if (timer.value) clearTimeout(timer.value);
-      timer.value = setTimeout(() => {
-        latestOne.value = null;
-      }, 1000);
-    }
-    prevScores.value = [...newVal];
-  },
-  {
-    deep: true,
-  }
-);
-
-watch(
-  () => props.blueScores,
-  (newVal) => {
-    if (newVal.length - prevBlueScores.value.length === 1) {
-      bluelatestOne.value = newVal[newVal.length - 1];
-      if (timer.value) clearTimeout(timer.value);
-      timer.value = setTimeout(() => {
-        bluelatestOne.value = null;
-      }, 1000);
-    }
-    prevBlueScores.value = [...newVal];
-  },
-  {
-    deep: true,
-  }
-);
-
-function calcRealX(num, offset = 3.4) {
-  const len = 20.4 + num;
-  return `calc(${(len / 40.8) * 100 - offset / 2}%)`;
+function getRoundText(shot) {
+  if (shot?.ringX) return "X环";
+  if (shot?.ring) return `${shot.ring}环`;
+  return props.missAsZero ? "0环" : "未上靶";
 }
-function calcRealY(num, offset = 3.4) {
-  const len = num < 0 ? Math.abs(num) + 20.4 : 20.4 - num;
-  return `calc(${(len / 40.8) * 100 - offset / 2}%)`;
+
+function buildShotEffectKey(team, shot, index) {
+  return [
+    team,
+    index,
+    shot?.playerId ?? "",
+    shot?.x ?? "",
+    shot?.y ?? "",
+    shot?.ring ?? "",
+    shot?.ringX ? 1 : 0,
+  ].join("-");
+}
+
+function hasShotPoint(shot) {
+  const x = Number(shot?.x);
+  const y = Number(shot?.y);
+  return Number.isFinite(x) && Number.isFinite(y);
+}
+
+function shouldPlayShotEffect(shot) {
+  return props.isSvip && !!shot && Number(shot.ring) > 0 && hasShotPoint(shot);
+}
+
+function clearTipTimer() {
+  if (timer.value) {
+    clearTimeout(timer.value);
+    timer.value = null;
+  }
+}
+
+function showShotTip(team, shot) {
+  clearTipTimer();
+  if (team === "red") {
+    latestOne.value = shot;
+    timer.value = setTimeout(() => {
+      latestOne.value = null;
+      timer.value = null;
+    }, 1000);
+    return;
+  }
+
+  bluelatestOne.value = shot;
+  timer.value = setTimeout(() => {
+    bluelatestOne.value = null;
+    timer.value = null;
+  }, 1000);
+}
+
+function triggerShotEffect(team, shot, index) {
+  const key = buildShotEffectKey(team, shot, index);
+
+  if (shotEffect.value?.team === "red") hiddenRedLatestKey.value = "";
+  if (shotEffect.value?.team === "blue") hiddenBlueLatestKey.value = "";
+
+  if (team === "red") {
+    latestOne.value = null;
+    hiddenRedLatestKey.value = key;
+  } else {
+    bluelatestOne.value = null;
+    hiddenBlueLatestKey.value = key;
+  }
+
+  shotEffect.value = { key, team, shot };
+}
+
+function completeShotEffect(key) {
+  if (!shotEffect.value || shotEffect.value.key !== key) return;
+
+  const { team, shot } = shotEffect.value;
+  if (team === "red") hiddenRedLatestKey.value = "";
+  if (team === "blue") hiddenBlueLatestKey.value = "";
+  shotEffect.value = null;
+  showShotTip(team, shot);
+}
+
+function shakeTarget() {
+  targetShaking.value = false;
+  if (shakeTimer.value) {
+    clearTimeout(shakeTimer.value);
+    shakeTimer.value = null;
+  }
+
+  nextTick(() => {
+    targetShaking.value = true;
+    shakeTimer.value = setTimeout(() => {
+      targetShaking.value = false;
+      shakeTimer.value = null;
+    }, 260);
+  });
+}
+
+function updateTargetRect() {
+  nextTick(() => {
+    const query = instance?.proxy
+      ? uni.createSelectorQuery().in(instance.proxy)
+      : uni.createSelectorQuery();
+
+    query
+      .select(".target")
+      .boundingClientRect((rect) => {
+        const left = Number(rect?.left);
+        const top = Number(rect?.top);
+        const width = Number(rect?.width);
+        const height = Number(rect?.height);
+        if (
+          !Number.isFinite(left) ||
+          !Number.isFinite(top) ||
+          !Number.isFinite(width) ||
+          !Number.isFinite(height)
+        ) {
+          return;
+        }
+        if (width <= 0 || height <= 0) return;
+        targetRect.value = { left, top, width, height };
+      })
+      .exec();
+  });
+}
+
+function handleWindowResize() {
+  updateTargetRect();
+}
+
+function shouldHideRedHit(index) {
+  return !!hiddenRedLatestKey.value && index === props.scores.length - 1;
+}
+
+function shouldHideBlueHit(index) {
+  return !!hiddenBlueLatestKey.value && index === props.blueScores.length - 1;
+}
+
+watch(
+  () => props.scores.length,
+  (newLen, oldLen) => {
+    if (newLen === oldLen + 1) {
+      const latestShot = props.scores[newLen - 1];
+      if (shouldPlayShotEffect(latestShot)) {
+        triggerShotEffect("red", latestShot, newLen - 1);
+      } else {
+        showShotTip("red", latestShot);
+      }
+      return;
+    }
+
+    if (newLen < oldLen) {
+      latestOne.value = null;
+      hiddenRedLatestKey.value = "";
+      if (shotEffect.value?.team === "red") shotEffect.value = null;
+    }
+  }
+);
+
+watch(
+  () => props.blueScores.length,
+  (newLen, oldLen) => {
+    if (newLen === oldLen + 1) {
+      const latestShot = props.blueScores[newLen - 1];
+      if (shouldPlayShotEffect(latestShot)) {
+        triggerShotEffect("blue", latestShot, newLen - 1);
+      } else {
+        showShotTip("blue", latestShot);
+      }
+      return;
+    }
+
+    if (newLen < oldLen) {
+      bluelatestOne.value = null;
+      hiddenBlueLatestKey.value = "";
+      if (shotEffect.value?.team === "blue") shotEffect.value = null;
+    }
+  }
+);
+
+const safeTargetRadius = computed(() => {
+  const radius = Number(props.targetRadius);
+  return Number.isFinite(radius) && radius > 0 ? radius : 20;
+});
+
+const currentHitRadiusPx = computed(() => {
+  const radius = Number(
+    pMode.value ? props.zoomHitRadiusPx : props.hitRadiusPx
+  );
+  return Number.isFinite(radius) && radius >= 0 ? radius : 0;
+});
+
+function getShotPoint(shot, fallbackCenter = false) {
+  const x = Number(shot?.x);
+  const y = Number(shot?.y);
+  if (Number.isFinite(x) && Number.isFinite(y)) return { x, y };
+  return fallbackCenter ? { x: 0, y: 0 } : null;
+}
+
+function getPointDirection(point) {
+  if (!point) return null;
+  const distance = Math.sqrt(point.x * point.x + point.y * point.y);
+  if (distance === 0) return null;
+
+  return {
+    x: point.x / distance,
+    y: point.y / distance,
+  };
+}
+
+function formatPxOffset(value) {
+  if (!value) return "";
+  const operator = value > 0 ? "+" : "-";
+  return ` ${operator} ${Math.abs(value)}px`;
+}
+
+function formatTargetPosition(percent, offset) {
+  const pxOffset = formatPxOffset(offset);
+  return pxOffset ? `calc(${percent}%${pxOffset})` : `${percent}%`;
+}
+
+function getTargetPositionStyle(point, offsetPx = 0, extraOffset = {}) {
+  if (!point) return { display: "none" };
+
+  const radius = safeTargetRadius.value;
+  const diameter = radius * 2;
+  const direction = getPointDirection(point);
+  const xOffset = (direction ? direction.x * offsetPx : 0) + (extraOffset.x || 0);
+  const yOffset = (direction ? -direction.y * offsetPx : 0) + (extraOffset.y || 0);
+  const leftPercent = ((point.x + radius) / diameter) * 100;
+  const topPercent = ((radius - point.y) / diameter) * 100;
+
+  return {
+    left: formatTargetPosition(leftPercent, xOffset),
+    top: formatTargetPosition(topPercent, yOffset),
+    transform: "translate(-50%, -50%)",
+  };
+}
+
+function getHitStyle(shot) {
+  const radius = currentHitRadiusPx.value;
+  const point = getShotPoint(shot);
+
+  return {
+    ...getTargetPositionStyle(point, radius),
+    width: `${radius * 2}px`,
+    height: `${radius * 2}px`,
+  };
+}
+
+function getSvipHitBgStyle(shot) {
+  const radius = currentHitRadiusPx.value;
+  const point = getShotPoint(shot);
+
+  return {
+    ...getTargetPositionStyle(point, radius),
+  };
+}
+
+function getRoundTipStyle(shot) {
+  const point = getShotPoint(shot, true);
+  return getTargetPositionStyle(
+    point,
+    shot?.ring ? currentHitRadiusPx.value : 0,
+    { y: ROUND_TIP_OFFSET_Y }
+  );
+}
+
+function getExperienceTipStyle(shot) {
+  const point = getShotPoint(shot, true);
+  return getTargetPositionStyle(
+    point,
+    shot?.ring ? currentHitRadiusPx.value : 0,
+    { y: EXPERIENCE_TIP_OFFSET_Y }
+  );
 }
 const simulShoot = async () => {
   if (device.value.deviceId) await simulShootAPI(device.value.deviceId);
@@ -98,6 +366,14 @@ const simulShoot2 = async () => {
   }
 };
 
+const openAim = async () => {
+  await laserAimAPI();
+};
+
+const closeAim = async () => {
+  await laserCloseAPI();
+};
+
 const env = computed(() => {
   const accountInfo = uni.getAccountInfoSync();
   return accountInfo.miniProgram.envVersion;
@@ -135,6 +411,8 @@ async function onReceiveMessage(message) {
 
 onMounted(() => {
   uni.$on("socket-inbox", onReceiveMessage);
+  updateTargetRect();
+  if (uni.onWindowResize) uni.onWindowResize(handleWindowResize);
 });
 
 onBeforeUnmount(() => {
@@ -146,12 +424,17 @@ onBeforeUnmount(() => {
     clearTimeout(dirTimer.value);
     dirTimer.value = null;
   }
+  if (shakeTimer.value) {
+    clearTimeout(shakeTimer.value);
+    shakeTimer.value = null;
+  }
   uni.$off("socket-inbox", onReceiveMessage);
+  if (uni.offWindowResize) uni.offWindowResize(handleWindowResize);
 });
 </script>
 
 <template>
-  <view class="container">
+  <view :class="['container', { 'container--effecting': shotEffect }]">
     <view class="header" v-if="totalRound > 0">
       <text v-if="totalRound > 0" class="round-count">{{
         (currentRound > totalRound ? totalRound : currentRound) +
@@ -159,7 +442,7 @@ onBeforeUnmount(() => {
         totalRound
       }}</text>
     </view>
-    <view class="target">
+    <view :class="['target', { 'target--shake': targetShaking }]">
       <view v-if="angle !== null" class="arrow-dir" :style="arrowStyle">
         <view :style="{ background: circleColor }">
           <image src="../static/dot-circle.png" mode="widthFix" />
@@ -169,22 +452,15 @@ onBeforeUnmount(() => {
       <view
         v-if="latestOne && latestOne.ring && user.id === latestOne.playerId"
         class="e-value fade-in-out"
-        :style="{
-          left: calcRealX(latestOne.ring ? latestOne.x : 0, 20),
-          top: calcRealY(latestOne.ring ? latestOne.y : 0, 40),
-        }"
+        :style="getExperienceTipStyle(latestOne)"
       >
         经验 +1
       </view>
       <view
         v-if="latestOne"
         class="round-tip fade-in-out"
-        :style="{
-          left: calcRealX(latestOne.ring ? latestOne.x : 0, 28),
-          top: calcRealY(latestOne.ring ? latestOne.y : 0, 28),
-        }"
-        >{{ latestOne.ringX ? "X" : latestOne.ring || "未上靶"
-        }}<text v-if="latestOne.ring">环</text>
+        :style="getRoundTipStyle(latestOne)"
+        >{{ getRoundText(latestOne) }}
       </view>
       <view
         v-if="
@@ -193,53 +469,70 @@ onBeforeUnmount(() => {
           user.id === bluelatestOne.playerId
         "
         class="e-value fade-in-out"
-        :style="{
-          left: calcRealX(bluelatestOne.ring ? bluelatestOne.x : 0, 20),
-          top: calcRealY(bluelatestOne.ring ? bluelatestOne.y : 0, 40),
-        }"
+        :style="getExperienceTipStyle(bluelatestOne)"
       >
         经验 +1
       </view>
       <view
         v-if="bluelatestOne"
         class="round-tip fade-in-out"
-        :style="{
-          left: calcRealX(bluelatestOne.ring ? bluelatestOne.x : 0, 28),
-          top: calcRealY(bluelatestOne.ring ? bluelatestOne.y : 0, 28),
-        }"
-        >{{ bluelatestOne.ringX ? "X" : bluelatestOne.ring || "未上靶"
-        }}<text v-if="bluelatestOne.ring">环</text></view
+        :style="getRoundTipStyle(bluelatestOne)"
+        >{{ getRoundText(bluelatestOne) }}</view
       >
       <block v-for="(bow, index) in scores" :key="index">
+        <image
+          v-if="pMode && isSvip && bow.ring > 0 && !shouldHideRedHit(index)"
+          class="svip-hit-bg"
+          src="../static/vip/svip-xuan.png"
+          :style="getSvipHitBgStyle(bow)"
+          mode="aspectFit"
+        />
         <view
-          v-if="bow.ring > 0"
+          v-if="bow.ring > 0 && !shouldHideRedHit(index)"
           :class="`hit ${pMode ? 'b' : 's'}-point ${
             index === scores.length - 1 && latestOne ? 'pump-in' : ''
           }`"
           :style="{
-            left: calcRealX(bow.x, pMode ? '3.4' : '2'),
-            top: calcRealY(bow.y, pMode ? '3.4' : '2'),
+            ...getHitStyle(bow),
             backgroundColor: mode === 'solo' ? '#00bf04' : '#FF0000',
           }"
           ><text v-if="pMode">{{ index + 1 }}</text></view
         >
       </block>
       <block v-for="(bow, index) in blueScores" :key="index">
+        <image
+          v-if="pMode && isSvip && bow.ring > 0 && !shouldHideBlueHit(index)"
+          class="svip-hit-bg"
+          src="../static/vip/svip-xuan.png"
+          :style="getSvipHitBgStyle(bow)"
+          mode="aspectFit"
+        />
         <view
-          v-if="bow.ring > 0"
+          v-if="bow.ring > 0 && !shouldHideBlueHit(index)"
           :class="`hit ${pMode ? 'b' : 's'}-point ${
             index === blueScores.length - 1 && bluelatestOne ? 'pump-in' : ''
           }`"
           :style="{
-            left: calcRealX(bow.x, pMode ? '3.4' : '2'),
-            top: calcRealY(bow.y, pMode ? '3.4' : '2'),
+            ...getHitStyle(bow),
             backgroundColor: '#1840FF',
           }"
         >
           <text v-if="pMode">{{ index + 1 }}</text>
         </view>
       </block>
-      <image src="../static/bow-target.png" mode="widthFix" />
+      <BowShotEffect
+        :shot="shotEffect && shotEffect.shot"
+        :playKey="shotEffect ? shotEffect.key : ''"
+        :targetRadius="safeTargetRadius"
+        :targetLeft="targetRect.left"
+        :targetTop="targetRect.top"
+        :targetWidth="targetRect.width"
+        :targetHeight="targetRect.height"
+        :hitOffsetPx="currentHitRadiusPx"
+        @impact="shakeTarget"
+        @complete="completeShotEffect"
+      />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/bow-target.png" mode="widthFix" />
     </view>
     <view class="footer">
       <PointSwitcher
@@ -250,6 +543,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>
@@ -260,13 +555,22 @@ onBeforeUnmount(() => {
   height: calc(100vw - 30px);
   padding: 0px 15px;
   position: relative;
+  z-index: 3;
+}
+.container--effecting {
+  z-index: 10000;
 }
 .target {
   position: relative;
   margin: 10px;
   width: calc(100% - 20px);
   height: calc(100% - 20px);
-  z-index: -1;
+  z-index: 1;
+  pointer-events: none;
+  transform-origin: center center;
+}
+.target--shake {
+  animation: target-shake 0.26s ease-out;
 }
 .e-value {
   position: absolute;
@@ -292,31 +596,55 @@ onBeforeUnmount(() => {
   font-size: 24px;
   margin-left: 5px;
 }
+@keyframes target-tip-fade-in-out {
+  0% {
+    transform: translate(-50%, -50%) translateY(20px);
+    opacity: 0;
+  }
+
+  30% {
+    transform: translate(-50%, -50%);
+    opacity: 1;
+  }
+
+  80% {
+    transform: translate(-50%, -50%);
+    opacity: 1;
+  }
+
+  100% {
+    transform: translate(-50%, -50%);
+    opacity: 0;
+  }
+}
+.round-tip.fade-in-out,
+.e-value.fade-in-out {
+  animation: target-tip-fade-in-out 1.2s ease forwards;
+}
 .target > image:last-child {
   width: 100%;
   height: 100%;
 }
+.svip-hit-bg {
+  position: absolute;
+  width: 48rpx;
+  height: 48rpx;
+  z-index: 1;
+  pointer-events: none;
+  transform-origin: center center;
+  animation: svip-hit-xuan 1.2s linear infinite;
+}
 .hit {
   position: absolute;
   border-radius: 50%;
-  z-index: 1;
+  z-index: 2;
   color: #fff;
-  transition: all 0.3s ease;
-}
-.s-point {
-  width: 4px;
-  height: 4px;
-  min-width: 4px;
-  min-height: 4px;
+  transition: transform 0.2s ease, opacity 0.2s ease;
+  box-sizing: border-box;
 }
 .b-point {
-  width: 10px;
-  height: 10px;
-  min-width: 10px;
-  min-height: 10px;
   border: 1px solid #fff;
-  z-index: 1;
-  box-sizing: border-box;
+  z-index: 2;
   display: flex;
   justify-content: center;
   align-items: center;
@@ -332,6 +660,56 @@ onBeforeUnmount(() => {
   transform: translate(-50%, -50%);*/
   margin-top: 2rpx;
 }
+@keyframes svip-hit-xuan {
+  0% {
+    opacity: 0.9;
+    transform: translate(-50%, -50%) rotate(0deg) scale(0.92);
+  }
+  50% {
+    opacity: 1;
+    transform: translate(-50%, -50%) rotate(180deg) scale(1.08);
+  }
+  100% {
+    opacity: 0.9;
+    transform: translate(-50%, -50%) rotate(360deg) scale(0.92);
+  }
+}
+@keyframes target-pump-in {
+  from {
+    transform: translate(-50%, -50%) scale(2);
+  }
+
+  to {
+    transform: translate(-50%, -50%) scale(1);
+  }
+}
+@keyframes target-shake {
+  0% {
+    transform: translate(0, 0);
+  }
+  14% {
+    transform: translate(-20rpx, 8rpx);
+  }
+  28% {
+    transform: translate(16rpx, -8rpx);
+  }
+  44% {
+    transform: translate(-12rpx, 6rpx);
+  }
+  64% {
+    transform: translate(8rpx, -4rpx);
+  }
+  82% {
+    transform: translate(-4rpx, 2rpx);
+  }
+  100% {
+    transform: translate(0, 0);
+  }
+}
+.hit.pump-in {
+  animation: target-pump-in 0.3s ease-out forwards;
+  transform-origin: center center;
+}
 .header {
   width: 100%;
   display: flex;

src/components/Container.vue

@@ -1,5 +1,5 @@
 <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";
@@ -7,7 +7,7 @@ import ScreenHint from "@/components/ScreenHint.vue";
 import BackToGame from "@/components/BackToGame.vue";
 import {laserAimAPI, getBattleAPI, matchGameAPI} from "@/apis";
 import { capsuleHeight, debounce } from "@/util";
-import AudioManager from "@/audioManager";
+import { returnToBattle } from "@/utils/matchReturn";
 const props = defineProps({
   title: {
     type: String,
@@ -25,6 +25,10 @@ const props = defineProps({
     type: Boolean,
     default: true,
   },
+  usePageScroll: {
+    type: Boolean,
+    default: false,
+  },
   isHome: {
     type: Boolean,
     default: false,
@@ -41,18 +45,31 @@ const props = defineProps({
     type: Boolean,
     default: true,
   },
+  headerClass: {
+    type: String,
+    default: "",
+  },
+  titleStyle: {
+    type: [String, Object, Array],
+    default: () => ({}),
+  },
   showBottom: {
     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;
@@ -63,49 +80,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; // 防止重复点击
 
@@ -113,16 +102,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?battleId=${result.matchId}`,
-        });
-      } else {
-        uni.navigateTo({
-          url: `/pages/melee-battle?battleId=${result.matchId}`,
-        });
-      }
+      await returnToBattle(result, navigateTo);
     }
   } catch (error) {
     console.error("获取当前游戏失败:", error);
@@ -152,12 +132,27 @@ const goCalibration = async () => {
     <AppBackground :type="bgType" :bgColor="bgColor" />
     <Header
       v-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"
@@ -206,7 +201,7 @@ const goCalibration = async () => {
           <button hover-class="none" @click="() => (showHint = false)">
             取消
           </button>
-          <button hover-class="none" @click="cancelMatching">确认</button>
+          <button hover-class="none" @click="$clickSound(cancelMatching)">确认</button>
         </view>
       </view>
       <view v-if="hintType === 4" class="tip-content">
@@ -219,22 +214,16 @@ 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>
   </view>
@@ -278,6 +267,7 @@ const goCalibration = async () => {
   color: #666;
   opacity: 0.6;
 }
+
 .audio-progress {
   z-index: 999;
   width: 100vw;
@@ -291,11 +281,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;
@@ -306,34 +298,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>

src/components/CreateRoom.vue

@@ -17,18 +17,26 @@ const props = defineProps({
   },
 });
 
-const battleMode = ref(1);
-const targetMode = ref(1);
+/** 对战模式：0=未选 1=1v1 2=乱斗 3=2v2 4=3v3 */
+const battleMode = ref(0);
+/** 靶纸尺寸：0=未选 1=20cm 2=40cm */
+const targetMode = ref(0);
 const loading = ref(false);
 const roomNumber = ref("");
 
 const createRoom = debounce(async () => {
+  // 校验必填项：对战模式与靶纸均必须选择
+  if (!battleMode.value || !targetMode.value) {
+    uni.showToast({ title: '请完善创建信息', icon: 'none' });
+    return;
+  }
   if (game.value.inBattle) {
     uni.$showHint(1);
     return;
   }
   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;
@@ -42,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>
@@ -57,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">
@@ -105,7 +117,7 @@ const createRoom = debounce(async () => {
         <text>40厘米全环靶</text>
       </view>
     </view>
-    <SButton :onClick="createRoom">创建房间</SButton>
+    <SButton :disabled="loading" :onClick="() => { $clickSound(); return createRoom(); }">创建房间</SButton>
   </view>
 </template>
 

src/components/Guide.vue

@@ -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"

src/components/GuideTwo.vue

@@ -9,12 +9,12 @@ defineProps({
 
 <template>
   <view class="container">
-    <image class="shooter2" src="../static/shooter2.png" mode="widthFix" />
+    <image class="shooter2" src="https://static.shelingxingqiu.com/shootmini/static/shooter2.png" mode="widthFix" />
     <view class="bg-box">
       <image
         class="bg"
         v-if="!noBg"
-        src="../static/long-bubble-border.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/long-bubble-border.png"
         mode="widthFix"
       />
       <slot />
@@ -26,20 +26,21 @@ defineProps({
 .container {
   display: flex;
   align-items: center;
-  padding: 0 15px;
+  padding: 0 26rpx 0 28rpx;
   margin-bottom: 14rpx;
-  width: clac(100% - 30px);
+  width: clac(100% - 54rpx);
 }
 .container .shooter2 {
-  width: 150rpx;
-  height: 162rpx;
+  display: block;
+  width: 133rpx;
+  height: 144rpx;
 }
 .container .bg-box {
   color: #fff;
   font-size: 28rpx;
   position: relative;
   flex: 1;
-  min-height: 55px;
+  height: 128rpx;
   display: flex;
   align-items: center;
   justify-content: center;

src/components/Header.vue

@@ -6,7 +6,7 @@ import Avatar from "@/components/Avatar.vue";
 import useStore from "@/store";
 import { storeToRefs } from "pinia";
 const store = useStore();
-const { user } = storeToRefs(store);
+const { user, game } = storeToRefs(store);
 
 const currentPage = computed(() => {
   const pages = getCurrentPages();
@@ -26,6 +26,10 @@ const props = defineProps({
     type: Boolean,
     default: true,
   },
+  titleStyle: {
+    type: [String, Object, Array],
+    default: () => ({}),
+  },
 });
 
 const onClick = () => {
@@ -55,12 +59,14 @@ const signin = () => {
   }
 };
 
+const isSVip = computed(() => user.value.sVip === true);
+const isVip = computed(() => user.value.vip === true && user.value.sVip !== true);
+
 const loading = ref(false);
 const pointBook = ref(null);
-const showProgress = ref(false);
 const heat = ref(0);
-/** 当前对战房间的房号，由 battle-room 页面通过 uni.$emit 传入 */
-const battleRoomNumber = ref("");
+/** 房间号按钮动态定位样式（position: fixed，根据胶囊真实位置计算，脱离 flex 流避免挤压标题） */
+const battleRoomBtnStyle = ref({});
 
 const updateLoading = (value) => {
   loading.value = value;
@@ -70,14 +76,6 @@ const updateHot = (value) => {
   heat.value = value;
 };
 
-/**
- * 接收 battle-room 页面发出的房间信息，更新房号展示
- * @param {{ roomNumber: string }} info
- */
-const updateBattleRoomInfo = (info) => {
-  battleRoomNumber.value = info.roomNumber || "";
-};
-
 onMounted(() => {
   const pages = getCurrentPages();
   const currentPage = pages[pages.length - 1];
@@ -90,15 +88,27 @@ onMounted(() => {
       pointBook.value = uni.getStorageSync("last-point-book");
     }
   }
-  if (currentPage.route === "pages/team-battle") {
-    showProgress.value = true;
+  // 仅在对战房间页获取胶囊位置，按钮用 fixed 定位精确贴靠胶囊左侧（脱离 flex 流，不挤压标题）
+  if (currentPage.route === "pages/battle-room") {
+    try {
+      const menuButtonRect = uni.getMenuButtonBoundingClientRect();
+      const { windowWidth } = uni.getSystemInfoSync();
+      battleRoomBtnStyle.value = {
+        // 按钮右边缘距视口右侧 = 屏幕宽 - 胶囊左边缘 + 4px 安全间隙
+        right: (windowWidth - menuButtonRect.left + 4) + "px",
+        // 垂直位置与胶囊顶部对齐
+        top: menuButtonRect.top + "px",
+        // 高度与胶囊一致，视觉融合
+        height: menuButtonRect.height + "px",
+      };
+    } catch (e) {
+      // 获取失败时使用 CSS 兜底定位（28vw + 4px 作为 right，8px 作为 top）
+    }
   }
   uni.$on("update-hot", updateHot);
-  uni.$on("battle-room-info", updateBattleRoomInfo);
 });
 onBeforeUnmount(() => {
   uni.$off("update-hot", updateHot);
-  uni.$off("battle-room-info", updateBattleRoomInfo);
 });
 </script>
 
@@ -112,7 +122,9 @@ onBeforeUnmount(() => {
         mode="widthFix"
       />
     </view>
-    <view :style="{ color: whiteBackArrow ? '#fff' : '#000' }">
+    <view
+      :style="[{ color: whiteBackArrow ? '#fff' : '#000' }, titleStyle]"
+    >
       <view
         v-if="currentPage === 'pages/point-book'"
         class="user-header"
@@ -125,7 +137,21 @@ onBeforeUnmount(() => {
             :size="40"
             borderColor="#333"
           />
-          <text class="truncate">{{ user.nickName }}</text>
+          <view
+            v-if="isVip || isSVip"
+            :class="[
+              'point-book-user-name',
+              'member-nickname',
+              isVip ? 'member-nickname--vip' : '',
+              isSVip ? 'member-nickname--svip' : '',
+            ]"
+          >
+            <text class="member-nickname__text">{{ user.nickName }}</text>
+            <text v-if="isSVip" class="member-nickname__shine">
+              {{ user.nickName }}
+            </text>
+          </view>
+          <text v-else class="truncate">{{ user.nickName }}</text>
           <image
             v-if="heat"
             :src="`../static/hot${heat}.png`"
@@ -139,8 +165,8 @@ onBeforeUnmount(() => {
       </view>
       <block
         v-if="
-          '-凹造型-感知距离-小试牛刀'.indexOf(title) === -1 ||
-          '-凹造型-感知距离-小试牛刀'.indexOf(title) === 10
+          '-箭前准备-感知距离-小试牛刀'.indexOf(title) === -1 ||
+          '-箭前准备-感知距离-小试牛刀'.indexOf(title) === 11
         "
       >
         <text>{{ title }}</text>
@@ -148,12 +174,12 @@ onBeforeUnmount(() => {
       <block
         v-if="
           title &&
-          '-凹造型-感知距离-小试牛刀'.indexOf(title) !== -1 &&
-          '-凹造型-感知距离-小试牛刀'.indexOf(title) !== 10
+          '-箭前准备-感知距离-小试牛刀'.indexOf(title) !== -1 &&
+          '-箭前准备-感知距离-小试牛刀'.indexOf(title) !== 11
         "
       >
         <view class="first-try-steps">
-          <text :class="title === '-凹造型' ? 'current-step' : ''">凹造型</text>
+          <text :class="title === '-箭前准备' ? 'current-step' : ''">箭前准备</text>
           <text>-</text>
           <text :class="title === '-感知距离' ? 'current-step' : ''"
             >感知距离</text
@@ -182,17 +208,24 @@ onBeforeUnmount(() => {
         }}</text
       >
     </view>
-    <view v-if="showProgress" class="battle-progress">
+    <view
+      v-if="
+        currentPage === 'pages/team-battle' ||
+        currentPage === 'pages/team-battle/index'
+      "
+      class="battle-progress"
+    >
       <HeaderProgress />
     </view>
-    <!-- 对战房间：整个胶囊为分享按钮，点击任意区域均可触发分享 -->
+    <!-- 对战房间：整个胶囊为分享按钮，房号从 Store 读取；fixed 定位紧靠系统胶囊左侧 -->
     <button
-      v-if="currentPage === 'pages/battle-room' && battleRoomNumber"
+      v-if="currentPage === 'pages/battle-room' && game.roomNumber"
       open-type="share"
       hover-class="none"
       class="battle-room-number"
+      :style="battleRoomBtnStyle"
     >
-      <text class="battle-room-number__text">房号: {{ battleRoomNumber }}</text>
+      <text class="battle-room-number__text">房号: {{ game.roomNumber }}</text>
       <image src="../static/share2.png" mode="widthFix" class="battle-room-number__icon" />
     </button>
   </view>
@@ -275,17 +308,20 @@ onBeforeUnmount(() => {
   width: 36rpx;
   height: 36rpx;
 }
-.user-header > text:nth-child(2) {
+.user-header > text:nth-child(2),
+.user-header > .point-book-user-name {
   font-weight: 500;
   font-size: 30rpx;
   color: #333333;
   margin: 0 20rpx;
   max-width: 300rpx;
 }
-/* 对战房间：整个胶囊作为分享按钮，靠右对齐 */
+/* 对战房间：整个胶囊作为分享按钮，fixed 定位脱离 flex 流，紧贴系统胶囊左侧 */
 .battle-room-number {
-  margin-left: auto;
-  margin-right: 10rpx;
+  position: fixed;
+  /* 兜底定位（JS 获取胶囊位置失败时生效）：约 28vw 对应胶囊区域左边缘 */
+  right: calc(28vw + 4px);
+  top: 8px;
   display: flex;
   align-items: center;
   justify-content: center;
@@ -294,9 +330,7 @@ onBeforeUnmount(() => {
   background: rgba(0, 0, 0, 0.15);
   border-radius: 96rpx;
   border: 1rpx solid #5b5758;
-  flex-shrink: 0;
   padding: 0;
-  line-height: normal;
 }
 /* 重置 button 默认边框 */
 .battle-room-number::after {
@@ -306,7 +340,7 @@ onBeforeUnmount(() => {
   width: 156rpx;
   height: 28rpx;
   font-weight: 400;
-  font-size: 20rpx;
+  font-size: 24rpx;
   color: #ffffff;
   text-align: center;
   line-height: 28rpx;

src/components/HeaderProgress.vue

@@ -19,12 +19,17 @@ const ended = ref(false);
 const halfTime = ref(false);
 const currentShot = ref(0);
 const totalShot = ref(0);
+/** 标记组件是否已完成挂载，防止 immediate watcher 在挂载前用旧 store 值触发意外播音 */
+const isMounted = ref(false);
 
 watch(
   () => tips.value,
   (newVal) => {
+    // 挂载完成前不播音（避免 immediate store watcher 用旧值触发多余播报）
+    if (!isMounted.value) return;
+    // 空字符串或含"重回"的 tips 均不播音
+    if (!newVal || newVal.includes("重回")) return;
     let key = [];
-    if (newVal.includes("重回")) return;
     if (currentRoundEnded.value) {
       // 播放当前轮次语音
       key.push(`第${["一", "二", "三", "四", "五"][currentRound.value]}轮`);
@@ -33,8 +38,8 @@ watch(
       newVal.includes("你")
         ? "轮到你了"
         : newVal.includes("红队")
-        ? "请红方射箭"
-        : "请蓝方射箭"
+          ? "请红方射箭"
+          : "请蓝方射箭"
     );
     audioManager.play(key, false);
     currentRoundEnded.value = false;
@@ -52,14 +57,20 @@ async function onReceiveMessage(message) {
   const { type, mode, current, shootData } = message;
   if (type === MESSAGETYPESV2.BattleStart) {
     melee.value = Boolean(mode > 3);
-    totalShot.value = mode === 1 ? 3 : 2;
+    // 优先使用后端返回的 shootNumber，降级则根据 mode 推算
+    totalShot.value = message.shootNumber ?? (mode === 1 ? 3 : 2);
     currentRoundEnded.value = true;
     audioManager.play("比赛开始");
   } else if (type === MESSAGETYPESV2.BattleEnd) {
     audioManager.play("比赛结束", false);
   } else if (type === MESSAGETYPESV2.ShootResult) {
     if (melee.value && current.playerId !== user.value.id) return;
-    if (current.playerId === user.value.id) currentShot.value++;
+    // 从 indexMap 按当前用户 id 取已射箭数，由后端维护准确值，不在前端自增。
+    // 注意：后端在 ShootResult 中会将 playerId 重置为 0（无当前射手），
+    // 因此不能依赖 playerId === user.id 判断，改为直接读取 indexMap[user.id]。
+    // indexMap[user.id] 只在本人射箭后才增加，队友射箭时该值不变，逻辑等价且更准确。
+    const myShot = current.indexMap?.[user.value.id];
+    if (myShot !== undefined) currentShot.value = myShot;
     if (message.shootData) {
       let key = [];
       key.push(
@@ -92,22 +103,36 @@ const onUpdateTips = (newVal) => {
   tips.value = newVal;
 };
 
-const onUpdateTotalShot = (newVal) => {
-  currentShot.value = newVal.currentShot;
-  totalShot.value = newVal.totalShot;
-};
+// 监听 Pinia store 中 totalShot 变化，用于比赛恢复时同步箭数（替代 uni.$emit 避免时序问题）
+// 使用 immediate: true 确保组件创建时立即读取 store 当前值（解决重入时 totalShot 值不变 watch 不触发的问题）
+watch(() => store.game.totalShot, (newVal) => {
+  if (newVal > 0) {
+    totalShot.value = newVal;
+    currentShot.value = store.game.currentShot;
+  }
+}, { immediate: true });
+
+// 监听 Pinia store 中 tips 变化，用于比赛恢复时同步提示文案（替代 uni.$emit 避免时序问题）
+// 使用 immediate: true 确保组件创建时立即读取 store 当前值（解决 onShow 早于 onMounted 导致 uni.$emit 事件丢失的问题）
+// 注意：使用 != null 而非 if(newVal)，确保空字符串 "" 也能触发清空（避免重新开赛时旧文案残留）
+watch(() => store.game.tips, (newVal) => {
+  if (newVal != null) {
+    tips.value = newVal;
+  }
+}, { immediate: true });
 
 onMounted(() => {
-  uni.$on("update-shot", onUpdateTotalShot);
+  isMounted.value = true;
   uni.$on("update-tips", onUpdateTips);
   uni.$on("socket-inbox", onReceiveMessage);
   uni.$on("play-sound", playSound);
 });
 
 onBeforeUnmount(() => {
-  uni.$off("update-shot", onUpdateTotalShot);
   uni.$off("socket-inbox", onReceiveMessage);
   uni.$off("play-sound", playSound);
+  // 补充取消 update-tips 监听，防止页面重建时监听器叠加
+  uni.$off("update-tips", onUpdateTips);
   if (timer.value) clearInterval(timer.value);
 });
 </script>
@@ -117,10 +142,7 @@ onBeforeUnmount(() => {
     <text>{{ (tips || "").replace(/你/g, "").replace(/重回/g, "") }}</text>
     <text v-if="totalShot > 0"> ({{ currentShot }}/{{ totalShot }}) </text>
     <button v-if="!!tips" hover-class="none" @click="updateSound">
-      <image
-        :src="`../static/sound${sound ? '' : '-off'}-yellow.png`"
-        mode="widthFix"
-      />
+      <image :src="`../static/sound${sound ? '' : '-off'}-yellow.png`" mode="widthFix" />
     </button>
   </view>
 </template>
@@ -134,11 +156,13 @@ onBeforeUnmount(() => {
   justify-content: center;
   font-weight: 500;
 }
-.container > button:last-child {
+
+.container>button:last-child {
   width: 36px;
   height: 36px;
 }
-.container > button:last-child > image {
+
+.container>button:last-child>image {
   width: 36px;
   min-height: 36px;
 }

src/components/Matching.vue

@@ -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"
     />
@@ -123,7 +123,7 @@ onBeforeUnmount(() => {
         </text>
       </view>
     </view>
-    <button hover-class="none" @click="stopMatch">取消匹配</button>
+    <button hover-class="none" @click="$clickSound(stopMatch)">取消匹配</button>
   </view>
 </template>
 

src/components/ModalDialog.vue

@@ -0,0 +1,234 @@
+<script setup>
+const props = defineProps({
+  show: {
+    type: Boolean,
+    default: false,
+  },
+  title: {
+    type: String,
+    default: "",
+  },
+  content: {
+    type: String,
+    default: "",
+  },
+  cancelText: {
+    type: String,
+    default: "取消",
+  },
+  confirmText: {
+    type: String,
+    default: "确定",
+  },
+  showCancel: {
+    type: Boolean,
+    default: true,
+  },
+  showConfirm: {
+    type: Boolean,
+    default: true,
+  },
+  onCancel: {
+    type: Function,
+    default: null,
+  },
+  onConfirm: {
+    type: Function,
+    default: null,
+  },
+});
+
+const handleCancel = () => {
+  props.onCancel?.();
+};
+
+const handleConfirm = () => {
+  props.onConfirm?.();
+};
+</script>
+
+<template>
+  <view class="modal-mask" :style="{ display: show ? 'flex' : 'none' }">
+    <view class="modal-wrap scale-in">
+      <image
+        class="dialog-light"
+        src="https://static.shelingxingqiu.com/shootmini/static/common/dialog-light.png"
+        mode="widthFix"
+      />
+      <image
+        class="dialog-icon"
+        src="https://static.shelingxingqiu.com/shootmini/static/common/dialog-icon.png"
+        mode="widthFix"
+      />
+
+      <view class="dialog-panel">
+        <image
+          class="dialog-bg"
+          src="https://static.shelingxingqiu.com/shootmini/static/common/dialog-bg.png"
+          mode="scaleToFill"
+        />
+        <view class="dialog-content">
+          <slot>
+            <text v-if="title" class="dialog-title">{{ title }}</text>
+            <text v-if="content" class="dialog-text">{{ content }}</text>
+          </slot>
+        </view>
+
+        <view
+          v-if="showCancel || showConfirm"
+          class="dialog-actions"
+          :class="{ single: !(showCancel && showConfirm) }"
+        >
+          <view
+            v-if="showCancel"
+            class="dialog-button cancel"
+            @click="handleCancel"
+          >
+            <text>{{ cancelText }}</text>
+          </view>
+          <view
+            v-if="showConfirm"
+            class="dialog-button confirm"
+            @click="handleConfirm"
+          >
+            <text>{{ confirmText }}</text>
+          </view>
+          
+        </view>
+      </view>
+    </view>
+  </view>
+</template>
+
+<style scoped lang="scss">
+.modal-mask {
+  width: 100vw;
+  height: 100vh;
+  position: fixed;
+  top: 0;
+  left: 0;
+  background-color: rgba(0, 0, 0, 0.62);
+  justify-content: center;
+  align-items: center;
+  z-index: 999;
+}
+
+.modal-wrap {
+  position: relative;
+  display: flex;
+  width: 549rpx;
+  min-height: 318rpx;;
+  padding-top: 168rpx;
+  justify-content: flex-start;
+  align-items: center;
+}
+
+.dialog-light {
+  position: absolute;
+  top: 0;
+  left: 50%;
+  width: 520rpx;
+  z-index: 1;
+  transform-origin: center center;
+  animation: rotateLight 8s linear infinite;
+}
+
+.dialog-icon {
+  position: absolute;
+  top: 70rpx;
+  left: 50%;
+  width: 250rpx;
+  z-index: 5;
+  transform: translateX(-50%);
+}
+
+.dialog-panel {
+  position: relative;
+  width: 100%;
+  min-height: 318rpx;
+  padding: 98rpx 36rpx 40rpx 36rpx;
+  box-sizing: border-box;
+  z-index: 3;
+  border-radius: 24rpx;
+  border: 2rpx solid rgba(249, 213, 161, 0.5);
+  overflow: hidden;
+}
+
+.dialog-bg {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  border-radius: 24rpx;
+}
+
+.dialog-content {
+  position: relative;
+  z-index: 1;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  color: #fff;
+  text-align: center;
+}
+
+.dialog-title {
+  font-size: 28rpx;
+  font-weight: 700;
+  line-height: 40rpx;
+}
+
+.dialog-text {
+  margin-top: 10rpx;
+  font-size: 26rpx;
+  line-height: 36rpx;
+  white-space: pre-wrap;
+}
+
+.dialog-actions {
+  position: relative;
+  z-index: 1;
+  display: flex;
+  margin-top: 50rpx;
+  justify-content: space-between;
+  align-items: center;
+  gap: 20rpx;
+}
+
+.dialog-actions.single {
+  justify-content: center;
+}
+
+.dialog-button {
+  display: flex;
+  width: 232rpx;
+  height: 70rpx;
+  line-height: 70rpx;
+  border-radius: 44rpx;
+  justify-content: center;
+  align-items: center;
+  font-size: 26rpx;
+  font-weight: 500;
+}
+
+.dialog-button.cancel {
+  color: #fff;
+  background-color: rgba(255,255,255,0.2);
+}
+
+.dialog-button.confirm {
+  color: #000000;
+  background-color: #ffda3f;
+}
+
+@keyframes rotateLight {
+  from {
+    transform: translateX(-50%) rotate(0deg);
+  }
+
+  to {
+    transform: translateX(-50%) rotate(360deg);
+  }
+}
+</style>

src/components/OtaModal.vue

@@ -0,0 +1,429 @@
+<script setup>
+import { computed } from "vue";
+import { getDeviceBatteryAPI } from "@/apis";
+
+const OTA_MIN_BATTERY = 50;
+const OTA_LOW_BATTERY_TEXT = "电量不足 50%，暂不支持 OTA 升级";
+const OTA_OFFLINE_TEXT = "请先开启智能弓";
+
+const props = defineProps({
+  visible: {
+    type: Boolean,
+    default: false,
+  },
+  state: {
+    type: String,
+    default: "new_version", // new_version | update_progress | update_success | update_failure
+  },
+  version: {
+    type: String,
+    default: "",
+  },
+  progress: {
+    type: Number,
+    default: 40,
+  },
+  // 副标题：如“新版本将优化智能弓体验”
+  description: {
+    type: String,
+    default: "",
+  },
+  // 详细说明：如“升级前请确保：...”
+  changelog: {
+    type: String,
+    default: "",
+  },
+  forceUpdate: {
+    type: Boolean,
+    default: false,
+  },
+});
+
+const emit = defineEmits(["update", "skip", "close", "done", "retry"]);
+
+const isNewVersion = computed(() => props.state === "new_version");
+const isProgress = computed(() => props.state === "update_progress");
+const isSuccess = computed(() => props.state === "update_success");
+const isFailure = computed(() => props.state === "update_failure");
+// Clamp progress to keep the progress bar width within its container.
+const progressValue = computed(() => Math.min(100, Math.max(0, Number(props.progress) || 0)));
+
+// 点击立即更新前先校验设备在线状态，再校验设备电量。
+const handleUpdateClick = async () => {
+  try {
+    const deviceStatus = await getDeviceBatteryAPI();
+    if (deviceStatus?.online !== true) {
+      uni.showToast({
+        title: OTA_OFFLINE_TEXT,
+        icon: "none",
+      });
+      return;
+    }
+
+    if (Number(deviceStatus?.battery) <= OTA_MIN_BATTERY) {
+      uni.showToast({
+        title: OTA_LOW_BATTERY_TEXT,
+        icon: "none",
+      });
+      return;
+    }
+  } catch (err) {
+    emit("update");
+    return;
+  }
+  emit("update");
+};
+</script>
+
+<template>
+  <view v-if="visible" class="ota-mask">
+    <!-- 图标 + 弹窗卡片 容器 -->
+    <view
+      class="ota-outer"
+      :class="isNewVersion ? 'outer-new' : 'outer-result'"
+    >
+      <!-- 悬浮图标（溢出卡片顶部） -->
+      <image
+        v-if="isNewVersion"
+        src="https://static.shelingxingqiu.com/shootmini/static/ota/ota-mascot.png"
+        mode="aspectFit"
+        class="float-icon float-mascot"
+      />
+      <image
+        v-else-if="isSuccess"
+        src="https://static.shelingxingqiu.com/shootmini/static/ota/check-char.png"
+        mode="aspectFit"
+        class="float-icon float-check"
+      />
+      <image
+        v-else-if="isFailure"
+        src="https://static.shelingxingqiu.com/shootmini/static/ota/close-char.png"
+        mode="aspectFit"
+        class="float-icon float-close"
+      />
+      <image
+        v-else-if="isProgress"
+        src="https://static.shelingxingqiu.com/shootmini/static/ota/target-char.png"
+        mode="aspectFit"
+        class="float-icon float-target"
+      />
+
+      <!-- 弹窗卡片：overflow:visible 允许按钮溢出底部，背景图通过 ota-bg-clip 独立裁剪保持圆角 -->
+      <view class="ota-dialog">
+        <view class="ota-bg-clip">
+          <image src="https://static.shelingxingqiu.com/shootmini/static/ota/ota-bg.png" mode="aspectFill" class="ota-bg" />
+        </view>
+        <view
+          class="ota-content"
+          :class="{ 'content-new': isNewVersion, 'content-result': isProgress || isSuccess || isFailure }"
+        >
+
+          <!-- 发现新版本：new-ver.png 已包含标题图，不再重复文字；版本号使用 ota-ver.png 胶囊背景 -->
+          <block v-if="isNewVersion">
+            <image src="https://static.shelingxingqiu.com/shootmini/static/ota/new-ver.png" mode="aspectFit" class="new-ver-img" />
+            <view v-if="version" class="version-tag-wrap">
+              <image src="https://static.shelingxingqiu.com/shootmini/static/ota/ota-ver.png" mode="aspectFit" class="version-tag-bg-img" />
+              <text class="version-tag">{{ version }}</text>
+            </view>
+            <!-- 副标题：如“新版本将优化智能弓体验”，离下方详情 12rpx -->
+            <text v-if="description" class="desc-text">{{ description }}</text>
+            <!-- 详细说明：如“升级前请确保：...” -->
+            <text v-if="changelog" class="changelog-text">{{ changelog }}</text>
+            <view class="btn-group">
+              <view class="primary-btn" @click="handleUpdateClick">
+                <text class="primary-btn-text">立即更新</text>
+              </view>
+              <text v-if="!forceUpdate" class="skip-text" @click="emit('skip')">暂不更新</text>
+            </view>
+          </block>
+
+          <!-- 更新成功：图片左边距 34rpx，文案左边距 44rpx，按钮浮动底部居中 -->
+          <block v-else-if="isSuccess">
+            <image src="https://static.shelingxingqiu.com/shootmini/static/ota/update-ok.png" mode="aspectFit" class="result-title-img" style="width: 220rpx; height: 62rpx;" />
+            <text class="dialog-desc">请关机并重启智能弓</text>
+            <view class="btn-group-result">
+              <view class="primary-btn" @click="emit('done')">
+                <text class="primary-btn-text">完成</text>
+              </view>
+            </view>
+          </block>
+
+          <!-- 更新中：复用成功标题图，正文区域展示进度条，无底部按钮 -->
+          <block v-else-if="isProgress">
+            <image src="https://static.shelingxingqiu.com/shootmini/static/ota/update_progress.png" mode="aspectFit" class="result-title-img" style="width: 220rpx; height: 62rpx;" />
+            <view class="progress-wrap">
+              <view class="progress-track">
+                <view class="progress-fill" :style="{ width: `${progressValue}%` }"></view>
+              </view>
+            </view>
+          </block>
+
+          <!-- 更新失败：图片左边距 34rpx，文案左对齐 44rpx，按钮浮动底部居中 -->
+          <block v-else-if="isFailure">
+            <image src="https://static.shelingxingqiu.com/shootmini/static/ota/update-fail.png" mode="aspectFit" class="result-title-img" style="width: 222rpx; height: 62rpx;" />
+            <text class="dialog-desc">请确保：</text>
+            <text class="dialog-desc">1、智能弓已开启</text>
+            <text class="dialog-desc">2、网路连接稳定</text>
+            <view class="btn-group-result">
+              <view class="primary-btn" @click="emit('retry')">
+                <text class="primary-btn-text">重试</text>
+              </view>
+            </view>
+          </block>
+
+        </view>
+      </view>
+    </view>
+
+    <!-- 关闭按钮（仅新版本状态，非强制更新时，位于弹窗下方） -->
+    <view
+      v-if="(isNewVersion || isFailure) && !forceUpdate"
+      class="ota-close-below"
+      @click="emit('close')"
+    >
+      <image src="../static/sicon/close.png" mode="aspectFit" style="width: 56rpx; height: 56rpx;" />
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.ota-mask {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background-color: rgba(0, 0, 0, 0.7);
+  z-index: 1000;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+}
+
+/* 外层容器：相对定位，为浮动图标创造溢出空间 */
+.ota-outer {
+  position: relative;
+  overflow: visible;
+}
+/* 设计图：吉祥物向上突出弹窗顶部 40px（375px基准）× 2 = 80rpx */
+.outer-new {
+  padding-top: 80rpx;
+}
+.outer-result {
+  padding-top: 80rpx;
+  padding-bottom: 66rpx;
+}
+
+/* 浮动图标（绝对定位，位于卡片顶部上方） */
+.float-icon {
+  position: absolute;
+  z-index: 2;
+}
+/* 吉祥物尺寸：设计图 149×109px（375px基准）× 2 = 298×218rpx */
+.float-mascot {
+  width: 298rpx;
+  height: 218rpx;
+  top: -5px;
+  right: -74rpx;
+}
+.float-check {
+  width: 194rpx;
+  height: 166rpx;
+  top: 20px;
+  right: 30rpx;
+}
+.float-close {
+  width: 194rpx;
+  height: 164rpx;
+  top: 20px;
+  right: 30rpx;
+}
+.float-target {
+  width: 194rpx;
+  height: 166rpx;
+  top: 20px;
+  right: 30rpx;
+}
+
+/* 弹窗卡片：overflow:visible 允许按钮溢出底部，背景通过 ota-bg-clip 独立裁剪 */
+.ota-dialog {
+  position: relative;
+  width: 482rpx;
+  border-radius: 24rpx;
+  border: 2rpx solid #F9D5A1;
+  overflow: visible;
+  background-color: #392F1D;
+}
+/* 背景图裁剪层：独立 overflow:hidden + border-radius 保持圆角效果 */
+.ota-bg-clip {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  border-radius: 24rpx;
+  overflow: hidden;
+  z-index: 0;
+}
+.ota-bg {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+.ota-content {
+  position: relative;
+  z-index: 1;
+  display: flex;
+  flex-direction: column;
+  /* 按钮以外内容均左对齐 */
+  align-items: flex-start;
+}
+.content-new {
+  padding: 30rpx 0 40rpx 0;
+}
+.content-result {
+  padding: 30rpx 0 66rpx 0;
+}
+
+/* 发现新版本内容 */
+.new-ver-img {
+  width: 274rpx;
+  height: 62rpx;
+  /* 左边距 34rpx，去掉 margin-bottom */
+  margin-left: 34rpx;
+}
+/* 版本号胶囊容器：相对定位，使 ota-ver.png 作为背景衬底 */
+.version-tag-wrap {
+  position: relative;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 116rpx;
+  height: 44rpx;
+  /* 离标题图 -10rpx，左边距 50rpx，离下方副标题 22rpx */
+  margin-top: -10rpx;
+  margin-left: 50rpx;
+  margin-bottom: 22rpx;
+}
+/* ota-ver.png 胶囊背景图 */
+.version-tag-bg-img {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+/* 版本号文字：浮于背景图之上 */
+.version-tag {
+  position: relative;
+  z-index: 1;
+  color: rgba(254, 222, 100, 1);
+  font-size: 24rpx;
+  padding: 8rpx 22rpx 4rpx 24rpx;
+}
+/* 副标题（如"新版本将优化智能弓体验"）：左边距 44rpx，离下方文案 12rpx */
+.desc-text {
+  font-weight: 500;
+  font-size: 26rpx;
+  color: #FFFFFF;
+  line-height: 36rpx;
+  text-align: left;
+  margin-left: 44rpx;
+  margin-bottom: 12rpx;
+}
+/* 详细说明文案（如“升级前请确保：...”）：左边距 44rpx */
+.changelog-text {
+  font-weight: 400;
+  font-size: 26rpx;
+  color: #FFFFFF;
+  line-height: 40rpx;
+  text-align: left;
+  margin-left: 44rpx;
+  margin-bottom: 0;
+}
+
+/* 按钮组（新版本状态）：离上方文案 30rpx，内部按钮间距 24rpx */
+.btn-group {
+  width: 100%;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  margin-top: 30rpx;
+  gap: 24rpx;
+}
+/* 按钮组（结果状态）：绝对定位，溢出卡片底边 -35rpx 悬浮在底边中间 */
+.btn-group-result {
+  position: absolute;
+  bottom: -35rpx;
+  left: 0;
+  right: 0;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+/* 主按钮：按照设计规范 width: 232rpx, height: 70rpx */
+.primary-btn {
+  width: 232rpx;
+  height: 70rpx;
+  background-color: #FED847;
+  border-radius: 44rpx;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+.primary-btn-text {
+  font-weight: 500;
+  font-size: 26rpx;
+  color: #000000;
+  line-height: 36rpx;
+}
+/* 暂不更新：设计规范颜色 #5FADFF 蓝色 */
+.skip-text {
+  font-weight: 400;
+  font-size: 26rpx;
+  color: #5FADFF;
+  line-height: 36rpx;
+}
+
+/* 更新结果内容：图片左边距 34rpx，下边距 16rpx */
+.result-title-img {
+  margin-left: 34rpx;
+  margin-bottom: 16rpx;
+}
+/* 结果页文案：左对齐，左边距 44rpx，与 new_version 保持一致 */
+.dialog-desc {
+  font-weight: 400;
+  font-size: 26rpx;
+  color: #FFFFFF;
+  line-height: 40rpx;
+  text-align: left;
+  margin-left: 44rpx;
+}
+.progress-wrap {
+  width: 394rpx;
+  margin-top: 40rpx;
+  margin-left: 44rpx;
+}
+.progress-track {
+  width: 100%;
+  height: 18rpx;
+  background-color: rgba(255, 255, 255, 0.28);
+  border-radius: 999rpx;
+  overflow: hidden;
+}
+.progress-fill {
+  height: 100%;
+  background-color: #FED847;
+  border-radius: 999rpx;
+}
+
+/* 关闭按钮（位于弹窗下方） */
+.ota-close-below {
+  margin-top: 40rpx;
+  display: flex;
+  justify-content: center;
+}
+</style>

src/components/PlayerScore.vue

@@ -15,6 +15,19 @@ const props = defineProps({
 });
 
 const rowCount = new Array(6).fill(0);
+
+const getRingText = (arrow) => {
+  if (!arrow) return "-";
+  if (arrow.ringX && arrow.ring) return "X环";
+  return `${Number(arrow.ring) || 0}环`;
+};
+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" : "",
+];
 </script>
 
 <template>
@@ -31,27 +44,32 @@ const rowCount = new Array(6).fill(0);
       mode="widthFix"
     />
     <image :src="player.avatar || '../static/user-icon.png'" mode="widthFix" />
-    <text>{{ player.name }}</text>
+    <view
+      v-if="isMember(player)"
+      :class="['player-score-name', ...getMemberNicknameClass(player)]"
+    >
+      <text class="member-nickname__text">{{ player.name }}</text>
+      <text v-if="player.sVip === true" class="member-nickname__shine">
+        {{ player.name }}
+      </text>
+    </view>
+    <text v-else>{{ player.name }}</text>
     <view>
       <view>
         <view v-for="(_, index) in rowCount" :key="index">
-          <text>{{
-            scores[0] && scores[0][index] ? `${scores[0][index].ring}环` : "-"
-          }}</text>
+          <text>{{ getRingText(scores[0]?.[index]) }}</text>
         </view>
       </view>
       <view>
         <view v-for="(_, index) in rowCount" :key="index">
-          <text>{{
-            scores[1] && scores[1][index] ? `${scores[0][index].ring}环` : "-"
-          }}</text>
+          <text>{{ getRingText(scores[1]?.[index]) }}</text>
         </view>
       </view>
     </view>
     <text
       >{{
         scores
-          .map((s) => s.reduce((last, next) => last + next.ring, 0))
+          .map((s) => (s || []).reduce((last, next) => last + next.ring, 0))
           .reduce((last, next) => last + next, 0)
       }}环</text
     >
@@ -96,6 +114,13 @@ const rowCount = new Array(6).fill(0);
   text-overflow: ellipsis;
   width: 20%;
 }
+.player-score-name {
+  width: 20%;
+}
+.player-score-name .member-nickname__text,
+.player-score-name .member-nickname__shine {
+  font-size: 14px;
+}
 .container > view:nth-child(4) {
   display: flex;
   flex-direction: column;

src/components/PlayerSeats.vue

@@ -14,14 +14,28 @@ const props = defineProps({
     type: Function,
     default: () => {},
   },
+  /** 当前用户是否为房主；仅房主可见踢人按钮 */
+  isOwner: {
+    type: Boolean,
+    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'"
@@ -35,18 +49,36 @@ 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`"
         mode="widthFix"
         class="player-bg"
       /> -->
+      <!-- 仅房主（isOwner=true）且非空座位时展示踢人按钮 -->
       <button
-        v-if="index > 0 && players[index]"
+        v-if="index > 0 && players[index] && isOwner"
         hover-class="none"
         class="remove-player"
         @click="() => removePlayer(players[index])"
@@ -102,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;

src/components/PointRankItem.vue

@@ -22,6 +22,15 @@ const props = defineProps({
 const like = ref(props.data.ifLike);
 const likeCount = ref(props.data.likeTotal || 0);
 
+const isMember = (data = {}) => data.vip === true || data.sVip === true;
+
+const getMemberNicknameClass = (data = {}) => [
+  "point-rank-name",
+  "member-nickname",
+  data.vip === true && data.sVip !== true ? "member-nickname--vip" : "",
+  data.sVip === true ? "member-nickname--svip" : "",
+];
+
 watch(
   () => props.data,
   (newVal) => {
@@ -53,7 +62,13 @@ const onClick = async () => {
     <view>
       <Avatar :src="data.avatar || '../static/user-icon.png'" :size="36" />
       <view>
-        <text class="truncate">{{ data.name }}</text>
+        <view v-if="isMember(data)" :class="getMemberNicknameClass(data)">
+          <text class="member-nickname__text">{{ data.name }}</text>
+          <text v-if="data.sVip === true" class="member-nickname__shine">
+            {{ data.name }}
+          </text>
+        </view>
+        <text v-else class="truncate">{{ data.name }}</text>
         <view>
           <text>{{ data.totalDay }}天</text>
           <view />
@@ -118,6 +133,14 @@ const onClick = async () => {
   color: #333333;
   margin-bottom: 5rpx;
 }
+.rank-item > view:nth-child(2) > view:last-child > .point-rank-name {
+  width: 200rpx;
+  margin-bottom: 5rpx;
+}
+.point-rank-name .member-nickname__text,
+.point-rank-name .member-nickname__shine {
+  font-size: 28rpx;
+}
 .rank-item > view:nth-child(2) > view:last-child > view {
   display: flex;
   align-items: center;

src/components/PointRecord.vue

@@ -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>

src/components/RewardUs.vue

@@ -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

src/components/ScorePanel.vue

@@ -26,8 +26,8 @@ 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(

src/components/ScoreResult.vue

@@ -70,13 +70,18 @@ const arrows = computed(() => {
 });
 
 const validArrows = computed(() => arrows.value.filter((a) => !!a.ring).length);
+const isMember = computed(() => user.value.vip === true || user.value.sVip === true);
+const openCoachComment = () => {
+  if (!isMember.value) return;
+  showComment.value = true;
+};
 </script>
 
 <template>
   <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
@@ -112,9 +117,10 @@ const validArrows = computed(() => arrows.value.filter((a) => !!a.ring).length);
             :onClick="onClickShare"
           />
           <IconButton
+            v-if="isMember"
             name="教练点评"
             src="../static/review.png"
-            :onClick="() => (showComment = true)"
+            :onClick="openCoachComment"
           />
         </block>
         <SButton
@@ -137,7 +143,7 @@ const validArrows = computed(() => arrows.value.filter((a) => !!a.ring).length);
           }}</text
           >环的成绩，所有箭支上靶后的平均点间距为<text
             :style="{ color: '#fed847' }"
-            >{{ Number((result.average_distance || 0).toFixed(2)) }}</text
+            >{{ Number((result?.interpretation?.spreadStability || 0).toFixed(2)) }}</text
           >，{{
             result.spreadEvaluation === "Dispersed"
               ? "还需要持续改进哦~"

src/components/ScreenHint.vue

@@ -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 />

src/components/ScreenHint2.vue

@@ -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

src/components/ShootProgress.vue

@@ -38,6 +38,10 @@ const props = defineProps({
     type: Boolean,
     default: false,
   },
+  halfRest: {
+    type: Boolean,
+    default: false,
+  },
   onStop: {
     type: Function,
     default: () => {},
@@ -136,22 +140,27 @@ const updateSound = () => {
 async function onReceiveMessage(msg) {
   if (Array.isArray(msg)) return;
   if (msg.type === MESSAGETYPESV2.BattleStart) {
+    const audioKey = props.melee && (halfTime.value || props.halfRest) ? "下半场开始" : "比赛开始";
     halfTime.value = false;
-    audioManager.play("比赛开始");
+    audioManager.play(audioKey);
   } else if (msg.type === MESSAGETYPESV2.BattleEnd) {
-    audioManager.play("比赛结束");
+    audioManager.play("比赛结束", 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;
@@ -186,7 +195,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

src/components/ShootProgress2.vue

@@ -29,6 +29,33 @@ const updateRemain = (value) => {
     if (timer.value) clearInterval(timer.value);
     return
   }
+  // zeroThenReset：ToSomeoneShoot 到达时，若进度条仍在倒计时则先瞬间清零（约 150ms 停留）再显示下一玩家满值
+  // 若进度条已到 0（loading 状态），直接切换满值
+  if (value.zeroThenReset) {
+    if (timer.value) clearInterval(timer.value);
+    const wasNonZero = remain.value > 0;
+    // 更新下一玩家颜色和方向（在清零和满值时均生效）
+    currentTeam.value = value.team;
+    if (value.team === 'red') barColor.value = "linear-gradient( 180deg, #FFA0A0 0%, #FF6060 100%)";
+    if (value.team === 'blue') barColor.value = "linear-gradient( 180deg, #9AB3FF 0%, #4288FF 100%)";
+    transitionStyle.value = "none";
+    if (wasNonZero) {
+      // 瞬间清零，停留约 150ms 后切换为满值
+      remain.value = 0;
+      loading.value = true;
+      setTimeout(() => {
+        remain.value = value.value;
+        loading.value = false;
+        setTimeout(() => { transitionStyle.value = "all 1s linear"; }, 50);
+      }, 150);
+    } else {
+      // 已在底部，直接切换满值
+      remain.value = value.value;
+      loading.value = false;
+      setTimeout(() => { transitionStyle.value = "all 1s linear"; }, 50);
+    }
+    return;
+  }
   loading.value = false;
   currentTeam.value = value.team
   if (value.team === 'red')
@@ -36,7 +63,14 @@ const updateRemain = (value) => {
   if (value.team === 'blue')
     barColor.value = "linear-gradient( 180deg, #9AB3FF 0%, #4288FF 100%)";
   if (value.reset) {
+    // 重置前先清除旧计时器，防止超时未射箭时旧 interval 残留，导致进度条震荡
+    if (timer.value) clearInterval(timer.value);
+    // 重置时瞬间跳满格，禁用 CSS 过渡避免从旧值「涨到满」的动画
+    transitionStyle.value = "none";
     remain.value = value.value;
+    setTimeout(() => {
+      transitionStyle.value = "all 1s linear";
+    }, 50);
     return;
   }
   const newVal = Math.round(value.value);
@@ -51,6 +85,8 @@ const updateRemain = (value) => {
     remain.value = newVal;
   }
 
+  // 启动前先清除旧计时器，防止多次 {stop:false} 事件叠加多个 interval
+  if (timer.value) clearInterval(timer.value);
   timer.value = setInterval(() => {
     loading.value = remain.value === 0;
     if (remain.value > 0) remain.value--;

src/components/Signin.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { ref } from "vue";
+import { ref, watch } from "vue";
 import { onShow } from "@dcloudio/uni-app";
 import SModal from "@/components/SModal.vue";
 import Avatar from "@/components/Avatar.vue";
@@ -11,12 +11,13 @@ import {
   loginAPI,
   getHomeData,
   getPhoneNumberAPI,
+  getPhoneNumberAPIv2,
   getDeviceBatteryAPI,
 } from "@/apis";
 
 import useStore from "@/store";
 const store = useStore();
-const { updateUser, updateDevice, updateOnline } = store;
+const { updateUser, updateDevice, updateOnline, clearDevice } = store;
 
 const props = defineProps({
   show: {
@@ -43,12 +44,12 @@ const handleAgree = () => {
 
 async function getphonenumber(e) {
   if (e.detail.code) {
-    const wxResult = await wxLogin();
-    const result = await getPhoneNumberAPI({
-      ...e.detail,
-      code: wxResult.code,
+    // const wxResult = await wxLogin();
+    const result = await getPhoneNumberAPIv2({
+      // ...e.detail,
+      code: e.detail.code,
     });
-    if (result.phone) phone.value = result.phone;
+    if (result.purePhoneNumber) phone.value = result.purePhoneNumber;
   }
 }
 
@@ -60,6 +61,21 @@ function onNicknameChange(e) {
   nickName.value = e.detail.value;
 }
 
+const resetForm = () => {
+  loading.value = false;
+  agree.value = false;
+  phone.value = "";
+  avatarUrl.value = "";
+  nickName.value = "";
+};
+
+watch(
+  () => props.show,
+  (show) => {
+    if (show) resetForm();
+  }
+);
+
 const handleLogin = async () => {
   if (loading.value) return;
   if (!phone.value) {
@@ -107,6 +123,8 @@ async function doLogin() {
       );
       const data = await getDeviceBatteryAPI();
       updateOnline(data.online);
+    } else {
+      clearDevice();
     }
     props.onClose();
   } catch (error) {
@@ -137,11 +155,7 @@ const openPrivacyLink = () => {
 };
 
 onShow(() => {
-  loading.value = false;
-  agree.value = false;
-  phone.value = "";
-  avatarUrl.value = "";
-  nickName.value = "";
+  resetForm();
 });
 </script>
 
@@ -187,10 +201,11 @@ onShow(() => {
         <text :style="{ color: noBg ? '#666' : '#fff' }">昵称:</text>
         <input
           type="nickname"
+          :value="nickName"
           placeholder="请输入昵称"
           :placeholder-style="`color: ${noBg ? '#666' : '#fff9'} `"
+          @input="onNicknameChange"
           @change="onNicknameChange"
-          @blur="onNicknameBlur"
           :style="{ color: noBg ? '#333' : '#fff' }"
         />
       </view>

src/components/Swiper.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { ref } from "vue";
+import { ref, watch } from "vue";
 
 const props = defineProps({
   interval: {
@@ -14,13 +14,24 @@ const props = defineProps({
     type: Array,
     default: () => [],
   },
+  current: {
+    type: Number,
+    default: 0,
+  },
   onChange: {
     type: Function,
     default: (index) => {},
   },
 });
 
-const currentIndex = ref(0);
+const currentIndex = ref(props.current);
+
+watch(
+  () => props.current,
+  (index) => {
+    currentIndex.value = index;
+  }
+);
 
 const handleChange = (e) => {
   currentIndex.value = e.detail.current;
@@ -75,7 +86,7 @@ const handleChange = (e) => {
 
 .dots {
   position: absolute;
-  bottom: 5%;
+  bottom: 2%;
   left: 50%;
   transform: translateX(-50%);
   display: flex;

src/components/TargetCanvas.vue

@@ -0,0 +1,531 @@
+<script setup>
+import { computed, getCurrentInstance, nextTick, onMounted, ref, watch } from "vue";
+
+const defaultCanvasSize = 300;
+const defaultRingCount = 10;
+
+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,
+  },
+  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,
+});
+
+// 完整靶纸默认样式，调用方可以通过 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) => {
+  const angles = getSectorAngles(props.activeSector, props.sectorCount);
+  if (!angles) 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.endAngle,
+    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 = () => {
+  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 (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);
+
+  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 = drawKey;
+};
+
+const setCanvasSizeAndDraw = async (width, height) => {
+  canvasSize.value = {
+    width: width > 0 ? width : defaultCanvasSize,
+    height: height > 0 ? height : width || defaultCanvasSize,
+  };
+
+  await nextTick();
+  drawTarget();
+};
+
+// 读取 canvas 实际渲染尺寸后再绘制，保证小程序真机尺寸和坐标一致。
+const measureAndDraw = () => {
+  const propWidth = Math.round(getNumber(props.canvasWidth, 0));
+  const propHeight = Math.round(getNumber(props.canvasHeight, 0));
+
+  if (propWidth > 0 && propHeight > 0) {
+    setCanvasSizeAndDraw(propWidth, propHeight);
+    return;
+  }
+
+  const query = uni.createSelectorQuery().in(instance?.proxy);
+
+  query
+    .select(`#${currentCanvasId.value}`)
+    .boundingClientRect(async (rect) => {
+      const width = Math.round(getNumber(rect?.width, defaultCanvasSize));
+      const height = Math.round(getNumber(rect?.height, width || defaultCanvasSize));
+
+      await setCanvasSizeAndDraw(width, height);
+    })
+    .exec();
+};
+
+// 等待 Vue 完成 DOM 更新后重新测量和绘制。
+const scheduleDraw = async () => {
+  await nextTick();
+  measureAndDraw();
+};
+
+watch(
+  () => [
+    props.coordinateRadius,
+    props.showCrosshair,
+    props.showRingLabels,
+    props.sectorCount,
+    props.activeSector,
+    props.activeRing,
+    props.showSectorLabels,
+    props.highlightOnly,
+    props.canvasWidth,
+    props.canvasHeight,
+    props.targetStyleConfig,
+    props.crosshairStyle,
+    props.sectorStyle,
+    props.sectorLabelStyle,
+    props.highlightStyle,
+  ],
+  scheduleDraw,
+  {
+    deep: true,
+  }
+);
+
+onMounted(() => {
+  setTimeout(measureAndDraw, 30);
+});
+</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>

src/components/TeamAvatars.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { ref, watch, onMounted, computed } from "vue";
+import { ref, watch } from "vue";
 const props = defineProps({
   isRed: {
     type: Boolean,
@@ -10,7 +10,7 @@ const props = defineProps({
     default: () => [],
   },
   currentShooterId: {
-    type: Number,
+    type: [Number, String],
     default: "",
   },
 });
@@ -30,31 +30,35 @@ const getPos = (id) => {
   return sort * 40;
 };
 
-onMounted(() => {
-  props.team.forEach((p, index) => {
-    players.value[p.id] = { sort: index, ...p };
+const syncPlayers = () => {
+  const nextPlayers = {};
+  const shooterId = props.currentShooterId;
+  const shooterIndex = props.team.findIndex(
+    (p) => String(p?.id) === String(shooterId)
+  );
+  const nextTeam = [...props.team];
+
+  currentTeam.value = !!shooterId && shooterIndex >= 0;
+  firstName.value = "";
+
+  if (currentTeam.value) {
+    const target = nextTeam.splice(shooterIndex, 1)[0];
+    if (target) {
+      nextTeam.unshift(target);
+      firstName.value = target.name || "";
+    }
+  }
+
+  nextTeam.forEach((p, index) => {
+    if (p?.id) nextPlayers[p.id] = { sort: index, ...p };
   });
-});
+  players.value = nextPlayers;
+};
 
 watch(
-  () => props.currentShooterId,
-  (newVal) => {
-    if (!newVal) return;
-    const index = props.team.findIndex((p) => p.id === newVal);
-    currentTeam.value = index >= 0;
-    if (index >= 0) {
-      const newPlayers = [...props.team];
-      const target = newPlayers.splice(index, 1)[0];
-      if (target) {
-        newPlayers.unshift(target);
-        firstName.value = target.name;
-        newPlayers.forEach((p, index) => {
-          players.value[p.id] = { sort: index, ...p };
-        });
-      }
-    }
-  },
-  { immediate: true }
+  [() => props.team, () => props.currentShooterId],
+  syncPlayers,
+  { immediate: true, deep: true }
 );
 </script>
 
@@ -70,7 +74,7 @@ watch(
     />
     <view
       v-for="(item, index) in team"
-      :key="index"
+      :key="item.id || index"
       class="player"
       :style="{
         width: (isFirst(item.id) ? 80 : 60) + 'rpx',

src/components/TestDistance.vue

@@ -111,7 +111,7 @@ 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>{{ count }}</text>

src/components/UserHeader.vue

@@ -19,6 +19,8 @@ const nextLvlPoints = ref(0);
 const containerWidth = computed(() =>
   props.showRank ? "72%" : "calc(100% - 15px)"
 );
+const isSVip = computed(() => user.value.sVip === true);
+const isVip = computed(() => user.value.vip === true && !isSVip.value);
 const toUserPage = () => {
   // 获取当前页面路径
   const pages = getCurrentPages();
@@ -69,7 +71,18 @@ watch(
       />
       <view class="user-details" @click="toUserPage">
         <view class="user-name">
-          <text>{{ user.nickName }}</text>
+          <view
+            :class="[
+              'member-nickname',
+              isVip ? 'member-nickname--vip' : '',
+              isSVip ? 'member-nickname--svip' : '',
+            ]"
+          >
+            <text class="member-nickname__text">{{ user.nickName }}</text>
+            <text v-if="isSVip" class="member-nickname__shine">{{
+              user.nickName
+            }}</text>
+          </view>
           <image
             class="user-name-image"
             src="../static/vip1.png"
@@ -148,12 +161,13 @@ watch(
   margin-bottom: 5px;
 }
 
-.user-name > text:first-child {
-  font-size: 13px;
+.user-name .member-nickname {
   max-width: 180rpx;
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
+}
+
+.user-name .member-nickname__text,
+.user-name .member-nickname__shine {
+  font-size: 13px;
 }
 
 .user-name-image {

src/components/UserUpgrade.vue

@@ -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>

src/constants.js

@@ -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

src/main.js

@@ -1,11 +1,26 @@
 import { createSSRApp } from 'vue'
 import { createPinia } from 'pinia'
+import piniaPluginPersistedstate from 'pinia-plugin-persistedstate'
 import App from './App.vue'
+import audioManager from './audioManager'
 
 export function createApp() {
   const app = createSSRApp(App)
   const pinia = createPinia()
+  pinia.use(piniaPluginPersistedstate)
   app.use(pinia)
+
+  /**
+   * 全局点击音效工具函数，用于在任意按钮/元素点击时自动播放音效。
+   * 用法：@click="$clickSound(handler)" 或 @click="$clickSound(() => doSomething())"
+   * @param {Function} handler - 原始点击回调函数（可选，点击时直接调用）
+   * @param {string} [soundKey='点击按钮'] - audioManager 中的音效 key
+   */
+  app.config.globalProperties.$clickSound = (handler, soundKey = '点击按钮') => {
+    audioManager.play(soundKey);
+    if (typeof handler === 'function') handler();
+  };
+
   return {
     app
   }

src/manifest.json

@@ -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,
@@ -64,7 +311,11 @@
         "usingComponents" : true,
         "darkmode" : true,
         "themeLocation" : "theme.json",
-        "permission" : {},
+        "permission" : {
+          "scope.userLocation": {
+            "desc": "用于扫描附近 WiFi，完成设备 OTA 升级网络连接"
+          }
+        },
         "requiredPrivateInfos" : [ "getLocation", "chooseLocation" ]
     }
 }

src/mock/index.js

@@ -0,0 +1,104 @@
+// 首页一周打卡展示数据，直接对应顶部 7 个日期卡片。
+export const trainingHomeWeekSchedule = [
+  {
+    key: "mon",
+    label: "周一",
+    status: "done",
+    icon: "https://static.shelingxingqiu.com/shootmini/static/training-home/done.png",
+  },
+  {
+    key: "tue",
+    label: "周二",
+    status: "done",
+    icon: "https://static.shelingxingqiu.com/shootmini/static/training-home/done.png",
+  },
+  {
+    key: "wed",
+    label: "周三",
+    status: "missed",
+    icon: "https://static.shelingxingqiu.com/shootmini/static/training-home/missed.png",
+  },
+  {
+    key: "thu",
+    label: "周四",
+    status: "missed",
+    icon: "https://static.shelingxingqiu.com/shootmini/static/training-home/missed.png",
+  },
+  {
+    key: "fri",
+    label: "周五",
+    status: "done",
+    icon: "https://static.shelingxingqiu.com/shootmini/static/training-home/done.png",
+  },
+  {
+    key: "sat",
+    label: "周六",
+    status: "done",
+    icon: "https://static.shelingxingqiu.com/shootmini/static/training-home/done.png",
+  },
+  {
+    key: "sun",
+    label: "周日",
+    status: "missed",
+    icon: "https://static.shelingxingqiu.com/shootmini/static/training-home/missed.png",
+  },
+];
+
+// 首页统计卡数据，按设计稿从左到右展示。
+export const trainingHomeStats = [
+  { key: "days", value: "12", unit: "天", label: "共训练" },
+  { key: "shots", value: "112", unit: "支", label: "累计射箭" },
+  { key: "hitRate", value: "30", unit: "%", label: "命中率" },
+  { key: "endurance", value: "6", unit: "支/分钟", label: "耐力射击" },
+  { key: "calories", value: "31W", unit: "卡路里", label: "共消耗" },
+];
+
+// 雷达图区文案与数值配置。
+export const trainingHomeRadar = {
+  labels: ["基础", "精准", "力量", "节奏", "耐力"],
+  values: [5.5, 6.3, 10, 4.5, 6],
+  maxValue: 10,
+  surpassValue: '80%'
+};
+
+// 首页主推荐训练卡数据。
+export const trainingHomeFeatured = {
+  title: "基础训练",
+  progressText: "当前进度 LV7 >",
+};
+
+// 首页四个训练入口卡片数据。
+export const trainingHomeModes = [
+  {
+    key: "endurance",
+    title: "耐力训练",
+    progressText: "当前进度 LV5 >",
+    icon: "https://static.shelingxingqiu.com/shootmini/static/training-home/img_3.png",
+    recommended: true,
+    disabled: false,
+  },
+  {
+    key: "precision",
+    title: "精准训练",
+    progressText: "当前进度 LV3 >",
+    icon: "https://static.shelingxingqiu.com/shootmini/static/training-home/img_4.png",
+    recommended: false,
+    disabled: false,
+  },
+  {
+    key: "rhythm",
+    title: "节奏训练",
+    progressText: "当前进度 LV6 >",
+    icon: "https://static.shelingxingqiu.com/shootmini/static/training-home/img_5.png",
+    recommended: false,
+    disabled: false,
+  },
+  {
+    key: "power",
+    title: "力量训练",
+    progressText: "Coming!  LV10",
+    icon: "https://static.shelingxingqiu.com/shootmini/static/training-home/img_6.png",
+    recommended: false,
+    disabled: true,
+  },
+];

src/mock/trainingDifficulty.js

@@ -0,0 +1,113 @@
+// 难度页当前用于保存“开始训练前上下文”的本地存储 key。
+export const trainingDifficultyStorageKey = "training-selection";
+
+// 当前是页面联调用的模拟数据：
+// 1. 总难度 20 级
+// 2. 已解锁到 Lv3
+// 3. 前三关展示不同完成进度
+const totalDifficultyLevel = 20;
+const mockedUnlockedDifficultyId = "lv3";
+const mockedDifficultyProgressMap = {
+  lv1: 100,
+  lv2: 90,
+  lv3: 70,
+};
+
+const modeList = [
+  {
+    key: "endurance",
+    title: "耐力训练",
+  },
+  {
+    key: "precision",
+    title: "精准训练",
+  },
+  {
+    key: "rhythm",
+    title: "节奏训练",
+  },
+  {
+    key: "basic",
+    title: "基础训练",
+  },
+  {
+    key: "power",
+    title: "力量训练",
+  },
+  {
+    key: "focus",
+    title: "专注训练",
+  },
+];
+
+const createDifficultyId = (level) => `lv${level}`;
+
+const createDifficultyLabel = (level) => `Lv${level}`;
+
+// 根据等级生成模拟文案，方便一次性扩展到更多关卡。
+const createDifficultySummary = (level) => {
+  return [
+    `箭靶划分为${Math.min(1 + Math.floor((level - 1) / 5), 4)}个区域`,
+    `需${4 + level}次命中目标`,
+    `${100 + Math.floor((level - 1) / 2) * 10}秒内完成所有射击`,
+    "需使用20CM全环靶",
+  ];
+};
+
+// 难度页的节点位置已经在页面内统一计算，
+// 这里保留最核心的 id / label 即可，不再维护无效的 left / top / style 字段。
+const createDifficultyNode = (level) => {
+  return {
+    id: createDifficultyId(level),
+    label: createDifficultyLabel(level),
+  };
+};
+
+const createDifficultyDetail = (level) => {
+  const id = createDifficultyId(level);
+  const label = createDifficultyLabel(level);
+
+  return {
+    id,
+    label,
+    title: `${label}难度`,
+    summary: createDifficultySummary(level),
+    startText: "开始",
+    targetPaperType: "20CM全环靶",
+  };
+};
+
+// 所有训练模式当前共用同一套难度定义。
+const sharedDifficultyNodes = Array.from(
+  { length: totalDifficultyLevel },
+  (_, index) => createDifficultyNode(index + 1)
+);
+
+const sharedDifficultyDetails = Object.fromEntries(
+  Array.from({ length: totalDifficultyLevel }, (_, index) => {
+    const detail = createDifficultyDetail(index + 1);
+    return [detail.id, detail];
+  })
+);
+
+const createModeConfig = ({ key, title, reward = null }) => {
+  return {
+    key,
+    title,
+    nodes: sharedDifficultyNodes,
+    details: sharedDifficultyDetails,
+    activeDifficultyId: mockedUnlockedDifficultyId,
+    progressMap: mockedDifficultyProgressMap,
+    reward,
+  };
+};
+
+// 难度页数据源入口：
+// 页面通过 getTrainingDifficultyModeConfig(modeKey) 获取当前模式完整配置。
+export const trainingDifficultyModeMap = Object.fromEntries(
+  modeList.map((mode) => [mode.key, createModeConfig(mode)])
+);
+
+export const getTrainingDifficultyModeConfig = (modeKey) => {
+  return trainingDifficultyModeMap[modeKey] || trainingDifficultyModeMap.precision;
+};

src/pages.json

@@ -30,15 +30,15 @@
         "navigationBarTitleText": ""
       }
     },
-    {
-      "path": "pages/team-battle"
-    },
     {
       "path": "pages/melee-battle"
     },
     {
       "path": "pages/battle-result"
     },
+    {
+      "path": "pages/friend-battle-result"
+    },
     {
       "path": "pages/point-book-edit"
     },
@@ -66,15 +66,6 @@
     {
       "path": "pages/user"
     },
-    {
-      "path": "pages/orders"
-    },
-    {
-      "path": "pages/order-detail"
-    },
-    {
-      "path": "pages/be-vip"
-    },
     {
       "path": "pages/grade-intro"
     },
@@ -108,14 +99,17 @@
     {
       "path": "pages/match-detail"
     },
-    {
-      "path": "pages/team-bow-data"
-    },
     {
       "path": "pages/melee-bow-data"
     },
     {
       "path": "pages/mine-bow-data"
+    },
+    {
+      "path": "pages/ota-wifi",
+      "style": {
+        "navigationStyle": "custom"
+      }
     }
   ],
   "globalStyle": {
@@ -135,5 +129,51 @@
       "^uni-(.*)": "@dcloudio/uni-ui/lib/uni-$1/uni-$1.vue"
     }
   },
-  "subPackages": []
+  "subPackages": [
+    {
+      "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"
+        }
+      ]
+    }
+  ]
 }

src/pages/battle-result.vue

@@ -82,7 +82,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 +107,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 +117,8 @@ const checkBowData = () => {
             }deg)`,
           }"
         >
-          <view v-if="data.mvp && data.mvp[0].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 +127,7 @@ const checkBowData = () => {
                   margin: '0 3px',
                   fontWeight: '600',
                 }"
-                >{{ data.mvp[0].totalRings }}</text
+                >{{ data.mvp.player_match_result.total_ring }}</text
               >环</text
             >
           </view>
@@ -153,7 +153,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 +173,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 +248,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"

src/pages/battle-room.vue

@@ -1,24 +1,27 @@
 <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";
 import SButton from "@/components/SButton.vue";
 import Avatar from "@/components/Avatar.vue";
 import ScreenHint from "@/components/ScreenHint.vue";
+import ModalDialog from "@/components/ModalDialog.vue";
 import {
   getRoomAPI,
-  destroyRoomAPI,
   exitRoomAPI,
-  startRoomAPI,
   chooseTeamAPI,
   getReadyAPI,
   kickPlayerAPI,
+  getBattleAPI,
 } from "@/apis";
+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);
 
@@ -30,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
@@ -42,16 +59,178 @@ const battleTitle = computed(() => {
   return `${half}v${half}对抗赛`;
 });
 
+/** 靶纸尺寸（cm），由 URL 参数或 API 返回的 targetType 字段填充 */
+const targetSize = ref(0);
+
+/**
+ * 根据 targetSize 动态生成靶纸尺寸文本，如"40cm"
+ * 数据未就绪时显示 "--"；数据来源：创建者取 URL 参数 target，加入者取 API 返回的 targetType
+ */
+const targetSizeLabel = computed(() =>
+  targetSize.value ? `${targetSize.value}cm` : '--'
+);
+
 const ready = ref(false);
 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) {
+    targetSize.value = result.targetType;
+    uni.setStorageSync(`targetSize_${roomNumber.value}`, result.targetType);
+  } else if (targetSize.value === 0) {
+    // API 无该字段时，从本地缓存兜底（如"返回房间"场景）
+    const stored = uni.getStorageSync(`targetSize_${roomNumber.value}`);
+    if (stored) targetSize.value = stored;
+  }
   owner.value = {};
   opponent.value = {};
   const members = result.members || [];
@@ -66,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;
     }
@@ -80,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,
         };
       }
     });
@@ -96,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({});
@@ -109,28 +294,47 @@ async function refreshRoomData() {
   }
   if (timer.value) clearInterval(timer.value);
   // timer.value = setTimeout(refreshRoomData, 2000);
-
-  // 通知 Header 组件更新房号展示
-  uni.$emit("battle-room-info", { roomNumber: roomNumber.value });
+  return false;
 }
 
-const startGame = async () => {
-  const result = await startRoomAPI(room.value.number);
+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;
 };
 
-const getReady = async () => {
-  await getReadyAPI(roomNumber.value);
+const goVipPage = () => {
+  showLimitModal.value = false;
+  uni.navigateTo({
+    url: "/pages/member/be-vip",
+  });
 };
 
 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++) {
@@ -172,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?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);
     }
   }
 }
@@ -192,14 +401,6 @@ const chooseTeam = async (team) => {
   refreshMembers(result.members);
 };
 
-const destroyRoom = async () => {
-  if (roomNumber.value) await destroyRoomAPI(roomNumber.value);
-};
-
-const exitRoom = async () => {
-  uni.navigateBack();
-};
-
 /** 待确认踢出的玩家信息 */
 const playerToKick = ref(null);
 /** 控制踢出确认弹窗的显示状态 */
@@ -240,35 +441,113 @@ const canClick = computed(() => {
   return true;
 });
 
+/**
+ * 根据对战类型和人数动态生成分享文案
+ * 1v1 / 默认 → "星球论箭，来一决高下敢否?"
+ * 2v2 → "2v2对抗赛，是兄弟来助我一把!"
+ * 3v3 → "3v3对抗赛，来了马上发车!"
+ * 乱斗 → "热血乱斗赛，敢来争锋?"
+ */
+const shareTitle = computed(() => {
+  const { battleType, count } = room.value;
+  if (battleType === 2) return '热血乱斗赛，敢来争锋?';
+  if (battleType === 1 && count === 4) return '2v2对抗赛，是兄弟来助我一把!';
+  if (battleType === 1 && count === 6) return '3v3对抗赛，来了马上发车!';
+  return '星球论箭，来一决高下敢否?';
+});
+
+/**
+ * 根据对战类型和靶纸尺寸动态返回分享封面图路径，共 4 张图：
+ *   contest_share_20.png — 约战/对抗赛 + 20cm 靶
+ *   contest_share_40.png — 约战/对抗赛 + 40cm 靶
+ *   melee_share_20.png   — 多人乱斗 + 20cm 靶
+ *   melee_share_40.png   — 多人乱斗 + 40cm 靶
+ *
+ * 当 targetSize 未知时默认取 20cm 图。
+ */
+const shareImage = computed(() => {
+  const type = room.value.battleType === 2 ? 'melee' : 'contest';
+  const size = targetSize.value === 40 ? '40' : '20';
+  return `https://static.shelingxingqiu.com/shootmini/static/share/${type}_share_${size}.png`;
+});
+
 onShareAppMessage(() => {
   return {
-    title: "邀请您进入房间对战",
+    title: shareTitle.value,
     path: "/pages/friend-battle?roomID=" + roomNumber.value,
-    imageUrl: "",
+    imageUrl: shareImage.value,
   };
 });
 
+/**
+ * onShow 生命周期：页面显示时刷新房间数据
+ * 注：uni-app 中 onShow 可能早于 onLoad 执行，此时 roomNumber 尚未赋值，
+ * refreshRoomData 会提前 return。
+ */
 onShow(() => {
   goBattle.value = false;
-  refreshRoomData();
+  navigationPending.value = false;
+  pageVisible = true;
+  const generation = ++foregroundGeneration;
+  if (pageMounted) void reconcileBattleRoom(generation);
 });
 
+onHide(() => {
+  pageVisible = false;
+  foregroundGeneration += 1;
+});
+
+/**
+ * 页面加载时解析路由参数，初始化房间号
+ * - 存入本地 ref（供页面内部逻辑使用）
+ * - 同步到 Pinia Store（供 Header 组件展示房号胶囊）
+ */
 onLoad(async (options) => {
+  // 从结算页跳回时携带 fromResult=1，标记跳过进场语音
+  if (options.fromResult) skipTargetAudio.value = true;
   if (options.roomNumber) {
     roomNumber.value = options.roomNumber;
-    // 立即通知 Header 显示房号，无需等待异步 API 返回
-    uni.$emit("battle-room-info", { roomNumber: options.roomNumber });
+    store.updateRoomNumber(options.roomNumber);
+  }
+  // 创建者通过 URL 参数 target（1→20cm，2→40cm）初始化靶纸尺寸，并持久化到本地缓存
+  if (options.target) {
+    targetSize.value = parseInt(options.target) * 20;
+    uni.setStorageSync(`targetSize_${roomNumber.value}`, targetSize.value);
+  } else if (roomNumber.value) {
+    // "返回房间"等无 target 参数的场景：从本地缓存恢复（待 refreshRoomData 进一步覆盖）
+    const stored = uni.getStorageSync(`targetSize_${roomNumber.value}`);
+    if (stored) targetSize.value = stored;
+  }
+  if (pageMounted && pageVisible) {
+    const generation = ++foregroundGeneration;
+    void reconcileBattleRoom(generation);
   }
 });
 
+/**
+ * 组件挂载后：保持屏幕常亮、注册 WebSocket 消息监听
+ * 房间号已通过 onLoad 同步到 Store，Header 从 Store 直接读取，无需额外通知
+ */
 onMounted(() => {
   uni.setKeepScreenOn({
     keepScreenOn: true,
   });
   uni.$on("socket-inbox", onReceiveMessage);
+  pageMounted = true;
+  if (pageVisible) void reconcileBattleRoom(foregroundGeneration);
+  // 页面加载完成 1 秒后根据靶纸尺寸播报对应语音；从结算页返回时跳过
+  setTimeout(() => {
+    if (!skipTargetAudio.value) {
+      const key = targetSize.value === 40 ? '40CM全环靶' : '20CM全环靶';
+      audioManager.play(key);
+    }
+  }, 1000);
 });
 
 onBeforeUnmount(() => {
+  pageMounted = false;
+  pageVisible = false;
+  foregroundGeneration += 1;
   uni.setKeepScreenOn({
     keepScreenOn: false,
   });
@@ -285,11 +564,8 @@ onBeforeUnmount(() => {
       <GuideTwo>
         <view class="battle-guide">
           <view class="guide-tips">
-            <text>弓箭手们，人都到齐了吗?</text>
-            <text v-if="room.battleType === 1">{{
-              `${room.count / 2}v${room.count / 2}比赛即将开始!`
-            }}</text>
-            <text v-if="room.battleType === 2">大乱斗即将开始! </text>
+            <text class="guide-tips__target">请使用{{ targetSizeLabel }}全环靶</text>
+            <text class="guide-tips__warn">如果实际靶纸与选择靶纸不同，将导致射箭无效</text>
           </view>
         </view>
       </GuideTwo>
@@ -299,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" />
@@ -324,13 +618,14 @@ 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" />
               <text v-if="owner.id === item.id">管理员</text>
-              <button v-if="owner.id !== item.id && item.id" hover-class="none" class="remove-player"
+              <!-- 仅房主可见踢人按钮，且不能踢自己 -->
+              <button v-if="owner.id !== item.id && item.id && owner.id === user.id" hover-class="none" class="remove-player"
                 @click="() => removePlayer(item)" :style="{ top: '-10rpx', right: '-10rpx' }">
                 <image src="../static/close-white.png" mode="widthFix" />
               </button>
@@ -343,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>
@@ -355,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>
@@ -370,10 +683,14 @@ onBeforeUnmount(() => {
           </view>
         </view>
       </block>
+      <!-- isOwner：当前用户是房主时才展示踢人按钮 -->
       <PlayerSeats v-if="room.battleType === 2" :total="room.count || 10" :players="players"
-        :removePlayer="removePlayer" />
+        :removePlayer="removePlayer" :isOwner="owner.id === user.id" />
       <view>
-        <SButton :disabled="!canClick" :onClick="getReady">
+        <SButton
+          :disabled="!canClick || readySubmitting"
+          :onClick="() => { $clickSound(); return getReady(); }"
+        >
           {{
             allReady.value
               ? "即将进入对局..."
@@ -386,6 +703,14 @@ onBeforeUnmount(() => {
       </view>
     </view>
   </Container>
+  <ModalDialog
+    :show="showLimitModal"
+    :content="'今日约战次数已经用完\n开通会员可增加次数'"
+    cancelText="知道了"
+    confirmText="去开通"
+    :onCancel="closeLimitModal"
+    :onConfirm="goVipPage"
+  />
   <!-- 踢出玩家二次确认弹窗（不传 onClose，屏蔽 X 关闭按钮） -->
   <ScreenHint :show="showKickConfirm">
     <view class="kick-confirm">
@@ -484,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;
@@ -496,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;
@@ -743,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;
@@ -785,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;
@@ -804,4 +1140,23 @@ onBeforeUnmount(() => {
   border: 1rpx solid #a3793f66;
   color: #fed847;
 }
+
+.guide-tips__target {
+  font-weight: 400;
+  font-size: 26rpx;
+  color: rgba(255, 217, 71, 0.8);
+}
+
+.guide-tips__warn {
+  font-weight: 400;
+  font-size: 22rpx;
+  color: rgba(255, 255, 255, 0.8);
+  margin-top: 6rpx;
+}
+
+.guide-tips {
+  display: flex;
+  flex-direction: column;
+  padding-left: 20rpx;
+}
 </style>

src/pages/be-vip.vue

@@ -1,258 +0,0 @@
-<script setup>
-import { ref, onMounted, onBeforeUnmount } from "vue";
-import Container from "@/components/Container.vue";
-import Avatar from "@/components/Avatar.vue";
-import SButton from "@/components/SButton.vue";
-import Signin from "@/components/Signin.vue";
-import UserHeader from "@/components/UserHeader.vue";
-import { createOrderAPI, getHomeData, getVIPDescAPI } from "@/apis";
-import { formatTimestamp } from "@/util";
-import useStore from "@/store";
-import { storeToRefs } from "pinia";
-const store = useStore();
-const { user, config } = storeToRefs(store);
-const { updateUser } = store;
-
-const selectedVIP = ref(0);
-const showModal = ref(false);
-const lastDate = ref(user.value.expiredAt);
-const refreshing = ref(false);
-const timer = ref(null);
-const richContent = ref("");
-
-const onPay = async () => {
-  if (!user.value.id) {
-    showModal.value = true;
-  } else if (config.value.vipMenus[selectedVIP.value]) {
-    if (config.value.vipMenus[selectedVIP.value].id) {
-      const result = await createOrderAPI(
-        config.value.vipMenus[selectedVIP.value].id
-      );
-      if (!result.pay) return;
-      const params = result.pay.order.jsApi.params;
-      if (params) {
-        wx.requestPayment({
-          timeStamp: params.timeStamp, // 时间戳
-          nonceStr: params.nonceStr, // 随机字符串
-          package: params.package, // 统一下单接口返回的 prepay_id 参数值，格式：prepay_id=***
-          paySign: params.paySign, // 签名
-          signType: "RSA", // 签名类型，默认为RSA
-          async success(res) {
-            uni.showToast({
-              title: "支付成功",
-              icon: "none",
-            });
-            timer.value = setInterval(async () => {
-              refreshing.value = true;
-              const result = await getHomeData();
-              if (result.user.expiredAt > lastDate.value) {
-                refreshing.value = false;
-                if (result.user) updateUser(result.user);
-                clearInterval(timer.value);
-              }
-            }, 1000);
-          },
-          fail(res) {
-            console.log("pay error", res);
-          },
-        });
-      }
-    }
-  }
-};
-
-onMounted(async () => {
-  const result = await getVIPDescAPI();
-  richContent.value = result.describe;
-});
-
-const toOrderPage = () => {
-  uni.navigateTo({
-    url: "/pages/orders",
-  });
-};
-
-onBeforeUnmount(() => {
-  if (timer.value) clearInterval(timer.value);
-});
-</script>
-
-<template>
-  <Container title="会员说明">
-    <view v-if="user.id" class="header">
-      <view>
-        <Avatar :src="user.avatar" :size="35" />
-        <text class="truncate">{{ user.nickName }}</text>
-        <image
-          class="user-name-image"
-          src="../static/vip1.png"
-          mode="widthFix"
-        />
-      </view>
-      <block v-if="refreshing">
-        <image
-          src="../static/btn-loading.png"
-          mode="widthFix"
-          class="loading"
-        />
-      </block>
-      <block v-else>
-        <text v-if="user.expiredAt">
-          {{ formatTimestamp(user.expiredAt) }} 到期
-        </text>
-      </block>
-    </view>
-    <view
-      class="container"
-      :style="{ height: !user.id ? 'calc(100% - 10px)' : 'calc(100% - 62px)' }"
-    >
-      <view class="content vip-content">
-        <view class="title-bar">
-          <view />
-          <text>VIP 介绍</text>
-        </view>
-        <view :style="{ marginTop: '10rpx' }">
-          <rich-text :nodes="richContent" />
-        </view>
-      </view>
-      <view class="content">
-        <view class="title-bar">
-          <view />
-          <text>会员续费</text>
-        </view>
-        <view class="vip-items">
-          <view
-            v-for="(item, index) in config.vipMenus || []"
-            :key="index"
-            :style="{
-              color: selectedVIP === index ? '#fff' : '#333333',
-              borderColor: selectedVIP === index ? '#FF7D57' : '#eee',
-              background:
-                selectedVIP === index
-                  ? '#FF7D57'
-                  : 'linear-gradient(180deg, #fbfbfb 0%, #f5f5f5 100%)',
-            }"
-            @click="() => (selectedVIP = index)"
-          >
-            {{ item.name }}
-          </view>
-        </view>
-      </view>
-      <SButton :onClick="onPay">支付</SButton>
-      <view class="my-orders" v-if="user.id">
-        <view @click="toOrderPage">
-          <text>我的订单</text>
-          <image src="../static/enter-arrow-blue.png" mode="widthFix" />
-        </view>
-      </view>
-      <Signin :show="showModal" :onClose="() => (showModal = false)" />
-    </view>
-  </Container>
-</template>
-
-<style scoped>
-.header {
-  width: calc(100% - 30px);
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  color: #fff;
-  padding: 15px;
-  padding-top: 0;
-  font-size: 14px;
-}
-.header > view {
-  display: flex;
-  align-items: center;
-}
-.header > view > text {
-  margin-left: 10px;
-  max-width: 120px;
-  text-align: left;
-}
-.header > view > image {
-  margin-left: 5px;
-  width: 20px;
-}
-.header > text:nth-child(2) {
-  color: #fed847;
-}
-.container {
-  width: 100%;
-  background-color: #f5f5f5;
-  padding-top: 10px;
-}
-.content {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  background-color: #fff;
-  padding: 15px;
-  margin-bottom: 10px;
-}
-.title-bar {
-  width: 100%;
-  display: flex;
-  align-items: center;
-  color: #000;
-}
-.title-bar > view:first-child {
-  width: 5px;
-  height: 15px;
-  border-radius: 10px;
-  background-color: #fed847;
-  margin-right: 10px;
-}
-.content > view:nth-child(2) {
-  font-size: 14px;
-  color: #333;
-}
-.vip-items {
-  width: 100%;
-  display: grid;
-  grid-template-columns: repeat(4, 23.5%);
-  padding: 10px;
-  row-gap: 5%;
-  column-gap: 2%;
-}
-.vip-items > view {
-  border: 1px solid #eee;
-  padding: 12px 0;
-  border-radius: 10px;
-  text-align: center;
-  font-size: 27rpx;
-}
-.vip-content {
-  max-height: 62%;
-}
-.vip-content > view:nth-child(2) {
-  overflow: auto;
-}
-.vip-content > view:nth-child(2)::-webkit-scrollbar {
-  width: 0;
-  height: 0;
-  color: transparent;
-}
-.my-orders {
-  display: flex;
-  justify-content: center;
-  color: #39a8ff;
-  margin-top: 10px;
-  font-size: 13px;
-}
-.my-orders > view {
-  display: flex;
-  align-items: center;
-}
-.my-orders > view > image {
-  width: 15px;
-}
-.loading {
-  width: 20px;
-  height: 20px;
-  margin-left: 10px;
-  transition: all 0.3s ease;
-  background-blend-mode: darken;
-  animation: rotate 2s linear infinite;
-}
-</style>

src/pages/device-intro.vue

@@ -33,7 +33,7 @@ const onScrollView = (e) => {
     >
       <image
         :style="{ opacity: addBg ? 1 : 0 }"
-        src="../static/app-bg.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/app-bg.png"
         mode="widthFix"
       />
       <navigator open-type="navigateBack">

src/pages/first-try.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { ref, onMounted, onBeforeUnmount } from "vue";
+import { computed, ref, onMounted, onBeforeUnmount } from "vue";
 import Guide from "@/components/Guide.vue";
 import SButton from "@/components/SButton.vue";
 import Swiper from "@/components/Swiper.vue";
@@ -15,23 +15,27 @@ 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 { 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);
 const total = 12;
 const stepButtonTexts = [
   "开始",
   "进入下一个任务",
+  "我已校准",
   "进入下一个任务",
   "我准备好了，开始",
   "",
@@ -43,8 +47,13 @@ const practiseResult = ref({});
 const btnDisabled = ref(false);
 const practiseId = ref("");
 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",
   "https://static.shelingxingqiu.com/attachment/2026-02-08/dg9ev0wwdpgwt9e6du.png",
   "https://static.shelingxingqiu.com/attachment/2026-02-08/dg9ev0wvv9sw4zioqk.png",
   "https://static.shelingxingqiu.com/attachment/2026-02-08/dg9ev0ww3khaycallu.png",
@@ -54,28 +63,97 @@ const guideImages = [
   "https://static.shelingxingqiu.com/attachment/2026-02-08/dg9ev0wwr6hfjhyfn5.png",
 ];
 
+const calibrationGuides = [
+  {
+    title: "箭头面向靶子",
+    src: "https://static.shelingxingqiu.com/attachment/2025-10-30/ddv9p5fk5wscg7hrfo.png",
+  },
+  {
+    title: "摆出拉弓姿势",
+    src: "https://static.shelingxingqiu.com/attachment/2025-10-30/ddv9p5fk5b7ljrhx3o.png",
+  },
+  {
+    title: "调整瞄准器",
+    src: "https://static.shelingxingqiu.com/attachment/2025-10-29/dduexjgrcxf9wjaiv4.png",
+  },
+];
+
 const onSwiperIndexChange = (index) => {
-  if (index + 1 === guideImages.length) {
-    showGuide.value = true;
-  }
+  guideSwiperIndex.value = index;
+  showGuide.value = index + 1 === guideImages.length;
+};
+
+const isGuideLastImage = computed(
+  () => guideSwiperIndex.value + 1 === guideImages.length
+);
+
+const currentStepButtonText = computed(() => {
+  if (step.value === 1 && isGuideLastImage.value) return "去校准智能弓";
+  return stepButtonTexts[step.value];
+});
+
+const openCalibrationLaser = async () => {
+  if (laserActive.value) return;
+  await laserAimAPI();
+  laserActive.value = true;
+};
+
+const closeCalibrationLaser = async () => {
+  if (!laserActive.value) return;
+  await laserCloseAPI();
+  laserActive.value = false;
 };
 
 const createPractise = async (arrows) => {
-  const result = await createPractiseAPI(arrows, 1);
+  closeMatchWebSocket({ reason: "practice-recreate" });
+  const result = await createPractiseAPI(
+    arrows,
+    120,
+    1,
+    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) {
-    scores.value = msg.details;
+    isSvip.value = msg.sVip === true;
+    scores.value = Array.isArray(msg.details) ? msg.details : scores.value;
   } else if (msg.type === MESSAGETYPESV2.BattleEnd) {
-    setTimeout(onOver, 1500);
-  } else if (msg.type === MESSAGETYPESV2.TestDistance) {
+    setTimeout(() => onOver(msg), 1500);
+  } else if (msg.type === MESSAGETYPESV2.TestDistance && step.value === 3) {
     if (msg.shootData.distance / 100 >= 5) {
       audioManager.play("距离合格");
       btnDisabled.value = false;
@@ -98,11 +176,23 @@ async function onReceiveMessage(msg) {
 }
 
 const onClickShare = debounce(async () => {
-  await sharePractiseData("shareCanvas", 1, user.value, practiseResult.value);
-  await wxShare("shareCanvas");
+  if (sharing.value) return;
+  sharing.value = true;
+  try {
+    await sharePractiseData("shareCanvas", 1, user.value, practiseResult.value);
+    await wxShare("shareCanvas");
+  } catch (e) {
+    uni.showToast({
+      title: "海报生成失败，请稍后重试",
+      icon: "none",
+    });
+  } finally {
+    sharing.value = false;
+  }
 });
 
 onMounted(() => {
+  void audioManager.warmAll();
   uni.setKeepScreenOn({
     keepScreenOn: true,
   });
@@ -110,41 +200,59 @@ onMounted(() => {
   uni.$on("share-image", onClickShare);
 });
 
-onBeforeUnmount(() => {
+onBeforeUnmount(async () => {
   uni.setKeepScreenOn({
     keepScreenOn: false,
   });
   uni.$off("socket-inbox", onReceiveMessage);
   uni.$off("share-image", onClickShare);
+  await closeCalibrationLaser();
   audioManager.stopAll();
-  endPractiseAPI();
+  closeMatchWebSocket({ reason: "practice-leave" });
 });
 
 const nextStep = async () => {
   if (step.value === 0) {
     step.value = 1;
-    title.value = "-凹造型";
+    title.value = "-箭前准备";
   } else if (step.value === 1) {
+    if (!isGuideLastImage.value) {
+      guideSwiperIndex.value += 1;
+      showGuide.value = guideSwiperIndex.value + 1 === guideImages.length;
+      return;
+    }
+    showGuide.value = false;
+    step.value = 2;
+    // title.value = "-校准智能弓";
+    await openCalibrationLaser();
+  } else if (step.value === 2) {
+    await closeCalibrationLaser();
     showGuide.value = false;
     btnDisabled.value = true;
-    step.value = 2;
-    title.value = "-感知距离";
-    const result = await createPractiseAPI(total, 120);
-    if (result) practiseId.value = result.id;
-  } else if (step.value === 2) {
-    showGuide.value = false;
     step.value = 3;
-    title.value = "-小试牛刀";
+    title.value = "-感知距离";
+    const result = await createPractise(total);
+    if (!result) {
+      btnDisabled.value = false;
+      step.value = 2;
+      return;
+    }
   } else if (step.value === 3) {
-    title.value = "小试牛刀";
-    await startPractiseAPI();
-    scores.value = [];
+    showGuide.value = false;
     step.value = 4;
+    title.value = "-小试牛刀";
+  } else if (step.value === 4) {
+    title.value = "小试牛刀";
+    const result = await beginPractise();
+    if (!result) return;
+    scores.value = [];
+    isSvip.value = false;
+    step.value = 5;
     start.value = true;
     setTimeout(() => {
       uni.$emit("play-sound", "请开始射击");
     }, 300);
-  } else if (step.value === 5) {
+  } else if (step.value === 6) {
     uni.navigateBack({
       delta: 1,
     });
@@ -159,28 +267,35 @@ const onClose = async () => {
     setTimeout(() => {
       practiseResult.value = {};
       showGuide.value = false;
-      step.value = 5;
+      step.value = 6;
     }, 500);
   } else {
     practiseResult.value = {};
     start.value = false;
     scores.value = [];
-    step.value = 3;
-    const result = await createPractiseAPI(total, 120);
-    if (result) practiseId.value = result.id;
+    isSvip.value = false;
+    step.value = 4;
+    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>
-  <Container :bgType="1" :title="title" :showBottom="step !== 4">
+  <Container :bgType="1" :title="title" :showBottom="step !== 5">
     <view class="container">
       <Guide
-        v-if="step !== 4"
+        v-if="step !== 5"
         :type="
-          step === 2
+          step === 3
             ? 2
-            : step === 5 || (step === 0 && user.nickName.length > 6)
+            : step === 6 || (step === 0 && user.nickName.length > 6)
             ? 1
             : 0
         "
@@ -196,25 +311,28 @@ const onClose = async () => {
           ，这是新人必刷小任务，0基础小白也能快速掌握弓箭技巧和游戏规则哦~：）
         </text>
         <text v-if="step === 1" :style="{ fontSize: '28rpx' }"
-          >这是我们人帅技高的高教练。首先，请按教练示范，尝试自己去做这些动作和手势吧。</text
+          >这位就是人帅技高的高教练！接下来请跟随教练指引，做好射箭前期准备。</text
+        >
+        <text v-if="step === 2" :style="{ fontSize: '28rpx' }"
+          >请按下方步骤完成智能弓校准，让瞄准器和靶子保持对齐。</text
         >
         <view
           class="guide-tips"
           :style="{ marginTop: '8rpx' }"
-          v-if="step === 2"
+          v-if="step === 3"
         >
           <text>你知道5米射程有多远吗？</text>
           <text>
             在我们的排位赛中，射程小于5米的成绩无效、哦！建议平时练习距离至少5米。现在，来边射箭边调整你的站位点吧！
           </text>
         </view>
-        <view class="guide-tips" v-if="step === 3">
+        <view class="guide-tips" v-if="step === 4">
           <text>一切准备就绪</text>
           <text :style="{ fontSize: '28rpx' }"
             >试着完成一个真正的弓箭手任务吧！</text
           >
         </view>
-        <view class="guide-tips" v-if="step === 5">
+        <view class="guide-tips" v-if="step === 6">
           <text>新手试炼场通关啦，优秀！</text>
           <text :style="{ fontSize: '28rpx' }"
             >反曲弓运动基本知识和射灵世界系统规则你已Get，是不是挺容易呀：）</text
@@ -231,35 +349,54 @@ const onClose = async () => {
         src="https://static.shelingxingqiu.com/attachment/2025-11-17/deas80ef1sf9td0leq.png"
         class="try-tip"
         mode="widthFix"
-        v-if="step === 3"
+        v-if="step === 4"
       />
       <image
         src="https://static.shelingxingqiu.com/attachment/2025-07-01/db0ehpz9lav58g5drl.png"
         class="try-tip"
         mode="widthFix"
-        v-if="step === 5"
+        v-if="step === 6"
       />
       <view style="height: 570px" v-if="step === 1">
-        <Swiper :onChange="onSwiperIndexChange" :data="guideImages" />
+        <Swiper
+          :current="guideSwiperIndex"
+          :onChange="onSwiperIndexChange"
+          :data="guideImages"
+        />
       </view>
-      <ShootProgress v-if="step === 4" tips="请开始连续射箭" :start="start" />
-      <TestDistance v-if="step === 2" :guide="false" />
+      <view class="calibration-container" v-if="step === 2">
+        <view
+          v-for="(guide, index) in calibrationGuides"
+          :key="guide.title"
+          class="calibration-guide"
+        >
+          <view>
+            <text>{{ index + 1 }}</text>
+            <text>{{ guide.title }}</text>
+          </view>
+          <image :src="guide.src" mode="widthFix" />
+        </view>
+        <text>请完成以上步骤校准智能弓</text>
+      </view>
+      <ShootProgress v-if="step === 5" tips="请开始连续射箭" :start="start" />
+      <TestDistance v-if="step === 3" :guide="false" />
       <view
         class="user-row"
-        v-if="step === 4"
-        :style="{ marginBottom: step === 2 ? '40px' : '0' }"
+        v-if="step === 5"
+        :style="{ marginBottom: '0' }"
       >
         <Avatar :src="user.avatar" :size="35" />
         <BowPower />
       </view>
       <BowTarget
-        v-if="step === 4"
-        :currentRound="step === 4 ? scores.length : 0"
-        :totalRound="step === 4 ? total : 0"
+        v-if="step === 5"
+        :currentRound="step === 5 ? scores.length : 0"
+        :totalRound="step === 5 ? total : 0"
         :scores="scores"
+        :isSvip="isSvip"
       />
       <ScorePanel
-        v-if="step === 4"
+        v-if="step === 5"
         :total="total"
         :rowCount="6"
         :arrows="scores"
@@ -270,13 +407,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>
@@ -287,7 +418,7 @@ const onClose = async () => {
             step === 1 ? "学会了，我摆得比教练还帅" : "我找到合适的点位了"
           }}</text>
         </BubbleTip>
-        {{ stepButtonTexts[step] }}
+        {{ currentStepButtonText }}
       </SButton>
     </template>
   </Container>
@@ -301,4 +432,43 @@ const onClose = async () => {
   width: calc(100% - 20px);
   margin: 0 10px;
 }
+.calibration-container {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+.calibration-guide {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  font-size: 26rpx;
+  color: #ffffff;
+  margin-bottom: 15rpx;
+}
+.calibration-guide > view {
+  width: 100%;
+  margin: 25rpx 0;
+  display: flex;
+  align-items: center;
+}
+.calibration-guide > view > text:first-child {
+  font-size: 24rpx;
+  background: #e89024;
+  border-radius: 50%;
+  width: 32rpx;
+  height: 32rpx;
+  line-height: 32rpx;
+  display: block;
+  text-align: center;
+  margin-right: 15rpx;
+}
+.calibration-guide > image {
+  width: 630rpx;
+  height: 250rpx;
+}
+.calibration-container > text {
+  font-size: 24rpx;
+  color: #fff9;
+  margin: 30rpx;
+}
 </style>

src/pages/friend-battle.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { ref } from "vue";
+import { computed, ref } from "vue";
 import { onLoad, onShow } from "@dcloudio/uni-app";
 import Container from "@/components/Container.vue";
 import GuideTwo from "@/components/GuideTwo.vue";
@@ -8,14 +8,16 @@ import SModal from "@/components/SModal.vue";
 import Signin from "@/components/Signin.vue";
 import CreateRoom from "@/components/CreateRoom.vue";
 import Avatar from "@/components/Avatar.vue";
+import ModalDialog from "@/components/ModalDialog.vue";
 
-import { getRoomAPI, joinRoomAPI, getBattleDataAPI } from "@/apis";
-import { debounce, canEenter } from "@/util";
+import { getRoomAPI, joinRoomAPI, getBattleDataAPI, getDailyCountAPI } from "@/apis";
+import { debounce, canEenter, getLimitCountText, isLimitReached } from "@/util";
 
 import useStore from "@/store";
 import { storeToRefs } from "pinia";
 const store = useStore();
-const { user, device, online, game } = storeToRefs(store);
+const { user, device, online, game, dailyCount } = storeToRefs(store);
+const { updateDailyCount } = store;
 
 const showModal = ref(false);
 const showSignin = ref(false);
@@ -24,6 +26,13 @@ const roomNumber = ref("");
 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(() =>
+  getLimitCountText("约战", dailyCount.value.challenge)
+);
 
 const enterRoom = debounce(async (number) => {
   if (loading.value) return;
@@ -37,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) {
@@ -55,18 +66,55 @@ 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;
-  warnning.value = "";
-  showModal.value = true;
+  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;
+  }
+});
+
+const closeLimitModal = () => {
+  showLimitModal.value = false;
+};
+
+const goVipPage = () => {
+  showLimitModal.value = false;
+  uni.navigateTo({
+    url: "/pages/member/be-vip",
+  });
+};
+
+const loadDailyCount = async () => {
+  if (!user.value.id) return dailyCount.value;
+  try {
+    const result = await getDailyCountAPI();
+    updateDailyCount(result);
+    return result || dailyCount.value;
+  } catch (error) {
+    console.log("load daily count error", error);
+    return dailyCount.value;
+  }
 };
 const onSignin = () => {
   if (roomID.value && user.value.id) enterRoom(roomID.value);
@@ -80,8 +128,12 @@ const goMyRecord = () => {
   });
 };
 onShow(async () => {
+  loading.value = false;
   if (user.value.id) {
-    const result = await getBattleDataAPI();
+    const [result] = await Promise.all([
+      getBattleDataAPI(),
+      loadDailyCount(),
+    ]);
     data.value = result;
   }
 });
@@ -98,13 +150,26 @@ onLoad(async (options) => {
   <Container title="好友约战" :showBackToGame="true">
     <view :style="{ width: '100%', height: '100%' }">
       <GuideTwo>
-        <text :style="{color: 'rgba(255,217,71,0.8)'}">约上朋友开几局，欢乐多，不寂寞</text>
-        <text>一起练升级更快，早日加入全国排位赛！</text>
+        <view class="guide-tips">
+          <text class="guide-tips__main">约上朋友开几局，欢乐多，不寂寞</text>
+          <text class="guide-tips__sub">一起练升级更快，早日加入全国排位赛！</text>
+        </view>
       </GuideTwo>
       <view class="my-data">
         <view>
           <Avatar :rankLvl="user.rankLvl" :src="user.avatar" :size="30" />
-          <text class="truncate">{{ user.nickName }}</text>
+          <view
+            :class="[
+              'member-nickname',
+              isVip ? 'member-nickname--vip' : '',
+              isSVip ? 'member-nickname--svip' : '',
+            ]"
+          >
+            <text class="member-nickname__text">{{ user.nickName }}</text>
+            <text v-if="isSVip" class="member-nickname__shine">{{
+              user.nickName
+            }}</text>
+          </view>
           <text class="my-record-btn" @click="goMyRecord">我的战绩</text>
         </view>
         <view>
@@ -139,21 +204,29 @@ onLoad(async (options) => {
         <image src="../static/founded-room.png" mode="widthFix" />
         <view>
           <input placeholder="输入房间号" v-model="roomNumber" placeholder-style="color: #ccc" />
-          <view @click="enterRoom(roomNumber)">进入房间</view>
+          <view @click="$clickSound(() => enterRoom(roomNumber))">进入房间</view>
         </view>
       </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>
         </view>
         <view>
-          <SButton width="80%" :rounded="30" :onClick="onCreateRoom">
+          <view v-if="challengeLimitText" class="pp-text">
+            {{ challengeLimitText }}
+          </view>
+          <SButton
+            width="80%"
+            :rounded="30"
+            :disabled="createRoomLoading"
+            :onClick="() => { $clickSound(); return onCreateRoom(); }"
+          >
             创建约战房
           </SButton>
         </view>
@@ -162,14 +235,41 @@ onLoad(async (options) => {
         <view v-if="warnning" class="warnning">
           {{ warnning }}
         </view>
-        <CreateRoom v-if="!warnning" :onConfirm="() => (showModal = false)" />
+        <!-- showModal 关闭时立即销毁组件，重开时重建，确保选项重置为 0 -->
+        <CreateRoom v-if="!warnning && showModal" :onConfirm="() => (showModal = false)" />
       </SModal>
       <Signin :show="showSignin" :onClose="onSignin" />
     </view>
   </Container>
+  <ModalDialog
+    :show="showLimitModal"
+    :content="'今日约战次数已经用完\n开通会员可增加次数'"
+    cancelText="知道了"
+    confirmText="去开通"
+    :onCancel="closeLimitModal"
+    :onConfirm="goVipPage"
+  />
 </template>
 
 <style scoped>
+.guide-tips {
+  display: flex;
+  flex-direction: column;
+  padding-left: 112rpx;
+  width: 100%;
+}
+.guide-tips__main {
+  font-weight: 400;
+  font-size: 26rpx;
+  color: rgba(255, 217, 71, 0.8);
+}
+.guide-tips__sub {
+  font-weight: 400;
+  font-size: 22rpx;
+  color: rgba(255, 255, 255, 0.8);
+  margin-top: 6rpx;
+}
+
 .founded-room {
   display: flex;
   flex-direction: column;
@@ -234,7 +334,7 @@ onLoad(async (options) => {
 }
 
 .create-room>view:nth-child(3) {
-  margin: 12vw auto;
+  margin: 12vw auto 5vw auto;
   position: relative;
   display: flex;
   align-items: center;
@@ -270,6 +370,13 @@ onLoad(async (options) => {
   margin-right: 2px;
 }
 
+.pp-text{
+  color: #fff;
+  text-align: center;
+  font-size: 22rpx;
+  margin-bottom: 20rpx;
+}
+
 .warnning {
   width: 100%;
   height: 100%;
@@ -314,13 +421,17 @@ onLoad(async (options) => {
   margin-left: auto;
 }
 
-.my-data>view:first-child>text {
+.my-data>view:first-child>.member-nickname {
   color: #fff;
-  font-size: 17px;
   margin-left: 10px;
   width: 120px;
 }
 
+.my-data>view:first-child>.member-nickname__text,
+.my-data>view:first-child>.member-nickname__shine {
+  font-size: 17px;
+}
+
 .my-data>view:last-child {
   margin-bottom: 15px;
 }

src/pages/grade-intro.vue

@@ -1,31 +1,66 @@
 <script setup>
+import { computed } from "vue";
 import Container from "@/components/Container.vue";
 import useStore from "@/store";
 import { storeToRefs } from "pinia";
 const store = useStore();
 const { user } = storeToRefs(store);
+
+const MAX_LEVEL = 100;
+const LEVEL_NODE_WIDTH_RPX = 72;
+const TRACK_PADDING_RPX = 20;
+const windowWidth = uni.getSystemInfoSync().windowWidth;
+const rpxToPx = (value) => (value * windowWidth) / 750;
+const levels = Array.from({ length: MAX_LEVEL }, (_, index) => index + 1);
+const currentLevel = computed(() => {
+  const level = Number(user.value?.lvl) || 1;
+  return Math.min(Math.max(level, 1), MAX_LEVEL);
+});
+const currentLevelScrollLeft = computed(() => {
+  const nodeWidth = rpxToPx(LEVEL_NODE_WIDTH_RPX);
+  const trackPadding = rpxToPx(TRACK_PADDING_RPX);
+  const contentWidth = rpxToPx(
+    TRACK_PADDING_RPX * 2 + MAX_LEVEL * LEVEL_NODE_WIDTH_RPX
+  );
+  const currentCenter =
+    trackPadding + (currentLevel.value - 1) * nodeWidth + nodeWidth / 2;
+  const targetLeft = currentCenter - windowWidth / 2;
+  const maxScrollLeft = Math.max(contentWidth - windowWidth, 0);
+
+  return Math.min(Math.max(targetLeft, 0), maxScrollLeft);
+});
 </script>
 
 <template>
   <Container title="等级介绍">
     <view class="container">
       <!-- 等级进度条 -->
-      <view class="level-progress">
-        <view v-for="(_, index) in 10" :key="index" class="progress-dot">
+      <scroll-view
+        class="level-progress"
+        scroll-x
+        :show-scrollbar="false"
+        :scroll-left="currentLevelScrollLeft"
+        scroll-with-animation
+      >
+        <view class="level-track">
           <view
-            :style="{
-              backgroundColor:
-                index + 1 < user.lvl
-                  ? '#fff9'
-                  : index + 1 === user.lvl
-                  ? '#fed847'
-                  : 'transparent',
-              borderColor: index + 1 === user.lvl ? '#fed847' : '#fff9',
-            }"
-          />
-          <view />
+            v-for="level in levels"
+            :id="`level-${level}`"
+            :key="level"
+            :class="[
+              'level-node',
+              level < currentLevel ? 'level-node--done' : '',
+              level === currentLevel ? 'level-node--current' : '',
+            ]"
+          >
+            <view class="level-node__top">
+              <view class="level-node__dot" />
+              <view v-if="level < MAX_LEVEL" class="level-node__line" />
+            </view>
+            <text class="level-node__label">{{ level }}</text>
+          </view>
         </view>
-      </view>
+      </scroll-view>
 
       <!-- 说明文本 -->
       <view class="body">
@@ -65,28 +100,80 @@ const { user } = storeToRefs(store);
 
 .level-progress {
   width: 100%;
-  height: 32rpx;
-  display: flex;
-  justify-content: center;
-  padding-top: 20rpx;
-  padding-bottom: 40rpx;
+  white-space: nowrap;
+  padding: 24rpx 0 34rpx;
+  box-sizing: border-box;
 }
 
-.progress-dot {
+.level-track {
+  display: inline-flex;
+  align-items: flex-start;
+  padding-left: 20rpx;
+  padding-right: 20rpx;
+}
+
+.level-node {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  width: 72rpx;
+  flex: 0 0 72rpx;
+}
+
+.level-node__top {
   display: flex;
   align-items: center;
+  width: 100%;
 }
-.progress-dot > view:first-child {
-  width: 3.8vw;
-  height: 3.8vw;
+
+.level-node__dot {
+  width: 28rpx;
+  height: 28rpx;
   border-radius: 50%;
-  border: 1px solid #fff9;
+  border: 3rpx solid rgba(255, 255, 255, 0.45);
+  box-sizing: border-box;
 }
-.progress-dot > view:last-child {
-  width: 3.8vw;
-  height: 1px;
-  margin: 0 2px;
-  background-color: #fff9;
+
+.level-node__line {
+  flex: 1;
+  height: 2rpx;
+  background-color: rgba(255, 255, 255, 0.45);
+}
+
+.level-node__label {
+  width: 28rpx;
+  margin-top: 14rpx;
+  color: rgba(255, 255, 255, 0.45);
+  font-size: 24rpx;
+  line-height: 28rpx;
+  text-align: center;
+}
+
+.level-node--done .level-node__dot {
+  background-color: #ffffff;
+  border-color: #ffffff;
+}
+
+.level-node--done .level-node__line {
+  background-color: rgba(255, 255, 255, 0.8);
+}
+
+.level-node--done .level-node__label {
+  color: rgba(255, 255, 255, 0.72);
+}
+
+.level-node--current .level-node__dot {
+  background-color: #fed847;
+  border-color: #fed847;
+}
+
+.level-node--current .level-node__line {
+  background-color: rgba(255, 255, 255, 0.45);
+}
+
+.level-node--current .level-node__label {
+  color: #fed847;
+  font-weight: 700;
 }
 
 .body {

src/pages/index.vue

@@ -1,19 +1,23 @@
 <script setup>
-import {onMounted, ref} from "vue";
+import {onMounted, onUnmounted, ref} from "vue";
 import {onShareAppMessage, onShareTimeline, onShow} from "@dcloudio/uni-app";
 import Container from "@/components/Container.vue";
 import AppFooter from "@/components/AppFooter.vue";
 import UserHeader from "@/components/UserHeader.vue";
 import Signin from "@/components/Signin.vue";
 import BubbleTip from "@/components/BubbleTip.vue";
+import OtaModal from "@/components/OtaModal.vue";
 
 import {
   checkUserBindAPI,
   getAppConfig,
   getDeviceBatteryAPI,
+  getHardwareBoxTaskStatusAPI,
+  getHardwareBoxVersionAPI,
   getHomeData,
   getMyDevicesAPI,
-  getRankListAPI,
+  getScoreRankList,
+  sendHardwareBoxUpdateAPI,
   silentLoginAPI,
 } from "@/apis";
 import {topThreeColors} from "@/constants";
@@ -26,26 +30,232 @@ const {
   updateConfig,
   updateUser,
   updateDevice,
-  updateRank,
+  clearDevice,
   getLvlName,
   getLvlNameByScore,
   updateOnline,
 } = store;
-const {user, device, rankData, online, game} = storeToRefs(store);
+const {user, device, online, game} = storeToRefs(store);
 
 const showModal = ref(false);
 const showGuide = ref(false);
+const scoreRankList = ref([]);
+
+// OTA 相关
+const otaVisible = ref(false);
+const otaState = ref("new_version");
+const otaProgress = ref(0);
+const otaInfo = ref({
+  versionNumber: "",
+  versionInfo: "",
+  resourceUrl: "",
+  forceUpdate: false,
+});
+const isStartingOta = ref(false);
+let otaProgressTimer = null;
+let otaStatusTimer = null;
+let otaTimeoutTimer = null;
+
+// 清理首页 OTA 更新定时器，避免弹窗关闭或页面卸载后继续轮询。
+const clearOtaUpdateTimers = () => {
+  clearInterval(otaProgressTimer);
+  clearTimeout(otaStatusTimer);
+  clearTimeout(otaTimeoutTimer);
+  otaProgressTimer = null;
+  otaStatusTimer = null;
+  otaTimeoutTimer = null;
+};
+
+// 启动首页 OTA 本地进度动画，最终成功失败以后端任务状态为准。
+const startOtaProgressAnimation = () => {
+  clearInterval(otaProgressTimer);
+  otaProgressTimer = setInterval(() => {
+    if (otaProgress.value >= 90) {
+      clearInterval(otaProgressTimer);
+      return;
+    }
+    const increment = Math.max(0.5, 2 - otaProgress.value / 60);
+    otaProgress.value = Math.min(90, otaProgress.value + increment);
+  }, 500);
+};
+
+// 获取并保存后端返回的 OTA 版本信息，供弹窗展示和更新接口使用。
+const applyOtaVersionInfo = (versionInfo) => {
+  otaInfo.value = {
+    versionNumber: versionInfo?.versionNumber || "",
+    versionInfo: versionInfo?.versionInfo || "",
+    resourceUrl: versionInfo?.resourceUrl || "",
+    forceUpdate: Number(versionInfo?.forceUpdate) === 1,
+  };
+};
+
+// 检查当前设备盒子是否存在可升级版本。
+const checkOtaUpdate = async () => {
+  let versionInfo;
+  try {
+    versionInfo = await getHardwareBoxVersionAPI();
+  } catch (err) {
+    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;
+};
+
+// 拼接 OTA WiFi 页参数，让未连 WiFi 的设备继续使用同一份版本信息。
+const getOtaWifiUrl = () => {
+  const { versionNumber, resourceUrl } = otaInfo.value;
+  const query = [
+    `versionNumber=${encodeURIComponent(versionNumber)}`,
+    `resourceUrl=${encodeURIComponent(resourceUrl)}`,
+  ].join("&");
+  return `/pages/ota-wifi?${query}`;
+};
+
+// 处理 OTA 弹窗暂不更新，强制更新时不允许关闭。
+const handleOtaDismiss = () => {
+  if (otaInfo.value.forceUpdate) return;
+  uni.setStorageSync("ota_dismissed_at", Date.now());
+  otaVisible.value = false;
+};
+
+// 将首页 OTA 直连更新流程标记为失败。
+const failHomeOtaUpdate = () => {
+  clearOtaUpdateTimers();
+  isStartingOta.value = false;
+  otaState.value = "update_failure";
+  otaVisible.value = true;
+};
+
+// 将首页 OTA 直连更新流程标记为成功。
+const completeHomeOtaUpdate = () => {
+  clearOtaUpdateTimers();
+  isStartingOta.value = false;
+  otaProgress.value = 100;
+  setTimeout(() => {
+    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();
+    }
+  }, 3000);
+};
+
+// 设备盒子已连 WiFi 时，从首页直接传空 WiFi 信息发起 OTA 更新。
+const startHomeOtaUpdate = async () => {
+  otaState.value = "update_progress";
+  otaVisible.value = true;
+  otaProgress.value = 0;
+  startOtaProgressAnimation();
+  otaTimeoutTimer = setTimeout(() => {
+    if (otaState.value === "update_progress") {
+      failHomeOtaUpdate();
+    }
+  }, 5 * 60 * 1000);
+
+  try {
+    const updateResult = await sendHardwareBoxUpdateAPI({
+      versionNumber: otaInfo.value.versionNumber,
+      wifiSsid: "",
+      wifiPassword: "",
+      resourceUrl: otaInfo.value.resourceUrl,
+    });
+    if (!updateResult?.taskId) {
+      failHomeOtaUpdate();
+      return;
+    }
+    pollHomeOtaTaskStatus(updateResult.taskId);
+  } catch (err) {
+    failHomeOtaUpdate();
+  }
+};
+
+// 点击立即更新时先判断设备是否在线并已通过 WiFi 联网，已联网则首页直接更新，否则跳转 WiFi 页面。
+const handleOtaUpdate = async () => {
+  if (isStartingOta.value) return;
+  isStartingOta.value = true;
+  let deviceStatus;
+  try {
+    deviceStatus = await getDeviceBatteryAPI();
+  } catch (err) {
+    isStartingOta.value = false;
+    uni.showToast({
+      title: "获取设备状态失败，请重试",
+      icon: "none",
+    });
+    return;
+  }
+
+  if (deviceStatus?.online !== true) {
+    isStartingOta.value = false;
+    uni.showToast({
+      title: "请先开启智能弓",
+      icon: "none",
+    });
+    return;
+  }
+
+  if (String(deviceStatus?.netType || "").toLowerCase() === "wifi") {
+    startHomeOtaUpdate();
+    return;
+  }
+
+  isStartingOta.value = false;
+  otaVisible.value = false;
+  uni.navigateTo({ url: getOtaWifiUrl() });
+};
+
+// 处理 OTA 更新成功后的完成按钮，关闭结果弹窗。
+const handleOtaDone = () => {
+  otaVisible.value = false;
+};
+
+// 处理 OTA 更新失败后的重试按钮，重新走立即更新判断流程。
+const handleOtaRetry = () => {
+  handleOtaUpdate();
+};
+
+// 提取积分榜接口返回的榜单数组，兼容数组和对象两种返回格式。
+const getScoreRankData = (result) => {
+  if (Array.isArray(result)) return result;
+  if (Array.isArray(result?.list)) return result.list;
+  if (Array.isArray(result?.items)) return result.items;
+  return [];
+};
 
 const toPage = async (path) => {
   if (!user.value.id) {
     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});
 };
 
@@ -55,44 +265,53 @@ const toRankListPage = () => {
   });
 };
 
-onShow(async () => {
+onShow(async (options) => {
   const env = uni.getAccountInfoSync().miniProgram.envVersion;
   const token = uni.getStorageSync(`${env}_token`);
 
-  if (!user.value.id && !token) {
-    try {
-      const wxResult = await uni.login({provider: "weixin"});
-      const bindResult = await checkUserBindAPI(wxResult.code);
-      if (bindResult.binded) {
-        const newResult = await uni.login({provider: "weixin"});
-        const silentResult = await silentLoginAPI(newResult.code);
-        if (silentResult.user) updateUser(silentResult.user);
-        const devices = await getMyDevicesAPI();
-        if (devices.bindings && devices.bindings.length) {
-          updateDevice(
-              devices.bindings[0].deviceId,
-              devices.bindings[0].deviceName
-          );
-          const data = await getDeviceBatteryAPI();
-          updateOnline(data.online);
-        }
-      } else {
-        showModal.value = true;
-      }
-    } catch (e) {
-      console.log("检查绑定状态失败", e);
-    }
+  // 检查是否从 OTA 更新页面返回
+  if (options && options.updateResult) {
+    otaState.value = options.updateResult;
+    otaVisible.value = true;
+  } else if (token || user.value.id) {
+    await checkOtaUpdate();
   }
 
-  const promises = [getRankListAPI()];
+  if (!user.value.id && !token) {
+    // showModal.value = true;
+    // try {
+    //   const wxResult = await uni.login({provider: "weixin"});
+    //   const bindResult = await checkUserBindAPI(wxResult.code);
+    //   if (bindResult.binded) {
+    //     const newResult = await uni.login({provider: "weixin"});
+    //     const silentResult = await silentLoginAPI(newResult.code);
+    //     if (silentResult.user) updateUser(silentResult.user);
+    //     const devices = await getMyDevicesAPI();
+    //     if (devices.bindings && devices.bindings.length) {
+    //       updateDevice(
+    //           devices.bindings[0].deviceId,
+    //           devices.bindings[0].deviceName
+    //       );
+    //       const data = await getDeviceBatteryAPI();
+    //       updateOnline(data.online);
+    //     }
+    //   } else {
+    //     showModal.value = true;
+    //   }
+    // } catch (e) {
+    //   console.log("检查绑定状态失败", e);
+    // }
+  }
+
+  const promises = [getScoreRankList(undefined, 1, 10)];
   if (token || user.value.id) {
     promises.push(getHomeData());
   }
 
   const [rankList, homeData] = await Promise.all(promises);
 
-  console.log("排行数据", rankList);
-  updateRank(rankList);
+  console.log("积分榜数据", rankList);
+  scoreRankList.value = getScoreRankData(rankList).slice(0, 10);
 
   if (homeData) {
     console.log("首页数据：", homeData);
@@ -118,6 +337,8 @@ onShow(async () => {
         );
         const data = await getDeviceBatteryAPI();
         updateOnline(data.online);
+      } else {
+        clearDevice();
       }
     }
   }
@@ -129,6 +350,10 @@ onMounted(async () => {
   console.log("全局配置：", config);
 });
 
+onUnmounted(() => {
+  clearOtaUpdateTimers();
+});
+
 onShareAppMessage(() => {
   return {
     title: "智能真弓：实时捕捉+毫秒级同步，弓箭选手全球竞技！", // 分享卡片的标题
@@ -149,12 +374,27 @@ onShareTimeline(() => {
 
 <template>
   <Container :isHome="true" :showBackToGame="true">
+    <!-- OTA 升级弹窗：使用 visible 控制显隐，description 为副标题，changelog 为详细说明 -->
+    <OtaModal
+      :visible="otaVisible"
+      :state="otaState"
+      :version="otaInfo.versionNumber"
+      :progress="otaProgress"
+      :description="''"
+      :changelog="otaInfo.versionInfo"
+      :forceUpdate="otaInfo.forceUpdate"
+      @update="handleOtaUpdate"
+      @skip="handleOtaDismiss"
+      @close="handleOtaDismiss"
+      @done="handleOtaDone"
+      @retry="handleOtaRetry"
+    />
     <view class="container">
       <view class="top-theme">
-        <image
+        <!-- <image
             src="https://static.shelingxingqiu.com/attachment/2025-12-31/dfc9dxrq4xn7e6y2pp.png"
             mode="widthFix"
-        />
+        /> -->
       </view>
       <UserHeader showRank :onSignin="() => (showModal = true)"/>
       <view :style="{ padding: '12px 10px' }">
@@ -170,7 +410,7 @@ onShareTimeline(() => {
                 v-else
                 src="https://static.shelingxingqiu.com/attachment/2026-01-04/dffohwtk1gwh0xfa6h.png"
                 mode="widthFix"
-                @click="() => toPage('/pages/my-device')"
+                @click="$clickSound(() => toPage('/pages/my-device'))"
             />
             <block v-if="user.id">
               <text v-if="!device.deviceId">绑定我的智能弓</text>
@@ -178,7 +418,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')"
             />
@@ -188,11 +428,12 @@ onShareTimeline(() => {
             </BubbleTip>
           </view>
           <view class="play-card">
-            <view @click="() => 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="() => toPage('/pages/friend-battle')">
-              <image src="../static/friend-battle.png" mode="widthFix"/>
+            <view @click="$clickSound(() => toPage('/pages/friend-battle'))">
+              <image src="https://static.shelingxingqiu.com/shootmini/static/friend-battle.png" mode="widthFix"/>
             </view>
           </view>
         </view>
@@ -203,11 +444,11 @@ onShareTimeline(() => {
           />
           <button
               class="into-btn"
-              @click="() => toPage('/pages/ranking')"
+              @click="$clickSound(() => toPage('/pages/ranking'))"
               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
@@ -216,7 +457,7 @@ onShareTimeline(() => {
                   class="player-avatar"
                   :style="{
                   zIndex: 8 - i,
-                  borderColor: rankData.rank[i - 1]
+                  borderColor: scoreRankList[i - 1]
                     ? topThreeColors[i - 1] || '#000'
                     : '#000',
                 }"
@@ -227,21 +468,21 @@ onShareTimeline(() => {
                 <view v-if="i > 3">{{ i }}</view>
                 <image
                     :src="
-                    rankData.rank[i - 1]
-                      ? rankData.rank[i - 1].avatar
+                    scoreRankList[i - 1]
+                      ? (scoreRankList[i - 1].avatar || '../static/user-icon.png')
                       : '../static/user-icon-dark.png'
                   "
                     mode="aspectFill"
                 />
               </view>
               <view class="more-players">
-                <text>{{ rankData.rank.length }}</text>
+                <text>{{ scoreRankList.length }}</text>
               </view>
             </view>
           </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>
@@ -467,7 +708,7 @@ onShareTimeline(() => {
 
 .top-theme {
   position: absolute;
-  display: flex;
+  display: none;
   align-items: center;
   justify-content: center;
   width: 100%;

src/pages/match-detail.vue

@@ -13,39 +13,87 @@ 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) {
-    players.value = result.resultList.map((item, index) => {
-      const plist = result.teams[0] ? result.teams[0].players : [];
-      const p = plist.find((p) => p.id === item.userId);
+    const plist = result.teams[0] ? result.teams[0].players : [];
+    // 以 id 为 key 建立 teams 玩家快速查找表
+    const teamPlayerMap = {};
+    plist.forEach((p) => { teamPlayerMap[p.id] = p; });
+
+    // 处理有成绩的玩家（resultList 顺序即排名顺序）
+    const rankedPlayers = (result.resultList || []).map((item, index) => {
+      const playerId = item.userId || item.id;
+      const p = teamPlayerMap[playerId] || item;
       const arrows = new Array(12);
-      result.rounds.forEach((r, index) => {
-        if (r.shoots[item.userId]) {
-          r.shoots[item.userId].forEach((s, index2) => {
-            arrows[index2 + index * 6] = s;
+      result.rounds.forEach((r, rIndex) => {
+        if (r.shoots[playerId]) {
+          r.shoots[playerId].forEach((s, sIndex) => {
+            arrows[sIndex + rIndex * 6] = s;
           });
         }
       });
       return {
         ...item,
+        id: playerId,
         rank: index + 1,
-        name: p.name,
-        avatar: p.avatar || "",
+        name: (p && p.name) || item.name,
+        avatar: (p && p.avatar) || item.avatar || "",
         arrows,
       };
     });
+
+    // 追加未出现在 resultList 中的玩家（未射箭），rank=0 隐藏角标
+    const rankedIds = new Set(rankedPlayers.map((p) => p.id));
+    const unrankedPlayers = plist
+      .filter((p) => !rankedIds.has(p.id))
+      .map((p) => ({
+        id: p.id,
+        name: p.name,
+        avatar: p.avatar || "",
+        arrows: [],
+        totalScore: 0,
+        rank: 0,
+      }));
+
+    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) => {
   if (data.value.mode <= 3) {
     uni.navigateTo({
-      url: `/pages/team-bow-data?battleId=${battleId.value}&selected=${selected}`,
+      url: `/pages/team-battle/team-bow-data?battleId=${battleId.value}&selected=${selected}`,
     });
   } else {
     uni.navigateTo({
@@ -58,14 +106,26 @@ 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"
         :blueTeam="data.teams[1] ? data.teams[1].players : []"
         :redTeam="data.teams[2] ? data.teams[2].players : []"
         :players="players"
       />
       <view
-        v-if="data.mode >= 3"
+        v-if="data.mode > 3"
         class="score-header"
         :style="{ border: 'none', padding: '5px 15px' }"
       >
@@ -76,14 +136,14 @@ const checkBowData = (selected) => {
         </view>
       </view>
       <PlayerScore2
-        v-if="data.mode >= 3"
+        v-if="data.mode > 3"
         v-for="(player, index) in players"
         :key="index"
         :name="player.name"
         :avatar="player.avatar"
         :arrows="player.arrows"
         :totalScore="player.totalScore"
-        :rank="index + 1"
+        :rank="player.rank"
       />
       <view
         v-if="data.mode <= 3"
@@ -142,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;

src/pages/match-page.vue

@@ -3,22 +3,199 @@ import { ref, onMounted, onBeforeUnmount } from "vue";
 import { onLoad, onShow, onHide } from "@dcloudio/uni-app";
 import Container from "@/components/Container.vue";
 import Matching from "@/components/Matching.vue";
-import { matchGameAPI } from "@/apis";
+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 = () => {
+  if (matchTimeoutTimer.value) {
+    clearTimeout(matchTimeoutTimer.value);
+    matchTimeoutTimer.value = null;
+  }
+};
+
+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" });
+      await returnToCurrentBattle(battle);
+    } else {
+      uni.showToast({ title: "匹配超时，请重试", icon: "none" });
+      try {
+        if (gameType.value && teamSize.value) {
+          await matchGameAPI(false, gameType.value, teamSize.value);
+        }
+      } catch (_) { /* 取消失败忽略 */ }
+      uni.navigateBack();
+    }
+  } catch (e) {
+    uni.showToast({ title: "匹配超时，请重试", icon: "none" });
+    uni.navigateBack();
+  }
+};
 
 async function stopMatch() {
   uni.$showHint(3);
 }
 
+const closeLimitModal = () => {
+  showLimitModal.value = false;
+  uni.navigateBack();
+};
+
+const goVipPage = () => {
+  showLimitModal.value = false;
+  uni.redirectTo({
+    url: "/pages/member/be-vip",
+  });
+};
+
+/**
+ * 取消匹配，带容错处理：
+ * - 取消成功 → 返回大厅
+ * - 取消失败（后端已分配对局但 WS 未到达）→ 查询并跳入当前对局
+ */
 async function cancelMatch() {
-  if (gameType.value && teamSize.value) {
-    await matchGameAPI(false, gameType.value, teamSize.value);
+  if (navigationPending.value) return;
+  foregroundGeneration += 1;
+  clearMatchTimeout();
+  try {
+    if (gameType.value && teamSize.value) {
+      await matchGameAPI(false, gameType.value, teamSize.value);
+    }
+    uni.navigateBack();
+  } catch (e) {
+    // 取消匹配接口失败，尝试查询是否已被分配对局
+    try {
+      const battle = await getBattleAPI();
+      if (battle && battle.matchId) {
+        await returnToCurrentBattle(battle);
+      } else {
+        uni.navigateBack();
+      }
+    } catch (_) {
+      uni.navigateBack();
+    }
   }
-  uni.navigateBack()
 }
 
 async function onReceiveMessage(msg) {
@@ -26,14 +203,21 @@ async function onReceiveMessage(msg) {
     onComplete.value = () => {}
   }
   if (msg.type === MESSAGETYPESV2.AboutToStart) {
-    if (gameType.value == 1) {
-      uni.redirectTo({
-        url: `/pages/team-battle?battleId=${msg.id}&gameMode=2`,
-      });
-    } else if (gameType.value == 2) {
-      uni.redirectTo({
-        url: `/pages/melee-battle?battleId=${msg.id}&gameMode=2`,
-      });
+    if (navigationPending.value) return;
+    // 收到开始消息，清除超时计时器
+    clearMatchTimeout();
+    // 使用后端下发的 mode 字段判断跳转目标，与好友约战（battle-room.vue）保持一致
+    // mode <= 3 为团队对抗，mode > 3 为大乱斗，覆盖全部 gameType（1~5），不再遗漏
+    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);
     }
   }
 }
@@ -43,17 +227,28 @@ onLoad(async (options) => {
     gameType.value = options.gameType;
     teamSize.value = options.teamSize;
   }
+  if (pageMounted && pageVisible) {
+    const generation = ++foregroundGeneration;
+    void reconcileMatchingPage(generation);
+  }
 });
 
 onMounted(() => {
+  void audioManager.warmAll();
   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,
   });
@@ -61,14 +256,18 @@ onBeforeUnmount(() => {
   uni.$off("cancelMatching", cancelMatch);
 });
 
-onShow(async () => {
-  if (gameType.value && teamSize.value) {
-    matchGameAPI(true, gameType.value, teamSize.value);
-  }
+onShow(() => {
+  pageVisible = true;
+  navigationPending.value = false;
+  const generation = ++foregroundGeneration;
+  clearMatchTimeout();
+  if (pageMounted) void reconcileMatchingPage(generation);
 });
 
 onHide(() => {
-
+  pageVisible = false;
+  foregroundGeneration += 1;
+  clearMatchTimeout();
 });
 </script>
 
@@ -78,6 +277,14 @@ onHide(() => {
       <Matching :stopMatch="stopMatch" :onComplete="onComplete" />
     </view>
   </Container>
+  <ModalDialog
+    :show="showLimitModal"
+    :content="'今日排位赛次数已经用完\n开通会员可增加次数'"
+    cancelText="知道了"
+    confirmText="去开通"
+    :onCancel="closeLimitModal"
+    :onConfirm="goVipPage"
+  />
 </template>
 
 <style scoped>

src/pages/melee-battle.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { ref, onMounted, onBeforeUnmount } from "vue";
+import { ref, onMounted, onBeforeUnmount, watch, nextTick, computed } from "vue";
 import { onLoad, onShow, onHide } from "@dcloudio/uni-app";
 import Container from "@/components/Container.vue";
 import BowTarget from "@/components/BowTarget.vue";
@@ -10,16 +10,26 @@ import SButton from "@/components/SButton.vue";
 import Avatar from "@/components/Avatar.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();
-const { user } = storeToRefs(store);
+const { user, online } = storeToRefs(store);
 const title = ref("");
 const start = ref(null);
 const battleId = ref("");
+/** 对战模式：1=好友约战 2=排位赛，用于结算页跳转判断 */
+const way = ref(0);
 const currentRound = ref(1);
 const tips = ref("即将开始...");
 const players = ref([]);
@@ -27,16 +37,230 @@ const playersSorted = ref([]);
 const playersScores = ref([]);
 const halfTimeTip = ref(false);
 const halfRest = ref(false);
-
-const navigateToResult = () => {
-  uni.redirectTo({ url: `/pages/battle-result?battleId=${battleId.value}` });
+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);
+let battleEnded = false;
+let skipNextRestoreOnShow = false;
+let restoreGeneration = 0;
+
+function clearHalfRestCountdown() {
+  if (halfRestTimer) {
+    clearInterval(halfRestTimer);
+    halfRestTimer = null;
+  }
+}
+
+function leaveHalfRest() {
+  clearHalfRestCountdown();
+  halfTimeTip.value = false;
+  halfRest.value = false;
+}
+
+function getHalfRestSeconds(battleInfo) {
+  const remainCandidates = [
+    battleInfo?.halfRestRemain,
+    battleInfo?.halfRestRemainSeconds,
+    battleInfo?.restRemain,
+    battleInfo?.restRemainSeconds,
+  ];
+
+  for (const item of remainCandidates) {
+    const remain = Number(item);
+    if (Number.isFinite(remain) && remain > 0 && remain <= HALF_REST_SECONDS) {
+      return Math.ceil(remain);
+    }
+  }
+
+  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 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;
+}
+
+function startHalfRestCountdown(seconds = HALF_REST_SECONDS) {
+  clearHalfRestCountdown();
+  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;
+
+  halfRestTimer = setInterval(() => {
+    if (halfRestRemain.value <= 1) {
+      halfRestRemain.value = 0;
+      clearHalfRestCountdown();
+      return;
+    }
+
+    halfRestRemain.value -= 1;
+  }, 1000);
+}
+const currentPlayer = computed(() =>
+  players.value.find((player) => String(player?.id) === String(user.value.id))
+);
+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,
+  });
+}
+
+/**
+ * 监听设备在线状态，大乱斗比赛进行中设备离线时弹窗提示用户
+ */
+watch(online, (newVal, oldVal) => {
+  if (!newVal && oldVal && start.value === true) {
+    showOfflineModal.value = true;
+  }
+});
 
 function recoverData(battleInfo, { force = false } = {}) {
+  battleInfo = normalizeBattleInfo(battleInfo);
   if (!battleInfo) return;
+  if (battleInfo.status !== undefined) {
+    battleEnded = [2, 4].includes(Number(battleInfo.status));
+  }
   try {
     if (battleInfo.way === 1) title.value = "好友约战 - 大乱斗";
     if (battleInfo.way === 2) title.value = "排位赛 - 大乱斗";
+    // 保存 way 供结算跳转时使用
+    way.value = battleInfo.way ?? 0;
     
     // 优先使用接口数据，否则使用缓存
     if (battleInfo.teams?.[0]?.players) {
@@ -49,19 +273,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) => {
@@ -77,15 +309,16 @@ function recoverData(battleInfo, { force = false } = {}) {
       halfTimeTip.value = true;
       halfRest.value = true;
       tips.value = "准备下半场";
-      // 剩余休息时间
-      // const remain = (Date.now() - battleInfo.timeoutTime) / 1000;
+      startHalfRestCountdown(getHalfRestSeconds(battleInfo));
       setTimeout(() => {
         uni.$emit("update-remain", 0);
       }, 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(() => {
@@ -98,8 +331,64 @@ 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;
+  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) => {
@@ -110,20 +399,28 @@ onLoad(async (options) => {
 
 async function onReceiveMessage(msg) {
   if (Array.isArray(msg)) return;
-  if (msg.type === MESSAGETYPESV2.BattleStart) {
-    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) {
     recoverData(msg);
+    if (msg.shootData?.threeConsecutive10Rings === true) {
+      nextTick(() => audioManager.play("tententen", false));
+    }
   } else if (msg.type === MESSAGETYPESV2.HalfRest) {
     halfTimeTip.value = true;
     halfRest.value = true;
     tips.value = "准备下半场";
+    startHalfRestCountdown(getHalfRestSeconds(msg));
   } else if (msg.type === MESSAGETYPESV2.BattleEnd) {
+    battleEnded = true;
+    notifyMatchAudioAck(msg);
     setTimeout(() => {
+      // 全部跳转到新结算页
       uni.redirectTo({
-        url: "/pages/battle-result?battleId=" + msg.matchId,
+        url: "/pages/friend-battle-result?battleId=" + msg.matchId,
       });
     }, 1000);
   }
@@ -133,32 +430,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>
 
@@ -166,13 +462,19 @@ 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"
+      />
       <ShootProgress
         :show="start"
         :start="start && !halfRest"
         :tips="tips"
         :total="90"
         :melee="true"
+        :halfRest="halfRest"
         :battleId="battleId"
       />
       <view v-if="start" class="user-row">
@@ -186,6 +488,8 @@ onShow(async () => {
         "
         :totalRound="12"
         :scores="playersScores.map((r) => r[user.id]).flat()"
+        :isSvip="isCurrentUserSvip"
+        :missAsZero="true"
         :stop="halfRest"
       />
       <view :style="{ paddingBottom: '20px' }">
@@ -200,13 +504,25 @@ onShow(async () => {
       <ScreenHint
         :show="halfTimeTip"
         mode="small"
-        :onClose="() => (halfTimeTip = false)"
       >
         <view class="half-time-tip">
           <text>上半场结束，休息一下吧:）</text>
-          <text>20秒后开始下半场</text>
+          <text>{{ halfRestRemain }}秒后开始下半场</text>
         </view>
       </ScreenHint>
+      <!-- 设备离线提示弹窗 -->
+      <SModal
+        :show="showOfflineModal"
+        :noBg="true"
+        height="360rpx"
+        :onClose="() => (showOfflineModal = false)"
+      >
+        <view class="offline-modal">
+          <text class="offline-title">设备已离线</text>
+          <text class="offline-desc">检测到设备已断开连接，请检查设备后继续比赛</text>
+          <SButton @click="showOfflineModal = false">我知道了</SButton>
+        </view>
+      </SModal>
     </view>
   </Container>
 </template>
@@ -216,4 +532,25 @@ onShow(async () => {
   width: 100%;
   height: 100%;
 }
+
+.offline-modal {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  padding: 60rpx 40rpx 40rpx;
+  gap: 24rpx;
+}
+
+.offline-title {
+  font-size: 36rpx;
+  font-weight: bold;
+  color: #FED847;
+}
+
+.offline-desc {
+  font-size: 28rpx;
+  color: #CCCCCC;
+  text-align: center;
+  line-height: 1.6;
+}
 </style>

src/pages/melee-bow-data.vue

@@ -13,13 +13,31 @@ const currentUser = ref({
 });
 const players = ref([]);
 
+function getRingTotal(arrows = []) {
+  return arrows.reduce((last, next) => last + (Number(next?.ring) || 0), 0);
+}
+
+function getScoreLabel(score) {
+  if (!score) return "";
+  return score.ringX ? "X" : score.ring || "";
+}
+
+const isMember = (player = {}) => player.vip === true || player.sVip === true;
+
+const getMemberNicknameClass = (player = {}) => [
+  "player-name",
+  "member-nickname",
+  player.vip === true && player.sVip !== true ? "member-nickname--vip" : "",
+  player.sVip === true ? "member-nickname--svip" : "",
+];
+
 onLoad(async (options) => {
   if (!options.battleId) return;
   const result = await getBattleAPI(options.battleId || "59348111700660224");
+  const plist = result.teams?.[0]?.players || [];
   players.value = result.resultList.map((item, index) => {
-    const plist = result.teams[0] ? result.teams[0].players : [];
-    const p = plist.find((p) => p.id === item.userId);
-    const arrows = new Array(12);
+    const p = plist.find((p) => String(p.id) === String(item.userId));
+    const arrows = Array.from({ length: 12 }, () => ({}));
     result.rounds.forEach((r, index) => {
       if (r.shoots[item.userId]) {
         r.shoots[item.userId].forEach((s, index2) => {
@@ -29,9 +47,11 @@ onLoad(async (options) => {
     });
     return {
       ...item,
+      ...p,
+      userId: item.userId,
       rank: index + 1,
-      name: p.name,
-      avatar: p.avatar || "",
+      name: p?.name || item.name,
+      avatar: p?.avatar || item.avatar || "",
       arrows,
     };
   });
@@ -45,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' }"
       />
@@ -68,18 +88,27 @@ onLoad(async (options) => {
             class="player-bg"
           />
           <Avatar :src="player.avatar" :rankLvl="player.rankLvl" :size="40" />
-          <text>{{ player.name }}</text>
+          <view v-if="isMember(player)" :class="getMemberNicknameClass(player)">
+            <text class="member-nickname__text">{{ player.name }}</text>
+            <text v-if="player.sVip === true" class="member-nickname__shine">
+              {{ player.name }}
+            </text>
+          </view>
+          <text v-else>{{ player.name }}</text>
         </view>
       </view>
       <view :style="{ marginTop: '10px' }">
-        <BowTarget :scores="currentUser.arrows" />
+        <BowTarget
+          :scores="currentUser.arrows"
+          :isSvip="currentUser.sVip === true"
+        />
       </view>
       <view class="score-text"
         ><text :style="{ color: '#fed847' }">{{
           currentUser.arrows.length
         }}</text
         >支箭，共<text :style="{ color: '#fed847' }">{{
-          currentUser.arrows.reduce((last, next) => last + next.ring, 0)
+          getRingTotal(currentUser.arrows)
         }}</text
         >环</view
       >
@@ -90,7 +119,7 @@ onLoad(async (options) => {
           class="score-item"
           :style="{ width: '13vw', height: '13vw' }"
         >
-          {{ score.ringX ? "X" : score.ring }}
+          {{ getScoreLabel(score) }}
         </view>
       </view>
     </view>
@@ -149,6 +178,16 @@ onLoad(async (options) => {
   text-align: center;
   position: relative;
 }
+.players > view > .player-name {
+  margin: 5px 0;
+  width: 80%;
+  position: relative;
+  justify-content: center;
+}
+.player-name .member-nickname__text,
+.player-name .member-nickname__shine {
+  font-size: 12px;
+}
 .score-text {
   width: 100%;
   color: #fff;

src/pages/member/agreement.vue

@@ -0,0 +1,120 @@
+<script setup>
+import { computed, ref } from "vue";
+import { onLoad } from "@dcloudio/uni-app";
+import Container from "@/components/Container.vue";
+import { getMemberAgreement } from "./agreementData";
+
+const agreementType = ref("renew");
+
+onLoad((options) => {
+  agreementType.value = options.type || "renew";
+});
+
+const agreement = computed(() => getMemberAgreement(agreementType.value));
+</script>
+
+<template>
+  <Container :title="agreement.navTitle">
+    <scroll-view scroll-y class="agreement-page" :show-scrollbar="false">
+      <view class="content">
+        <view class="page-title">{{ agreement.title }}</view>
+        <view v-if="agreement.meta" class="meta">{{ agreement.meta }}</view>
+
+        <block v-for="(item, index) in agreement.content" :key="index">
+          <view v-if="item.type === 'heading'" class="section-title">
+            {{ item.text }}
+          </view>
+          <view v-else-if="item.type === 'list'" class="list">
+            <view v-for="(listItem, listIndex) in item.items" :key="listIndex" class="list-item">
+              <text class="list-dot">•</text>
+              <text class="list-text">{{ listItem }}</text>
+            </view>
+          </view>
+          <view v-else class="paragraph">
+            <text>{{ item.text }}</text>
+          </view>
+        </block>
+
+        <view class="company">{{ agreement.company }}</view>
+      </view>
+    </scroll-view>
+  </Container>
+</template>
+
+<style scoped lang="scss">
+.agreement-page {
+  width: 100%;
+  height: 100%;
+  background-color: #ffffff;
+}
+
+.content {
+  padding: 30rpx;
+  box-sizing: border-box;
+}
+
+.page-title,
+.section-title {
+  color: #333333;
+  font-size: 28rpx;
+  line-height: 40rpx;
+  font-weight: 700;
+}
+
+.page-title {
+  margin-bottom: 20rpx;
+}
+
+.meta {
+  margin-bottom: 26rpx;
+  color: #666666;
+  font-size: 24rpx;
+  line-height: 34rpx;
+}
+
+.section-title {
+  margin: 42rpx 0 22rpx;
+}
+
+.paragraph,
+.list-item,
+.company {
+  color: #333333;
+  font-size: 26rpx;
+  line-height: 38rpx;
+}
+
+.paragraph {
+  margin-bottom: 22rpx;
+}
+
+.list {
+  margin-bottom: 22rpx;
+}
+
+.list-item {
+  display: flex;
+  align-items: flex-start;
+  margin-bottom: 14rpx;
+}
+
+.list-dot {
+  width: 28rpx;
+  flex-shrink: 0;
+  color: #333333;
+  line-height: 38rpx;
+}
+
+.list-text {
+  flex: 1;
+  color: #333333;
+  line-height: 38rpx;
+}
+
+.company {
+  margin-top: 42rpx;
+  padding-bottom: 30rpx;
+  text-align: right;
+  font-weight: 700;
+}
+</style>

src/pages/member/agreementData.js

@@ -0,0 +1,322 @@
+export const memberAgreements = {
+  renew: {
+    navTitle: "会员自动续费服务协议",
+    title: "射灵星球小程序会员自动续费服务协议",
+    content: [
+      {
+        type: "paragraph",
+        text: "欢迎您使用射灵星球小程序付费会员服务（以下简称“本服务”）！",
+      },
+      {
+        type: "paragraph",
+        text: "本服务是由广州光点飞舞网络有限公司（以下简称“公司”或“我们”）为您提供。本服务为付费服务。为了保障您的权益，请在使用本服务前详细阅读并遵守本《射灵星球小程序会员服务协议（含自动续费服务规则）》（以下简称“本协议”）以及公司已发布或将来可能发布的各项服务协议与规则。您在申请开通本服务并进入购买程序前，请务必审慎阅读、充分理解各服务协议及规则，特别是免除或限制责任条款、法律适用和争议解决条款。",
+      },
+      {
+        type: "paragraph",
+        text: "当您依照本服务开通页面提示进行阅读并同意本协议，完成全部服务开通程序后（包括但不限于点击“同意”、“下一步”或“确认支付”等确认按钮，或您开始使用本服务），即表示您已充分阅读、理解并接受本协议的全部内容，您已与本服务提供方达成一致，成为“射灵星球小程序”付费会员。本协议即在您与公司之间产生法律效力，成为对双方均具有约束力的法律文件。",
+      },
+      { type: "heading", text: "一、定义及适用范围" },
+      {
+        type: "paragraph",
+        text: "1.1 射灵星球小程序付费会员：指已按照服务协议及规则完成射灵星球小程序登录的用户，在签署本协议并根据本服务开通页面所展示的收费标准支付相应费用后获取的特殊资格，在本协议中简称为“会员”或“您”。公司根据业务发展可能会新增、调整会员类型或名称，实际以开通页面展示为准，这不影响您的实际权益。",
+      },
+      {
+        type: "paragraph",
+        text: "1.2 付费会员权益：指用户基于其付费会员资格所享有的特殊权益，具体权益内容应以本服务购买页面展示内容及相关权益说明为准。您理解并同意，公司可能会根据设备型号、系统版本、客户端等因素开发不同的版本，不同版本实际可使用的具体权益或服务内容可能有所差别，具体以购买页面展示为准。",
+      },
+      {
+        type: "paragraph",
+        text: "1.3 本协议内容同时包括公司已经发布及后续可能不断发布的关于本服务的相关协议、规则等内容。前述内容一经正式发布，并以适当的方式送达您（服务购买页面、网站公布、系统通知等），即为本协议不可分割的组成部分，您应同样遵守。",
+      },
+      {
+        type: "paragraph",
+        text: "1.4 为了给会员用户提供更多选择，公司可能会与第三方合作推出联合会员服务，或为购买会员服务的用户赠送第三方会员服务。如果您选择购买或接受以上服务，则表示您理解并认可，我们仅提供射灵星球小程序付费会员服务，不对第三方的会员服务负责。第三方会员服务的权益、使用、收费规则等，将由第三方执行和向您解释。",
+      },
+      { type: "heading", text: "二、服务开通、权益内容、服务期限及收费标准" },
+      {
+        type: "paragraph",
+        text: "2.1 本服务仅支持射灵星球小程序登录用户开通。您在开通本服务时，应仔细核对已登录的账号名称、会员类型、付费类型、服务期限等具体信息。因您个人原因充错账号、开通错服务类型或服务时长的，公司不予退还已收取的费用。",
+      },
+      {
+        type: "paragraph",
+        text: "2.2 您可通过已有和未来新增的支付渠道或公司指定支付方式完成本服务的购买。当您根据本服务页面提示进行确认、并成功支付了会员服务费和/或完成了成为付费会员的所有程序，您将成为射灵星球小程序付费会员。",
+      },
+      {
+        type: "paragraph",
+        text: "2.3 本服务的期限（以下简称“服务期限”）以您选择并成功开通的期限为准。会员计费与服务时长采用自然时间（自然月/自然年）方式计算。具体截止时间为相应续费到期自然日的对应时间点。服务期限届满后，公司将停止继续向您提供本服务。如您同时开通了多种会员服务，其消耗及重叠规则以开通页面的官方具体规则为准。",
+      },
+      {
+        type: "paragraph",
+        text: "2.4 本服务的收费标准及具体权益内容以本服务开通页面所展示的为准。基于市场与业务的发展及服务权益调整，公司可能会随时调整本服务开通所需费用及/或具体权益内容。费用或权益内容调整自公布之日起生效，您在调整生效前已开通的服务将不受影响，但该服务到期后的续费开通或自动续费扣款，则需按照调整后的标准执行。",
+      },
+      {
+        type: "paragraph",
+        text: "2.5 射灵星球小程序付费会员服务为虚拟内容消费，除因本服务存在重大瑕疵导致您完全无法使用等公司的违约情形、法律法规要求必须退款或公司同意退款等情形外，完成支付和购买后，不可进行退款或转让。您在会员到期前主动取消或终止会员资格的，已支付费用不予退还。",
+      },
+      {
+        type: "paragraph",
+        text: "2.6 为了保护您的账号安全、防止账号被盗风险，我们会对您开通会员服务的账号登录设备及使用范围作出合理限制。您不得将账号提供给多名第三方同时使用，否则公司有权根据安全风控能力随时调整或限制您的登录及使用权限。",
+      },
+      { type: "heading", text: "三、连续购买和自动续费服务" },
+      { type: "paragraph", text: "3.1 自动续费服务类型/计费周期" },
+      {
+        type: "paragraph",
+        text: "射灵星球小程序付费会员自动续费服务包含「连续包月」、「连续包年」等服务。本服务的自动续费及对应计费周期采用按自然时间（自然月/自然年）对日顺延的方式计算。即：若您在某月18日开通连续包月服务，则下一次自动扣费续费日期为次月18日；若开通当月无对应日期的（例如1月31日开通，2月无31日），则自动调整为该自然月最后一日进行扣费续费。公司可能会根据会员需求增加或调整自动续费服务类型，具体服务类型以服务开通页面展示为准。",
+      },
+      { type: "paragraph", text: "3.2 自动续费服务说明" },
+      {
+        type: "paragraph",
+        text: "（1）本自动续费服务基于您对于自动续费的需求，在您已开通会员服务的前提下，为避免您因疏忽或其他原因导致未能及时续费而中断服务，您授权公司可在您的会员服务期限到期前，从您开通本自动续费服务时所绑定的Apple ID账户余额、或绑定的第三方支付账户（包括但不限于微信支付、支付宝支付等）余额中自动代扣下一个计费周期的费用，从而延长对应的会员服务期限。",
+      },
+      {
+        type: "paragraph",
+        text: "（2）自动续费扣费日期以您开通本自动续费服务的支付渠道实际扣款时间为准：如您是通过苹果公司iOS渠道开通本服务，扣费日期通常为开通服务之日起每个计费周期的对应日期前24小时内；如您是通过安卓Android渠道或直接在小程序内通过微信支付等渠道开通本服务，扣费日期通常为每个计费周期到期前1至2日。如支付渠道根据实际情况或相关平台规则自行调整扣费时间的，以实际扣款时间为准。",
+      },
+      {
+        type: "paragraph",
+        text: "（3）请您关注上述账户及可扣款余额情况，保证上述账户扣款成功以确保会员服务顺利续期。如因上述账户中可扣款余额不足导致续费失败，公司有权中断或终止相应的会员权益及服务，由此导致的风险或损失将由您自行承担。",
+      },
+      {
+        type: "paragraph",
+        text: "（4）为了方便您知悉自动续费情况，公司将在扣费日期前5日以站内信、小程序系统消息推送或短信等方式提示您即将发生续期扣费的信息，第三方支付渠道也可能向您发送通知提醒即将扣费。",
+      },
+      {
+        type: "paragraph",
+        text: "（5）系统会在每个扣费日期自动从您开通服务时所绑定的支付账户扣费。如扣费日期因账户问题或余额不足导致续费失败，若您未主动明确取消本服务，将视为您同意公司在扣费日期后继续发出扣款尝试，一旦您的账户扣款成功，公司将继续为您提供相应会员服务权益。",
+      },
+      {
+        type: "paragraph",
+        text: "（6）如您未在每个扣费日期前操作取消自动续费服务，则公司将根据此前与您达成的委托在扣费日期继续发出续费代扣指令，一旦扣款成功，公司将自动为您开通下一个计费周期的连续服务。对于已成功完成会员服务续费的费用，原则上不予退还。",
+      },
+      {
+        type: "paragraph",
+        text: "（7）您在自动续费服务期间可以额外购买或通过参与活动等方式获取付费会员服务，会员服务期限将在原服务期限基础上相应延长，但如您未主动取消自动续费服务，系统仍会按照您所开通的自动续费服务进行扣费及续期。",
+      },
+      { type: "paragraph", text: "3.3 自动续费服务的退订" },
+      {
+        type: "paragraph",
+        text: "（1）您有权决定是否取消自动续费服务，如果您希望取消自动续费服务，需在每个扣费日期前（至少提前24小时）操作取消，否则将视为您同意继续授权自动续费。",
+      },
+      {
+        type: "paragraph",
+        text: "（2）购买自动续费服务后，您可在小程序的会员管理页中关闭自动续费，或通过如下第三方支付渠道方式取消自动续费服务：",
+      },
+      {
+        type: "list",
+        items: [
+          "iOS用户（Apple ID订阅）：打开苹果手机“设置” -> 点击顶部的“Apple ID/机主姓名” -> 进入“订阅” -> 选择“射灵星球” -> 点击“取消订阅”；或打开“App Store” -> 点击右上角头像进入“账户” -> 点击“订阅”进行管理。",
+          "微信支付自动续费用户：打开微信APP -> 点击“我” -> “服务” -> “钱包” -> “支付设置” -> “自动续费” -> 选择“射灵星球小程序会员” -> 点击“关闭服务”。",
+          "支付宝自动续费用户：打开支付宝APP -> 点击“我的” -> “设置” -> “支付设置” -> “免密支付/自动扣款” -> 选择“射灵星球小程序会员” -> 点击“关闭服务”。",
+        ],
+      },
+      {
+        type: "paragraph",
+        text: "3.4 公司有权根据市场情况、业务规划、运营策略变化等原因单方面决定停止向您提供自动续费服务，并通过公告或站内信等方式通知您，您的付费会员服务期限自当前服务期限届满之日起终止。",
+      },
+      { type: "heading", text: "四、服务使用规范与限制" },
+      {
+        type: "paragraph",
+        text: "4.1 本服务及会员权益仅限您本人使用。未经公司书面同意，禁止以任何形式赠与、借用、出租、转让、售卖或以其他方式许可他人使用该账号及账号项下的会员服务与权益。如发生泄漏、遗失、被盗等行为，而该等行为并非公司过错导致，损失将由您自行承担。",
+      },
+      {
+        type: "paragraph",
+        text: "4.2 如您存在如下违法或不当使用本服务的情形，公司有权取消您的会员资格、作废会员权益且不予退还您所支付的会员服务费用，并有权向您追偿给公司造成的损失：",
+      },
+      {
+        type: "list",
+        items: [
+          "以盗窃、利用系统漏洞、通过任何非公司官方或授权渠道获得本服务的行为；",
+          "利用本服务进行盈利或非法获利，或以各种形式转让、借用您的会员权益；",
+          "通过非法手段对本服务会员账户的服务期限、交易状态进行修改或篡改；",
+          "主动对公司用于保护本服务会员权益的任何安全措施技术进行破解、更改、反操作或破坏；",
+          "其他违反法律法规、诚实信用原则、服务协议及相关小程序运营规则的行为。",
+        ],
+      },
+      { type: "heading", text: "五、服务中止、终止及变更" },
+      {
+        type: "paragraph",
+        text: "5.1 因国家或相关政府监管部门要求、发生不可抗力事件、或由于用户违反本协议约定，公司有权中止或终止向用户提供服务。",
+      },
+      {
+        type: "paragraph",
+        text: "5.2 您知悉并确认，您开通本服务后，如您中途主动取消本服务、放弃会员权益或终止资格，您将无法退还部分或全部会员服务费用。本协议终止后，用户无权要求公司继续向其提供任何服务，且不影响终止前基于本协议已产生的权利义务。",
+      },
+      {
+        type: "paragraph",
+        text: "5.3 公司可根据国家法律法规变化、业务实际变更需求、保护用户权益的需要等，不时修改本协议，并按照法律法规规定的程序及方式进行公告。如用户不同意变更后的内容，则用户有权主动停止使用本服务；如用户在变更内容生效后仍继续使用本服务，即视为用户同意该等内容的变更。",
+      },
+      { type: "heading", text: "六、责任限制与免责条款" },
+      {
+        type: "paragraph",
+        text: "6.1 您理解并同意，本服务是按照现有技术和条件所能达到的现状提供的。公司将尽最大努力确保服务的连贯性和安全性，但不能随时预见和防范技术以及其他风险，包括但不限于不可抗力、网络原因、第三方服务瑕疵等原因可能导致的服务中断、数据丢失以及其他的损失和风险。",
+      },
+      {
+        type: "paragraph",
+        text: "6.2 基于收益与赔偿相一致及公平合理的原则，如因公司原因造成本服务不正常中断或服务不可用，您所可能获得的最高赔偿额不超过本协议项下公司就该计费周期已实际收取您的相关服务费用总额。",
+      },
+      { type: "heading", text: "七、法律适用与争议解决" },
+      {
+        type: "paragraph",
+        text: "7.1 本协议的成立、生效、履行、解释及争议的解决均应适用中华人民共和国法律。",
+      },
+      {
+        type: "paragraph",
+        text: "7.2 本协议的签订地为广东省广州市南沙区。若您因本协议与公司发生任何争议，双方应尽量友好协商解决；如协商不成的，任何一方均同意应将相关争议提交至本协议签订地有管辖权的人民法院诉讼解决。",
+      },
+      {
+        type: "paragraph",
+        text: "7.3 本协议任一条款被视为废止、无效或不可执行，该条应视为可分的且并不影响本协议其余条款的有效性及可执行性。",
+      },
+    ],
+    company: "广州光点飞舞网络有限公司",
+  },
+  deduct: {
+    navTitle: "扣款授权服务协议",
+    title: "扣费授权服务协议",
+    meta: "版本号：V1.0  生效日期：2026年6月22日",
+    content: [
+      { type: "heading", text: "一、授权声明" },
+      {
+        type: "paragraph",
+        text: "本人（即授权人，以下简称“乙方”）作为射灵星球小程序的注册用户，在自愿、平等、知悉全部授权内容的基础上，同意向广州光点飞舞网络有限公司（以下简称“甲方”）及甲方委托的第三方支付机构（包含微信支付、支付宝、苹果支付等，以下简称“支付机构”）作出本扣费授权，双方就授权扣费相关事宜达成如下协议。",
+      },
+      { type: "heading", text: "二、授权主体" },
+      {
+        type: "paragraph",
+        text: "授权人（乙方）：射灵星球小程序注册用户，用户ID以平台系统记录为准。",
+      },
+      {
+        type: "paragraph",
+        text: "被授权人（甲方）：广州光点飞舞网络有限公司，作为会员服务提供方及扣费指令发起方。",
+      },
+      {
+        type: "paragraph",
+        text: "支付执行方：乙方绑定的第三方支付机构，受甲方委托执行扣费操作。",
+      },
+      { type: "heading", text: "三、授权内容" },
+      {
+        type: "paragraph",
+        text: "授权场景：乙方开通射灵星球会员自动续费服务后，授权甲方在每个会员周期届满前，向支付机构发起扣费指令，用于支付下一周期的会员服务费用。",
+      },
+      {
+        type: "paragraph",
+        text: "授权金额：扣费金额以乙方开通时选择的自动续费套餐对应价格为准，具体以会员购买页面公示价格为准；若价格调整，甲方将提前通过公示或通知形式告知乙方，乙方继续使用服务视为认可并接受调整后的金额。",
+      },
+      {
+        type: "paragraph",
+        text: "授权支付账户：乙方开通自动续费时绑定的微信支付、支付宝等第三方支付账户，账户信息以支付机构记录为准。",
+      },
+      {
+        type: "paragraph",
+        text: "授权扣费次数：本授权为周期性授权。在授权有效期内，甲方可按会员周期重复发起扣费指令，直至乙方依法撤销授权为止。",
+      },
+      { type: "heading", text: "四、授权有效期" },
+      {
+        type: "paragraph",
+        text: "1. 本授权自乙方点击确认开通自动续费服务之日起生效，至乙方成功取消自动续费服务之日终止。",
+      },
+      {
+        type: "paragraph",
+        text: "2. 若乙方注销射灵星球小程序账号，本授权自账号注销完成之日自动终止。",
+      },
+      {
+        type: "paragraph",
+        text: "3. 若因国家政策调整、支付机构规则变更、乙方支付账户注销/冻结等非甲方主观原因导致授权无法履行的，本授权自动终止。",
+      },
+      { type: "heading", text: "五、扣费与提醒规则" },
+      {
+        type: "paragraph",
+        text: "1. 扣费提醒：甲方将在每个自动续费扣费日期前5日，通过微信服务通知、小程序系统消息或短信等显著方式提示乙方即将发生续期扣费的信息，以保障乙方的知情权与选择权。",
+      },
+      {
+        type: "paragraph",
+        text: "2. 扣费时机：甲方将在乙方当前会员有效期届满前24小时内发起下一周期的扣费指令，支付机构根据指令从乙方授权账户中划扣对应费用。",
+      },
+      {
+        type: "paragraph",
+        text: "3. 扣费失败处理：若因账户余额不足等原因导致首次扣费失败的，甲方及支付机构可在合规范围内依法尝试补扣；若补扣仍失败或账户处于异常状态的，本期自动续费暂停，乙方会员到期后自动失效。",
+      },
+      {
+        type: "paragraph",
+        text: "4. 扣费凭证：支付机构的扣费记录作为扣费成功的有效凭证，乙方可在支付账户账单中查询明细；甲方同步为乙方提供电子扣费记录，可在会员中心查看。",
+      },
+      { type: "heading", text: "六、授权的变更与撤销" },
+      {
+        type: "paragraph",
+        text: "1. 授权变更：本授权内容如需变更（如更换支付账户、调整续费套餐），乙方需先取消原自动续费服务，再重新开通新套餐。新授权自重新开通成功之日起生效，原授权同步终止。",
+      },
+      {
+        type: "paragraph",
+        text: "2. 授权撤销：乙方可随时退订本自动续费服务，解约后不影响乙方已生效周期的会员服务。根据乙方开通时选择的支付执行方，具体撤销路径如下：",
+      },
+      {
+        type: "list",
+        items: [
+          "微信支付用户：可通过微信APP内（路径：我 -> 服务 -> 钱包 -> 支付设置 -> 自动续费）或在小程序会员中心页面撤销本授权。",
+          "支付宝用户：可通过支付宝APP内（路径：我的 -> 设置 -> 支付设置 -> 免密支付/自动扣款）或在小程序会员中心页面撤销本授权。",
+          "苹果支付（iOS/App Store订阅）用户：必须通过苹果系统自带的功能进行取消（路径：iOS设备“设置” -> 点击顶部的Apple ID -> 订阅 -> 选择“射灵星球” -> 取消订阅）。",
+        ],
+      },
+      {
+        type: "paragraph",
+        text: "3. 退订生效时效：",
+      },
+      {
+        type: "list",
+        items: [
+          "针对微信支付和支付宝：撤销操作成功后，本授权即时终止，甲方不得再发起新的扣费指令。因第三方支付平台系统结算延迟等客观原因，导致退订生效前系统已自动扣款成功的，该期会员权益将正常发放，已扣费用原则上不予退还。",
+          "针对苹果支付：根据苹果公司政策，乙方需在当前计费周期届满前至少24小时手动取消订阅，否则苹果系统可能会自动续订并扣款。苹果渠道的扣费与退款均由苹果公司独立处理，甲方无权干涉，因乙方未及时取消导致扣费的，由乙方自行承担或向苹果公司申诉。",
+        ],
+      },
+      { type: "heading", text: "七、免责条款" },
+      {
+        type: "paragraph",
+        text: "1. 因乙方支付账户余额不足、账户冻结、挂失、注销、限额等非甲方原因导致扣费失败的，甲方不承担任何责任，由此造成的会员权益中断等后果由乙方自行承担。",
+      },
+      {
+        type: "paragraph",
+        text: "2. 因支付机构系统故障、网络中断、政策调整等第三方不可抗力或外部原因导致扣费延迟、失败或错误的，甲方将协助乙方协调解决，但不承担相应的赔偿责任。",
+      },
+      {
+        type: "paragraph",
+        text: "3. 因乙方泄露支付账户密码、账号被盗用等自身保管不当原因导致的异常扣费，甲方不承担责任，乙方应自行向支付机构或公安机关主张权利。",
+      },
+      { type: "heading", text: "八、信息保密" },
+      {
+        type: "paragraph",
+        text: "1. 甲方及支付机构应对乙方的授权信息、支付信息、个人身份信息严格保密，不得用于本授权以外的任何用途。",
+      },
+      {
+        type: "paragraph",
+        text: "2. 除法律法规规定、司法机关或监管部门依法要求外，甲方不得向任何第三方泄露乙方的授权及支付相关信息。",
+      },
+      { type: "heading", text: "九、争议解决" },
+      {
+        type: "paragraph",
+        text: "1. 本授权协议的订立、效力、履行及争议解决均适用中华人民共和国法律。",
+      },
+      {
+        type: "paragraph",
+        text: "2. 因本协议产生的任何争议，双方应尽量友好协商解决；协商不成的，任何一方均可向甲方住所地（广东省广州市天河区）有管辖权的人民法院提起诉讼。",
+      },
+      { type: "heading", text: "十、其他" },
+      {
+        type: "paragraph",
+        text: "1. 本协议为《射灵星球小程序会员服务协议》的配套协议，与该协议具有同等法律效力；本协议未约定事项，参照主协议执行。",
+      },
+      {
+        type: "paragraph",
+        text: "2. 甲方有权根据业务及监管要求调整本协议内容，调整后的协议将在平台公示，乙方继续使用自动续费服务视为接受调整后的内容。",
+      },
+      {
+        type: "paragraph",
+        text: "3. 甲方客服联系方式：请通过射灵星球小程序内【在线客服】或发送邮件至官方客服邮箱进行反馈。",
+      },
+    ],
+    company: "广州光点飞舞网络有限公司",
+  },
+};
+
+export const getMemberAgreement = (type) => {
+  return memberAgreements[type] || memberAgreements.renew;
+};

src/pages/member/be-vip.vue

@@ -0,0 +1,894 @@
+<script setup>
+import { computed, ref } from "vue";
+import { onShow } from "@dcloudio/uni-app";
+import Container from "@/components/Container.vue";
+import Signin from "@/components/Signin.vue";
+import { virtualPayOrderAPI, getAppConfig, getHomeData, getOrderDetailAPI } from "@/apis";
+import { capsuleHeight, wxLogin } from "@/util";
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+
+const store = useStore();
+const { user, config } = storeToRefs(store);
+const { updateConfig, updateUser } = store;
+
+const currentTypeIndex = ref(1);
+const selectedPackageIndex = ref(0);
+const showModal = ref(false);
+const loadingConfig = ref(false);
+const paying = ref(false);
+const refreshing = ref(false);
+
+// 会员页核心展示数据：视觉、权益按蓝湖当前两张设计稿拆分，套餐完全使用接口数据。
+const memberTypes = [
+  {
+    key: "normal",
+    tab: "VIP",
+    title: "普通会员",
+    prefix: "成为射灵星球",
+    desc: "特享约战竞技次数包、专属会员标识",
+    benefitTitle: "普通会员专属权益",
+    themeClass: "vip-page--normal",
+    heroCard: "https://static.shelingxingqiu.com/shootmini/static/vip/vip-title.png",
+    activeHeroCard: "https://static.shelingxingqiu.com/shootmini/static/vip/vip-title2.png",
+    orderIcon: "../../static/vip/vip-order.png",
+    heroBadge: "../../static/vip/normal-hero-badge.png",
+    buttonClass: "activate-btn--normal",
+    benefits: [
+      { 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" },
+      { label: "约战\n每日+20次", icon: "../../static/vip/vip-battle.png" },
+    ],
+  },
+  {
+    key: "super",
+    tab: "SVIP",
+    title: "超级会员",
+    prefix: "成为射灵星球",
+    desc: "尊享专属特效、无限制约战竞技、专属会员标识",
+    benefitTitle: "超级会员专属权益",
+    themeClass: "vip-page--super",
+    heroCard: "https://static.shelingxingqiu.com/shootmini/static/vip/svip-title.png",
+    activeHeroCard: "https://static.shelingxingqiu.com/shootmini/static/vip/svip-title2.png",
+    orderIcon: "../../static/vip/svip-order.png",
+    heroBadge: "../../static/vip/super-hero-badge.png",
+    buttonClass: "activate-btn--super",
+    benefits: [
+      { 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-comment.png" },
+      { label: "约战无限制", icon: "../../static/vip/svip-battle.png" },
+      { label: "排位赛无限制", icon: "../../static/vip/svip-rank.png" },
+      { label: "专享SVIP客服", icon: "../../static/vip/svip-service.png" },
+    ],
+  },
+];
+
+const currentType = computed(() => memberTypes[currentTypeIndex.value]);
+
+// 后端到期时间可能是秒级时间戳、毫秒级时间戳或日期字符串，这里统一转成毫秒。
+const toTimestamp = (value) => {
+  if (!value) return 0;
+  const numberValue = Number(value);
+  if (!Number.isNaN(numberValue)) {
+    return numberValue < 1000000000000 ? numberValue * 1000 : numberValue;
+  }
+  const time = new Date(value).getTime();
+  return Number.isNaN(time) ? 0 : time;
+};
+
+// 当前卡片只关心本 tab 对应的会员到期时间，普通会员和超级会员互不兜底。
+const getVipExpiredValue = (type, source = user.value) => {
+  if (!source) return 0;
+  return type.key === "super" ? source.superVipExpiredAt : source.normalVipExpiredAt;
+};
+
+// 未过期才展示“会员生效中”样式，已过期或无值继续展示未开通样式。
+const isVipActive = (type) => {
+  return toTimestamp(getVipExpiredValue(type)) > Date.now();
+};
+
+// 会员卡片展示完整到期时间。
+const formatVipDate = (value) => {
+  const timestamp = toTimestamp(value);
+  if (!timestamp) return "";
+  const date = new Date(timestamp);
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hour = String(date.getHours()).padStart(2, "0");
+  const minute = String(date.getMinutes()).padStart(2, "0");
+  const second = String(date.getSeconds()).padStart(2, "0");
+  return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
+};
+
+// 会员生效时使用 title2 切图，未生效时沿用原来的开通引导图。
+const getHeroCard = (type) => {
+  return isVipActive(type) ? type.activeHeroCard : type.heroCard;
+};
+
+const getActiveVipExpiredDate = (type) => {
+  return formatVipDate(getVipExpiredValue(type));
+};
+
+// 设计稿里的“下期自动续费”按到期日前一天展示。
+const getActiveVipRenewDate = (type) => {
+  const timestamp = toTimestamp(getVipExpiredValue(type));
+  if (!timestamp) return "";
+  return formatVipDate(timestamp - 24 * 60 * 60 * 1000);
+};
+
+const configMenus = computed(() => {
+  return config.value.vipMenus || [];
+});
+
+const getMenuName = (item) => {
+  return item.name || item.vipName || item.title || "";
+};
+
+const formatPrice = (value) => {
+  if (value === undefined || value === null || value === "") return "";
+  return String(value).replace("￥", "").replace("¥", "");
+};
+
+const getMenuPrice = (item) => {
+  return formatPrice(item && item.price);
+};
+
+const getMenuOriginalPrice = (item) => {
+  return formatPrice(item && item.originalPrice);
+};
+
+const getMenuSortValue = (item) => {
+  const value = item && item.sort;
+  if (value === undefined || value === null || value === "") return Number.MAX_SAFE_INTEGER;
+  const sort = Number(value);
+  return Number.isFinite(sort) ? sort : Number.MAX_SAFE_INTEGER;
+};
+
+const sortMenusBySort = (menus = []) => {
+  return menus
+    .map((item, index) => ({ item, index }))
+    .sort((a, b) => {
+      const sortDiff = getMenuSortValue(a.item) - getMenuSortValue(b.item);
+      return sortDiff || a.index - b.index;
+    })
+    .map(({ item }) => item);
+};
+
+const getMenuType = (item) => {
+  const vipType = Number(item.vipType);
+  if (vipType === 1) return "normal";
+  if (vipType === 2) return "super";
+
+  const type = String(item.type || "").toLowerCase();
+  if (["super", "svip"].includes(type)) return "super";
+  if (["normal", "vip"].includes(type)) return "normal";
+
+  const name = getMenuName(item);
+  if (/超级|SVIP/i.test(name)) return "super";
+  if (/普通|VIP|会员/i.test(name)) return "normal";
+  return "";
+};
+
+const getPackages = (type) => {
+  return sortMenusBySort(configMenus.value)
+    .filter((item) => getMenuType(item) === type.key)
+    .map((item) => {
+      return {
+        source: item,
+        id: item.id,
+        name: getMenuName(item),
+        price: getMenuPrice(item),
+        originalPrice: getMenuOriginalPrice(item),
+        icon: item.icon,
+      };
+    });
+};
+
+const currentPackages = computed(() => {
+  return getPackages(currentType.value);
+});
+
+const selectedPackage = computed(() => {
+  return currentPackages.value[selectedPackageIndex.value] || currentPackages.value[0];
+});
+
+const switchType = (index) => {
+  currentTypeIndex.value = index;
+  selectedPackageIndex.value = 0;
+};
+
+const onSwiperChange = (event) => {
+  currentTypeIndex.value = event.detail.current;
+  selectedPackageIndex.value = 0;
+};
+
+const selectPackage = (index) => {
+  selectedPackageIndex.value = index;
+};
+
+const toPackageDesc = () => {
+  uni.navigateTo({
+    url: "/pages/member/vip-intro",
+  });
+};
+
+const toOrderPage = () => {
+  uni.navigateTo({
+    url: "/pages/member/orders",
+  });
+};
+
+const toAgreement = (type) => {
+  uni.navigateTo({
+    url: `/pages/member/agreement?type=${type}`,
+  });
+};
+
+const loadVipConfig = async () => {
+  if (loadingConfig.value || configMenus.value.length) return;
+  loadingConfig.value = true;
+  try {
+    const result = await getAppConfig();
+    if (result) updateConfig(result);
+  } catch (error) {
+    console.log("load vip config error", error);
+  } finally {
+    loadingConfig.value = false;
+  }
+};
+
+const refreshUserAfterPay = async () => {
+  refreshing.value = true;
+  try {
+    const result = await getHomeData();
+    if (result.user) {
+      updateUser(result.user);
+    }
+  } catch (error) {
+    console.log("refresh user after pay error", error);
+  } finally {
+    refreshing.value = false;
+  }
+};
+
+const getVirtualPaySignData = (result) => {
+  // 后端可能返回字符串或对象，这里统一转成微信虚拟支付需要的 JSON 字符串。
+  const signDataObj = typeof result?.signData === "string" ? JSON.parse(result.signData) : result?.signData;
+  if (!signDataObj) return "";
+
+  // 微信虚拟支付短剧/虚拟商品模式需要购买数量；后端未返回时使用订单数量兜底。
+  if (!signDataObj.buyQuantity) {
+    signDataObj.buyQuantity = result.quantity || 1;
+  }
+  return JSON.stringify(signDataObj);
+};
+
+const isVirtualPayCancel = (res = {}) => {
+  const message = String(res.errMsg || res.message || "").toLowerCase();
+  const errCode = Number(res.errCode);
+  const errno = Number(res.errno);
+
+  return message.includes("cancel") || errCode === -23 || errno === -2;
+};
+
+const onPay = async () => {
+  if (paying.value || refreshing.value) return;
+  if (!user.value.id) {
+    showModal.value = true;
+    return;
+  }
+  if (!configMenus.value.length) {
+    await loadVipConfig();
+  }
+  const vipId = selectedPackage.value && selectedPackage.value.id;
+  if (!vipId) {
+    uni.showToast({
+      title: loadingConfig.value ? "套餐配置加载中" : "套餐暂不可购买",
+      icon: "none",
+    });
+    return;
+  }
+  if (typeof wx === "undefined" || !wx.requestVirtualPayment) {
+    uni.showToast({
+      title: "当前环境不支持微信虚拟支付",
+      icon: "none",
+    });
+    return;
+  }
+  paying.value = true;
+  let waitingPayment = false;
+  let payToast = null;
+  try {
+    // 微信虚拟支付创建订单前需要登录 code，服务端用它换取本次支付签名参数。
+    const wxResult = await wxLogin();
+    const result = await virtualPayOrderAPI(vipId, wxResult.code);
+    const finalSignData = getVirtualPaySignData(result);
+    if (!finalSignData || !result?.paySig || !result?.signature) {
+      uni.showToast({
+        title: "支付参数生成失败",
+        icon: "none",
+      });
+      refreshing.value = false;
+      return;
+    }
+    wx.requestVirtualPayment({
+      signData: finalSignData,
+      paySig: result.paySig,
+      signature: result.signature,
+      mode: "short_series_goods",
+      async success() {
+        payToast = {
+          title: "支付成功",
+          icon: "success",
+        };
+        if (result?.outTradeNo) {
+          try {
+            const orderDetail = await getOrderDetailAPI(result.outTradeNo);
+            console.log("virtual pay order detail", orderDetail);
+          } catch (error) {
+            console.log("virtual pay order detail error", error);
+          }
+        }
+        // 客户端支付成功后，会员是否真正生效仍以服务端用户信息刷新结果为准。
+        refreshUserAfterPay();
+      },
+      fail(res) {
+        console.log("virtual pay error", res);
+        if (isVirtualPayCancel(res)) {
+          payToast = {
+            title: "支付已取消",
+            icon: "none",
+          };
+          return;
+        }
+        payToast = {
+          title: res.message || "支付失败，请稍后重试",
+          icon: "none",
+        };
+      },
+      complete() {
+        paying.value = false;
+        if (payToast) {
+          setTimeout(() => {
+            uni.showToast(payToast);
+          }, 200);
+        }
+      },
+    });
+    waitingPayment = true;
+  } catch (error) {
+    console.log("create virtual pay order error", error);
+    uni.showToast({
+      title: error.message || "下单失败",
+      icon: "none",
+    });
+  } finally {
+    if (!waitingPayment) paying.value = false;
+  }
+};
+
+onShow(loadVipConfig);
+
+</script>
+
+<template>
+  <Container title="" :bgType="10" :scroll="false" :showBottom="false">
+    <view class="vip-page" :class="currentType.themeClass">
+      <view class="type-tabs" :style="{ top: capsuleHeight + 'px' }">
+        <view
+          v-for="(item, index) in memberTypes"
+          :key="item.key"
+          class="type-tab"
+          :class="{ 'type-tab--active': currentTypeIndex === index }"
+          @click="switchType(index)"
+        >
+          <text>{{ item.tab }}</text>
+          <view class="type-tab__indicator" />
+        </view>
+      </view>
+      <swiper
+        class="type-swiper"
+        :current="currentTypeIndex"
+        :duration="260"
+        @change="onSwiperChange"
+      >
+        <swiper-item v-for="type in memberTypes" :key="type.key">
+          <scroll-view scroll-y class="type-scroll" :show-scrollbar="false">
+            <view class="vip-content">
+              <view
+                class="hero-card"
+                :class="{ 'hero-card--active': isVipActive(type) }"
+              >
+                <image class="hero-card__bg" :src="getHeroCard(type)" mode="scaleToFill" />
+                <!-- 生效态卡片使用 title2 底图，补充有效期和订单入口叠层。 -->
+                <view v-if="isVipActive(type)" class="hero-card__content">
+                  <text class="hero-card__date">
+                    有效期至：{{ getActiveVipExpiredDate(type) }}
+                  </text>
+                  <!-- <text v-if="type.key === 'super'" class="hero-card__renew">
+                    下期会员将于：{{ getActiveVipRenewDate(type) }}自动续费
+                  </text> -->
+                  <view class="hero-card__order" @click.stop="toOrderPage">
+                    <image class="hero-card__order-icon" :src="type.orderIcon" mode="aspectFit" />
+                    <text>订单管理</text>
+                  </view>
+                </view>
+              </view>
+
+              <view class="benefit-title">
+                <view class="benefit-title__line" />
+                <text>{{ type.benefitTitle }}</text>
+                <view class="benefit-title__line" />
+              </view>
+
+              <view class="benefit-grid" :class="{ 'benefit-grid--normal': type.key === 'normal' }">
+                <view
+                  v-for="benefit in type.benefits"
+                  :key="benefit.label"
+                  class="benefit-item"
+                >
+                  <view class="benefit-icon">
+                    <image class="benefit-icon__img" :src="benefit.icon" mode="aspectFit" />
+                  </view>
+                  <text class="benefit-item__label">{{ benefit.label }}</text>
+                </view>
+              </view>
+
+              <view class="package-header">
+                <text class="package-header__title">选择套餐</text>
+                <view class="package-header__link" @click="toPackageDesc">
+                  <text>套餐说明</text>
+                  <image
+                    class="package-header__icon"
+                    src="../../static/enter.png"
+                    mode="aspectFit"
+                  />
+                </view>
+              </view>
+
+              <scroll-view scroll-x class="package-scroll" :show-scrollbar="false">
+                <view class="package-list">
+                  <view
+                    v-for="(pack, index) in getPackages(type)"
+                    :key="`${type.key}-${pack.id || pack.name || index}`"
+                    class="package-card"
+                    :class="{ 'package-card--active': selectedPackageIndex === index }"
+                    @click="selectPackage(index)"
+                  >
+                    <view class="package-card__inner">
+                      <text class="package-name">{{ pack.name }}</text>
+                      <view class="package-price">
+                        <text class="package-price__symbol">¥</text>
+                        <text class="package-price__value">{{ pack.price }}</text>
+                      </view>
+                      <view v-if="pack.originalPrice" class="package-origin">
+                        <text>¥{{ pack.originalPrice }}</text>
+                        <view class="package-origin__line" />
+                      </view>
+                    </view>
+                  </view>
+                </view>
+              </scroll-view>
+
+              <button
+                hover-class="none"
+                class="activate-btn"
+                :class="type.buttonClass"
+                :disabled="loadingConfig || paying || refreshing || !selectedPackage"
+                @click="onPay"
+              >
+                <text v-if="loadingConfig">加载套餐中</text>
+                <text v-else-if="paying">创建订单中</text>
+                <text v-else-if="refreshing">刷新会员状态中</text>
+                <text v-else-if="selectedPackage">¥ {{ selectedPackage.price }} 一键激活</text>
+                <text v-else>套餐暂不可购买</text>
+              </button>
+
+              <view class="agreement">
+                <text>支付即同意</text>
+                《&nbsp;<text class="agreement__link" @click.stop="toAgreement('renew')">会员自动续费服务协议</text>》
+                《&nbsp;<text class="agreement__link" @click.stop="toAgreement('deduct')">扣款授权服务协议</text>》
+              </view>
+            </view>
+          </scroll-view>
+        </swiper-item>
+      </swiper>
+      <Signin :show="showModal" :onClose="() => (showModal = false)" />
+    </view>
+  </Container>
+</template>
+
+<style scoped>
+.vip-page {
+  position: relative;
+  width: 100%;
+  height: 100%;
+}
+.type-tabs {
+  position: fixed;
+  left: 0;
+  z-index: 998;
+  width: 50%;
+  height: 50px;
+  margin-left: 50%;
+  transform:translateX(-60%);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  pointer-events: auto;
+}
+
+.type-tab {
+  width: 132rpx;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  color: rgba(255, 255, 255, 0.45);
+  font-size: 34rpx;
+  font-weight: 700;
+  font-style: italic;
+}
+
+.type-tab__indicator {
+  width: 40rpx;
+  height: 4rpx;
+  border-radius: 4rpx;
+  margin-top: 8rpx;
+  background-color: transparent;
+}
+
+.type-tab--active {
+  color: #ffffff;
+}
+
+.vip-page--normal .type-tab--active .type-tab__indicator {
+  background-color: #ffffff;
+}
+
+.vip-page--super .type-tab--active {
+  color: #fedab5;
+}
+
+.vip-page--super .type-tab--active .type-tab__indicator {
+  background-color: #fedab5;
+}
+
+.type-swiper {
+  position: relative;
+  z-index: 1;
+  width: 100%;
+  height: 100%;
+}
+
+.type-scroll {
+  width: 100%;
+  height: 100%;
+}
+
+.vip-content {
+  min-height: 100%;
+  padding: 32rpx 24rpx 52rpx;
+  box-sizing: border-box;
+}
+
+.hero-card {
+  position: relative;
+  width: 702rpx;
+  height: 260rpx;
+  overflow: hidden;
+}
+
+.hero-card__bg {
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 702rpx;
+  height: 260rpx;
+}
+
+.hero-card__content {
+  position: relative;
+  z-index: 1;
+  /* 对齐 title2 切图左侧预留文案区域。 */
+  padding: 132rpx 0 0 44rpx;
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  box-sizing: border-box;
+}
+
+.hero-card__date,
+.hero-card__renew {
+  color: #8d6d55;
+  font-size: 24rpx;
+  line-height: 34rpx;
+}
+
+.vip-page--normal .hero-card__date,
+.vip-page--normal .hero-card__renew {
+  color: #555555;
+}
+
+.hero-card__order {
+  display: flex;
+  align-items: center;
+  margin-top: 10rpx;
+  color: #6d5644;
+  font-size: 24rpx;
+  line-height: 34rpx;
+  text-decoration: underline;
+}
+
+.vip-page--normal .hero-card__order {
+  color: #555555;
+}
+
+.hero-card__order-icon {
+  width: 28rpx;
+  height: 32rpx;
+  margin-right: 8rpx;
+  flex-shrink: 0;
+}
+
+.benefit-title {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin-top: 38rpx;
+  color: #ffffff;
+  font-size: 24rpx;
+  line-height: 34rpx;
+}
+
+.benefit-title__line {
+  width: 14rpx;
+  height: 2rpx;
+  background-color: #ffffff;
+  margin: 0 10rpx;
+}
+
+.benefit-grid {
+  display: flex;
+  flex-wrap: wrap;
+  width: 622rpx;
+  margin: 38rpx auto 0;
+}
+
+.benefit-grid--normal {
+  width: 672rpx;
+}
+
+.benefit-item {
+  width: 144rpx;
+  height: 122rpx;
+  margin-right: 94rpx;
+  margin-bottom: 30rpx;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+
+.benefit-item:nth-child(3n) {
+  margin-right: 0;
+}
+
+.benefit-grid--normal .benefit-item {
+  margin-right: 120rpx;
+}
+
+.benefit-grid--normal .benefit-item:nth-child(3n) {
+  margin-right: 0;
+}
+
+.benefit-icon {
+  width: 80rpx;
+  height: 80rpx;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.benefit-icon__img {
+  width: 80rpx;
+  height: 80rpx;
+  display: block;
+}
+
+.benefit-item__label {
+  margin-top: 8rpx;
+  color: #ffffff;
+  opacity: 0.7;
+  font-size: 24rpx;
+  line-height: 34rpx;
+  text-align: center;
+  white-space: pre-line;
+}
+
+.package-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  margin-top: 56rpx;
+  padding-right: 8rpx;
+}
+
+.benefit-grid--normal + .package-header {
+  margin-top: 146rpx;
+}
+
+.package-header__title {
+  color: #ffffff;
+  font-size: 28rpx;
+  line-height: 40rpx;
+  font-weight: 500;
+}
+
+.vip-page--super .package-header__title {
+  color: #e7ba80;
+}
+
+.package-header__link {
+  display: flex;
+  align-items: center;
+  color: #999999;
+  font-size: 22rpx;
+  line-height: 32rpx;
+}
+
+.package-header__icon {
+  width: 24rpx;
+  height: 28rpx;
+}
+
+.package-scroll {
+  width: 100%;
+  margin-top: 40rpx;
+  white-space: nowrap;
+}
+
+.package-list {
+  display: inline-flex;
+  min-width: 100%;
+  padding: 6rpx 84rpx 6rpx 6rpx;
+  box-sizing: border-box;
+}
+
+.package-card {
+  position: relative;
+  width: 264rpx;
+  flex: 0 0 264rpx;
+  height: 224rpx;
+  border-radius: 16rpx;
+  border: 2rpx solid #999999;
+  margin-right: 32rpx;
+  padding: 0;
+  overflow: hidden;
+  box-sizing: border-box;
+  color: #999999;
+}
+
+.package-card__inner {
+  width: 100%;
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  box-sizing: border-box;
+  border-radius: inherit;
+}
+
+.package-card--active {
+  border-width: 6rpx;
+  border-color: #fed847;
+}
+
+.vip-page--super .package-card--active {
+  border: none;
+  padding: 6rpx;
+  background: linear-gradient(180deg, #fef3e6 0%, #f0c191 100%);
+}
+
+.vip-page--super .package-card--active .package-card__inner {
+  border-radius: 10rpx;
+  background-color: #050b19;
+}
+
+.package-name {
+  font-size: 24rpx;
+  line-height: 34rpx;
+}
+
+.package-price {
+  display: flex;
+  align-items: baseline;
+  margin-top: 12rpx;
+  color: #ffffff;
+}
+
+.package-card--active .package-price {
+  color: #fed847;
+}
+
+.vip-page--super .package-card--active .package-price {
+  color: #ffe8cd;
+}
+
+.package-price__symbol {
+  font-size: 30rpx;
+  line-height: 36rpx;
+  font-weight: 700;
+}
+
+.package-price__value {
+  font-size: 56rpx;
+  line-height: 66rpx;
+  font-weight: 700;
+}
+
+.package-origin {
+  position: relative;
+  margin-top: 2rpx;
+  color: #999999;
+  font-size: 24rpx;
+  line-height: 34rpx;
+}
+
+.package-origin__line {
+  position: absolute;
+  left: -4rpx;
+  right: -4rpx;
+  top: 16rpx;
+  height: 2rpx;
+  background-color: #999999;
+}
+
+.activate-btn {
+  width: 686rpx;
+  height: 88rpx;
+  border-radius: 44rpx;
+  margin: 34rpx auto 0;
+  padding: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: #000000;
+  font-size: 30rpx;
+  line-height: 42rpx;
+  font-weight: 500;
+}
+
+.activate-btn::after {
+  border: none;
+}
+
+.activate-btn--normal {
+  background-color: #fed847;
+}
+
+.activate-btn--super {
+  background: linear-gradient( 181deg, #FDFDFC 0%, #FDF8F2 0%, #FFC992 100%, #FFB96C 100%);
+}
+
+.agreement {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  margin-top: 24rpx;
+  color: #999999;
+  font-size: 20rpx;
+  line-height: 28rpx;
+}
+
+.agreement__link {
+  margin-left: -6rpx;
+  text-decoration: underline;
+}
+</style>

src/pages/member/order-detail.vue

@@ -61,6 +61,18 @@ const goPay = async () => {
   }
 };
 
+const copyOrderId = (orderId) => {
+  uni.setClipboardData({
+    data: String(orderId),
+    success: () => {
+      uni.showToast({
+        title: "复制成功",
+        icon: "success",
+      });
+    },
+  });
+};
+
 const cancelOrder = async () => {
   const result = await cancelOrderListAPI(data.value.orderId);
   data.value = result;
@@ -78,14 +90,17 @@ const cancelOrder = async () => {
       >
       <view class="order">
         <view>
-          <text>商品名：{{ data.vipName }}</text>
-          <text>订单号：{{ data.orderId }}</text>
-          <text>下单时间：{{ data.vipCreateAt }}</text>
-          <text
-            >支付时间：{{
+          <text>{{ data.vipName }}</text>
+          <view class="order-number">
+            <text>订单号：{{ data.orderId }}</text>
+            <text class="copy-action" @click.stop="copyOrderId(data.orderId)"
+              >复制</text
+            >
+          </view>
+          <text>创建时间：{{ data.orderCreateAt }}</text>
+          <text v-if="data.orderStatus === 4">支付时间：{{
               data.orderStatus === 4 ? data.paymentTime : ""
-            }}</text
-          >
+            }}</text>
           <text>金额：{{ data.total }} 元</text>
           <text>支付方式：微信</text>
         </view>
@@ -141,4 +156,25 @@ const cancelOrder = async () => {
   text-align: center;
   font-size: 11px;
 }
+
+.order-number {
+  display: flex;
+  align-items: center;
+  color: #666666;
+  font-size: 26rpx;
+  margin-top: 10rpx;
+}
+.order-number > text:first-child {
+  flex: 1;
+  min-width: 0;
+  word-break: break-all;
+}
+.copy-action {
+  flex-shrink: 0;
+  margin-left: 16rpx;
+  padding: 2rpx 14rpx;
+  color: #1f6ed4;
+  font-size: 24rpx;
+  line-height: 34rpx;
+}
 </style>

src/pages/member/orders.vue

@@ -3,6 +3,7 @@ import { ref, onMounted } from "vue";
 import { onShow } from "@dcloudio/uni-app";
 import Container from "@/components/Container.vue";
 import ScrollList from "@/components/ScrollList.vue";
+import ModalDialog from "@/components/ModalDialog.vue";
 import { getOrderListAPI } from "@/apis";
 import useStore from "@/store";
 import { orderStatusNames, getStatusColor } from "@/constants";
@@ -10,13 +11,34 @@ import { storeToRefs } from "pinia";
 const store = useStore();
 const { user, config } = storeToRefs(store);
 
+const autoRenewDialogVisible = ref(false);
+const selectedRenewOrder = ref(null);
+
 const toDetailPage = (detail) => {
   uni.setStorageSync("order", detail);
   uni.navigateTo({
-    url: `/pages/order-detail`,
+    url: "/pages/member/order-detail",
   });
 };
 
+const openAutoRenewDialog = (detail) => {
+  selectedRenewOrder.value = detail;
+  autoRenewDialogVisible.value = true;
+};
+
+const closeAutoRenewDialog = () => {
+  autoRenewDialogVisible.value = false;
+  selectedRenewOrder.value = null;
+};
+
+const confirmAutoRenewDialog = () => {
+  autoRenewDialogVisible.value = false;
+   uni.showToast({
+      title: "功能实现中",
+      icon: "none",
+    });
+}
+
 const list = ref([]);
 
 const onLoading = async (page) => {
@@ -44,7 +66,7 @@ onShow(() => {
 </script>
 
 <template>
-  <Container title="订单">
+  <Container title="订单管理">
     <view class="container">
       <ScrollList :onLoading="onLoading">
         <view
@@ -58,18 +80,31 @@ onShow(() => {
             >{{ orderStatusNames[item.orderStatus] }}</view
           >
           <text>{{ item.vipName }}</text>
-          <!-- <text>订单号：{{ item.orderId }}</text> -->
-          <!-- <text>创建时间：{{ item.vipCreateAt }}</text> -->
-          <text
+          <text>订单号：{{ item.orderId }}</text>
+          <text>创建时间：{{ item.orderCreateAt }}</text>
+          <!-- <text
             >支付时间：{{
               item.orderStatus === 4 ? item.paymentTime : ""
             }}</text
-          >
+          > -->
           <text>金额：{{ item.total }} 元</text>
-          <text>支付方式：微信</text>
+          <!-- <text>支付方式：微信</text> -->
+          <!-- <text class="renew-action" @click.stop="openAutoRenewDialog(item)">
+            自动续费
+          </text> -->
         </view>
       </ScrollList>
     </view>
+
+    <ModalDialog
+      :show="autoRenewDialogVisible"
+      title=""
+      :content="'确定关闭自动续费吗?\n会员到期后你将失去7项特权哦!'"
+      cancel-text="一意孤行"
+      confirm-text="继续享受"
+      :on-cancel="closeAutoRenewDialog"
+      :on-confirm="confirmAutoRenewDialog"
+    />
   </Container>
 </template>
 
@@ -78,15 +113,15 @@ onShow(() => {
   width: 100%;
   height: 100%;
   background-color: #f5f5f5;
-  padding-top: 10px;
+  padding-top: 16rpx;
 }
 .order-item {
   position: relative;
   background-color: #fff;
-  margin-bottom: 10px;
+  margin-bottom: 16rpx;
   display: flex;
   flex-direction: column;
-  padding: 15px;
+  padding: 28rpx 30rpx 18rpx 30rpx;
 }
 .order-item > view:first-child {
   position: absolute;
@@ -98,12 +133,20 @@ onShow(() => {
   font-size: 11px;
 }
 .order-item > text:nth-child(2) {
-  color: #000;
-  font-size: 16px;
+  color: #333333;
+  font-size: 30rpx;
+  font-weight: bold;
 }
 .order-item > text {
   color: #666666;
-  font-size: 13px;
-  margin-top: 5px;
+  font-size: 26rpx;
+  margin-bottom: 10rpx;
+}
+.order-item > .renew-action {
+  position: absolute;
+  right: 30rpx;
+  bottom: 18rpx;
+  color: #1f6ed4;
+  margin-bottom: 0;
 }
 </style>

src/pages/member/vip-intro.vue

@@ -0,0 +1,244 @@
+<script setup>
+import Container from "@/components/Container.vue";
+</script>
+
+<template>
+  <Container title="会员权益说明">
+    <scroll-view scroll-y class="vip-intro" :show-scrollbar="false">
+      <view class="content">
+        <view class="page-title">射灵星球会员权益</view>
+
+        <view class="paragraph">
+          <text class="strong">核心特权：</text>
+          <text>解锁约战、段位评级、实时排位赛、AI智能教练点评四大核心功能。</text>
+        </view>
+
+        <view class="paragraph">
+          <text class="strong">专属服务：</text>
+          <text>享全年不同阶段VIP专属客服，快速解决技术故障、规则疑问等所有问题。</text>
+        </view>
+
+        <view class="paragraph">
+          <text class="strong">新用户福利：</text>
+          <text>所有初次绑定设备的用户，免费赠送6个月普通会员。</text>
+        </view>
+
+        <view class="paragraph">
+          <text>
+            加入射灵星球，在真实射箭运动中体验在线竞技的乐趣，结识全球志同道合的弓友，持续享受新功能与系统升级，不断挑战自我，创造属于你的辉煌战绩！
+          </text>
+        </view>
+
+        <view class="table-wrap">
+          <view class="intro-toast">
+            <image class="intro-toast__bg" src="../../static/vip/intro-toast.png" mode="scaleToFill" />
+            <text class="intro-toast__text">初次绑定设备赠送6个月</text>
+          </view>
+          <view class="benefit-table">
+            <view class="table-row table-head">
+              <text class="table-cell table-cell--feature">特权</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>
+              <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>
+              <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>
+              <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>
+              <text class="table-cell">2次</text>
+              <text class="table-cell">22次</text>
+              <text class="table-cell">无限</text>
+            </view>
+            <view class="table-row">
+              <text class="table-cell table-cell--feature">每日排位赛次数</text>
+              <text class="table-cell">2次</text>
+              <text class="table-cell">22次</text>
+              <text class="table-cell">无限</text>
+            </view>
+            <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>
+            </view>
+            <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>
+            </view>
+            <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>
+            </view>
+          </view>
+        </view>
+
+        <view class="section-title">会员时长叠加与生效规则</view>
+
+        <view class="paragraph">
+          <text class="strong">等级优先级：</text>
+          <text>
+            同时拥有 超级会员 和 普通会员 时，优先使用超级会员权益，普通会员时长自动顺延，待 超级会员 到期后自动生效。
+          </text>
+        </view>
+
+        <view class="paragraph">
+          <text class="strong">连续套餐叠加：</text>
+          <text>
+            已有月 / 半年 / 年卡时再购买连续包月 / 包年，总有效期直接累加；连续套餐从下单日起算，下个周期正常自动扣费。
+          </text>
+        </view>
+
+        <view class="paragraph example">
+          <text>
+            示例：1 月 1 日买半年卡（7 月 1 日到期），1 月 10 日买连续包月，总有效期延至 8 月 1 日，8 月 1 日会发起首次自动扣款。
+          </text>
+        </view>
+
+        <view class="paragraph">
+          <text class="strong">升级超级会员规则：</text>
+          <text>
+            购买升级 超级会员 后立即生效，可升级时长以购买页面提示为准；未升级的剩余 普通会员 时长，将在 超级会员 到期后继续使用。
+          </text>
+        </view>
+      </view>
+    </scroll-view>
+  </Container>
+</template>
+
+<style scoped lang="scss">
+.vip-intro {
+  width: 100%;
+  height: 100%;
+  background-color: #ffffff;
+}
+
+.content {
+  padding: 30rpx;
+  box-sizing: border-box;
+}
+
+.page-title,
+.section-title {
+  color: #333333;
+  font-size: 28rpx;
+  line-height: 40rpx;
+  font-weight: 700;
+}
+
+.page-title {
+  margin-bottom: 26rpx;
+}
+
+.section-title {
+  margin: 42rpx 0 22rpx;
+}
+
+.paragraph {
+  margin-bottom: 22rpx;
+  color: #333333;
+  font-size: 26rpx;
+  line-height: 38rpx;
+}
+
+.strong {
+  color: #333333;
+  font-weight: 700;
+}
+
+.example {
+  color: #666666;
+}
+
+.table-wrap {
+  position: relative;
+  margin-top: 34rpx;
+}
+
+.intro-toast {
+  position: absolute;
+  top: -38rpx;
+  right: 118rpx;
+  z-index: 2;
+  width: 222rpx;
+  height: 54rpx;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.intro-toast__bg {
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 222rpx;
+  height: 54rpx;
+}
+
+.intro-toast__text {
+  position: relative;
+  z-index: 1;
+  color: #333333;
+  font-size: 18rpx;
+  line-height: 30rpx;
+  font-weight: 500;
+  white-space: nowrap;
+  margin-top: -6rpx;
+}
+
+.benefit-table {
+  width: 100%;
+  border-top: 1rpx solid #e5e5e5;
+  border-left: 1rpx solid #e5e5e5;
+  box-sizing: border-box;
+}
+
+.table-row {
+  display: flex;
+  min-height: 60rpx;
+}
+
+.table-cell {
+  width: 22.5%;
+  min-height: 60rpx;
+  padding: 12rpx 4rpx;
+  border-right: 1rpx solid #e5e5e5;
+  border-bottom: 1rpx solid #e5e5e5;
+  box-sizing: border-box;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: #333333;
+  font-size: 24rpx;
+  line-height: 34rpx;
+  text-align: center;
+}
+
+.table-cell--feature {
+  width: 32.5%;
+}
+
+.table-head .table-cell {
+  color: #666666;
+  font-weight: 700;
+}
+</style>

src/pages/mine-bow-data.vue

@@ -11,12 +11,14 @@ import { storeToRefs } from "pinia";
 const store = useStore();
 const { user } = storeToRefs(store);
 const arrows = ref([]);
+const isSvip = ref(false);
 const total = ref(0);
 
 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;
 });
 </script>
@@ -34,7 +36,7 @@ onLoad(async (options) => {
         </view>
       </view> -->
       <view :style="{ marginBottom: '20px' }">
-        <BowTarget :scores="arrows" />
+        <BowTarget :scores="arrows" :isSvip="isSvip" />
       </view>
       <view class="desc">
         <text>{{ arrows.length }}</text>

src/pages/my-device.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { ref } from "vue";
+import { computed, ref } from "vue";
 import { onShow } from "@dcloudio/uni-app";
 import Container from "@/components/Container.vue";
 import ScreenHint from "@/components/ScreenHint.vue";
@@ -16,11 +16,13 @@ const showTip = ref(false);
 const confirmBindTip = ref(false);
 const addDevice = ref();
 const store = useStore();
-const { updateDevice } = store;
+const { updateDevice, clearDevice } = store;
 const { user, device } = storeToRefs(store);
 const justBind = ref(false);
 const calibration = ref(false);
 const token = ref(null);
+const isSVip = computed(() => user.value.sVip === true);
+const isVip = computed(() => user.value.vip === true && !isSVip.value);
 
 // 扫描二维码方法
 const handleScan = () => {
@@ -84,13 +86,26 @@ const toFristTryPage = () => {
 };
 
 const unbindDevice = async () => {
-  await unbindDeviceAPI(device.value.deviceId);
+  try {
+    await unbindDeviceAPI(device.value.deviceId);
+  } catch (error) {
+    if (error?.type === "DEVICE_BIND_INVALID") {
+      uni.setStorageSync("calibration", false);
+      clearDevice();
+    }
+    return;
+  }
   uni.setStorageSync("calibration", false);
   uni.showToast({
     title: "解绑成功",
     icon: "success",
   });
-  device.value = {};
+  clearDevice();
+};
+
+/** 连接wifi跳转到wifi列表页面 */
+const joinWifi = () => {
+  uni.navigateTo({ url: "/pages/ota-wifi" });
 };
 
 const toDeviceIntroPage = () => {
@@ -122,16 +137,31 @@ const goCalibration = async () => {
   });
 };
 
-onShow(() => {
+const syncDeviceBinding = async () => {
+  if (!user.value.id) return;
+  try {
+    const devices = await getMyDevicesAPI();
+    if (devices.bindings && devices.bindings.length) {
+      updateDevice(devices.bindings[0].deviceId, devices.bindings[0].deviceName);
+    } else {
+      clearDevice();
+    }
+  } catch (error) {
+    console.log("sync device binding error", error);
+  }
+};
+
+onShow(async () => {
   calibration.value = uni.getStorageSync("calibration");
+  await syncDeviceBinding();
 });
 </script>
 
 <template>
   <Container title="弓箭绑定">
     <view v-if="!device.deviceId" class="scan-code">
-      <button hover-class="none" @click="handleScan">
-        <image src="../static/scan.png" mode="widthFix" />
+      <button hover-class="none" @click="$clickSound(handleScan)">
+        <image src="https://static.shelingxingqiu.com/shootmini/static/scan.png" mode="widthFix" />
       </button>
       <button hover-class="none" @click="showTip = true">
         <text>扫</text>
@@ -142,7 +172,7 @@ onShow(() => {
       <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"
@@ -189,7 +219,7 @@ onShow(() => {
         :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">
@@ -209,41 +239,54 @@ onShow(() => {
             mode="widthFix"
             :style="{ borderRadius: '50%' }"
           />
-          <text>{{ user.nickName }}</text>
+          <view
+            :class="[
+              'member-nickname',
+              isVip ? 'member-nickname--vip' : '',
+              isSVip ? 'member-nickname--svip' : '',
+            ]"
+          >
+            <text class="member-nickname__text">{{ user.nickName }}</text>
+            <text v-if="isSVip" class="member-nickname__shine">{{
+              user.nickName
+            }}</text>
+          </view>
         </view>
       </view>
-      <block v-if="calibration">
-        <SButton :onClick="toFristTryPage" width="60vw" :rounded="40"
-          >进入新手试炼</SButton
-        >
-        <view :style="{ marginTop: '15px' }">
-          <SButton
-            :onClick="backToHome"
-            backgroundColor="#fff3"
-            color="#fff"
-            width="60vw"
-            :rounded="40"
-            >返回首页</SButton
-          >
-        </view>
-      </block>
-      <block v-else>
+      <!-- <block v-if="calibration"> -->
         <view>
           <text>恭喜，你的弓箭和账号已成功绑定！</text>
           <text :style="{ color: '#fed847' }">已赠送6个月射灵世界会员</text>
         </view>
-        <SButton :onClick="goCalibration" width="60vw" :rounded="40">
+        <!-- <SButton :onClick="goCalibration" width="60vw" :rounded="40">
           开启智能弓进行校准
         </SButton>
         <text :style="{ marginTop: '20rpx', fontSize: '24rpx', color: '#fff9' }"
           >校准时弓箭激光将开启，请勿直视激光</text
-        >
-      </block>
+        > -->
+
+        <view>
+          <SButton
+          :onClick="backToHome"
+          backgroundColor="#fff3"
+          color="#fff"
+          width="60vw"
+          :rounded="40"
+          >返回首页</SButton
+          >
+        </view>
+        <view :style="{ marginTop: '15px' }">
+          <SButton :onClick="toFristTryPage" width="60vw" :rounded="40">进入新手试炼</SButton>
+        </view>
+      <!-- </block> -->
+      <!-- <block v-else>
+        
+      </block> -->
     </view>
     <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">
@@ -265,14 +308,30 @@ onShow(() => {
             mode="widthFix"
             :style="{ borderRadius: '50%' }"
           />
-          <text>{{ user.nickName }}</text>
+          <view
+            :class="[
+              'member-nickname',
+              isVip ? 'member-nickname--vip' : '',
+              isSVip ? 'member-nickname--svip' : '',
+            ]"
+          >
+            <text class="member-nickname__text">{{ user.nickName }}</text>
+            <text v-if="isSVip" class="member-nickname__shine">{{
+              user.nickName
+            }}</text>
+          </view>
         </view>
       </view>
       <view :style="{ marginTop: '240rpx' }">
-        <SButton :onClick="unbindDevice" width="80vw" :rounded="40"
+        <SButton :onClick="() => $clickSound(unbindDevice)" width="80vw" :rounded="40"
           >解绑</SButton
         >
       </view>
+      <view :style="{ marginTop: '20rpx' }">
+        <SButton :onClick="() => $clickSound(joinWifi)" width="80vw" :rounded="40"
+          >设备连接WIFI</SButton
+        >
+      </view>
     </view>
   </Container>
 </template>
@@ -394,7 +453,7 @@ onShow(() => {
   width: 140rpx;
   height: 140rpx;
   margin-bottom: 5px;
-  border-radius: 10px;
+  border-radius: 12px;
 }
 .device-binded > view > text {
   width: 120px;
@@ -403,6 +462,15 @@ onShow(() => {
   text-overflow: ellipsis;
   text-align: center;
 }
+.device-binded .member-nickname {
+  justify-content: center;
+  width: 120px;
+}
+.device-binded .member-nickname__text,
+.device-binded .member-nickname__shine {
+  font-size: 26rpx;
+  text-align: center;
+}
 .device-binded > image {
   width: 100rpx;
   margin: 0 20px;

src/pages/my-growth.vue

@@ -55,7 +55,14 @@ const onPractiseLoading = async (page) => {
 };
 const getName = (battle) => {
   if (battle.mode <= 3) return `${battle.mode}V${battle.mode}`;
-  return battle.mode + "人大乱斗";
+  // 排位赛大乱斗：mode 数字与实际人数不一致，使用固定映射
+  if (battle.way === 2) {
+    if (battle.mode === 4) return "5人大乱斗";
+    if (battle.mode === 5) return "10人大乱斗";
+  }
+  // 好友约战大乱斗：从 teams[0].players 取实际参与人数动态展示
+  const count = battle.teams?.[0]?.players?.length;
+  return count ? `${count}人大乱斗` : "大乱斗";
 };
 
 /**
@@ -108,7 +115,7 @@ onLoad((options) => {
                 :blueTeam="item.teams[1] ? item.teams[1].players : []"
                 :redTeam="item.teams[2] ? item.teams[2].players : []"
                 :winner="item.winTeam"
-                :showRank="item.teams[0]"
+                :showRank="!!item.teams[0]"
                 :showHeader="false"
               />
             </view>
@@ -131,7 +138,7 @@ onLoad((options) => {
                 :blueTeam="item.teams[1] ? item.teams[1].players : []"
                 :redTeam="item.teams[2] ? item.teams[2].players : []"
                 :winner="item.winTeam"
-                :showRank="item.teams[0]"
+                :showRank="!!item.teams[0]"
                 :showHeader="false"
               />
             </view>

src/pages/point-book-create.vue

@@ -114,7 +114,7 @@ onMounted(async () => {
       />
     </view>
     <template #bottom>
-      <SButton :rounded="50" :onClick="toEditPage">下一步</SButton>
+      <SButton :rounded="50" :onClick="() => $clickSound(toEditPage)">下一步</SButton>
     </template>
   </Container>
 </template>

src/pages/point-book-detail-share.vue

@@ -107,7 +107,7 @@ const targetTypeName = computed(() => {
 <template>
   <view class="container" :style="{ paddingTop: paddingTop + 'px' }">
     <image
-      src="../static/app-bg5.png"
+      src="https://static.shelingxingqiu.com/shootmini/static/app-bg5.png"
       class="bg-image"
       mode="aspectFill"
       :style="{ height: paddingTop + 60 + 'px' }"

src/pages/point-book-detail.vue

@@ -81,9 +81,17 @@ const loading = ref(false);
 const shareImage = async () => {
   if (loading.value) return;
   loading.value = true;
-  await generateShareImage("shareImageCanvas", record.value);
-  await wxShare("shareImageCanvas");
-  loading.value = false;
+  try {
+    await generateShareImage("shareImageCanvas", record.value);
+    await wxShare("shareImageCanvas");
+  } catch (e) {
+    uni.showToast({
+      title: "海报生成失败，请稍后重试",
+      icon: "none",
+    });
+  } finally {
+    loading.value = false;
+  }
 };
 
 onLoad(async (options) => {

src/pages/point-book-edit.vue

@@ -198,7 +198,7 @@ onLoad((options) => {
       </ScreenHint2>
     </view>
     <template #bottom>
-      <SButton :rounded="50" :onClick="onSubmit">
+      <SButton :rounded="50" :onClick="() => $clickSound(onSubmit)">
         {{ currentGroup === groups ? "保存并查看分析" : "下一组" }}
       </SButton>
     </template>

src/pages/point-book-rank.vue

@@ -15,11 +15,22 @@ const list = ref([]);
 const mine = ref({
   averageRing: 0,
 });
+const sharing = ref(false);
 
 const shareImage = async () => {
-  if (!mine.value.id) return;
-  await sharePointData("shareCanvas", mine.value);
-  await wxShare("shareCanvas");
+  if (!mine.value.id || sharing.value) return;
+  sharing.value = true;
+  try {
+    await sharePointData("shareCanvas", mine.value);
+    await wxShare("shareCanvas");
+  } catch (e) {
+    uni.showToast({
+      title: "海报生成失败，请稍后重试",
+      icon: "none",
+    });
+  } finally {
+    sharing.value = false;
+  }
 };
 
 onMounted(async () => {
@@ -33,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"

src/pages/point-book.vue

@@ -329,10 +329,10 @@ onShareTimeline(() => {
             </view>
           </view>
           <view>
-            <button hover-class="none" @click="toRecordPage" class="image-btn">
+            <button hover-class="none" @click="$clickSound(toRecordPage)" class="image-btn">
               <image src="../static/record-btn.png" mode="widthFix" />
             </button>
-            <button hover-class="none" @click="startScoring" class="image-btn">
+            <button hover-class="none" @click="$clickSound(startScoring)" class="image-btn">
               <image src="../static/start-scoring.png" mode="widthFix" />
             </button>
           </view>
@@ -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" />

src/pages/practise-one.vue

@@ -1,6 +1,6 @@
 <script setup>
-import { ref, onMounted, onBeforeUnmount } from "vue";
-import { onLoad } from "@dcloudio/uni-app";
+import { 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,16 +34,30 @@ 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 scores = ref([]);
+const isSvip = ref(false);
 const total = 12;
 const practiseResult = ref({});
 const practiseId = ref("");
+const serverAddr = ref("");
 const showGuide = ref(false);
 const tips = ref("");
 const targetType = ref(1);
+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) {
@@ -43,27 +65,131 @@ onLoad((options) => {
   }
 });
 
+const setPracticeAppHideResumable = (enabled) => {
+  appHideResumable.value = enabled === true;
+  setMatchAppHideResumable(appHideResumable.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 () => {
-  await startPractiseAPI();
+  const result = await beginPractise();
+  if (!result) return;
   scores.value = [];
+  isSvip.value = false;
   start.value = true;
   audioManager.play("练习开始");
 };
 
-const onOver = async () => {
-  practiseResult.value = await getPractiseAPI(practiseId.value);
+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;
 };
 
 async function onReceiveMessage(msg) {
   if (msg.type === MESSAGETYPESV2.ShootResult) {
-    scores.value = msg.details;
+    isSvip.value = msg.sVip === true;
+    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
   );
@@ -71,38 +197,236 @@ async function onComplete() {
     uni.navigateBack();
   } else {
     practiseId.value = "";
+    serverAddr.value = "";
     practiseResult.value = {};
     start.value = false;
     scores.value = [];
-    const result = await createPractiseAPI(total, 120);
-    if (result) practiseId.value = result.id;
+    isSvip.value = false;
+    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 () => {
-  await sharePractiseData("shareCanvas", 2, user.value, practiseResult.value);
-  await wxShare("shareCanvas");
+  if (sharing.value) return;
+  sharing.value = true;
+  try {
+    await sharePractiseData("shareCanvas", 2, user.value, practiseResult.value);
+    await wxShare("shareCanvas");
+  } catch (e) {
+    uni.showToast({
+      title: "海报生成失败，请稍后重试",
+      icon: "none",
+    });
+  } finally {
+    sharing.value = false;
+  }
+});
+
+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.warmAll();
   // 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);
-  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);
   audioManager.stopAll();
-  endPractiseAPI();
+  closeMatchWebSocket({ reason: "practice-leave" });
 });
 </script>
 
@@ -111,6 +435,7 @@ onBeforeUnmount(() => {
     :bgType="1"
     title="个人单组练习"
     :showBottom="!start && !scores.length"
+    :onBack="exitPractise"
   >
     <view>
       <TestDistance v-if="!start && !practiseResult.id" />
@@ -135,9 +460,11 @@ onBeforeUnmount(() => {
           <BowPower />
         </view>
         <BowTarget
+          v-if="!restoringSnapshot"
           :totalRound="start ? total / 4 : 0"
           :currentRound="scores.length % 3"
           :scores="scores"
+          :isSvip="isSvip"
         />
         <ScorePanel2 :arrows="scores" />
         <ScoreResult
@@ -146,13 +473,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>

src/pages/practise-two.vue

@@ -1,5 +1,6 @@
 <script setup>
-import { ref, onMounted, onBeforeUnmount } from "vue";
+import { 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,27 +15,48 @@ 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 scores = ref([]);
+const isSvip = ref(false);
 const total = 36;
 const practiseResult = ref({});
 const practiseId = ref("");
+const serverAddr = ref("");
 const showGuide = ref(false);
 const targetType = ref(1);
+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) {
@@ -42,23 +64,126 @@ onLoad((options) => {
   }
 });
 
+const setPracticeAppHideResumable = (enabled) => {
+  appHideResumable.value = enabled === true;
+  setMatchAppHideResumable(appHideResumable.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 () => {
-  await startPractiseAPI();
+  const result = await beginPractise();
+  if (!result) return;
   scores.value = [];
+  isSvip.value = false;
   start.value = true;
   audioManager.play("练习开始");
 };
 
-const onOver = async () => {
-  practiseResult.value = await getPractiseAPI(practiseId.value);
+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;
 };
 
 async function onReceiveMessage(msg) {
   if (msg.type === MESSAGETYPESV2.ShootResult) {
-    scores.value = msg.details;
+    isSvip.value = msg.sVip === true;
+    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) {
@@ -79,6 +204,7 @@ async function onReceiveMessage(msg) {
 }
 
 async function onComplete() {
+  setPracticeAppHideResumable(false);
   const validArrows = (practiseResult.value.details || []).filter(
     (a) => a.x !== -30 && a.y !== -30
   );
@@ -86,37 +212,235 @@ async function onComplete() {
     uni.navigateBack();
   } else {
     practiseId.value = "";
+    serverAddr.value = "";
     practiseResult.value = {};
     start.value = false;
     scores.value = [];
-    const result = await createPractiseAPI(total, 360);
-    if (result) practiseId.value = result.id;
+    isSvip.value = false;
+    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 () => {
-  await sharePractiseData("shareCanvas", 3, user.value, practiseResult.value);
-  await wxShare("shareCanvas");
+  if (sharing.value) return;
+  sharing.value = true;
+  try {
+    await sharePractiseData("shareCanvas", 3, user.value, practiseResult.value);
+    await wxShare("shareCanvas");
+  } catch (e) {
+    uni.showToast({
+      title: "海报生成失败，请稍后重试",
+      icon: "none",
+    });
+  } finally {
+    sharing.value = false;
+  }
+});
+
+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.warmAll();
   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, 360, 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>
 
@@ -125,6 +449,7 @@ onBeforeUnmount(() => {
     :bgType="1"
     title="日常耐力挑战"
     :showBottom="!start && !scores.length"
+    :onBack="exitPractise"
   >
     <view>
       <TestDistance v-if="!start && !practiseResult.id" />
@@ -132,7 +457,7 @@ onBeforeUnmount(() => {
         <ShootProgress
           :tips="`请连续射${total}支箭`"
           :start="start"
-          :total="360"
+          :total="3600"
           :onStop="onOver"
         />
         <view class="user-row">
@@ -144,9 +469,11 @@ onBeforeUnmount(() => {
           <BowPower />
         </view>
         <BowTarget
+          v-if="!restoringSnapshot"
           :currentRound="scores.length"
           :totalRound="start ? total : 0"
           :scores="scores"
+          :isSvip="isSvip"
         />
         <ScorePanel
           v-if="start"
@@ -162,13 +489,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>

src/pages/practise.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { ref } from "vue";
+import { computed, ref } from "vue";
 import { onShow } from "@dcloudio/uni-app";
 import Container from "@/components/Container.vue";
 import Guide from "@/components/Guide.vue";
@@ -15,6 +15,8 @@ const { user, device, online } = storeToRefs(store);
 const data = ref({});
 const showTargetPicker = ref(false);
 const pendingPractiseType = ref("");
+const isSVip = computed(() => user.value.sVip === true);
+const isVip = computed(() => user.value.vip === true && !isSVip.value);
 
 const goPractise = async (type) => {
   if (!canEenter(user.value, device.value, online.value)) return;
@@ -49,7 +51,18 @@ onShow(async () => {
         <view>
           <view>
             <Avatar :rankLvl="user.rankLvl" :src="user.avatar" :size="30" />
-            <text class="truncate">{{ user.nickName }}</text>
+            <view
+              :class="[
+                'member-nickname',
+                isVip ? 'member-nickname--vip' : '',
+                isSVip ? 'member-nickname--svip' : '',
+              ]"
+            >
+              <text class="member-nickname__text">{{ user.nickName }}</text>
+              <text v-if="isSVip" class="member-nickname__shine">{{
+                user.nickName
+              }}</text>
+            </view>
           </view>
           <view>
             <text>已练习打卡</text>
@@ -132,12 +145,15 @@ onShow(async () => {
   display: flex;
   align-items: flex-end;
 }
-.practise-data > view:first-child > view:first-child > text {
+.practise-data > view:first-child > view:first-child .member-nickname {
   color: #fff;
   margin-left: 10px;
-  font-size: 16px;
   width: 120px;
 }
+.practise-data > view:first-child > view:first-child .member-nickname__text,
+.practise-data > view:first-child > view:first-child .member-nickname__shine {
+  font-size: 16px;
+}
 .practise-data > view:first-child > view:last-child > text:nth-child(2) {
   color: #f7d247;
   margin: 0 3px;

src/pages/rank-intro.vue

@@ -13,7 +13,7 @@ import Container from "@/components/Container.vue";
         <view class="section">
           <view class="title">一、段位体系概述</view>
           <view class="text">
-            我们的段位体系分为多个等级，从低到高依次为：倔强青铜、秩序白银、黄金王者、永恒钻石、最强王者、非凡王者、无双王者、绝世王者、至圣王者、荣耀王者和传奇王者。每个大段位下又分为若干小段位，玩家需要通过积累积分来提升段位。
+            我们的段位体系分为多个等级，从低到高依次为：倔强青铜、秩序白银、荣耀黄金、永恒钻石、最强王者、非凡王者、无双王者、绝世王者、至圣王者、荣耀王者和传奇王者。每个大段位下又分为若干小段位，玩家需要通过积累积分来提升段位。
           </view>
         </view>
 
@@ -63,39 +63,39 @@ import Container from "@/components/Container.vue";
             <view class="table-row">
               <text>倔强青铜</text>
               <view>
-                <text>青铜1*</text>
-                <text>青铜2*</text>
-                <text>青铜3*</text>
+                <text>青铜1</text>
+                <text>青铜2</text>
+                <text>青铜3</text>
               </view>
               <text>每个小段位需要满 3星才能晋升到下一个段位，共9颗星。</text>
             </view>
             <view class="table-row">
               <text>秩序白银</text>
               <view>
-                <text>白铜1*</text>
-                <text>白铜2*</text>
-                <text>白铜3*</text>
+                <text>白铜1</text>
+                <text>白铜2</text>
+                <text>白铜3</text>
               </view>
               <text>每个小段位需要满 3颗星才能晋升到下一个段位，共9颗星。</text>
             </view>
             <view class="table-row">
-              <text>黄金王者</text>
+              <text>荣耀黄金</text>
               <view>
-                <text>黄金1*</text>
-                <text>黄金2*</text>
-                <text>黄金3*</text>
-                <text>黄金4*</text>
+                <text>黄金1</text>
+                <text>黄金2</text>
+                <text>黄金3</text>
+                <text>黄金4</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>
+                <text>钻石1</text>
+                <text>钻石2</text>
+                <text>钻石3</text>
+                <text>钻石4</text>
+                <text>钻石5</text>
               </view>
               <text>每个小段位需要满5颗星才能晋升到下一个段位，共25颗星。</text>
             </view>

src/pages/rank-list.vue

@@ -1,58 +1,344 @@
 <script setup>
-import { ref, onMounted } from "vue";
+import { computed, nextTick, onMounted, ref } from "vue";
+import { onLoad } from "@dcloudio/uni-app";
 import Avatar from "@/components/Avatar.vue";
+import {
+  getMvpRankList,
+  getMyMvpRank,
+  getMyScoreRank,
+  getMyTenRingRank,
+  getScoreRankList,
+  getTenRingRankList,
+} from "@/apis";
 import { capsuleHeight } from "@/util";
 import useStore from "@/store";
 import { storeToRefs } from "pinia";
+
+const PAGE_SIZE = 10;
+
 const store = useStore();
-const { user, rankData } = storeToRefs(store);
+const { user } = storeToRefs(store);
 const { getLvlName } = store;
 
-const selectedIndex = ref(0);
-const currentList = ref([]);
-const myData = ref({});
-const addBg = ref(false);
-
-onMounted(async () => {
-  handleSelect(0);
+const createRankState = () => ({
+  list: [],
+  page: 0,
+  pageSize: PAGE_SIZE,
+  loading: false,
+  noMore: false,
+  loaded: false,
+  scrollTop: 0,
+  myData: null,
+  myDataLoaded: false,
 });
 
-const handleSelect = (index) => {
-  selectedIndex.value = index;
-  myData.value = {};
-  currentList.value = [];
-  if (index === 0) {
-    currentList.value = rankData.value.rank;
-  } else if (index === 1) {
-    currentList.value = rankData.value.mvpRank;
-  } else if (index === 2) {
-    currentList.value = rankData.value.ringRank;
+const rankTabs = [
+  {
+    key: "score",
+    title: "积分榜",
+    subTitle: "排位赛积分",
+    listApi: getScoreRankList,
+    myApi: getMyScoreRank,
+  },
+  {
+    key: "mvp",
+    title: "MVP榜",
+    subTitle: "MVP次数",
+    listApi: getMvpRankList,
+    myApi: getMyMvpRank,
+  },
+  {
+    key: "tenRing",
+    title: "十环榜",
+    subTitle: "十环次数",
+    listApi: getTenRingRankList,
+    myApi: getMyTenRingRank,
+  },
+];
+
+// 解析 ranking 页面传入的榜单参数，进入页面时默认选中对应 tab。
+const getTabIndexByRouteParam = (tab) => {
+  if (tab === "mvp") return 1;
+  if (tab === "tenRing") return 2;
+  return 0;
+};
+
+const rankStates = ref({
+  score: createRankState(),
+  mvp: createRankState(),
+  tenRing: createRankState(),
+});
+
+const selectedIndex = ref(0);
+const initialTabIndex = ref(0);
+const pageMounted = ref(false);
+const initializedFromRoute = ref(false);
+const addBg = ref(false);
+const currentScrollTop = ref(0);
+const restoreScrollTop = ref(0);
+const tabSwitchAnimating = ref(false);
+const suppressScrollSync = ref(false);
+const suppressLoadMore = ref(false);
+const stickyTabsTop = capsuleHeight + 50;
+const stickyTabsActive = ref(false);
+const tabsStickyThreshold = ref(0);
+const tabsStickyReady = ref(false);
+const tabsHeight = ref(0);
+
+const getTabConfig = (index = selectedIndex.value) => rankTabs[index];
+const getTabKey = (index = selectedIndex.value) => getTabConfig(index).key;
+
+// 统一提取榜单接口返回的列表数据，兼容数组和对象两种返回格式。
+const getRankListFromResponse = (result) => {
+  if (Array.isArray(result)) return result;
+  if (Array.isArray(result?.list)) return result.list;
+  if (Array.isArray(result?.items)) return result.items;
+  return [];
+};
+
+// 为当前登录用户构造默认的个人榜单信息，避免接口未返回时底部区域缺数据。
+const buildDefaultMyData = () => ({
+  rank: null,
+  userId: user.value.id,
+  name: user.value.nickName,
+  avatar: user.value.avatar,
+  vip: user.value.vip,
+  sVip: user.value.sVip,
+  totalScore: 0,
+  mvpCount: 0,
+  tenRings: 0,
+  totalGames: 0,
+  totalCount: 0,
+  rankName: user.value.lvlName,
+  rankLvl: user.value.rankLvl,
+});
+
+const currentTabKey = computed(() => getTabKey(selectedIndex.value));
+const currentState = computed(() => rankStates.value[currentTabKey.value]);
+const currentList = computed(() => currentState.value.list);
+const currentSubTitle = computed(() => getTabConfig(selectedIndex.value).subTitle);
+const currentMyData = computed(() => {
+  if (!user.value.id) return null;
+  return currentState.value.myData || buildDefaultMyData();
+});
+
+// 统一格式化段位和场次文案，兼容不同接口的字段命名。
+const formatLevelText = (item = {}) => {
+  const levelName = item.rankName || getLvlName(item.rankLvl) || "暂无段位";
+  const totalGames = item.totalGames ?? item.TotalGames ?? 0;
+  return `${levelName}，${totalGames}场`;
+};
+
+// 统一读取榜单项的排名字段，没有后端 rank 时回退到前端序号。
+const getDisplayRank = (item = {}, index = 0) => {
+  return item.rank ?? index + 1;
+};
+
+// 底部个人排名在未上榜时展示占位符，而不是空白。
+const getDisplayMyRank = (item = {}) => {
+  return item.rank ?? "-";
+};
+
+const getScoreValue = (item = {}) => item.totalScore ?? 0;
+const getMvpValue = (item = {}) => item.mvpCount ?? item.totalScore ?? 0;
+const getTenRingValue = (item = {}) =>
+  item.tenRings ?? item.TenRings ?? item.totalScore ?? 0;
+
+// 根据当前选中的榜单类型，读取对应的展示值。
+const getRankValue = (item = {}, index = selectedIndex.value) => {
+  if (index === 0) return getScoreValue(item);
+  if (index === 1) return getMvpValue(item);
+  return getTenRingValue(item);
+};
+
+const getRankUnit = (index = selectedIndex.value) => {
+  if (index === 0) return "分";
+  return "次";
+};
+
+const isMember = (item = {}) => item.vip === true || item.sVip === true;
+
+const getMemberNicknameClass = (item = {}) => [
+  "rank-list-player-name",
+  "member-nickname",
+  item.vip === true && item.sVip !== true ? "member-nickname--vip" : "",
+  item.sVip === true ? "member-nickname--svip" : "",
+];
+
+// 统一设置页面当前的视觉滚动状态，避免吸顶和顶部背景不同步。
+const syncScrollVisualState = (scrollTop = 0) => {
+  currentScrollTop.value = scrollTop;
+  addBg.value = scrollTop > 100;
+  if (!tabsStickyReady.value) {
+    stickyTabsActive.value = false;
+    return;
   }
-  if (user.value.id) {
-    currentList.value.some((item) => {
-      if (item.userId === user.value.id) {
-        myData.value = item;
-        return true;
-      }
-      return false;
-    });
-    if (!myData.value.userId) {
-      myData.value = {
-        userId: user.value.id,
-        TotalGames: 0,
-        totalScore: 0,
-        mvpCount: 0,
-        TenRings: 0,
-      };
+  stickyTabsActive.value = scrollTop >= tabsStickyThreshold.value;
+};
+
+// 只保留一条滚动恢复链路：从当前滚动位置平滑滚到目标位置，避免多套控制同时生效造成闪烁。
+const applyScrollPosition = async (
+  fromScrollTop = currentScrollTop.value,
+  toScrollTop = 0,
+  withAnimation = false
+) => {
+  tabSwitchAnimating.value = withAnimation;
+  restoreScrollTop.value = fromScrollTop;
+  await nextTick();
+  restoreScrollTop.value = toScrollTop;
+  syncScrollVisualState(toScrollTop);
+};
+
+// 请求指定榜单的某一页数据，只有当前榜单会追加分页，不影响其他榜单的浏览状态。
+const loadRankPage = async (tabKey, { reset = false } = {}) => {
+  const state = rankStates.value[tabKey];
+  const config = rankTabs.find((item) => item.key === tabKey);
+  if (!config || state.loading) return;
+  if (!reset && state.noMore) return;
+
+  const nextPage = reset ? 1 : state.page + 1;
+  state.loading = true;
+  if (reset) state.noMore = false;
+
+  try {
+    const result = await config.listApi(undefined, nextPage, PAGE_SIZE);
+    const list = getRankListFromResponse(result);
+    state.list = reset ? list : state.list.concat(list);
+    state.page = nextPage;
+    state.loaded = true;
+    state.noMore = list.length < PAGE_SIZE;
+  } catch (error) {
+    if (reset) {
+      state.list = [];
+      state.page = 0;
+      state.loaded = false;
+      state.noMore = false;
     }
+    uni.showToast({
+      title: "排行榜加载失败",
+      icon: "none",
+    });
+    console.error("load rank page error", error);
+  } finally {
+    state.loading = false;
   }
 };
 
-const onScrollView = (e) => {
-  addBg.value = e.detail.scrollTop > 100;
+// 每个榜单独立请求一次个人排名信息，切回该榜单时直接复用，避免打断浏览上下文。
+const loadMyRankData = async (tabKey) => {
+  if (!user.value.id) return;
+
+  const state = rankStates.value[tabKey];
+  const config = rankTabs.find((item) => item.key === tabKey);
+  if (!config || state.myDataLoaded) return;
+
+  try {
+    const result = await config.myApi();
+    state.myData = {
+      ...buildDefaultMyData(),
+      ...(result || {}),
+    };
+  } catch (error) {
+    state.myData = buildDefaultMyData();
+    console.error("load my rank data error", error);
+  } finally {
+    state.myDataLoaded = true;
+  }
 };
 
-const subTitles = ["排位赛积分", "MVP次数", "十环次数"];
+// 首次进入或切换到未加载过的榜单时，初始化它的分页数据和个人横条数据。
+const ensureTabReady = async (index = selectedIndex.value) => {
+  const tabKey = getTabKey(index);
+  const state = rankStates.value[tabKey];
+
+  if (!state.loaded) {
+    await loadRankPage(tabKey, { reset: true });
+  }
+
+  if (user.value.id && !state.myDataLoaded) {
+    await loadMyRankData(tabKey);
+  }
+
+  await nextTick();
+  return state.scrollTop || 0;
+};
+
+onLoad((options = {}) => {
+  initialTabIndex.value = getTabIndexByRouteParam(options.tab);
+  selectedIndex.value = initialTabIndex.value;
+  if (pageMounted.value && !initializedFromRoute.value) {
+    initializePage();
+  }
+});
+
+// 页面初始化同时兼容 onLoad 和 onMounted 的先后顺序，确保首屏一定落到路由指定的榜单。
+const initializePage = async () => {
+  if (initializedFromRoute.value) return;
+  initializedFromRoute.value = true;
+  const nextScrollTop = await ensureTabReady(selectedIndex.value);
+  await applyScrollPosition(0, nextScrollTop, false);
+  setTimeout(() => {
+    measureTabsMetrics();
+  }, 0);
+};
+
+onMounted(async () => {
+  pageMounted.value = true;
+  await initializePage();
+});
+
+// 切换榜单时保留原榜单的列表和滚动位置，切回来后继续从之前的位置浏览。
+const handleSelect = async (index) => {
+  if (index === selectedIndex.value) return;
+
+  const previousTabKey = currentTabKey.value;
+  rankStates.value[previousTabKey].scrollTop = currentScrollTop.value;
+  const previousScrollTop = currentScrollTop.value;
+
+  suppressScrollSync.value = true;
+  suppressLoadMore.value = true;
+  selectedIndex.value = index;
+  const nextScrollTop = await ensureTabReady(index);
+  await applyScrollPosition(previousScrollTop, nextScrollTop, false);
+  setTimeout(() => {
+    tabSwitchAnimating.value = false;
+    suppressScrollSync.value = false;
+    suppressLoadMore.value = false;
+  }, 220);
+};
+
+// 触底后只加载当前榜单的下一页数据，其他榜单的数据和页码保持不变。
+const loadMore = async () => {
+  if (suppressLoadMore.value) return;
+  await loadRankPage(currentTabKey.value);
+};
+
+// 实时记录当前榜单的滚动位置，切换回来时恢复到上一次浏览位置。
+const onScrollView = (e) => {
+  const scrollTop = e.detail.scrollTop || 0;
+  if (suppressScrollSync.value) return;
+  syncScrollVisualState(scrollTop);
+  rankStates.value[currentTabKey.value].scrollTop = scrollTop;
+};
+
+// 计算 tab 在滚动内容中的真实位置和高度，作为吸顶切换的唯一依据。
+const measureTabsMetrics = () => {
+  const query = uni.createSelectorQuery();
+  query
+    .select("#rank-list-content-start")
+    .boundingClientRect()
+    .select(".rank-tabs-anchor")
+    .boundingClientRect()
+    .exec((res = []) => {
+      const [startRect, rect] = res;
+      if (!startRect || !rect) return;
+      const tabOffset = rect.top - startRect.top;
+      tabsStickyThreshold.value = Math.max(0, tabOffset - 92);
+      tabsHeight.value = rect.height || 0;
+      tabsStickyReady.value = true;
+      syncScrollVisualState(currentScrollTop.value);
+    });
+};
 </script>
 
 <template>
@@ -65,7 +351,7 @@ const subTitles = ["排位赛积分", "MVP次数", "十环次数"];
     >
       <image
         :style="{ opacity: addBg ? 1 : 0 }"
-        src="../static/app-bg.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/app-bg.png"
         mode="widthFix"
       />
       <navigator open-type="navigateBack">
@@ -75,18 +361,32 @@ const subTitles = ["排位赛积分", "MVP次数", "十环次数"];
     </view>
     <scroll-view
       scroll-y
+      :scroll-with-animation="tabSwitchAnimating"
+      :scroll-top="restoreScrollTop"
       @scroll="onScrollView"
-      :style="{ height: myData.userId ? '90vh' : '100vh' }"
+      @scrolltolower="loadMore"
+      :style="{ height: user.id ? '90vh' : '100vh' }"
     >
+      <view id="rank-list-content-start" class="content-start-anchor"></view>
       <image
         src="https://static.shelingxingqiu.com/attachment/2025-09-25/dd1p9b3wcrwnlnghiq.png"
         mode="widthFix"
         class="header-bg"
+        @load="measureTabsMetrics"
       />
-      <view class="rank-tabs">
+      <view
+        v-if="stickyTabsActive"
+        class="rank-tabs-placeholder"
+        :style="{ height: `${tabsHeight}px` }"
+      />
+      <view
+        class="rank-tabs rank-tabs-anchor"
+        :class="{ 'rank-tabs-anchor-fixed': stickyTabsActive }"
+        :style="stickyTabsActive ? { top: `${stickyTabsTop}px` } : {}"
+      >
         <view
-          v-for="(rankType, index) in ['积分榜', 'MVP榜', '十环榜']"
-          :key="index"
+          v-for="(rankType, index) in rankTabs"
+          :key="rankType.key"
           :style="{
             fontSize: index === selectedIndex ? '16px' : '14px',
             color: index === selectedIndex ? '#000' : '#fff',
@@ -94,18 +394,18 @@ const subTitles = ["排位赛积分", "MVP次数", "十环次数"];
           }"
           @tap="handleSelect(index)"
         >
-          {{ rankType }}
+          {{ rankType.title }}
         </view>
       </view>
       <view class="rank-list">
         <view class="rank-list-header">
           <text>排名</text>
           <text>用户ID</text>
-          <text>{{ subTitles[selectedIndex] }}</text>
+          <text>{{ currentSubTitle }}</text>
         </view>
         <view
           v-for="(item, index) in currentList"
-          :key="index"
+          :key="`${currentTabKey}-${index}-${item.userId || item.name}`"
           class="rank-list-item"
           :style="{
             backgroundColor: index % 2 === 0 ? '#9898981f' : 'transparent',
@@ -147,65 +447,82 @@ const subTitles = ["排位赛积分", "MVP次数", "十环次数"];
             src="../static/champ3.png"
             mode="widthFix"
           />
-          <view v-if="index > 2" class="view-crown">{{ index + 1 }}</view>
+          <view v-if="index > 2" class="view-crown">
+            {{ getDisplayRank(item, index) }}
+          </view>
           <Avatar :src="item.avatar" />
           <view class="rank-item-content">
-            <text class="truncate">{{ item.name }}</text>
-            <text>{{ getLvlName(item.rankLvl) }}，{{ item.TotalGames }}场</text>
+            <view v-if="isMember(item)" :class="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="rank-list-player-name truncate">{{ item.name }}</text>
+            <text>{{ formatLevelText(item) }}</text>
           </view>
-          <text class="rank-item-integral" v-if="selectedIndex === 0">
+          <text class="rank-item-integral">
             <text
               :style="{ fontSize: '14px', color: '#fff', marginRight: '5px' }"
-              >{{ item.totalScore }} </text
-            >分
-          </text>
-          <text class="rank-item-integral" v-if="selectedIndex === 1">
-            <text
-              :style="{ fontSize: '14px', color: '#fff', marginRight: '5px' }"
-              >{{ item.mvpCount }} </text
-            >次
-          </text>
-          <text class="rank-item-integral" v-if="selectedIndex === 2">
-            <text
-              :style="{ fontSize: '14px', color: '#fff', marginRight: '5px' }"
-              >{{ item.TenRings }} </text
-            >次
+            >
+              {{ getRankValue(item) }}
+            </text>
+            {{ getRankUnit() }}
           </text>
         </view>
-        <view v-if="!currentList.length" class="no-data">
-          <text>筹备中...</text>
+        <view
+          v-if="currentState.loading && !currentList.length"
+          class="no-data"
+        >
+          <text>加载中...</text>
+        </view>
+        <view
+          v-else-if="!currentState.loading && !currentList.length"
+          class="no-data"
+        >
+          <text>暂无数据</text>
+        </view>
+        <view v-else class="list-tip">
+          <text v-if="currentState.loading">加载中...</text>
+          <text v-else-if="currentState.noMore">没有更多了</text>
         </view>
       </view>
     </scroll-view>
-    <view class="my-rank-data" v-if="myData.userId">
+    <view class="my-rank-data" v-if="currentMyData">
       <image
         src="https://static.shelingxingqiu.com/attachment/2025-08-05/dbuaf19pf7qd8ps0uh.png"
         mode="widthFix"
       />
-      <text>{{ myData.rank }}</text>
-      <Avatar :src="user.avatar" />
+      <text>{{ getDisplayMyRank(currentMyData) }}</text>
+      <Avatar :src="currentMyData.avatar || user.avatar" />
       <view class="rank-item-content">
-        <text class="truncate">{{ user.nickName }}</text>
-        <text>{{ user.lvlName }}，{{ myData.TotalGames }}场</text>
+        <view
+          v-if="isMember(currentMyData)"
+          :class="getMemberNicknameClass(currentMyData)"
+        >
+          <text class="member-nickname__text">
+            {{ currentMyData.name || user.nickName }}
+          </text>
+          <text
+            v-if="currentMyData.sVip === true"
+            class="member-nickname__shine"
+          >
+            {{ currentMyData.name || user.nickName }}
+          </text>
+        </view>
+        <text v-else class="rank-list-player-name truncate">
+          {{ currentMyData.name || user.nickName }}
+        </text>
+        <text>{{ formatLevelText(currentMyData) }}</text>
       </view>
-      <text class="rank-item-integral" v-if="selectedIndex === 0">
+      <text class="rank-item-integral">
         <text
           :style="{ fontSize: '14px', color: '#fff', marginRight: '5px' }"
-          >{{ myData.totalScore || 0 }}</text
-        >分</text
-      >
-      <text class="rank-item-integral" v-if="selectedIndex === 1">
-        <text
-          :style="{ fontSize: '14px', color: '#fff', marginRight: '5px' }"
-          >{{ myData.mvpCount || 0 }}</text
-        >次</text
-      >
-      <text class="rank-item-integral" v-if="selectedIndex === 2">
-        <text
-          :style="{ fontSize: '14px', color: '#fff', marginRight: '5px' }"
-          >{{ myData.TenRings || 0 }}</text
-        >次</text
-      >
+        >
+          {{ getRankValue(currentMyData) }}
+        </text>
+        {{ getRankUnit() }}
+      </text>
     </view>
   </view>
 </template>
@@ -214,9 +531,16 @@ const subTitles = ["排位赛积分", "MVP次数", "十环次数"];
 .container {
   width: 100%;
 }
+
+.content-start-anchor {
+  width: 100%;
+  height: 0;
+}
+
 .header-bg {
   width: 100%;
 }
+
 .header {
   width: 100%;
   height: 50px;
@@ -227,6 +551,7 @@ const subTitles = ["排位赛积分", "MVP次数", "十环次数"];
   z-index: 10;
   overflow: hidden;
 }
+
 .header-back {
   width: 22px;
   height: 22px;
@@ -234,6 +559,7 @@ const subTitles = ["排位赛积分", "MVP次数", "十环次数"];
   margin-top: 5px;
   position: relative;
 }
+
 .header > image:first-child {
   width: 100vw;
   height: 100vh;
@@ -242,25 +568,40 @@ const subTitles = ["排位赛积分", "MVP次数", "十环次数"];
   left: 0;
   transition: all 0.5s ease;
 }
+
 .header > text {
   color: #fff;
   font-weight: bold;
   transition: all 0.5s ease;
   position: relative;
 }
+
 .rank-tabs {
   width: calc(100% - 20px);
   display: flex;
   justify-content: space-around;
-  padding: 0 10px;
-  margin-top: -15px;
+  padding: 20rpx 10px;
 }
+
 .rank-tabs > view {
   width: 25%;
   padding: 10px;
   text-align: center;
   border-radius: 20px;
 }
+
+.rank-tabs-placeholder {
+  width: 100%;
+}
+
+.rank-tabs-anchor-fixed {
+  position: fixed;
+  left: 0;
+  z-index: 11;
+  background: #000000;
+  backdrop-filter: blur(8px);
+}
+
 .rank-list {
   display: flex;
   flex-direction: column;
@@ -268,11 +609,12 @@ const subTitles = ["排位赛积分", "MVP次数", "十环次数"];
   width: calc(100% - 20px);
   color: #fff9;
   font-size: 12px;
-  margin: 10px;
+  margin: 0 10px 10px 10px;
   border: 1px solid rgb(255 217 71 / 0.2);
   border-radius: 10px;
   background-color: #313131;
 }
+
 .rank-list > view {
   display: flex;
   align-items: center;
@@ -281,20 +623,25 @@ const subTitles = ["排位赛积分", "MVP次数", "十环次数"];
   overflow: hidden;
   position: relative;
 }
+
 .rank-list-header {
   width: calc(100% - 20px) !important;
   padding: 10px;
 }
+
 .rank-list-header > text:nth-child(2) {
   width: 14%;
 }
+
 .rank-list-header > text:last-child {
   width: 30%;
   text-align: right;
 }
+
 .rank-list-item {
   padding: 10px 0;
 }
+
 .player-bg {
   position: absolute;
   width: 100%;
@@ -302,12 +649,14 @@ const subTitles = ["排位赛积分", "MVP次数", "十环次数"];
   top: 0;
   left: 0;
 }
+
 .player-crown {
   position: relative;
   width: 27px;
   height: 27px;
   margin: 0 15px;
 }
+
 .view-crown {
   width: 27px;
   height: 27px;
@@ -319,6 +668,7 @@ const subTitles = ["排位赛积分", "MVP次数", "十环次数"];
   background-color: #676767;
   position: relative;
 }
+
 .rank-item-content {
   display: flex;
   flex-direction: column;
@@ -328,17 +678,32 @@ const subTitles = ["排位赛积分", "MVP次数", "十环次数"];
   position: relative;
   padding-left: 10px;
 }
+
 .rank-item-content > text:first-child {
   color: #fff;
   font-size: 14px;
   margin-bottom: 3px;
   width: 120px;
 }
+
+.rank-list-player-name {
+  color: #fff;
+  font-size: 14px;
+  margin-bottom: 3px;
+  width: 120px;
+}
+
+.rank-list-player-name .member-nickname__text,
+.rank-list-player-name .member-nickname__shine {
+  font-size: 14px;
+}
+
 .rank-list-item > text:last-child {
   margin-right: 10px;
   width: 56px;
   text-align: right;
 }
+
 .my-rank-data {
   width: calc(100% - 30px);
   padding: 15px;
@@ -352,12 +717,14 @@ const subTitles = ["排位赛积分", "MVP次数", "十环次数"];
   overflow: hidden;
   border-radius: 10px;
 }
+
 .my-rank-data > image:first-child {
   position: absolute;
   width: 100%;
   left: 0;
   top: -5px;
 }
+
 .my-rank-data > text:nth-child(2) {
   background-color: #c1a434;
   position: relative;
@@ -369,20 +736,24 @@ const subTitles = ["排位赛积分", "MVP次数", "十环次数"];
   min-width: 15px;
   text-align: center;
 }
+
 .my-rank-data > text:last-child {
   position: relative;
   margin-right: 10px;
   width: 65px;
   text-align: right;
 }
+
 .my-rank-data > .rank-item-content > text:first-child {
   color: #fed847;
 }
+
 .my-rank-data > .rank-item-integral {
   color: #fff9;
   font-size: 12px;
   margin-right: 0 !important;
 }
+
 .no-data {
   width: 100%;
   height: 400px;
@@ -392,4 +763,11 @@ const subTitles = ["排位赛积分", "MVP次数", "十环次数"];
   color: #fff9;
   font-size: 14px;
 }
+
+.list-tip {
+  justify-content: center !important;
+  color: #fff9;
+  font-size: 12px;
+  min-height: 60rpx;
+}
 </style>

src/pages/team-battle.vue

@@ -1,5 +1,5 @@
 <script setup>
-import {ref, onMounted, onBeforeUnmount, nextTick} from "vue";
+import {ref, onMounted, onBeforeUnmount, nextTick, watch} from "vue";
 import {onLoad, onShow, onHide} from "@dcloudio/uni-app";
 import Container from "@/components/Container.vue";
 import BattleHeader from "@/components/BattleHeader.vue";
@@ -11,6 +11,7 @@ import RoundEndTip from "@/components/RoundEndTip.vue";
 import TestDistance from "@/components/TestDistance.vue";
 import TeamAvatars from "@/components/TeamAvatars.vue";
 import ShootProgress2 from "@/components/ShootProgress2.vue";
+import SModal from "@/components/SModal.vue";
 import {laserCloseAPI, getBattleAPI} from "@/apis";
 import {MESSAGETYPESV2} from "@/constants";
 import audioManager from "@/audioManager";
@@ -18,11 +19,13 @@ import useStore from "@/store";
 import {storeToRefs} from "pinia";
 
 const store = useStore();
-const {user} = storeToRefs(store);
+const {user, online} = storeToRefs(store);
 const start = ref(null);
 const tips = ref("");
 const battleId = ref("");
 const currentRound = ref(0);
+/** 专用于 RoundEndTip 展示的轮次，与进度条的 currentRound 解耦，避免 ToSomeoneShoot 提前更新 currentRound 导致 Tip 显示错误轮次 */
+const roundTipRound = ref(0);
 const goldenRound = ref(0);
 const currentRedPoint = ref(0);
 const currentBluePoint = ref(0);
@@ -38,10 +41,29 @@ const showRoundTip = ref(false);
 const isFinalShoot = ref(false);
 const matchStatus = ref(undefined);
 const updateRemainSecond = ref(0);
+/** 当前对局每人射击时间（秒），从后端 shootTime 字段动态读取，默认 15 */
+const shootTimeTotal = ref(15);
+/** 对战来源类型（1=好友约战，2=匹配对战），用于结算页分流 */
+const battleWay = ref(0);
+/** 上一次处理的 ToSomeoneShoot 关键字段，用于去重过滤重复消息 */
+const lastToSomeoneShootKey = ref("");
+/** 控制设备离线提示弹窗的显示状态 */
+const showOfflineModal = ref(false);
+
+/**
+ * 监听设备在线状态，比赛进行中设备离线时弹窗提示用户
+ */
+watch(online, (newVal, oldVal) => {
+  if (!newVal && oldVal && start.value === true) {
+    showOfflineModal.value = true;
+  }
+});
 
 const recoverData = (battleInfo, {force = false, arrowOnly = false} = {}) => {
   try {
     battleId.value = battleInfo.matchId;
+    // 存储对战来源，供结算跳转分流使用
+    if (battleInfo.way !== undefined) battleWay.value = battleInfo.way;
 
     // 优先使用接口返回的队伍数据，如果没有则尝试从缓存读取（应对匹配刚完成接口未就绪的情况）
     const t1 = battleInfo.teams?.[1] || {};
@@ -62,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);
@@ -71,6 +93,8 @@ const recoverData = (battleInfo, {force = false, arrowOnly = false} = {}) => {
       return;
     }
     if (!arrowOnly) {
+      // 在 ToSomeoneShoot 时同步更新当前轮次，使进度条轮次图片及时切换
+      currentRound.value = battleInfo.current.round || 1;
       currentShooterId.value = battleInfo.current.playerId;
       const redPlayer = battleInfo.teams[2].players.find(
           (item) => item.id === battleInfo.current.playerId
@@ -78,22 +102,64 @@ const recoverData = (battleInfo, {force = false, arrowOnly = false} = {}) => {
       let nextTips = redPlayer ? "请红队射箭" : "请蓝队射箭";
       if (force) nextTips += "重回";
       if (
-          battleInfo.current.playerId === user.value.id &&
-          redTeam.value.length > 1
+          battleInfo.current.playerId === user.value.id
       ) {
         nextTips += "你";
       }
+      // 同队连续出手时 tips 值不变，HeaderProgress watch 不触发音频
+      // 需在赋值前比较旧值，手动播放音频确保始终触发 onAudioEnded 启动计时器
+      // 注意：使用 interrupt=false 避免打断上一支箭的环数播报音频
+      if (tips.value === nextTips && !nextTips.includes("重回")) {
+        const audioKey = redPlayer ? "请红方射箭" : "请蓝方射箭";
+        audioManager.play(audioKey, false);
+      }
       tips.value = nextTips;
-      uni.$emit("update-tips", nextTips);
-      uni.$emit("update-remain", {reset: true, value: 15, team: redTeam?'red':'blue'});
+      // 同步写入 Pinia store，供 HeaderProgress 通过 immediate watch 在 onMounted 时立即读取
+      // 规避 WeChat 小程序 onShow 在组件 onMounted 之前触发导致 uni.$emit 事件丢失的时序问题
+      store.updateTips(nextTips);
+      // force 模式下改为在 nextTick 内发送 update-tips，规避 WeChat 小程序
+      // onShow 与 onMounted 时序问题导致 HeaderProgress 监听器尚未注册的边界情况
+      if (!force) {
+        uni.$emit("update-tips", nextTips);
+      }
+      // redPlayer 已在上方 find() 确认：不为 null 则当前射手在红队
+      const targetTeam = redPlayer ? 'red' : 'blue';
+      // 从后端消息读取本局射击时间，动态设置进度条满值与倒计时秒数（降级兜底 15s）
+      shootTimeTotal.value = battleInfo.shootTime ?? 15;
       if (force) {
-        const remain = (Date.now() - battleInfo.current.startTime) / 1000;
-        console.log(`当前轮已进行${remain}秒`);
-        if (remain > 0 && remain < 15) {
-          updateRemainSecond.value = 15 - remain - 0.2
+        // force 模式下 start.value 刚由 null 变 true，Vue 异步调度渲染，
+        // ShootProgress2（v-if="start"）尚未挂载，update-remain 事件会被丢弃。
+        // 同时 HeaderProgress 对含"重回"的 tips 拦截音频，倒计时无法依赖
+        // onAudioEnded 驱动，需在 nextTick 后直接启动。
+
+        // playerId=0 表示后端处于过渡状态（上一位射手已完成、下一位尚未分配）
+        // 此时 startTime/targetTeam 均不可靠，停止进度条并等待 WS ToSomeoneShoot 驱动
+        if (!battleInfo.current.playerId) {
+          nextTick(() => {
+            uni.$emit("update-tips", nextTips);
+            uni.$emit("update-remain", {stop: true});
+          });
+          return;
         }
+
+        const elapsed = (Date.now() - battleInfo.current.startTime) / 1000;
+        if (elapsed > 0 && elapsed < shootTimeTotal.value) {
+          updateRemainSecond.value = shootTimeTotal.value - elapsed - 0.2;
+        }
+        const actualRemain = updateRemainSecond.value;
+        nextTick(() => {
+          // 在 nextTick 内统一发送，确保 ShootProgress2 和 HeaderProgress 均已挂载
+          uni.$emit("update-tips", nextTips);
+          uni.$emit("update-remain", {reset: true, value: shootTimeTotal.value, team: targetTeam});
+          // 重置动画完成后，直接启动倒计时（无需依赖音频结束回调）
+          setTimeout(() => {
+            uni.$emit("update-remain", {stop: false, value: actualRemain, team: targetTeam});
+          }, 100);
+        });
       } else {
-        updateRemainSecond.value = battleInfo.readyTime
+        // ToSomeoneShoot 到达时：若进度条仍在倒计时则瞬间清零再切换满值，确保视觉连贯
+        uni.$emit("update-remain", {zeroThenReset: true, value: shootTimeTotal.value, team: targetTeam});
+        updateRemainSecond.value = shootTimeTotal.value;
       }
     } else {
       currentRound.value = battleInfo.current.round || 1;
@@ -113,27 +179,47 @@ const recoverData = (battleInfo, {force = false, arrowOnly = false} = {}) => {
 };
 
 function onAudioEnded(s) {
-  if (s.indexOf('请红方射箭') >= 0 || s.indexOf('请蓝方射箭') >= 0) {
-    let team = s.indexOf('请红方射箭') >= 0 ? 'red' : 'blue';
+  // "请红方射箭"/"请蓝方射箭"：队友或对手轮次；"轮到你了"：用户本人轮次（HeaderProgress特殊分支）
+  // 三者音频结束后均需启动倒计时进度条
+  if (s.indexOf('请红方射箭') >= 0 || s.indexOf('请蓝方射箭') >= 0 || s.indexOf('轮到你了') >= 0) {
+    let team;
+    if (s.indexOf('请红方射箭') >= 0) team = 'red';
+    else if (s.indexOf('请蓝方射箭') >= 0) team = 'blue';
+    else team = tips.value.includes('红队') ? 'red' : 'blue'; // 轮到你了：从当前tips判断用户所在队伍
     uni.$emit("update-remain", {stop: false, value: updateRemainSecond.value, team: team});
   }
   if (s.indexOf("比赛结束") >= 0) {
+    console.log("比赛结束");
     onBattleEnd()
   }
 }
 
 function onBattleEnd() {
   if (matchStatus.value === 2) {
+    // 全部跳转到新结算页
     uni.redirectTo({
-      url: `/pages/battle-result?battleId=${battleId.value}`,
+      url: `/pages/friend-battle-result?battleId=${battleId.value}`,
     });
   }
 }
 
-function onNewRound(msg) {
+/**
+ * @param {object} msg - NewRound 消息
+ * @param {number} prevRound - 在 NewRound 消息到达时即时捕获的旧轮次，用于 Tip 展示，避免异步延迟内 currentRound 已被更新
+ */
+function onNewRound(msg, prevRound) {
   showRoundTip.value = true;
   isFinalShoot.value = msg.current.goldRound;
-  const latestRound = msg.rounds[currentRound.value - 1];
+  // 新轮次开始时立即清空靶纸箭迹，避免残留上一轮落点至新轮次第一箭到来
+  scores.value = [];
+  blueScores.value = [];
+  // 决金轮箭数不确定（平局后可能再加一箭），清零 totalShot 隐藏箭数显示
+  if (msg.current.goldRound) {
+    store.updateShotInfo(0, 0);
+  }
+  // 用传入的 prevRound（捕获时刻的旧轮次）展示结算 Tip，与进度条 currentRound 解耦
+  roundTipRound.value = prevRound;
+  const latestRound = msg.rounds[prevRound - 1];
   if (latestRound) {
     if (isFinalShoot.value) {
       currentBluePoint.value = msg.teams[1].score;
@@ -150,14 +236,23 @@ async function onReceiveMessage(msg) {
   if (msg.type === MESSAGETYPESV2.BattleStart) {
     start.value = true;
   } else if (msg.type === MESSAGETYPESV2.ToSomeoneShoot) {
+    // 去重防护：如果 playerId + round 与上一次处理完全相同，则忽略重复推送的消息
+    // （防止 onBeforeUnmount 未及时 off 和页面重创建导致同一事件被处理多次）
+    const key = `${msg?.current?.playerId}-${msg?.current?.round}`;
+    if (key === lastToSomeoneShootKey.value) return;
+    lastToSomeoneShootKey.value = key;
     recoverData(msg);
   } else if (msg.type === MESSAGETYPESV2.ShootResult) {
-    uni.$emit("update-remain", {stop: true})
     showRoundTip.value = false;
     recoverData(msg, {arrowOnly: true});
+    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;
     setTimeout(() => {
-      onNewRound(msg)
+      onNewRound(msg, prevRound)
     }, 800)
   } else if (msg.type === MESSAGETYPESV2.BattleEnd) {
     matchStatus.value = msg.status;
@@ -174,6 +269,9 @@ async function onReceiveMessage(msg) {
 
 onLoad(async (options) => {
   if (options.battleId) battleId.value = options.battleId;
+  // 重置箭数和提示文案，防止因 Pinia 保留上一场比赛的旧值而错误展示
+  store.updateShotInfo(0, 0);
+  store.updateTips("");
   // uni.enableAlertBeforeUnload({
   //   message: "离开比赛可能导致比赛失败，是否继续？",
   //   success: (res) => {
@@ -193,23 +291,37 @@ onBeforeUnmount(() => {
   uni.setKeepScreenOn({
     keepScreenOn: false,
   });
+  // 注销所有第三方事件盓听，防止页面重创建时监听叠加导致消息重复处理
+  uni.$off("socket-inbox", onReceiveMessage);
   uni.$off("audioEnded", onAudioEnded);
   audioManager.stopAll();
 });
 const refreshTimer = ref(null);
 onShow(async () => {
   if (battleId.value) {
+    // 延迟 300ms 等待网络恢复，避免小程序从后台切回时网络尚未就绪导致请求失败报错
+    await new Promise(resolve => setTimeout(resolve, 300));
     const result = await getBattleAPI(battleId.value);
     if (!result) return;
     if (result.status === 2) {
-      uni.showToast({
-        title: "比赛已结束",
-        icon: "none",
-      });
-      uni.navigateBack({
-        delta: 2,
+      // 比赛已结束（如切后台再回来）：跳新结算页
+      uni.redirectTo({
+        url: `/pages/friend-battle-result?battleId=${result.matchId}`,
       });
     } else {
+      if (result.status !== 0) {
+        // 比赛进行中，从后端恢复箭数（测距阶段不展示）
+        // 决金轮不展示箭数；其余轮次从 indexMap 按用户 id 取已射箭数
+        if (result.shootNumber && !result.current?.goldRound) {
+          store.updateShotInfo(result.current?.indexMap?.[user.value.id] ?? 0, result.shootNumber);
+        }
+      } else {
+        // 测距阶段重置箭数和提示文案，防止 ImmediateWatcher 读取 Pinia 保留的旧值
+        store.updateShotInfo(0, 0);
+        // 同步清空 Pinia tips 与本地 tips，避免重新开赛时 HeaderProgress 展示上一场旧文案
+        store.updateTips("");
+        tips.value = "";
+      }
       recoverData(result, {force: true});
     }
   }
@@ -219,10 +331,12 @@ onShow(async () => {
 <template>
   <Container :bgType="start ? 3 : 1">
     <view class="container">
+      <!-- winner=0 表示对局尚未开始，不显示胜者徽章 -->
       <BattleHeader
           v-if="start === false"
           :redTeam="redTeam"
           :blueTeam="blueTeam"
+          :winner="0"
       />
       <TestDistance v-if="start === false" :guide="false" :isBattle="true"/>
       <view v-if="start" class="players-row">
@@ -233,6 +347,7 @@ onShow(async () => {
         />
         <ShootProgress2
             :tips="tips"
+            :total="shootTimeTotal"
             :currentRound="
             goldenRound > 0 ? 'gold' + goldenRound : 'round' + currentRound
           "
@@ -254,21 +369,33 @@ onShow(async () => {
       />
       <ScreenHint
           :show="showRoundTip"
-          :onClose="() => (showRoundTip = false)"
           :mode="isFinalShoot ? 'tall' : 'normal'"
       >
         <RoundEndTip
             v-if="showRoundTip"
             :isFinal="isFinalShoot"
-            :round="currentRound"
+            :round="roundTipRound"
             :bluePoint="currentBluePoint"
             :redPoint="currentRedPoint"
             :roundData="
-            roundResults[currentRound - 1] ? roundResults[currentRound - 1] : []
+            roundResults[roundTipRound - 1] ? roundResults[roundTipRound - 1] : []
           "
             :onAutoClose="()=>{ showRoundTip = false}"
         />
       </ScreenHint>
+      <!-- 设备离线提示弹窗 -->
+      <SModal
+          :show="showOfflineModal"
+          :noBg="true"
+          height="360rpx"
+          :onClose="() => (showOfflineModal = false)"
+      >
+        <view class="offline-modal">
+          <text class="offline-title">设备已离线</text>
+          <text class="offline-desc">检测到设备已断开连接，请检查设备后继续比赛</text>
+          <SButton @click="showOfflineModal = false">我知道了</SButton>
+        </view>
+      </SModal>
     </view>
   </Container>
 </template>
@@ -286,4 +413,25 @@ onShow(async () => {
   margin-top: -2%;
   margin-bottom: 6%;
 }
+
+.offline-modal {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  padding: 60rpx 40rpx 40rpx;
+  gap: 24rpx;
+}
+
+.offline-title {
+  font-size: 36rpx;
+  font-weight: bold;
+  color: #FED847;
+}
+
+.offline-desc {
+  font-size: 28rpx;
+  color: #CCCCCC;
+  text-align: center;
+  line-height: 1.6;
+}
 </style>

src/pages/team-battle/components/AppBackground.vue

@@ -0,0 +1,91 @@
+<script setup>
+import { capsuleHeight } from "@/util";
+
+const props = defineProps({
+  type: {
+    type: Number,
+    default: 0,
+  },
+  bgColor: {
+    type: String,
+    default: "#050b19",
+  },
+});
+</script>
+
+<template>
+  <view class="background" :style="{ backgroundColor: bgColor }">
+    <image
+      class="bg-image"
+      v-if="type === 0"
+      src="https://static.shelingxingqiu.com/shootmini/static/app-bg.png"
+      mode="widthFix"
+    />
+    <image
+      class="bg-image"
+      v-if="type === 1"
+      src="https://static.shelingxingqiu.com/shootmini/static/app-bg2.png"
+      mode="widthFix"
+    />
+    <image
+      class="bg-image"
+      v-if="type === 2"
+      src="https://static.shelingxingqiu.com/shootmini/static/app-bg3.png"
+      :style="{ height: capsuleHeight + 50 + 'px' }"
+    />
+    <image
+      class="bg-image"
+      v-if="type === 3"
+      src="https://static.shelingxingqiu.com/shootmini/static/app-bg4.png"
+      mode="widthFix"
+    />
+    <image
+      class="bg-image"
+      v-if="type === 4"
+      src="https://static.shelingxingqiu.com/shootmini/static/app-bg5.png"
+      mode="widthFix"
+    />
+    <image
+      class="bg-image"
+      v-if="type === 5"
+      src="https://static.shelingxingqiu.com/attachment/2026-01-05/dfgf3b5kp459tfyn0f.png"
+      mode="widthFix"
+    />
+	<image
+	  class="bg-image"
+	  v-if="type === 6"
+	  src="https://static.shelingxingqiu.com/shootmini/static/rank/rank-bg.png"
+	  mode="widthFix"
+	/>
+    <view class="bg-overlay" v-if="type === 0"></view>
+  </view>
+</template>
+
+<style scoped>
+.background {
+  position: fixed;
+  width: 100%;
+  height: 100%;
+  left: 0;
+  top: 0;
+  z-index: -1;
+}
+
+.bg-image {
+  width: 100%;
+  /* height: 100%; */
+}
+
+.bg-overlay {
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  left: 0;
+  top: 0;
+  background: linear-gradient(
+    to bottom,
+    rgba(26, 26, 26, 0.2),
+    rgba(0, 0, 0, 0.2)
+  );
+}
+</style>

src/pages/team-battle/components/Avatar.vue

@@ -0,0 +1,123 @@
+<script setup>
+import { ref, onMounted, watch } from "vue";
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+const store = useStore();
+const { getLvlImage } = store;
+const { config } = storeToRefs(store);
+const props = defineProps({
+  src: {
+    type: String,
+    default: "",
+  },
+  rankLvl: {
+    type: Number,
+    default: undefined,
+  },
+  onClick: {
+    type: Function,
+    default: () => {},
+  },
+  rank: {
+    type: Number,
+    default: 0,
+  },
+  size: {
+    type: Number,
+    default: 45,
+  },
+  borderColor: {
+    type: String,
+    default: "",
+  },
+});
+const avatarFrame = ref("");
+watch(
+  () => [config.value, props.rankLvl],
+  () => {
+    if (props.rankLvl !== undefined) {
+      avatarFrame.value = getLvlImage(props.rankLvl);
+    }
+  },
+  {
+    immediate: true,
+  }
+);
+</script>
+
+<template>
+  <view class="avatar" @click="onClick">
+    <image
+      v-if="avatarFrame"
+      :src="avatarFrame"
+      mode="widthFix"
+      :style="{
+        width: Number(size) + 10 + 'px',
+        height: Number(size) + 10 + 'px',
+      }"
+      class="avatar-frame"
+    />
+    <image
+      v-if="rank === 1"
+      src="../../../static/champ1.png"
+      mode="widthFix"
+      class="avatar-rank"
+    />
+    <image
+      v-if="rank === 2"
+      src="../../../static/champ2.png"
+      mode="widthFix"
+      class="avatar-rank"
+    />
+    <image
+      v-if="rank === 3"
+      src="../../../static/champ3.png"
+      mode="widthFix"
+      class="avatar-rank"
+    />
+    <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',
+      }"
+      class="avatar-image"
+    />
+  </view>
+</template>
+
+<style scoped>
+.avatar {
+  position: relative;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+.avatar-frame {
+  position: absolute;
+}
+.avatar-rank,
+.rank-view {
+  position: absolute;
+  width: 20px;
+  height: 15px;
+  top: -6px;
+  right: -4px;
+}
+.rank-view {
+  background-color: #6d6d6d;
+  text-align: center;
+  line-height: 15px;
+  font-size: 12px;
+  border-top-left-radius: 50%;
+  border-bottom-right-radius: 50%;
+}
+.avatar-image {
+  border-radius: 50%;
+  border: 1px solid #fff;
+}
+</style>

src/pages/team-battle/components/BackToGame.vue

@@ -0,0 +1,143 @@
+<script setup>
+import { ref, watch, onMounted, onBeforeUnmount } from "vue";
+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";
+const store = useStore();
+const { user, game } = storeToRefs(store);
+const { updateGame } = store;
+
+const props = defineProps({
+  signin: {
+    type: Function,
+    default: () => {},
+  },
+});
+const loading = ref(false);
+const navigating = ref(false);
+
+/** 统一获取当前环境 token，用于守卫：无有效 token 时不发起接口请求 */
+const getToken = () =>
+  uni.getStorageSync(`${uni.getAccountInfoSync().miniProgram.envVersion}_token`);
+
+onShow(async () => {
+  navigating.value = false;
+  if (user.value.id && getToken()) {
+    setTimeout(async () => {
+      const state = await getUserGameState();
+      updateGame(state.gaming, state.roomId);
+    }, 1000);
+  }
+});
+
+watch(
+  () => user.value,
+  async (value) => {
+    if (!value.id) {
+      updateGame(false, "");
+    } else if (getToken()) {
+      // 有有效 token 时才查询在局状态，避免 token 失效时反复发起无效请求
+      const state = await getUserGameState();
+      updateGame(state.gaming, state.roomId);
+    }
+  }
+);
+
+const navigateOnce = (url) =>
+  new Promise((resolve, reject) => {
+    navigating.value = true;
+    uni.navigateTo({
+      url,
+      success: resolve,
+      fail: (error) => {
+        navigating.value = false;
+        reject(error);
+      },
+    });
+  });
+
+const onClick = debounce(async () => {
+  if (loading.value || navigating.value) return;
+  try {
+    loading.value = true;
+    const result = await getBattleAPI();
+    if (result && result.matchId) {
+      await returnToBattle(result, navigateOnce);
+      return;
+    }
+    if (game.value.roomID) {
+      await navigateOnce("/pages/battle-room?roomNumber=" + game.value.roomID);
+    } else {
+      updateGame(false, "");
+    }
+  } finally {
+    loading.value = false;
+  }
+});
+const gameOver = () => {
+  updateGame(false, "");
+};
+onMounted(() => {
+  uni.$on("game-over", gameOver);
+});
+onBeforeUnmount(() => {
+  uni.$off("game-over", gameOver);
+});
+</script>
+
+<template>
+  <view
+    v-if="game.inBattle || game.roomID"
+    class="back-to-game"
+    @click="onClick"
+  >
+    <image src="https://static.shelingxingqiu.com/shootmini/static/back-to-game-bg.png" mode="widthFix" />
+    <block v-if="game.inBattle">
+      <image src="https://static.shelingxingqiu.com/shootmini/static/pk-icon.png" mode="widthFix" />
+      <text>返回进行中的对局</text>
+    </block>
+    <block v-else-if="game.roomID">
+      <text>返回房间</text>
+    </block>
+    <image src="../../../static/back.png" mode="widthFix" />
+  </view>
+</template>
+
+<style scoped>
+.back-to-game {
+  position: fixed;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: #fff;
+  width: 56vw;
+  left: calc(50% - 28vw);
+  top: 12%;
+  z-index: 999;
+}
+.back-to-game > image:first-child {
+  position: absolute;
+  width: 100%;
+  height: 100rpx;
+}
+.back-to-game > image:nth-child(2) {
+  position: relative;
+  width: 60px;
+  height: 60px;
+}
+.back-to-game > text {
+  position: relative;
+  font-size: 14px;
+}
+.back-to-game > image:last-child {
+  position: relative;
+  width: 15px;
+  margin-left: 5px;
+  transform: rotate(180deg);
+}
+</style>

src/pages/team-battle/components/BattleFooter.vue

@@ -0,0 +1,203 @@
+=
+<script setup>
+import { computed } from "vue";
+import BowPower from "./BowPower.vue";
+import { RoundImages } from "@/constants";
+const props = defineProps({
+  roundResults: {
+    type: Array,
+    default: () => [],
+  },
+  bluePoints: {
+    type: Number,
+    default: 0,
+  },
+  redPoints: {
+    type: Number,
+    default: 0,
+  },
+  goldenRound: {
+    type: Number,
+    default: 0,
+  },
+});
+
+const normalRounds = computed(() => {
+  const count = props.roundResults.findIndex((item) => !!item.ifGold);
+  return count > 0 ? count : props.roundResults.length;
+});
+</script>
+
+<template>
+  <view class="container">
+    <view class="guide-row">
+      <image src="https://static.shelingxingqiu.com/shootmini/static/shooter.png" mode="widthFix" />
+      <view
+        :style="{
+          marginBottom: '10px',
+          transform: 'scale(0.8) translateX(10px)',
+        }"
+      >
+        <BowPower />
+      </view>
+    </view>
+    <view>
+      <image src="https://static.shelingxingqiu.com/shootmini/static/battle-header-melee.png" mode="widthFix" />
+      <text>蓝队({{ bluePoints }})</text>
+      <text>红队({{ redPoints }})</text>
+    </view>
+    <view class="players">
+      <view>
+        <view v-for="(result, index) in roundResults" :key="index">
+          <block v-if="index + 1 > normalRounds">
+            <image
+              :src="RoundImages[`gold${result.goldRound || index + 1 - normalRounds}`]"
+              mode="widthFix"
+            />
+          </block>
+          <block v-else>
+            <image :src="RoundImages[`round${index + 1}`]" mode="widthFix" />
+          </block>
+          <view>
+            <text>{{
+              result.shoots[1] && result.shoots[1].length
+                ? result.shoots[1]
+                    .map((item) => item.ring)
+                    .reduce((last, next) => last + next, 0)
+                : ""
+            }}</text>
+            <text>环</text>
+          </view>
+        </view>
+        <block v-if="roundResults.length < 3">
+          <view v-for="i in 3 - roundResults.length" :key="i">
+            <image
+              :src="RoundImages[`round${i + roundResults.length}`]"
+              mode="widthFix"
+            />
+            <view>
+              <text></text>
+              <text>环</text>
+            </view>
+          </view>
+        </block>
+      </view>
+      <view>
+        <view v-for="(result, index) in roundResults" :key="index">
+          <block v-if="index + 1 > normalRounds">
+            <image
+              :src="RoundImages[`gold${result.goldRound || index + 1 - normalRounds}`]"
+              mode="widthFix"
+            />
+          </block>
+          <block v-else>
+            <image :src="RoundImages[`round${index + 1}`]" mode="widthFix" />
+          </block>
+          <view>
+            <text>{{
+              result.shoots[2] && result.shoots[2].length
+                ? result.shoots[2]
+                    .map((item) => item.ring)
+                    .reduce((last, next) => last + next, 0)
+                : ""
+            }}</text>
+            <text>环</text>
+          </view>
+        </view>
+        <block v-if="roundResults.length < 3">
+          <view v-for="i in 3 - roundResults.length" :key="i">
+            <image
+              :src="RoundImages[`round${i + roundResults.length}`]"
+              mode="widthFix"
+            />
+            <view>
+              <text></text>
+              <text>环</text>
+            </view>
+          </view>
+        </block>
+      </view>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  width: 100%;
+  overflow: hidden;
+  margin-top: -100rpx;
+}
+.container > view:nth-child(2) {
+  position: relative;
+  display: flex;
+  justify-content: space-around;
+  align-items: center;
+  font-size: 13px;
+}
+.container > view:nth-child(2) > image:first-child {
+  position: absolute;
+  width: 100%;
+  top: -6px;
+}
+.container > view:nth-child(2) > text {
+  z-index: 1;
+  margin-top: 2px;
+  color: #8a323e;
+  font-weight: 500;
+}
+.container > view:nth-child(2) > text:nth-child(2) {
+  color: #004ac1;
+}
+.players {
+  display: flex;
+}
+.players > view {
+  width: 50%;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  color: #fff;
+  padding-top: 5px;
+}
+.players > view:first-child > view {
+  background: linear-gradient(270deg, #172a86 0%, #0000 100%);
+}
+.players > view:last-child > view {
+  background: linear-gradient(270deg, #0000 0%, #6a1212 100%);
+}
+.players > view > view {
+  min-height: 52rpx;
+  width: calc(100% - 40px);
+  padding: 2px 20px;
+  margin-bottom: 5px;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+.players > view > view > image:first-child {
+  width: 135rpx;
+  height: 20px;
+}
+.players > view > view > view:last-child {
+  font-size: 10px;
+}
+.players > view > view > view:last-child > text:first-child {
+  font-size: 16px;
+  color: #fed847;
+  margin-right: 5px;
+  font-weight: 500;
+}
+.guide-row {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-end;
+  padding: 0 5vw;
+  margin-bottom: -4px;
+  z-index: 2;
+  position: relative;
+}
+.guide-row > image {
+  width: 140rpx;
+}
+</style>

src/pages/team-battle/components/BattleHeader.vue

@@ -0,0 +1,243 @@
+<script setup>
+import Avatar from "./Avatar.vue";
+import { meleeAvatarColors } from "@/constants";
+defineProps({
+  players: {
+    type: Array,
+    default: () => [],
+  },
+  blueTeam: {
+    type: Array,
+    default: () => [],
+  },
+  redTeam: {
+    type: Array,
+    default: () => [],
+  },
+  showRank: {
+    type: Boolean,
+    default: false,
+  },
+  winner: {
+    type: Number,
+    default: 2,
+  },
+  showHeader: {
+    type: Boolean,
+    default: true,
+  },
+});
+
+const getMemberNicknameClass = (player = {}) => [
+  "member-nickname",
+  player.vip === true && player.sVip !== true ? "member-nickname--vip" : "",
+  player.sVip === true ? "member-nickname--svip" : "",
+];
+
+const isMember = (player = {}) => player.vip === true || player.sVip === true;
+</script>
+
+<template>
+  <view class="container" :style="{ paddingTop: showHeader ? '5px' : '0' }">
+    <image
+      v-if="showHeader"
+      :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' }"
+    >
+      <view>
+        <view
+          v-for="(player, index) in blueTeam"
+          :key="index"
+          :style="{
+            margin: blueTeam.length === 2 ? '0 -5px' : '0 6px',
+            width: `${100 / blueTeam.length - blueTeam.length * 3}%`,
+          }"
+        >
+          <Avatar :src="player.avatar" :rankLvl="player.rankLvl" :size="40" />
+          <view
+            v-if="isMember(player)"
+            :class="['player-name', ...getMemberNicknameClass(player)]"
+          >
+            <text class="member-nickname__text">{{ player.name }}</text>
+            <text v-if="player.sVip === true" class="member-nickname__shine">
+              {{ player.name }}
+            </text>
+          </view>
+          <text v-else class="player-name">{{ player.name }}</text>
+        </view>
+        <image
+          v-if="winner === 1"
+          src="../../../static/winner-badge.png"
+          mode="widthFix"
+          class="left-winner-badge"
+        />
+      </view>
+      <view>
+        <view
+          v-for="(player, index) in redTeam"
+          :key="index"
+          :style="{
+            margin: redTeam.length === 2 ? '0 -5px' : '0 6px',
+            width: `${100 / redTeam.length - redTeam.length * 3}%`,
+          }"
+        >
+          <Avatar :src="player.avatar" :rankLvl="player.rankLvl" :size="40" />
+          <view
+            v-if="isMember(player)"
+            :class="['player-name', ...getMemberNicknameClass(player)]"
+          >
+            <text class="member-nickname__text">{{ player.name }}</text>
+            <text v-if="player.sVip === true" class="member-nickname__shine">
+              {{ player.name }}
+            </text>
+          </view>
+          <text v-else class="player-name">{{ player.name }}</text>
+        </view>
+        <image
+          v-if="winner === 2"
+          src="../../../static/winner-badge.png"
+          mode="widthFix"
+          class="right-winner-badge"
+        />
+      </view>
+    </view>
+    <!-- 大乱斗玩家列表：scroll-view 作为横向滚动容器 -->
+    <!-- 小程序中 scroll-view 不支持直接 display:flex，需内部 wrapper view 承载 flex 布局 -->
+    <!-- 仅当玩家 >5 人（内容溢出宽度）时才阻止冒泡，防止与外层 swiper 切换 tab 的手势冲突 -->
+    <scroll-view
+      v-if="players.length"
+      class="players-melee"
+      scroll-x
+      @touchmove="(e) => players.length > 5 && e.stopPropagation()"
+      :style="{ paddingTop: showHeader ? '15px' : '0' }"
+    >
+      <view class="players-melee-inner">
+        <view
+          v-for="(player, index) in players"
+          :key="index"
+          :style="{
+            backgroundColor: meleeAvatarColors[index],
+            width: `${Math.max(100 / players.length, 18)}vw`,
+          }"
+        >
+          <Avatar
+            :src="player.avatar"
+            :rankLvl="showRank ? undefined : player.rankLvl"
+            :size="40"
+            :rank="showRank ? index + 1 : 0"
+          />
+          <view
+            v-if="isMember(player)"
+            :class="['player-name', ...getMemberNicknameClass(player)]"
+          >
+            <text class="member-nickname__text">{{ player.name }}</text>
+            <text v-if="player.sVip === true" class="member-nickname__shine">
+              {{ player.name }}
+            </text>
+          </view>
+          <text v-else class="player-name">{{ player.name }}</text>
+        </view>
+      </view>
+    </scroll-view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  width: 100%;
+  position: relative;
+  z-index: 999;
+  margin-bottom: 10px;
+}
+.container > image:first-child {
+  position: absolute;
+  width: 100%;
+  top: -5px;
+  z-index: 1;
+}
+.players {
+  display: flex;
+}
+.players > view {
+  width: 50%;
+  height: 75px;
+  color: #fff9;
+  font-size: 12px;
+  overflow: hidden;
+  position: relative;
+  padding-top: 5px;
+  display: flex;
+  justify-content: center;
+}
+.players > view:first-child {
+  background-color: #364469;
+}
+.players > view:last-child {
+  background-color: #692735;
+}
+.players > view > view {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+}
+.players-melee {
+  height: 80px;
+  width: 100%;
+}
+.players-melee::-webkit-scrollbar {
+  width: 0;
+  height: 0;
+  color: transparent;
+}
+/* 小程序 scroll-view 不支持直接 flex，通过内层 wrapper 承载横向排列 */
+.players-melee-inner {
+  display: flex;
+  height: 100%;
+  flex-wrap: nowrap;
+}
+.players-melee-inner > view {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  color: #fff9;
+  font-size: 12px;
+  padding-top: 7px;
+  flex: 0 0 auto;
+}
+.player-name {
+  margin-top: 3px;
+  width: 100%;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  text-align: center;
+}
+view.player-name {
+  justify-content: center;
+}
+.player-name .member-nickname__text,
+.player-name .member-nickname__shine {
+  font-size: 12px;
+}
+.left-winner-badge {
+  position: absolute;
+  width: 50px;
+  top: -12%;
+  left: -5%;
+  transform: rotate(-12deg);
+}
+.right-winner-badge {
+  position: absolute;
+  width: 50px;
+  top: -12%;
+  right: -5%;
+  transform: rotate(36deg);
+}
+</style>

src/pages/team-battle/components/BowPower.vue

@@ -0,0 +1,40 @@
+<script setup>
+import { ref, onMounted, onBeforeUnmount } from "vue";
+import { getDeviceBatteryAPI } from "@/apis";
+
+const power = ref(0);
+const timer = ref(null);
+
+onMounted(async () => {
+  const data = await getDeviceBatteryAPI();
+  power.value = data.battery;
+  timer.value = setInterval(async () => {
+    const data = await getDeviceBatteryAPI();
+    power.value = data.battery;
+  }, 1000 * 10);
+});
+
+onBeforeUnmount(() => {
+  clearInterval(timer.value);
+});
+</script>
+
+<template>
+  <view class="container">
+    <image src="../../../static/b-power.png" mode="widthFix" />
+    <view>电量{{ power || 1 }}%</view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  display: flex;
+  align-items: center;
+  color: #ffffffa8;
+  font-size: 13px;
+}
+.container > image {
+  width: 20px;
+  margin-right: 5px;
+}
+</style>

src/pages/team-battle/components/BowTarget.vue

@@ -0,0 +1,854 @@
+<script setup>
+import {
+  ref,
+  watch,
+  onMounted,
+  onBeforeUnmount,
+  computed,
+  nextTick,
+  getCurrentInstance,
+} from "vue";
+import PointSwitcher from "./PointSwitcher.vue";
+import BowShotEffect from "@/components/BowShotEffect.vue";
+
+import { MESSAGETYPES, MESSAGETYPESV2 } from "@/constants";
+import { simulShootAPI, laserAimAPI, laserCloseAPI } from "@/apis";
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+const store = useStore();
+const { user, device } = storeToRefs(store);
+
+const props = defineProps({
+  currentRound: {
+    type: Number,
+    default: 0,
+  },
+  totalRound: {
+    type: Number,
+    default: 0,
+  },
+  scores: {
+    type: Array,
+    default: () => [],
+  },
+  blueScores: {
+    type: Array,
+    default: () => [],
+  },
+  redTeam: {
+    type: Array,
+    default: () => [],
+  },
+  blueTeam: {
+    type: Array,
+    default: () => [],
+  },
+  latestShotFlash: {
+    type: Object,
+    default: null,
+  },
+  mode: {
+    type: String,
+    default: "solo", // solo 单排，team 双排
+  },
+  stop: {
+    type: Boolean,
+    default: false,
+  },
+  targetRadius: {
+    type: Number,
+    default: 20,
+  },
+  hitRadiusPx: {
+    type: Number,
+    default: 2,
+  },
+  zoomHitRadiusPx: {
+    type: Number,
+    default: 5,
+  },
+});
+
+const pMode = ref(true);
+const latestOne = ref(null);
+const bluelatestOne = ref(null);
+const timer = ref(null);
+const dirTimer = ref(null);
+const angle = ref(null);
+const circleColor = ref("");
+const shotEffect = ref(null);
+const hiddenRedLatestKey = ref("");
+const hiddenBlueLatestKey = ref("");
+const targetShaking = ref(false);
+const targetRect = ref({ left: 0, top: 0, width: 0, height: 0 });
+const shakeTimer = ref(null);
+const instance = getCurrentInstance();
+const ROUND_TIP_OFFSET_Y = -32;
+const EXPERIENCE_TIP_OFFSET_Y = -68;
+
+function buildShotEffectKey(team, shot, fallbackKey = "") {
+  return (
+    fallbackKey ||
+    [
+      team,
+      shot?.playerId ?? "",
+      shot?.x ?? "",
+      shot?.y ?? "",
+      shot?.ring ?? "",
+      shot?.ringX ? 1 : 0,
+    ].join("-")
+  );
+}
+
+function findShotPlayer(shot, team) {
+  const players = team === "red" ? props.redTeam : props.blueTeam;
+  return players.find((player) => String(player?.id) === String(shot?.playerId));
+}
+
+function isSvipShot(shot, team) {
+  return findShotPlayer(shot, team)?.sVip === true;
+}
+
+function shouldPlayShotEffect(shot, team) {
+  return !!shot && Number(shot.ring) > 0 && isSvipShot(shot, team);
+}
+
+function clearTipTimer() {
+  if (timer.value) clearTimeout(timer.value);
+  timer.value = null;
+}
+
+function showShotTip(team, shootData) {
+  clearTipTimer();
+
+  if (team === "red") {
+    latestOne.value = shootData;
+    timer.value = setTimeout(() => {
+      latestOne.value = null;
+      timer.value = null;
+    }, 1000);
+    return;
+  }
+
+  bluelatestOne.value = shootData;
+  timer.value = setTimeout(() => {
+    bluelatestOne.value = null;
+    timer.value = null;
+  }, 1000);
+}
+
+function triggerShotEffect(team, shot, fallbackKey = "") {
+  const key = buildShotEffectKey(team, shot, fallbackKey);
+
+  if (shotEffect.value?.team === "red") hiddenRedLatestKey.value = "";
+  if (shotEffect.value?.team === "blue") hiddenBlueLatestKey.value = "";
+
+  if (team === "red") {
+    latestOne.value = null;
+    hiddenRedLatestKey.value = key;
+  } else {
+    bluelatestOne.value = null;
+    hiddenBlueLatestKey.value = key;
+  }
+
+  shotEffect.value = { key, team, shot };
+}
+
+function completeShotEffect(key) {
+  if (!shotEffect.value || shotEffect.value.key !== key) return;
+
+  const { team, shot } = shotEffect.value;
+  if (team === "red") hiddenRedLatestKey.value = "";
+  if (team === "blue") hiddenBlueLatestKey.value = "";
+  shotEffect.value = null;
+  showShotTip(team, shot);
+}
+
+function shakeTarget() {
+  targetShaking.value = false;
+  if (shakeTimer.value) {
+    clearTimeout(shakeTimer.value);
+    shakeTimer.value = null;
+  }
+
+  nextTick(() => {
+    targetShaking.value = true;
+    shakeTimer.value = setTimeout(() => {
+      targetShaking.value = false;
+      shakeTimer.value = null;
+    }, 260);
+  });
+}
+
+function updateTargetRect() {
+  nextTick(() => {
+    const query = instance?.proxy
+      ? uni.createSelectorQuery().in(instance.proxy)
+      : uni.createSelectorQuery();
+
+    query
+      .select(".target")
+      .boundingClientRect((rect) => {
+        const left = Number(rect?.left);
+        const top = Number(rect?.top);
+        const width = Number(rect?.width);
+        const height = Number(rect?.height);
+        if (
+          !Number.isFinite(left) ||
+          !Number.isFinite(top) ||
+          !Number.isFinite(width) ||
+          !Number.isFinite(height)
+        ) {
+          return;
+        }
+        if (width <= 0 || height <= 0) return;
+        targetRect.value = { left, top, width, height };
+      })
+      .exec();
+  });
+}
+
+function handleWindowResize() {
+  updateTargetRect();
+}
+
+function shouldHideRedHit(index) {
+  return !!hiddenRedLatestKey.value && index === props.scores.length - 1;
+}
+
+function shouldHideBlueHit(index) {
+  return !!hiddenBlueLatestKey.value && index === props.blueScores.length - 1;
+}
+
+function showShotFlash(flash) {
+  const shootData = flash?.shootData;
+  if (!shootData) {
+    hiddenRedLatestKey.value = "";
+    hiddenBlueLatestKey.value = "";
+    shotEffect.value = null;
+    return;
+  }
+
+  const team = flash.team === "red" ? "red" : "blue";
+  if (shouldPlayShotEffect(shootData, team)) {
+    triggerShotEffect(team, shootData, flash.key);
+    return;
+  }
+
+  showShotTip(team, shootData);
+}
+
+watch(
+  () => props.latestShotFlash,
+  (newVal) => {
+    showShotFlash(newVal);
+  },
+  { immediate: true }
+);
+
+watch(
+  () => props.scores.length,
+  (newLen, oldLen) => {
+    if (newLen > oldLen) return;
+    latestOne.value = null;
+    hiddenRedLatestKey.value = "";
+    if (shotEffect.value?.team === "red") shotEffect.value = null;
+  }
+);
+
+watch(
+  () => props.blueScores.length,
+  (newLen, oldLen) => {
+    if (newLen > oldLen) return;
+    bluelatestOne.value = null;
+    hiddenBlueLatestKey.value = "";
+    if (shotEffect.value?.team === "blue") shotEffect.value = null;
+  }
+);
+
+const safeTargetRadius = computed(() => {
+  const radius = Number(props.targetRadius);
+  return Number.isFinite(radius) && radius > 0 ? radius : 20;
+});
+
+const currentHitRadiusPx = computed(() => {
+  const radius = Number(
+    pMode.value ? props.zoomHitRadiusPx : props.hitRadiusPx
+  );
+  return Number.isFinite(radius) && radius >= 0 ? radius : 0;
+});
+
+function getShotPoint(shot, fallbackCenter = false) {
+  const x = Number(shot?.x);
+  const y = Number(shot?.y);
+  if (Number.isFinite(x) && Number.isFinite(y)) return { x, y };
+  return fallbackCenter ? { x: 0, y: 0 } : null;
+}
+
+function getPointDirection(point) {
+  if (!point) return null;
+  const distance = Math.sqrt(point.x * point.x + point.y * point.y);
+  if (distance === 0) return null;
+
+  return {
+    x: point.x / distance,
+    y: point.y / distance,
+  };
+}
+
+function formatPxOffset(value) {
+  if (!value) return "";
+  const operator = value > 0 ? "+" : "-";
+  return ` ${operator} ${Math.abs(value)}px`;
+}
+
+function formatTargetPosition(percent, offset) {
+  const pxOffset = formatPxOffset(offset);
+  return pxOffset ? `calc(${percent}%${pxOffset})` : `${percent}%`;
+}
+
+function getTargetPositionStyle(point, offsetPx = 0, extraOffset = {}) {
+  if (!point) return { display: "none" };
+
+  const radius = safeTargetRadius.value;
+  const diameter = radius * 2;
+  const direction = getPointDirection(point);
+  const xOffset = (direction ? direction.x * offsetPx : 0) + (extraOffset.x || 0);
+  const yOffset = (direction ? -direction.y * offsetPx : 0) + (extraOffset.y || 0);
+  const leftPercent = ((point.x + radius) / diameter) * 100;
+  const topPercent = ((radius - point.y) / diameter) * 100;
+
+  return {
+    left: formatTargetPosition(leftPercent, xOffset),
+    top: formatTargetPosition(topPercent, yOffset),
+    transform: "translate(-50%, -50%)",
+  };
+}
+
+function getHitStyle(shot) {
+  const radius = currentHitRadiusPx.value;
+  const point = getShotPoint(shot);
+
+  return {
+    ...getTargetPositionStyle(point, radius),
+    width: `${radius * 2}px`,
+    height: `${radius * 2}px`,
+  };
+}
+
+function getSvipHitBgStyle(shot) {
+  const radius = currentHitRadiusPx.value;
+  const point = getShotPoint(shot);
+
+  return {
+    ...getTargetPositionStyle(point, radius),
+  };
+}
+
+function getRoundTipStyle(shot) {
+  const point = getShotPoint(shot, true);
+  return getTargetPositionStyle(
+    point,
+    shot?.ring ? currentHitRadiusPx.value : 0,
+    { y: ROUND_TIP_OFFSET_Y }
+  );
+}
+
+function getExperienceTipStyle(shot) {
+  const point = getShotPoint(shot, true);
+  return getTargetPositionStyle(
+    point,
+    shot?.ring ? currentHitRadiusPx.value : 0,
+    { y: EXPERIENCE_TIP_OFFSET_Y }
+  );
+}
+const simulShoot = async () => {
+  if (device.value.deviceId) await simulShootAPI(device.value.deviceId);
+};
+const simulShoot2 = async () => {
+  if (device.value.deviceId) {
+    const r1 = Math.random() > 0.5 ? 0.01 : 0.02;
+    await simulShootAPI(device.value.deviceId, r1, r1);
+  }
+};
+
+const openAim = async () => {
+  await laserAimAPI();
+};
+
+const closeAim = async () => {
+  await laserCloseAPI();
+};
+
+const env = computed(() => {
+  const accountInfo = uni.getAccountInfoSync();
+  return accountInfo.miniProgram.envVersion;
+});
+
+const arrowStyle = computed(() => {
+  return {
+    transform: `rotateX(180deg) translate(-50%, -50%) rotate(${
+      360 - angle.value
+    }deg) translateY(105%)`,
+  };
+});
+
+async function onReceiveMessage(message) {
+  if (Array.isArray(message)) return;
+  if (message.type === MESSAGETYPESV2.ShootResult && message.shootData) {
+    if (
+      message.shootData.playerId === user.value.id &&
+      !message.shootData.ring &&
+      message.shootData.angle >= 0
+    ) {
+      angle.value = null;
+      setTimeout(() => {
+        if (props.scores[0]) {
+          circleColor.value =
+            message.shootData.playerId === props.scores[0].playerId
+              ? "#ff4444"
+              : "#1840FF";
+        }
+        angle.value = message.shootData.angle;
+      }, 200);
+    }
+  }
+}
+
+onMounted(() => {
+  uni.$on("socket-inbox", onReceiveMessage);
+  updateTargetRect();
+  if (uni.onWindowResize) uni.onWindowResize(handleWindowResize);
+});
+
+onBeforeUnmount(() => {
+  if (timer.value) {
+    clearTimeout(timer.value);
+    timer.value = null;
+  }
+  if (dirTimer.value) {
+    clearTimeout(dirTimer.value);
+    dirTimer.value = null;
+  }
+  if (shakeTimer.value) {
+    clearTimeout(shakeTimer.value);
+    shakeTimer.value = null;
+  }
+  uni.$off("socket-inbox", onReceiveMessage);
+  if (uni.offWindowResize) uni.offWindowResize(handleWindowResize);
+});
+</script>
+
+<template>
+  <view :class="['container', { 'container--effecting': shotEffect }]">
+    <view class="header" v-if="totalRound > 0">
+      <text v-if="totalRound > 0" class="round-count">{{
+        (currentRound > totalRound ? totalRound : currentRound) +
+        "/" +
+        totalRound
+      }}</text>
+    </view>
+    <view :class="['target', { 'target--shake': targetShaking }]">
+      <view v-if="angle !== null" class="arrow-dir" :style="arrowStyle">
+        <view :style="{ background: circleColor }">
+          <image src="../../../static/dot-circle.png" mode="widthFix" />
+        </view>
+      </view>
+      <view v-if="stop" class="stop-sign">中场休息</view>
+      <view
+        v-if="latestOne && latestOne.ring && user.id === latestOne.playerId"
+        class="e-value fade-in-out"
+        :style="getExperienceTipStyle(latestOne)"
+      >
+        经验 +1
+      </view>
+      <view
+        v-if="latestOne"
+        class="round-tip fade-in-out"
+        :style="getRoundTipStyle(latestOne)"
+        >{{ latestOne.ringX ? "X" : latestOne.ring || "未上靶"
+        }}<text v-if="latestOne.ring">环</text>
+      </view>
+      <view
+        v-if="
+          bluelatestOne &&
+          bluelatestOne.ring &&
+          user.id === bluelatestOne.playerId
+        "
+        class="e-value fade-in-out"
+        :style="getExperienceTipStyle(bluelatestOne)"
+      >
+        经验 +1
+      </view>
+      <view
+        v-if="bluelatestOne"
+        class="round-tip fade-in-out"
+        :style="getRoundTipStyle(bluelatestOne)"
+        >{{ bluelatestOne.ringX ? "X" : bluelatestOne.ring || "未上靶"
+        }}<text v-if="bluelatestOne.ring">环</text></view
+      >
+      <block v-for="(bow, index) in scores" :key="index">
+        <image
+          v-if="
+            pMode &&
+            bow.ring > 0 &&
+            isSvipShot(bow, 'red') &&
+            !shouldHideRedHit(index)
+          "
+          class="svip-hit-bg"
+          src="../../../static/vip/svip-xuan.png"
+          :style="getSvipHitBgStyle(bow)"
+          mode="aspectFit"
+        />
+        <view
+          v-if="bow.ring > 0 && !shouldHideRedHit(index)"
+          :class="`hit ${pMode ? 'b' : 's'}-point ${
+            index === scores.length - 1 && latestOne ? 'pump-in' : ''
+          }`"
+          :style="{
+            ...getHitStyle(bow),
+            backgroundColor: mode === 'solo' ? '#00bf04' : '#FF0000',
+          }"
+          ><text v-if="pMode">{{ index + 1 }}</text></view
+        >
+      </block>
+      <block v-for="(bow, index) in blueScores" :key="index">
+        <image
+          v-if="
+            pMode &&
+            bow.ring > 0 &&
+            isSvipShot(bow, 'blue') &&
+            !shouldHideBlueHit(index)
+          "
+          class="svip-hit-bg"
+          src="../../../static/vip/svip-xuan.png"
+          :style="getSvipHitBgStyle(bow)"
+          mode="aspectFit"
+        />
+        <view
+          v-if="bow.ring > 0 && !shouldHideBlueHit(index)"
+          :class="`hit ${pMode ? 'b' : 's'}-point ${
+            index === blueScores.length - 1 && bluelatestOne ? 'pump-in' : ''
+          }`"
+          :style="{
+            ...getHitStyle(bow),
+            backgroundColor: '#1840FF',
+          }"
+        >
+          <text v-if="pMode">{{ index + 1 }}</text>
+        </view>
+      </block>
+      <BowShotEffect
+        :shot="shotEffect && shotEffect.shot"
+        :playKey="shotEffect ? shotEffect.key : ''"
+        :targetRadius="safeTargetRadius"
+        :targetLeft="targetRect.left"
+        :targetTop="targetRect.top"
+        :targetWidth="targetRect.width"
+        :targetHeight="targetRect.height"
+        :hitOffsetPx="currentHitRadiusPx"
+        @impact="shakeTarget"
+        @complete="completeShotEffect"
+      />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/bow-target.png" mode="widthFix" />
+    </view>
+    <view class="footer">
+      <PointSwitcher
+        :onChange="(val) => (pMode = val)"
+        :style="{ zIndex: 999 }"
+      />
+    </view>
+    <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>
+
+<style scoped>
+.container {
+  width: calc(100vw - 30px);
+  height: calc(100vw - 30px);
+  padding: 0px 15px;
+  position: relative;
+  z-index: 3;
+}
+.container--effecting {
+  z-index: 10000;
+}
+.target {
+  position: relative;
+  margin: 10px;
+  width: calc(100% - 20px);
+  height: calc(100% - 20px);
+  z-index: 1;
+  pointer-events: none;
+  transform-origin: center center;
+}
+.target--shake {
+  animation: target-shake 0.26s ease-out;
+}
+.e-value {
+  position: absolute;
+  background-color: #0006;
+  color: #fff;
+  font-size: 12px;
+  padding: 4px 7px;
+  border-radius: 5px;
+  z-index: 2;
+  width: 50px;
+  text-align: center;
+}
+.round-tip {
+  position: absolute;
+  color: #fff;
+  font-size: 30px;
+  font-weight: bold;
+  z-index: 2;
+  width: 100px;
+  text-align: center;
+}
+.round-tip > text {
+  font-size: 24px;
+  margin-left: 5px;
+}
+@keyframes target-tip-fade-in-out {
+  0% {
+    transform: translate(-50%, -50%) translateY(20px);
+    opacity: 0;
+  }
+
+  30% {
+    transform: translate(-50%, -50%);
+    opacity: 1;
+  }
+
+  80% {
+    transform: translate(-50%, -50%);
+    opacity: 1;
+  }
+
+  100% {
+    transform: translate(-50%, -50%);
+    opacity: 0;
+  }
+}
+.round-tip.fade-in-out,
+.e-value.fade-in-out {
+  animation: target-tip-fade-in-out 1.2s ease forwards;
+}
+.target > image:last-child {
+  width: 100%;
+  height: 100%;
+}
+.svip-hit-bg {
+  position: absolute;
+  width: 48rpx;
+  height: 48rpx;
+  z-index: 1;
+  pointer-events: none;
+  transform-origin: center center;
+  animation: svip-hit-xuan 1.2s linear infinite;
+}
+.hit {
+  position: absolute;
+  border-radius: 50%;
+  z-index: 2;
+  color: #fff;
+  transition: transform 0.2s ease, opacity 0.2s ease;
+  box-sizing: border-box;
+}
+.b-point {
+  border: 1px solid #fff;
+  z-index: 2;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+.b-point > text {
+  font-size: 16rpx;
+  color: #fff;
+  font-family: "DINCondensed";
+  /* text-align: center;
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);*/
+  margin-top: 2rpx;
+}
+@keyframes svip-hit-xuan {
+  0% {
+    opacity: 0.9;
+    transform: translate(-50%, -50%) rotate(0deg) scale(0.92);
+  }
+  50% {
+    opacity: 1;
+    transform: translate(-50%, -50%) rotate(180deg) scale(1.08);
+  }
+  100% {
+    opacity: 0.9;
+    transform: translate(-50%, -50%) rotate(360deg) scale(0.92);
+  }
+}
+@keyframes target-pump-in {
+  from {
+    transform: translate(-50%, -50%) scale(2);
+  }
+
+  to {
+    transform: translate(-50%, -50%) scale(1);
+  }
+}
+@keyframes target-shake {
+  0% {
+    transform: translate(0, 0);
+  }
+  14% {
+    transform: translate(-20rpx, 8rpx);
+  }
+  28% {
+    transform: translate(16rpx, -8rpx);
+  }
+  44% {
+    transform: translate(-12rpx, 6rpx);
+  }
+  64% {
+    transform: translate(8rpx, -4rpx);
+  }
+  82% {
+    transform: translate(-4rpx, 2rpx);
+  }
+  100% {
+    transform: translate(0, 0);
+  }
+}
+.hit.pump-in {
+  animation: target-pump-in 0.3s ease-out forwards;
+  transform-origin: center center;
+}
+.header {
+  width: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  margin-bottom: -40px;
+}
+.header > image:first-child {
+  width: 40px;
+  height: 40px;
+}
+.round-count {
+  font-size: 20px;
+  color: #fed847;
+  top: 75px;
+  font-weight: bold;
+}
+.footer {
+  width: calc(100% - 20px);
+  padding: 0 10px;
+  display: flex;
+  margin-top: -40px;
+  justify-content: flex-end;
+  position: relative;
+  z-index: 999;
+}
+.footer > image {
+  width: 40px;
+  min-height: 40px;
+  max-height: 40px;
+  border-radius: 50%;
+  border: 1px solid #fff;
+}
+.simul {
+  position: absolute;
+  top: 0;
+  right: 20px;
+  margin-left: 20px;
+  z-index: 999;
+}
+.simul > button {
+  color: #fff;
+}
+.stop-sign {
+  position: absolute;
+  font-size: 44px;
+  color: #fff9;
+  text-align: center;
+  width: 200px;
+  height: 60px;
+  left: calc(50% - 100px);
+  top: calc(50% - 30px);
+  z-index: 99;
+  font-weight: bold;
+}
+.arrow-dir {
+  position: absolute;
+  width: 100%;
+  height: 52%;
+  left: 50%;
+  bottom: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+.arrow-dir > view {
+  width: 40rpx;
+  height: 40rpx;
+  border-radius: 50%;
+}
+.arrow-dir > view > image {
+  width: 100rpx;
+  height: 100rpx;
+  transform: translate(-30%, -30%);
+}
+@keyframes spring-in {
+  0% {
+    transform: scale(2);
+    opacity: 0.4;
+  }
+  15% {
+    transform: scale(3);
+    opacity: 1;
+  }
+  30% {
+    transform: scale(2);
+    opacity: 0.4;
+  }
+  45% {
+    transform: scale(3);
+    opacity: 1;
+  }
+  60% {
+    transform: scale(2);
+    opacity: 0.4;
+  }
+  75% {
+    transform: scale(3);
+    opacity: 1;
+  }
+  100% {
+    transform: scale(1);
+    opacity: 0;
+  }
+}
+@keyframes disappear {
+  0% {
+    opacity: 1;
+  }
+  75% {
+    opacity: 1;
+  }
+  100% {
+    opacity: 0;
+  }
+}
+.arrow-dir > view {
+  animation: disappear 3s ease forwards;
+}
+.arrow-dir > view > image {
+  animation: spring-in 3s ease forwards;
+  width: 100%;
+}
+</style>

src/pages/team-battle/components/Container.vue

@@ -0,0 +1,306 @@
+<script setup>
+import { ref } from "vue";
+import { onShow } from "@dcloudio/uni-app";
+import AppBackground from "./AppBackground.vue";
+import Header from "./Header.vue";
+import ScreenHint from "./ScreenHint.vue";
+import BackToGame from "./BackToGame.vue";
+import {laserAimAPI, getBattleAPI, matchGameAPI} from "@/apis";
+import { capsuleHeight, debounce } from "@/util";
+import { returnToBattle } from "@/utils/matchReturn";
+const props = defineProps({
+  title: {
+    type: String,
+    default: "",
+  },
+  bgType: {
+    type: Number,
+    default: 0,
+  },
+  onBack: {
+    type: Function,
+    default: null,
+  },
+  scroll: {
+    type: Boolean,
+    default: true,
+  },
+  isHome: {
+    type: Boolean,
+    default: false,
+  },
+  showBackToGame: {
+    type: Boolean,
+    default: false,
+  },
+  bgColor: {
+    type: String,
+    default: "#050b19",
+  },
+  whiteBackArrow: {
+    type: Boolean,
+    default: true,
+  },
+  showBottom: {
+    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 showGlobalHint = (type) => {
+  hintType.value = type;
+  showHint.value = true;
+};
+
+const hideGlobalHint = () => {
+  showHint.value = false;
+};
+
+onShow(() => {
+  uni.$showHint = showGlobalHint;
+  uni.$hideHint = hideGlobalHint;
+  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; // 防止重复点击
+
+  try {
+    isLoading.value = true;
+    const result = await getBattleAPI();
+    if (result && result.matchId) {
+      await returnToBattle(result, navigateTo);
+    }
+  } catch (error) {
+    console.error("获取当前游戏失败:", error);
+  } finally {
+    isLoading.value = false;
+  }
+});
+
+const goBack = () => {
+  uni.navigateBack();
+};
+
+const cancelMatching = async () => {
+  uni.$emit("cancelMatching");
+}
+
+const goCalibration = async () => {
+  await laserAimAPI();
+  uni.navigateTo({
+    url: "/pages/calibration",
+  });
+};
+</script>
+
+<template>
+  <view :style="{ paddingTop: capsuleHeight + 'px' }">
+    <AppBackground :type="bgType" :bgColor="bgColor" />
+    <Header
+      v-if="!isHome"
+      :title="title"
+      :onBack="onBack"
+      :whiteBackArrow="whiteBackArrow"
+    />
+    <BackToGame v-if="showBackToGame" />
+    <scroll-view
+      :scroll-y="scroll"
+      :enhanced="true"
+      :bounces="false"
+      :show-scrollbar="false"
+      :style="{
+        height: `calc(100vh - ${capsuleHeight + (isHome ? 0 : 50)}px - ${
+          $slots.bottom && showBottom ? (isIOS ? '75px' : '65px') : '0px'
+        })`,
+      }"
+    >
+      <slot></slot>
+    </scroll-view>
+    <view
+      class="bottom-part"
+      v-if="$slots.bottom && showBottom"
+      :style="{ height: isIOS ? '65px' : '55px', paddingTop: '10px' }"
+    >
+      <slot name="bottom"></slot>
+    </view>
+    <ScreenHint :show="showHint">
+      <view v-if="hintType === 1" class="tip-content">
+        <text>完成进行中的对局才能开启新的。</text>
+        <text>您有正在进行中的对局，是否进入?</text>
+        <view>
+          <button hover-class="none" @click="() => (showHint = false)">
+            不进入
+          </button>
+          <button hover-class="none" @click="backToGame" :disabled="isLoading">
+            {{ isLoading ? "加载中..." : "进入" }}
+          </button>
+        </view>
+      </view>
+      <view v-if="hintType === 2" class="tip-content">
+        <text>离开比赛可能会导致比赛失败，</text>
+        <text>确认离开吗？</text>
+        <view>
+          <button hover-class="none" @click="goBack">离开比赛</button>
+          <button hover-class="none" @click="() => (showHint = false)">
+            继续比赛
+          </button>
+        </view>
+      </view>
+      <view v-if="hintType === 3" class="tip-content">
+        <text>今天不玩了吗？</text>
+        <view>
+          <button hover-class="none" @click="() => (showHint = false)">
+            取消
+          </button>
+          <button hover-class="none" @click="$clickSound(cancelMatching)">确认</button>
+        </view>
+      </view>
+      <view v-if="hintType === 4" class="tip-content">
+        <text>完成智能弓校准，即可解锁全部功能</text>
+        <view>
+          <button hover-class="none" @click="() => (showHint = false)">
+            取消
+          </button>
+          <button hover-class="none" @click="goCalibration">去校准</button>
+        </view>
+      </view>
+    </ScreenHint>
+    <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: '100%' }">
+          <!-- <image
+            src="https://static.shelingxingqiu.com/attachment/2025-11-24/degu91a7si77sg9jqv.png"
+            mode="widthFix"
+          /> -->
+        </view>
+      </view>
+      <view>
+        <text>{{ loadingText || "加载中..." }}</text>
+      </view>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.tip-content {
+  flex-direction: column;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: #fff;
+  width: 100%;
+  font-size: 14px;
+}
+.tip-content > text {
+  text-align: center;
+}
+.tip-content > view {
+  display: flex;
+  align-items: center;
+  justify-content: space-around;
+  margin-top: 50rpx;
+  width: 100%;
+}
+.tip-content > view > button {
+  padding: 12px;
+  border-radius: 20px;
+  background-color: #fff6;
+  color: #fff;
+  width: 45%;
+  font-size: 16px;
+}
+.tip-content > view > button:last-child {
+  background-color: #fed847;
+  color: #000;
+}
+
+.tip-content > view > button:disabled {
+  background-color: #ccc;
+  color: #666;
+  opacity: 0.6;
+}
+.audio-progress {
+  z-index: 999;
+  width: 100vw;
+  height: 100vh;
+  position: fixed;
+  top: 0;
+  left: 0;
+  background: rgb(0 0 0 / 0.8);
+  display: flex;
+  flex-direction: column;
+  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;
+  background: #595959;
+  border-radius: 4rpx;
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  justify-content: flex-start;
+}
+.audio-progress > view:nth-child(2) > view {
+  background: #ffe431;
+  min-height: 6rpx;
+  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>