update：翻译备份

# Conflicts:
#	src/apis.js

.gitignore

@@ -8,6 +8,12 @@ pnpm-debug.log*
 lerna-debug.log*
 
 node_modules
+.history
+.github
+.claude
+openspec
+CLAUDE.md
+docs
 .DS_Store
 dist
 *.local

.vscode/settings.json

@@ -0,0 +1,9 @@
+{
+  "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
+* 写好中文注释
+
+除非用户明确要求：
+否则不要输出完整项目。

ENGLISH_LOCALIZATION.md

@@ -0,0 +1,62 @@
+# 小程序英文静态文案交付记录
+
+## 实现范围
+
+- 固定英文，使用现有 `vue-i18n`；没有新增或升级依赖，没有增加语言切换入口或在线翻译请求。
+- `src/locales/en.json` 为英文词条，`zh-CN.json` 为中文校对基线，`source-keys.json` 为原文到文案键的索引。
+- 已整理 1,108 条词条，覆盖主包、会员/设备/金币/团队对战/训练分包，以及保留在源码中的历史页面和公共组件。
+- 页面文本、输入提示、弹窗默认文案、前端固定错误提示、静态说明、协议、状态显示、分享标题及 Canvas 绘制文字均纳入翻译；`manifest.json` 中的小程序定位权限用途说明使用对应英文常量。
+- 公共按钮支持英文换行，弹窗和教练点评支持长文案滚动；会员提示和分享 Canvas 的文字做了局部排版调整。
+
+## 业务隔离
+
+- API 地址、请求结构、路由、状态码、缓存键、WebSocket/Protobuf 字段、计分、射距及靶纸判断保持原样。
+- `audioManager.js` 完全未修改，中文音频键、语音结束事件与播放顺序继续使用原值。
+- 比赛提示继续以原值参与状态与语音判断，由 `formatBattleTip` 在明确的渲染位置显示英文。
+- 新手引导步骤标题保留原值；Header 只对四个已知的静态步骤值转换显示，不对任意动态标题做翻译。
+- Wi-Fi 样式判断继续使用原始状态；段位图片的 `picNames` 和名称保持中文，仅在文本节点展示英文。
+- 训练雷达的兜底数据增加仅用于显示的 `staticLabel`，原始 `name` 及其映射保持原样。服务端返回的维度名称直接显示原文。
+- `translateStatic` 只用于明确来自前端配置或前端计算结果的展示，不应用于接口响应、用户输入或 store 的整体数据。
+
+## 保留内容及后续交接
+
+| 内容 | 当前处理 | 后续负责人/事项 |
+| --- | --- | --- |
+| 底部导航图片 `tab-vip.png`、`tab-point-book.png`、`tab-mall.png` | 地址与资源不变 | UI 提供英文图 |
+| 首页、引导、设备介绍、VIP/SVIP、训练标题及比赛结果等图片 | 地址与资源不变，图片内中文保留 | UI 按原尺寸与资源位交付英文图 |
+| 分享卡片底图、二维码、徽章等 | 保留；只翻译代码绘制的文字 | UI 后续提供需要替换的英文底图 |
+| 音频、视频 | 保留 | 如需英语语音，另行准备资源与实施方案 |
+| 商品、门店、套餐、公告、固件说明、服务端规则与协议、接口错误消息 | 保留接口原文 | 后端/运营提供英文内容 |
+| 接口段位名称及介绍 | 所有后端 HTTP 请求统一携带 `Accept-Language: en-US`，直接展示后端响应 | 后端部署并维护英文段位配置；图标仍按接口原地址展示 |
+| 昵称、组织名、设备别名、Wi-Fi 名称、记分备注等用户内容 | 原样展示及提交 | 不机翻 |
+| WebView 外部页面、微信授权和支付系统界面 | 保持原有行为 | 对应内容方/系统管理 |
+| 调试日志、音频测试页中的原始音频标识、中文正则与判断字符串 | 保留技术原值 | 无需作为页面文案替换 |
+
+币种、金额、距离、时区与日期计算不作转换。品牌名暂译为 **Sheling Planet**；段位和射箭术语已统一机翻用词，正式品牌译名及协议可由业务方继续校对。
+
+## 验证记录
+
+- 比赛界面修复：独立及公共 `BattleFooter` 的空回合循环改用明确的变量名，避免编译后的文案字段与 `wx:for-item="i"` 同名，导致文本节点输出 `[object Object]`。不修改回合数据、得分求和或回合图片。
+- 独立比赛顶部进度组件接入 `formatBattleTip`，仅在渲染时转换英文，保留原始中文提示和语音队列；英文顶部文字与调试按钮做局部排版调整，调试按钮保留非正式环境才显示的原条件。
+- `npm run battle:display:check`：先在旧微信编译产物复现行对象输出，再在修复后的 JS + WXML 中验证 0–3 个正常回合、加赛回合、空成绩/零分、红蓝方英文提示和中文状态不变。调试按钮改为紧凑两列，最终真机视觉效果仍需预览验收。
+- 全局英文请求头：统一请求封装的所有 HTTP 请求均携带 `Accept-Language: en-US`，移除段位接口白名单；独立的 `aimRenewAPI` 同样携带英文头，保留不等待响应和忽略响应结果的行为。认证、请求参数、接口地址及响应处理不变。首页继续使用现有 `/user/myHome`，未按文档示例替换成 `/index/myHome`。
+- 固定英文版缓存兼容：恢复用户缓存时仅清空 `lvlName`、`rankName`、`nextRankName` 中的旧中文显示名，等待原有接口回填；保留英文缓存、昵称、身份、设备、段位编号、成绩与图标。配置和榜单维持现有不持久化方式，不新增语言切换或整体清缓存。
+- `npm run rank:i18n:check`：验证所有已覆盖 HTTP 请求的英文头（包括 GET、POST、PUT、DELETE 和独立调瞄续期），有/无登录凭证、分页/赛季参数及原始错误消息保持原行为，并通过真实 Pinia 持久化插件验证旧中文缓存恢复和英文缓存再次恢复。
+- 2026-11-05 只读联调 `/index/appConfig`：测试环境 `apitest.shelingxingqiu.com` 返回 74 条段位，中文请求为 `倔强青铜I / 倔强青铜`，英文请求为 `Bronze I / Bronze`；正式环境 `api.shelingxingqiu.com` 的英文请求仍返回中文，需要后端确认正式环境的多语言支持。两边的中英文请求中，段位编号、升级积分及图标地址均一致。未使用用户凭证调用首页或个人榜单，登录态接口仍需真机联调。
+- 同日只读联调积分榜、十环榜、MVP 榜（各取 1 条、携带 `en-US`）：测试环境三榜均返回英文 `Bronze I`；正式环境三榜仍返回中文段位。这是后端响应差异，前端未额外机翻或覆盖这些动态字段。
+- 参数占位符修复：统一 `t` 入口直接读取固定英文词条并执行一次参数替换，兼容 uni-app 小程序运行库直接返回原文的情况。31 条参数文案对照完整版翻译库及当前 uni-app 消息编译器检查，包含数字 0、空字符串、布尔值及参数中含花括号的场景。页面调用和业务数据不作修改。
+- 上传限制修复：定位权限用途说明缩短为 `Find Wi-Fi for device updates`（29 个字符），并在 `i18n:check` 中检查权限说明为 1–30 个字符。上传校验与本地编译是不同步骤，本地构建通过不代表微信上传校验通过。
+- `npm run i18n:check`：通过。核查中英文键、占位符与插值、翻译函数遮蔽、163 个 Vue 文件的 SFC 编译，以及未翻译的模板直接文字与展示属性。
+- 专项用例通过：中文方向音效键、测距/无效射箭语音键、英文测距/无效射箭提示、499/500 cm 边界、次数上限消息、设备/新手试炼进入条件。
+- 使用本次修改前的 Git 基线完成附加对照：所有受影响源码中的资源 URL 一致，音频源码未改变；脚本语法树去除文案调用和明确的显示层调整后与基线一致。
+- `npm run build`：微信小程序构建通过；构建前的协议检查通过（12 个消息、164 个字段）。
+- 已清理四条不存在的旧主包路由：`pages/calibration`、`pages/my-device`、`pages/device-intro`、`pages/ota-wifi`。保留 `pages/device/` 下对应分包页面及现有跳转，剩余 58 条路由均有源文件。
+- 未执行真机视觉验收、实物智能弓/OTA 联调或真实支付。代码与构建检查不能替代这些验收。
+
+建议在微信开发者工具及真机重点检查首页、首次引导、设备三态、训练规则、比赛提示、结果页、会员协议、订单、记分本与分享图的英文排版；验证登录、绑定/解绑、OTA、训练/比赛、支付/取消与分享仍按原流程工作。
+
+## 日常维护
+
+新增固定文案时同步维护三份词条文件，模板和脚本通过 `t(key, params)` 取值；整句使用参数，避免重新引入中文语序拼接。业务枚举、接口数据与媒体标识不要作为翻译目标。
+
+运行 `npm run i18n:check` 做本地检查；构建后运行 `npm run i18n:check -- --built`，对真实微信产物模块执行参数插值回归。`npm run battle:display:check` 检查比赛组件真实 JS + WXML 的渲染作用域及英文提示。`node scripts/localization-inventory.cjs` 可只读输出保留中文候选。候选包含日志、语音及判断字符串，不能作为全文替换清单。

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

@@ -7,12 +7,11 @@
     "types": [
       "vite/client",
       "@dcloudio/types",
-      "@mini-types/alipay",
+      "miniprogram-api-typings"
-      "miniprogram-api-typings",
-      "@uni-helper/uni-types"
     ]
   },
   "vueCompilerOptions": {
     "plugins": ["@uni-helper/uni-types/volar-plugin"]
-  }
+  },
+  "exclude": ["node_modules", "dist"]
 }

package.json

@@ -3,22 +3,48 @@
   "version": "0.1.0",
   "private": true,
   "scripts": {
+    "i18n:check": "node scripts/check-localization.cjs",
+    "rank:i18n:check": "node scripts/check-rank-i18n.cjs",
+    "battle:display:check": "node scripts/check-battle-display.cjs",
+    "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": {
-    "@dcloudio/uni-app": "3.0.0-4050620250312001",
+    "@dcloudio/uni-app": "3.0.0-4060620250520001",
-    "@dcloudio/uni-components": "3.0.0-4050620250312001",
+    "@dcloudio/uni-app-harmony": "3.0.0-4060620250520001",
-    "@dcloudio/uni-mp-weixin": "3.0.0-4050620250312001",
+    "@dcloudio/uni-app-plus": "3.0.0-4060620250520001",
-    "vue": "3.4.21"
+    "@dcloudio/uni-components": "3.0.0-4060620250520001",
+    "@dcloudio/uni-h5": "3.0.0-4060620250520001",
+    "@dcloudio/uni-mp-alipay": "3.0.0-4060620250520001",
+    "@dcloudio/uni-mp-baidu": "3.0.0-4060620250520001",
+    "@dcloudio/uni-mp-harmony": "3.0.0-4060620250520001",
+    "@dcloudio/uni-mp-jd": "3.0.0-4060620250520001",
+    "@dcloudio/uni-mp-kuaishou": "3.0.0-4060620250520001",
+    "@dcloudio/uni-mp-lark": "3.0.0-4060620250520001",
+    "@dcloudio/uni-mp-qq": "3.0.0-4060620250520001",
+    "@dcloudio/uni-mp-toutiao": "3.0.0-4060620250520001",
+    "@dcloudio/uni-mp-weixin": "3.0.0-4060620250520001",
+    "@dcloudio/uni-mp-xhs": "3.0.0-4060620250520001",
+    "@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"
   },
   "devDependencies": {
-    "@dcloudio/types": "3.4.8",
+    "@dcloudio/types": "^3.4.8",
-    "@dcloudio/uni-automator": "3.0.0-4050620250312001",
+    "@dcloudio/uni-automator": "3.0.0-4060620250520001",
-    "@dcloudio/uni-cli-shared": "3.0.0-4050620250312001",
+    "@dcloudio/uni-cli-shared": "3.0.0-4060620250520001",
-    "@dcloudio/uni-stacktracey": "3.0.0-4050620250312001",
+    "@dcloudio/uni-stacktracey": "3.0.0-4060620250520001",
-    "@dcloudio/vite-plugin-uni": "3.0.0-4050620250312001",
+    "@dcloudio/vite-plugin-uni": "3.0.0-4060620250520001",
-    "@vue/runtime-core": "3.4.21",
+    "@vue/runtime-core": "^3.4.21",
     "miniprogram-api-typings": "^4.0.5",
     "sass": "1.64.2",
     "vite": "5.2.8"

project.config.json

@@ -1,9 +1,258 @@
 {
-  "appid": "wx0f07fb1df8a28105",
+  "appid": "wxa8f5989dcd45cc23",
   "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"
+      },
+      {
+        "type": "folder",
+        "value": "static/coin"
+      },
+      {
+        "type": "folder",
+        "value": "static/home-device"
+      }
+    ],
     "include": []
   },
   "setting": {
@@ -23,6 +272,7 @@
   "condition": {},
   "editorSetting": {
     "tabIndent": "insertSpaces",
-    "tabSize": 2
+    "tabSize": 2,
+    "printWidth": 120
   }
-}
+}

scripts/check-battle-display.cjs

@@ -0,0 +1,96 @@
+// 回归截图中的小程序循环作用域问题：执行真实 render，再按 WXML 作用域取文本。
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const {baseParse} = require('@vue/compiler-dom');
+const root = path.resolve(__dirname, '..');
+const read = file => fs.readFileSync(path.join(root, file), 'utf8');
+const en = JSON.parse(read('src/locales/en.json'));
+const sourceKeys = JSON.parse(read('src/locales/source-keys.json'));
+const localeCode = read('src/locales/index.js').replace(/^import .*;\r?\n/gm, '').replace(/export /g, '');
+const locale = new Function('createI18n','en','sourceKeys',localeCode+'\nreturn {t,formatBattleTip};')(
+  () => ({global: {t: key => key}}), en, sourceKeys);
+const computed = getter => ({get value() {return getter();}});
+const vendor = {
+  computed, unref: value => value,
+  e: (...parts) => Object.assign({}, ...parts),
+  f: (items, render) => (typeof items === 'number' ? Array.from({length: items}, (_,i) => i+1) : items)
+    .map((item,index) => render(item,index,index)),
+  t: value => value == null ? '' : String(value),
+  _export_sfc: component => component,
+};
+function loadComponent(file, dependencies) {
+  let component;
+  vm.runInNewContext(read(file), {
+    exports: {}, wx: {createComponent: value => {component = value;}},
+    require: id => {
+      for (const [suffix,value] of Object.entries(dependencies)) if (id.endsWith(suffix)) return value;
+      throw Error('Unexpected component dependency: '+id);
+    },
+  }, {filename: file});
+  assert(component, 'No compiled component: '+file);
+  return component;
+}
+const prefix = 'dist/build/mp-weixin/pages/team-battle/components/';
+const footer = loadComponent(prefix+'BattleFooter.js', {
+  'common/vendor.js': vendor,
+  'locales/index.js': locale,
+  'constants.js': {RoundImages: {round1:'round1',round2:'round2',round3:'round3',gold1:'gold1'}},
+});
+const wxml = baseParse(read(prefix+'BattleFooter.wxml'));
+function evaluate(expression, scope) {
+  return new Function('scope', 'with(scope){return ('+expression+');}')(scope);
+}
+function renderedTexts(node,scope) {
+  const attr = name => (node.props || []).find(p => p.name === name)?.value?.content;
+  const forValue = attr('wx:for');
+  if (forValue) {
+    const rows = evaluate(forValue.slice(2,-2),scope);
+    return rows.flatMap((item,index) => renderedTexts({...node,props:node.props.filter(p=>p.name!=='wx:for')},
+      {...scope,[attr('wx:for-item') || 'item']:item,[attr('wx:for-index') || 'index']:index}));
+  }
+  const ifValue = attr('wx:if');
+  if (ifValue && !evaluate(ifValue.slice(2,-2),scope)) return [];
+  if (node.tag === 'text') {
+    return [(node.children || []).map(child => {
+      const value = child.type === 5 ? evaluate(child.content.content,scope) : child.content || '';
+      assert(value === null || typeof value !== 'object', 'WXML rendered a loop object in a text node');
+      return value == null ? '' : String(value);
+    }).join('')];
+  }
+  return (node.children || []).flatMap(child => renderedTexts(child,scope));
+}
+for (const count of [0,1,2,3,4]) {
+  const roundResults = Array.from({length:count},(_,index)=>({
+    ifGold:index===3, goldRound:index===3 ? 1 : 0,
+    shoots:{1:[{ring:index===0 ? 10 : 0}],2:[{ring:8}]},
+  }));
+  const props = {roundResults,bluePoints:0,redPoints:0,goldenRound:count===4 ? 1 : 0};
+  const data = footer.setup(props)(props,{});
+  const texts = renderedTexts(wxml,data);
+  assert.equal(texts.filter(text=>text===en.pts).length, Math.max(3,count)*2);
+  assert(!texts.join('').includes('[object Object]'));
+  if (count) assert(texts.includes('10'), 'Completed round score lost');
+  if (count>1) assert(texts.includes('0'), 'Zero score lost');
+}
+// 顶部只转换显示值，监听器仍接收原始中文提示，语音控制不增加播放调用。
+for (const tip of ['请蓝队射箭','请红队射箭你重回']) {
+  const store = {game:{currentShot:1,totalShot:3,tips:tip}};
+  const header = loadComponent(prefix+'HeaderProgress.js', {
+    'common/vendor.js': {...vendor,
+      ref:value=>({value}), watch:(source,callback)=>callback(source()),
+      onMounted:()=>{},onBeforeUnmount:()=>{},o:handler=>handler,
+    },
+    'locales/index.js':locale,
+    'store.js':{useStore:()=>store},
+    'audioManager.js':{audioManager:{setMuted:()=>{}}},
+  });
+  const data = header.setup({})({},{});
+  assert.equal(data.a,locale.formatBattleTip(tip));
+  assert(!/[\u3400-\u9fff]/.test(data.a));
+  assert.equal(store.game.tips,tip);
+  assert.equal(data.c,'1');
+  assert.equal(data.d,'3');
+}
+console.log('Battle display checks passed: compiled JS + WXML, 0–3 rounds and golden round, blank/zero scores, English tips and original Chinese state preserved.');

scripts/check-localization.cjs

@@ -0,0 +1,220 @@
+// 英文文案与业务边界检查：不调用网络、设备或支付接口。
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const parser = require('@babel/parser');
+const traverse = require('@babel/traverse').default;
+const { parse, compileScript } = require('@vue/compiler-sfc');
+const { baseParse } = require('@vue/compiler-dom');
+const { createI18n } = require('vue-i18n');
+const root = path.resolve(__dirname, '..');
+const read = file => fs.readFileSync(path.join(root, file), 'utf8');
+const en = JSON.parse(read('src/locales/en.json'));
+const zh = JSON.parse(read('src/locales/zh-CN.json'));
+const sourceKeys = JSON.parse(read('src/locales/source-keys.json'));
+const han = /[\p{Script=Han}]/u;
+const manifest=JSON.parse(read('src/manifest.json'));
+assert.equal(manifest['mp-weixin'].permission['scope.userLocation'].desc,en.wifi_location_permission);
+// 微信上传会校验权限用途说明，英文也最多允许 30 个字符。
+for (const [scope, permission] of Object.entries(manifest['mp-weixin'].permission || {})) {
+  assert.equal(typeof permission.desc, 'string', `${scope}: permission description must be a string`);
+  assert(permission.desc.length > 0 && permission.desc.length <= 30,
+    `${scope}: permission description must contain 1–30 characters (got ${permission.desc.length})`);
+}
+const params = value => [...value.matchAll(/\{(p\d+)\}/g)].map(m=>m[1]).sort();
+assert.deepEqual(Object.keys(en).sort(), Object.keys(zh).sort());
+const localeCode = read('src/locales/index.js').replace(/^import .*;\r?\n/gm, '').replace(/export /g, '');
+const api = new Function('createI18n','en','sourceKeys', localeCode+'\nreturn {t,translateStatic,formatBattleTip};')(createI18n,en,sourceKeys);
+// 使用当前 uni-app 实际打包的消息编译器复现问题，避免只测 Node 完整版。
+const miniRuntimePath = path.join(path.dirname(require.resolve('@dcloudio/uni-cli-shared/package.json')),
+  'lib/vue-i18n/dist/vue-i18n.runtime.esm-bundler.js');
+const miniRuntimeCode = fs.readFileSync(miniRuntimePath, 'utf8');
+let miniCompilerCode;
+traverse(parser.parse(miniRuntimeCode, {sourceType: 'module'}), {
+  ObjectProperty(p) {
+    if (p.node.key.name === 'messageCompiler' && p.node.value.type === 'FunctionExpression') {
+      miniCompilerCode = miniRuntimeCode.slice(p.node.value.start, p.node.value.end);
+    }
+  },
+});
+assert(miniCompilerCode, 'Cannot locate uni-app message compiler; review runtime compatibility test');
+const miniCompiler = new Function('return (' + miniCompilerCode + ');')();
+const createMiniI18n = ({locale, messages}) => ({global: {t: (key, args = {}) => {
+  const message = messages[locale][key];
+  return message === undefined ? key : miniCompiler(message)({
+    normalize: values => values.join(''),
+    interpolate: value => String(value),
+    named: name => args[name],
+  });
+}}});
+const miniApi = new Function('createI18n','en','sourceKeys', localeCode+'\nreturn {t,translateStatic,formatBattleTip};')(createMiniI18n,en,sourceKeys);
+const referenceI18n = createI18n({legacy: false, locale: 'en', fallbackLocale: 'en', messages: {en}});
+const parameterized = Object.entries(en).filter(([,value]) => params(value).length);
+for (const [key,value] of parameterized) {
+  for (const example of [0, 7, -2, '', false, 'Bronze', '$& {p1}']) {
+    const args = Object.fromEntries(params(value).map(name => [name, example]));
+    const expected = referenceI18n.global.t(key, args);
+    assert.equal(api.t(key, args), expected, key + ': full runtime interpolation');
+    assert.equal(miniApi.t(key, args), expected, key + ': mini runtime interpolation');
+  }
+}
+assert.equal(miniApi.t('value_value_matches', {p0: 'Bronze', p1: 0}), 'Bronze, 0 matches');
+assert.equal(miniApi.t('value_value_matches', {p0: 'Bronze', p1: 12}), 'Bronze, 12 matches');
+assert.equal(miniApi.t('value_value_matches', {p0: '{p1}', p1: 12}), '{p1}, 12 matches');
+assert.equal(miniApi.t('value_value_matches', {p0: '', p1: 0}), ', 0 matches');
+assert.equal(miniApi.t('value_value_matches', {p0: null, p1: 0}), ', 0 matches');
+assert.equal(miniApi.t('value_value_matches', {p0: 'Bronze'}), 'Bronze, {p1} matches');
+assert.equal(miniApi.t('value_value_matches', Object.create({p0: 'Inherited', p1: 12})), en.value_value_matches);
+assert.equal(miniApi.formatBattleTip('请开始射箭第三轮'), 'Start shooting round 3');
+console.log(`Interpolation compatibility passed: ${parameterized.length} messages, full and uni-app mini compilers, zero/empty/boolean/literal-brace values.`);
+// 构建后检查真实产物模块；只替换平台启动依赖，沿用上方实际小程序编译器。
+if (process.argv.includes('--built')) {
+  const builtExports = {};
+  vm.runInNewContext(read('dist/build/mp-weixin/locales/index.js'), {
+    exports: builtExports,
+    require: id => {
+      assert(/common\/vendor\.js$/.test(id), 'Unexpected built locale dependency: ' + id);
+      return {createI18n: createMiniI18n};
+    },
+  }, {filename: 'dist/build/mp-weixin/locales/index.js'});
+  for (const [key,value] of parameterized) {
+    for (const example of [0, 12, '', false, 'Bronze', '$& {p1}']) {
+      const args = Object.fromEntries(params(value).map(name => [name, example]));
+      assert.equal(builtExports.t(key, args), referenceI18n.global.t(key, args), key + ': built module interpolation');
+    }
+  }
+  console.log(`Built WeChat locale module passed: ${parameterized.length} parameterized messages.`);
+}
+for (const [key,value] of Object.entries(en)) {
+  assert(!han.test(value), 'English contains Chinese: '+key);
+  assert.deepEqual(params(value), params(zh[key]), 'Placeholder mismatch: '+key);
+  const args=Object.fromEntries(params(value).map(name=>[name, name.toUpperCase()]));
+  const output=api.t(key,args);
+  for (const name of params(value)) assert(output.includes(args[name]),'Interpolation failed: '+key);
+}
+for (const [source,key] of Object.entries(sourceKeys)) assert.equal(zh[key],source);
+assert.equal(api.formatBattleTip('请红队射箭你重回'),'Red team, shoot');
+assert.equal(api.formatBattleTip('上半场：请先射6箭'),'First half: shoot 6 arrows first');
+assert.equal(api.formatBattleTip('请开始射箭第三轮'),'Start shooting round 3');
+assert.equal(api.translateStatic('An unknown server value'),'An unknown server value');
+let vueCount=0, references=0;
+const files=[];
+function walk(dir) {
+  for (const item of fs.readdirSync(path.join(root,dir),{withFileTypes:true})) {
+    const file=dir+'/'+item.name;
+    if (item.isDirectory()) {if (!['static','locales'].includes(item.name)) walk(file);}
+    else if (/\.(vue|js)$/.test(file) && !/match\.min\.js/.test(file)) files.push(file);
+  }
+}
+walk('src');
+function checkJs(code,file,expression=false) {
+  let ast;
+  try {ast=parser.parse(expression?'('+code+')':code,{sourceType:'module'});} catch(error) {if (expression) return;throw error;}
+  traverse(ast,{CallExpression(p) {
+    const n=p.node;
+    if (!['t','translate'].includes(n.callee.name) || n.arguments[0]?.type!=='StringLiteral') return;
+    const binding=p.scope.getBinding(n.callee.name);
+    if (!expression) assert(binding && binding.path.node.type==='ImportSpecifier' && /locales/.test(binding.path.parent.source.value),file+': translation function shadowed');
+    const key=n.arguments[0].value;
+    assert(Object.hasOwn(en,key),file+': missing key '+key);references++;
+    const supplied=n.arguments[1]?.properties?.map(prop=>prop.key.name)||[];
+    assert.deepEqual(supplied.sort(),params(en[key]),file+': wrong parameters for '+key);
+  }});
+}
+for (const file of files) {
+  const code=read(file);
+  if (!file.endsWith('.vue')) {checkJs(code,file);continue;}
+  const {descriptor,errors}=parse(code,{filename:file});
+  assert.equal(errors.length,0,file+': SFC parse failed');vueCount++;
+  if (descriptor.script || descriptor.scriptSetup) {
+    compileScript(descriptor,{id:file});
+    for (const b of [descriptor.script,descriptor.scriptSetup]) if (b) checkJs(b.content,file);
+  }
+  if (!descriptor.template) continue;
+  function visit(n) {
+    if (n.type===2) assert(!han.test(n.content),file+': untranslated template text '+n.content);
+    if (n.type===5) checkJs(n.content.content,file,true);
+    for (const prop of n.props||[]) {
+      if (prop.exp) checkJs(prop.exp.content,file,true);
+      if (prop.type===6 && prop.value && !/^(src|class|id|style|key|name|value|tips|end-audio-key|practice-end-audio-key)$/.test(prop.name)) assert(!han.test(prop.value.content),file+': untranslated attribute '+prop.name);
+    }
+    for (const c of n.children||[]) visit(c);
+  }
+  visit(baseParse(descriptor.template.content));
+}
+// 固件与比赛继续使用中文语音键，英文仅用于展示。
+const utilCode=read('src/util.js').replace(/^import .*;\r?\n/gm,'').replace(/export /g,'');
+const uni={getMenuButtonBoundingClientRect:()=>({top:20}),getAccountInfoSync:()=>({miniProgram:{envVersion:'release'}}),showToast:()=>{}};
+const util=new Function('t','translateStatic','uni',utilCode+'\nreturn {getDirectionText,getShootValidation,getDistanceCheckAudioKey,getDistanceCheckText,getInvalidShotAudioKey,getInvalidShotText,isLimitError,canEenter};')(api.t,api.translateStatic,uni);
+for (const [angle,expected] of [[0,'下'],[45,'左下'],[90,'左'],[135,'左上'],[180,'上'],[225,'右上'],[270,'右'],[315,'右下']]) assert.equal(util.getDirectionText(angle),expected);
+for (const shot of [null,{}, {distance:0}, {distance:-1}, {distance:499,targetOk:true}, {distance:500,targetOk:true}, {distance:600,targetOk:false}]) {
+  assert(han.test(util.getInvalidShotAudioKey(shot)));
+  assert(han.test(util.getDistanceCheckAudioKey(shot)));
+  assert(!han.test(util.getInvalidShotText(shot)));
+  assert(!han.test(util.getDistanceCheckText(shot)));
+}
+assert.equal(util.getShootValidation({distance:499,targetOk:true}).distanceOk,false);
+assert.equal(util.getShootValidation({distance:500,targetOk:true}).distanceOk,true);
+assert(util.isLimitError({message:'今日次数已达上限'}));
+assert(!util.isLimitError({message:'other error'}));
+assert.equal(util.canEenter({}, {}, true),false);
+assert.equal(util.canEenter({trio:1},{deviceId:'test'},true),true);
+assert.equal(util.canEenter({trio:1},{deviceId:'test'},false),false);
+assert.equal(util.canEenter({trio:0},{deviceId:'test'},true),false);
+// 对照 Git 基线检查协议资源未改动，只检查当前变更涉及的源码文件。
+const urls=code=>[...code.matchAll(/https?:\/\/[^\s"'`<>]+/g)].map(m=>m[0]).sort();
+function scriptShapes(code,file) {
+  const blocks=file.endsWith('.vue') ? ((d)=>[d.script,d.scriptSetup].filter(Boolean).map(b=>b.content))(parse(code).descriptor) : [code];
+  return blocks.map(block=>{
+    const ast=parser.parse(block,{sourceType:'module'});
+    function clean(value) {
+      if (Array.isArray(value)) return value.map(clean).filter(v=>v!==undefined);
+      if (!value || typeof value!=='object') return value;
+      if (value.type==='ImportDeclaration' && /locales/.test(value.source.value)) return undefined;
+      if (file==='src/pages/training/index.vue' && value.type==='ObjectProperty' && value.key.name==='staticLabel') return undefined;
+      if (file==='src/canvas.js' && value.type==='CallExpression' && value.callee.name==='renderText') {
+        const key=value.arguments[1]?.arguments?.[0]?.value;
+        if (key==='today_s_check_in') { assert.equal(value.arguments[2].value,9); value.arguments[2].value=14; }
+        if (key==='total') { assert.equal(value.arguments[4].value,102); value.arguments[4].value=122; }
+      }
+      if (value.type==='ExpressionStatement' && value.expression.callee?.property?.name==='use' && value.expression.arguments?.[0]?.name==='i18n') return undefined;
+      if (value.type==='CallExpression') {
+        if (value.callee.name==='translateStatic') return clean(value.arguments[0]);
+        if (['t','translate'].includes(value.callee.name) && value.arguments[0]?.type==='StringLiteral') {
+          const source=zh[value.arguments[0].value];
+          assert.notEqual(source,undefined,file+': unknown source');
+          const matches=[...source.matchAll(/\{(p\d+)\}/g)];
+          if (!matches.length) return {type:'StringLiteral',value:source};
+          const argumentsMap=Object.fromEntries((value.arguments[1]?.properties||[]).map(p=>[p.key.name,p.value]));
+          let cursor=0;
+          const quasis=matches.map(m=>{const text=source.slice(cursor,m.index);cursor=m.index+m[0].length;return {type:'TemplateElement',value:{cooked:text},tail:false};});
+          quasis.push({type:'TemplateElement',value:{cooked:source.slice(cursor)},tail:true});
+          return clean({type:'TemplateLiteral',quasis,expressions:matches.map(m=>argumentsMap[m[1]])});
+        }
+      }
+      if (value.type==='TemplateLiteral' && !value.expressions.length) return {type:'StringLiteral',value:value.quasis[0].value.cooked};
+      const result={};
+      for (const [key,item] of Object.entries(value)) {
+        if (['start','end','loc','extra','leadingComments','innerComments','trailingComments','comments','tokens','errors','raw'].includes(key)) continue;
+        const next=clean(item);
+        if (next!==undefined) result[key]=next;
+      }
+      // 唯一调整的脚本标点位于测距展示文本，不参与判断。
+      if (result.type==='TemplateElement' && result.value.cooked==='，') result.value.cooked='; ';
+      return result;
+    }
+    return clean(ast.program);
+  });
+}
+const baselinePath=process.argv.slice(2).find(arg => arg !== '--built');
+if (baselinePath) {
+  const baseline=JSON.parse(fs.readFileSync(baselinePath,'utf8').replace(/^\uFEFF/,''));
+  for (const [file,original] of Object.entries(baseline)) {
+    assert.deepEqual(urls(read(file)),urls(original),file+': URL changed');
+    assert.deepEqual(scriptShapes(read(file),file),scriptShapes(original,file),file+': non-localization script change');
+    if (file==='src/audioManager.js') assert.equal(read(file).replace(/\r\n/g,'\n'),original.replace(/\r\n/g,'\n'),'Audio resources or keys changed');
+  }
+  console.log('Git baseline media URLs and audio resources verified.');
+}
+console.log(`Localization checks passed: ${Object.keys(en).length} entries, ${references} references, ${vueCount} Vue files; placeholders, static templates, audio keys, shooting validation and entry conditions verified.`);

scripts/check-rank-i18n.cjs

@@ -0,0 +1,136 @@
+// 段位多语言集成回归：请求使用本地桩，缓存通过真实 Pinia 持久化插件恢复。
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { createPinia, defineStore } = require('pinia');
+const { createSSRApp } = require('vue');
+const persist = require('pinia-plugin-persistedstate').default;
+const root = path.resolve(__dirname, '..');
+const read = file => fs.readFileSync(path.join(root, file), 'utf8');
+const requests = [];
+let hasToken = true;
+let nextFailure;
+const rank = {rankLvl: 1, rankName: 'Bronze I', rankIcon: 'https://example.test/青铜1.png'};
+const apiUni = {
+  getAccountInfoSync: () => ({miniProgram: {envVersion: 'trial'}}),
+  getStorageSync: key => hasToken && key === 'trial_token' ? 'existing-token' : '',
+  request(options) {
+    requests.push(options);
+    if (options.url.endsWith('/user/device/aimRenew')) return {};
+    if (nextFailure) {
+      const error = nextFailure;
+      nextFailure = undefined;
+      options.success({statusCode: 200, data: error});
+      return;
+    }
+    const data = options.url.includes('/myHome')
+      ? {...rank, user: {id: 42, scores: 150, rankLvl: 1, nickName: '原昵称'}}
+      : {list: [{...rank}], randInfos: [{rank_id: 1, upgrade_scores: 100, name: 'Bronze I', icoin: rank.rankIcon}]};
+    options.success({statusCode: 200, data: {code: 0, data}});
+  },
+};
+const apiCode = read('src/apis.js').replace(/^import .*;\r?\n/gm, '').replace(/^export /gm, '');
+const api = new Function('uni', 't', 'normalizeBattleApiResult', apiCode + `
+return {request, getAppConfig, getHomeData, getScoreRankList, getTenRingRankList, getMvpRankList,
+getMyScoreRank, getMyTenRingRank, getMyMvpRank, getSeasonStats, getProvinceData, getDailyCountAPI, aimRenewAPI};
+`)(apiUni, key => key, data => data);
+
+const storeCode = read('src/store.js').replace(/^import .*;\r?\n/gm, '').replace('export default defineStore', 'return defineStore');
+function restore(cached) {
+  const storage = new Map([
+    ['store', JSON.stringify(cached)],
+    ['trial_token', 'existing-token'],
+    ['point-book', JSON.stringify({draft: true})],
+  ]);
+  const uni = {getStorageSync: key => storage.get(key), setStorageSync: (key, value) => storage.set(key, value)};
+  const useStore = new Function('defineStore', 'uni', storeCode)(defineStore, uni);
+  const pinia = createPinia();
+  pinia.use(persist);
+  createSSRApp({}).use(pinia);
+  return {store: useStore(pinia), storage};
+}
+
+async function main() {
+  const config = await api.getAppConfig();
+  const home = await api.getHomeData(42);
+  await api.getScoreRankList(42, 2, 20);
+  await api.getTenRingRankList(42, 2, 20);
+  await api.getMvpRankList(42, 2, 20);
+  await api.getMyScoreRank(42);
+  await api.getMyTenRingRank(42);
+  await api.getMyMvpRank(42);
+  await api.getSeasonStats(0);
+  await api.request('GET', '/index/myHome?seasonId=42');
+  for (const request of requests) {
+    assert.equal(request.header['Accept-Language'], 'en-US');
+    assert.equal(request.header.Authorization, 'Bearer existing-token');
+    assert.equal(request.method, 'GET');
+    assert(request.url.startsWith('https://apitest.shelingxingqiu.com/api/shoot/'));
+  }
+  assert(requests[1].url.endsWith('/user/myHome?seasonId=42'), 'Existing home route must remain unchanged');
+  assert.deepEqual(requests[2].data, {seasonId: 42, page: 2, perPage: 20});
+  assert.deepEqual(requests[8].data, {seasonId: 0});
+  assert.equal(home.user.rankName, rank.rankName);
+  assert.equal(home.user.rankIcon, rank.rankIcon);
+  assert.equal(home.user.nickName, '原昵称');
+  await api.getProvinceData();
+  await api.getDailyCountAPI();
+  await api.request('GET', '/index/appConfig/other');
+  await api.request('POST', '/index/appConfig');
+  await api.request('PUT', '/test/update', {value: 0});
+  await api.request('DELETE', '/test/delete', {id: 42});
+  for (const request of requests.slice(10)) {
+    assert.equal(request.header['Accept-Language'], 'en-US', 'All HTTP requests must declare English');
+    assert.equal(request.header.Authorization, 'Bearer existing-token');
+  }
+  assert.deepEqual(requests.at(-2).data, {value: 0});
+  assert.deepEqual(requests.at(-1).data, {id: 42});
+  // 续期请求即使未收到响应，也必须保持同步返回且不弹失败提示。
+  assert.equal(api.aimRenewAPI(), undefined);
+  assert.equal(requests.at(-1).header['Accept-Language'], 'en-US');
+  assert.equal(requests.at(-1).header.Authorization, 'Bearer existing-token');
+  assert.equal(requests.at(-1).method, 'POST');
+  assert.deepEqual(requests.at(-1).data, {});
+  assert.equal(requests.at(-1).timeout, 10000);
+  assert.equal(requests.at(-1).fail({errMsg: 'timeout'}), undefined);
+  hasToken = false;
+  await api.getAppConfig();
+  assert.deepEqual(requests.at(-1).header, {'Accept-Language': 'en-US'});
+  assert.equal(api.aimRenewAPI(), undefined);
+  assert.deepEqual(requests.at(-1).header, {'Accept-Language': 'en-US'});
+  hasToken = true;
+  nextFailure = {code: 400, message: '设备未连接', data: {reason: 'offline'}};
+  await assert.rejects(api.request('POST', '/test/error', {}, undefined, undefined, {showErrorToast: false}),
+    error => error.code === 400 && error.message === '设备未连接' && error.data.reason === 'offline');
+  assert.equal(requests.at(-1).header['Accept-Language'], 'en-US');
+
+  const legacy = {
+    user: {id: 42, nickName: '原昵称', avatar: 'avatar.png', trio: 1, scores: 150, rankLvl: 1,
+      lvlName: '倔强青铜I', rankName: '倔强青铜I', nextRankName: '倔强青铜II',
+      rankIcon: rank.rankIcon, nextRankIcon: 'next.png', lvlImage: 'level.png', vip: true},
+    device: {deviceId: 'unchanged-device', deviceName: '我的弓'},
+  };
+  const {store, storage} = restore(legacy);
+  for (const [field, value] of Object.entries(legacy.user)) {
+    assert.deepEqual(store.user[field], ['lvlName','rankName','nextRankName'].includes(field) ? '' : value);
+  }
+  assert.deepEqual({...store.device}, legacy.device);
+  assert.equal(storage.get('trial_token'), 'existing-token');
+  assert.equal(storage.get('point-book'), JSON.stringify({draft: true}));
+  assert.deepEqual([...storage.keys()].sort(), ['store', 'trial_token', 'point-book'].sort());
+  await store.updateConfig(config);
+  await store.updateUser(home.user);
+  assert.equal(store.user.rankName, 'Bronze I');
+  assert.equal(store.user.lvlName, 'Bronze I');
+  assert.equal(store.user.scores, 150);
+  assert.equal(store.user.rankLvl, 1);
+  store.$persist();
+  const next = restore(JSON.parse(storage.get('store'))).store;
+  assert.equal(next.user.rankName, 'Bronze I', 'English cached labels must survive cold start');
+  assert.equal(next.user.lvlName, 'Bronze I');
+  assert.equal(next.user.nickName, '原昵称');
+  assert.deepEqual({...next.device}, legacy.device);
+  assert.equal(restore({user: {id: 7, rankName: '', lvlName: null}, device: {}}).store.user.lvlName, null);
+  console.log('Rank i18n checks passed: global HTTP English headers (GET/POST/PUT/DELETE + aim renewal), auth/query/pagination and original errors preserved; non-blocking renewal and real Pinia cache hydration verified.');
+}
+main().catch(error => {console.error(error); process.exitCode = 1;});

scripts/generate-match-schema.mjs

@@ -0,0 +1,436 @@
+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";
+
+    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;
+}

scripts/localization-inventory.cjs

@@ -0,0 +1,63 @@
+// 只读提取源码中的中文候选；不扫描图片、生成物或第三方依赖。
+const fs = require('node:fs');
+const path = require('node:path');
+const parser = require('@babel/parser');
+const traverse = require('@babel/traverse').default;
+const sfc = require('@vue/compiler-sfc');
+const dom = require('@vue/compiler-dom');
+const han = /[\p{Script=Han}]/u;
+const root = path.resolve(__dirname, '../src');
+const entries = [];
+function scripts(code, file, offset = 0, context = 'script') {
+  if (context === 'expression') { code = '(' + code + ')'; offset -= 1; }
+  const ast = parser.parse(code, {sourceType: 'module', plugins: ['typescript'], errorRecovery: true});
+  traverse(ast, {
+    StringLiteral(p) { add(p, p.node.value, 'string'); },
+    TemplateLiteral(p) {
+      if (!p.node.quasis.some(q => han.test(q.value.cooked || q.value.raw))) return;
+      const text = p.node.quasis.map((q, i) => (q.value.cooked ?? q.value.raw) + (i < p.node.expressions.length ? `{p${i}}` : '')).join('');
+      add(p, text, 'template');
+    },
+  });
+  function add(p, text, kind) {
+    if (!han.test(text) || /^https?:/.test(text)) return;
+    const ancestors = [];
+    let q = p;
+    for (let i = 0; q && i < 5; i++, q = q.parentPath) {
+      const n = q.node;
+      ancestors.push(n.type + (n.key?.name ? ':' + n.key.name : '') + (n.type === 'CallExpression' ? ':' + code.slice(n.callee.start, n.callee.end) : ''));
+    }
+    entries.push({file, start: offset + p.node.start, end: offset + p.node.end, kind, text, context, ancestors: ancestors.join(' > '), snippet: code.slice(Math.max(0, p.node.start - 65), Math.min(code.length, p.node.end + 65))});
+  }
+}
+function inspect(file) {
+  const code = fs.readFileSync(path.join(root, file), 'utf8');
+  if (file.endsWith('.js')) return scripts(code, file);
+  const {descriptor} = sfc.parse(code);
+  for (const block of [descriptor.script, descriptor.scriptSetup]) if (block) scripts(block.content, file, block.loc.start.offset);
+  const block = descriptor.template;
+  if (!block) return;
+  const ast = dom.baseParse(block.content);
+  function walk(n) {
+    if (n.type === 2 && han.test(n.content)) entries.push({file, start: block.loc.start.offset + n.loc.start.offset, end: block.loc.start.offset + n.loc.end.offset, kind:'text', text:n.content, context:'template'});
+    if (n.type === 5 && han.test(n.content.content)) scripts(n.content.content, file, block.loc.start.offset + n.content.loc.start.offset, 'expression');
+    for (const prop of n.props || []) {
+      if (prop.type === 6 && prop.value && han.test(prop.value.content) && !/^(src|class|id|style|key|name|value)$/.test(prop.name)) entries.push({file, start:block.loc.start.offset + prop.loc.start.offset, end:block.loc.start.offset + prop.loc.end.offset, kind:'attribute', text:prop.value.content, attribute:prop.name, context:'template'});
+      if (prop.type === 7 && prop.exp && han.test(prop.exp.content)) {
+        try { scripts(prop.exp.content, file, block.loc.start.offset + prop.exp.loc.start.offset, 'expression'); } catch (e) { /* v-for 等非独立表达式保留人工检查 */ }
+      }
+    }
+    for (const child of n.children || []) walk(child);
+  }
+  walk(ast);
+}
+function walk(dir) {
+  for (const item of fs.readdirSync(path.join(root, dir), {withFileTypes:true})) {
+    const file = path.posix.join(dir, item.name);
+    if (item.isDirectory()) { if (item.name !== 'static' && item.name !== 'locales') walk(file); }
+    else if (/\.(vue|js)$/.test(file) && !/match\.min\.js|audioManager\.js/.test(file)) inspect(file);
+  }
+}
+walk('');
+if (require.main === module) process.stdout.write(JSON.stringify(entries, null, 2));
+module.exports = entries;

src/App.vue

@@ -1,7 +1,449 @@
 <script setup>
-import { onLaunch } from '@dcloudio/uni-app'
+import { t } from "@/locales";
 
-onLaunch(() => {})
+	import {
+		watch
+	} from "vue";
+	import {
+		onShow,
+		onHide
+	} from "@dcloudio/uni-app";
+	import websocket from "@/websocket";
+	import matchWebsocket from "@/matchWebsocket";
+	import {
+		MESSAGETYPES
+	} from "@/constants";
+	import useStore from "@/store";
+	import {
+		storeToRefs
+	} from "pinia";
+	import audioManager from "./audioManager";
+	const store = useStore();
+	const {
+		user,
+		device,
+		online
+	} = storeToRefs(store);
+	const {
+		updateUser,
+		updateDeviceStatus,
+		setDeviceOnline,
+		clearDeviceStatus,
+		showDeviceChargingDialog,
+		clearSessionState,
+		clearDevice
+	} = store;
+
+	watch(
+		() => user.value.id,
+		(newVal) => {
+			const token = uni.getStorageSync(
+				`${uni.getAccountInfoSync().miniProgram.envVersion}_token`
+			);
+			if (newVal && token) {
+				websocket.createWebSocket(token, onShootWsMsg);
+			}
+			if (!newVal) {
+				matchWebsocket.closeMatchWebSocket({
+					reason: "logout"
+				});
+				websocket.closeWebSocket();
+			}
+		}, {
+			deep: false, // 如果 user 是一个对象或数组，建议开启
+			immediate: false, // 若想在初始化时立即执行一次回调，可开启。
+		}
+	);
+
+	function emitUpdateUser(value) {
+		updateUser(value);
+	}
+
+	function onSessionKickedOut() {
+		const env = uni.getAccountInfoSync().miniProgram.envVersion;
+		uni.removeStorageSync(`${env}_token`);
+		clearSessionState();
+		uni.showModal({
+			title: t('notice'),
+			content: t('your_account_has_been_signed_in_on_another_device'),
+			showCancel: false,
+		});
+	}
+
+	function emitUpdateOnline(nextOnline) {
+		const wasOnline = Boolean(online.value);
+		setDeviceOnline(nextOnline === true);
+		if (!device.value.deviceId || wasOnline === (nextOnline === true)) return;
+		audioManager.play(nextOnline === true ? "设备已连接" : "设备连接已断开");
+	}
+
+	function onDeviceStatusPush(status) {
+		updateDeviceStatus(status);
+	}
+
+	function onShootSocketDisconnected() {
+		clearDeviceStatus();
+	}
+
+	function onDeviceBindInvalid() {
+		clearDevice();
+		uni.setStorageSync("calibration", false);
+	}
+
+	function onDeviceCharging() {
+		showDeviceChargingDialog();
+	}
+
+	function onDeviceShoot() {
+		// audioManager.play("射箭声音")
+	}
+
+	function onNetworkStatusChange(status) {
+		matchWebsocket.handleMatchNetworkStatusChange(status);
+	}
+
+	function connectMatchServerFromMessage(content) {
+		const messages = Array.isArray(content) ? content : [content];
+		messages.forEach((message) => {
+			if (
+				message?.constructor ===
+				MESSAGETYPES.ShootSyncBattleCreateMatchLinkID
+			) {
+				matchWebsocket.connectMatchWebSocketFromNotice(
+					message,
+					user.value.id
+				);
+			}
+		});
+	}
+
+	function onShootWsMsg(content) {
+		if (content?.event === "/addons/shoot/battery") {
+			onDeviceStatusPush(content.data);
+			return;
+		}
+		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("shoot-socket-disconnected", onShootSocketDisconnected);
+		uni.$on("session-kicked-out", onSessionKickedOut);
+		uni.$on("device-bind-invalid", onDeviceBindInvalid);
+		uni.$on("device-charging", onDeviceCharging);
+		if (typeof uni.offNetworkStatusChange === "function") {
+			uni.offNetworkStatusChange(onNetworkStatusChange);
+		}
+		if (typeof uni.onNetworkStatusChange === "function") {
+			uni.onNetworkStatusChange(onNetworkStatusChange);
+		}
+		if (typeof uni.getNetworkType === "function") {
+			uni.getNetworkType({
+				success: onNetworkStatusChange
+			});
+		}
+		const token = uni.getStorageSync(
+			`${uni.getAccountInfoSync().miniProgram.envVersion}_token`
+		);
+		if (user.value.id && token) {
+			console.log("回到前台，重新连接 websocket");
+			websocket.createWebSocket(token, onShootWsMsg);
+		}
+	});
+
+	onHide(() => {
+		uni.$off("update-user", emitUpdateUser);
+		uni.$off("update-online", emitUpdateOnline);
+		uni.$off("shoot-socket-disconnected", onShootSocketDisconnected);
+		uni.$off("session-kicked-out", onSessionKickedOut);
+		uni.$off("device-bind-invalid", onDeviceBindInvalid);
+		uni.$off("device-charging", onDeviceCharging);
+		if (typeof uni.offNetworkStatusChange === "function") {
+			uni.offNetworkStatusChange(onNetworkStatusChange);
+		}
+		matchWebsocket.closeMatchWebSocket({
+			reason: "app-hide"
+		});
+		clearDeviceStatus();
+		websocket.closeWebSocket();
+	});
 </script>
 
-<style></style>
+<style>
+	page {
+		-webkit-touch-callout: none;
+		-webkit-user-select: none;
+		user-select: none;
+		background-color: #000;
+	}
+
+	button {
+		margin: 0;
+		padding: 0;
+		border: none;
+		background: none;
+		line-height: 1;
+		outline: none;
+		box-sizing: border-box;
+	}
+
+	view::-webkit-scrollbar {
+		width: 0;
+		height: 0;
+		color: transparent;
+	}
+
+	button::after {
+		border: none;
+	}
+
+	.guide-tips {
+		display: flex;
+		flex-direction: column;
+		font-size: 28rpx;
+	}
+
+	.guide-tips>text:first-child {
+		color: #fed847;
+	}
+
+	.guide-tips>text:nth-child(2) {
+		font-size: 24rpx;
+	}
+
+	@keyframes fadeInOut {
+		0% {
+			transform: translateY(20px);
+			opacity: 0;
+		}
+
+		30% {
+			transform: translateY(0);
+			opacity: 1;
+		}
+
+		80% {
+			opacity: 1;
+		}
+
+		100% {
+			opacity: 0;
+		}
+	}
+
+	.fade-in-out {
+		animation: fadeInOut 1.2s ease forwards;
+	}
+
+	@keyframes fadeOut {
+		from {
+			transform: translateY(0);
+			opacity: 1;
+		}
+
+		to {
+			transform: translateY(20px);
+			opacity: 0;
+		}
+	}
+
+	.fade-out {
+		animation: fadeOut 0.3s ease forwards;
+	}
+
+	@keyframes scaleIn {
+		from {
+			transform: scale(0);
+			opacity: 0;
+		}
+
+		to {
+			transform: scale(1);
+			opacity: 1;
+		}
+	}
+
+	.scale-in {
+		animation: scaleIn 0.3s ease-out forwards;
+		transform-origin: center center;
+	}
+
+	@keyframes scaleOut {
+		from {
+			transform: scale(1);
+			opacity: 1;
+		}
+
+		to {
+			transform: scale(0);
+			opacity: 0;
+		}
+	}
+
+	.scale-out {
+		animation: scaleOut 0.3s ease-out forwards;
+		transform-origin: center center;
+	}
+
+	@keyframes rotate {
+		from {
+			transform: rotate(0deg);
+		}
+
+		to {
+			transform: rotate(360deg);
+		}
+	}
+
+	@keyframes pumpIn {
+		from {
+			transform: scale(2);
+		}
+
+		to {
+			transform: scale(1);
+		}
+	}
+
+	.pump-in {
+		animation: pumpIn 0.3s ease-out forwards;
+		transform-origin: center center;
+	}
+
+	.share-canvas {
+		width: 300px;
+		height: 530px;
+		position: absolute;
+		top: -1000px;
+		left: 0;
+	}
+
+	.truncate {
+		white-space: nowrap;
+		overflow: hidden;
+		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;
+		flex-direction: column;
+		align-items: center;
+		justify-content: center;
+	}
+
+	.user-row {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		padding: 0 15px;
+		padding-top: 7px;
+		position: relative;
+	}
+
+	.half-time-tip {
+		width: 100%;
+		display: flex;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+	}
+
+	.half-time-tip>text:last-child {
+		margin-top: 20px;
+		color: #fff9;
+	}
+
+	.see-more {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		margin-top: 20rpx;
+	}
+
+	.see-more>text {
+		color: #39a8ff;
+		font-size: 13px;
+	}
+
+	.see-more>image {
+		width: 15px;
+	}
+
+	@font-face {
+		font-family: "DINCondensed";
+		src: url("https://static.shelingxingqiu.com/font/DIN-Condensed-Bold-2.ttf") format("truetype");
+		font-weight: 700;
+		font-style: normal;
+		font-display: swap;
+	}
+</style>

src/apis.js

@@ -0,0 +1,816 @@
+import { t } from "@/locales";
+import { normalizeBattleApiResult } from "@/utils/matchAdapter";
+
+let BASE_URL = "https://api.shelingxingqiu.com/api/shoot"; // 默认正式版
+
+try {
+    const accountInfo = uni.getAccountInfoSync();
+    const envVersion = accountInfo.miniProgram.envVersion;
+
+    switch (envVersion) {
+        case "develop": // 开发版
+            // BASE_URL = "http://192.168.1.30:8000/api/shoot";
+            BASE_URL = "https://apitest.shelingxingqiu.com/api/shoot";
+            break;
+        case "trial": // 体验版
+            BASE_URL = "https://apitest.shelingxingqiu.com/api/shoot";
+            break;
+        case "release": // 正式版
+            BASE_URL = "https://api.shelingxingqiu.com/api/shoot";
+            break;
+        default:
+            // 保持默认值
+            break;
+    }
+} catch (e) {
+    console.error("获取环境信息失败，使用默认正式环境", e);
+}
+
+const ADDONS_BASE_URL = BASE_URL.replace(/\/api\/shoot$/, "/api/shoot");
+const API_ROOT_URL = BASE_URL.replace(/\/api\/shoot$/, "");
+// 统一处理业务接口请求，包含登录态、业务错误和特定接口空响应兼容。
+function request(method, url, data = {}, baseUrl = BASE_URL, successCodes = [0], options = {}) {
+    const {timeout = 10000, showErrorToast = true} = options;
+    const token = uni.getStorageSync(
+        `${uni.getAccountInfoSync().miniProgram.envVersion}_token`
+    );
+    // 英文版全部后端 HTTP 请求统一声明语言，保留原有认证与响应处理。
+    const header = {"Accept-Language": "en-US"};
+    if (token) header.Authorization = `Bearer ${token || ""}`;
+    return new Promise((resolve, reject) => {
+        uni.request({
+            url: `${baseUrl}${url}`,
+            method,
+            header,
+            data,
+            timeout,
+            success: (res) => {
+                if (
+                    url === "/user/hardwareBox/connectWifi" &&
+                    res.statusCode === 200 &&
+                    typeof res.data?.success === "boolean"
+                ) {
+                    resolve(res.data);
+                    return;
+                }
+                const acceptsEmptyResponse = [
+                    "/user/hardwareBox/connectWifi",
+                    "/user/device/unbindByQrcodeId",
+                ].includes(url);
+                if (acceptsEmptyResponse && res.statusCode === 200 && res.data && Object.keys(res.data).length === 0) {
+                    resolve({});
+                    return;
+                }
+                if (res.data) {
+                    const {code, data, message} = res.data;
+                    if (successCodes.includes(code)) 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});
+                            return;
+                        }
+                        if (message === "ERROR_ROOM_GAME_START") {
+                            resolve({started: true});
+                            return;
+                        }
+                        if (url.indexOf("/user/room") !== -1 && method === "GET") {
+                            resolve({});
+                            return;
+                        }
+                        if (message === "ERROR_BATTLE_GAMING") {
+                            resolve({});
+                            return;
+                        }
+                        if (message === "BIND_DEVICE") {
+                            resolve({binded: true});
+                            return;
+                        }
+                        if (message === "BIND_FAILD") {
+                            uni.$emit("device-bind-invalid");
+                            uni.showToast({
+                                title: t('your_device_binding_has_expired_please_bind_it_again'),
+                                icon: "none",
+                            });
+                            reject({type: "DEVICE_BIND_INVALID", message});
+                            return;
+                        }
+                        if (message === "ERROR_ORDER_UNPAY") {
+                            uni.showToast({
+                                title: t('you_have_an_unpaid_order'),
+                                icon: "none",
+                            });
+                            resolve({});
+                            return;
+                        }
+                        if (message === "ROOM_EMPTY") {
+                            return uni.showToast({
+                                title: t('this_room_has_expired'),
+                                icon: "none",
+                            });
+                        }
+                        if (showErrorToast) {
+                            uni.showToast({
+                                title: message,
+                                icon: "none",
+                            });
+                        }
+                        reject(error);
+                        return;
+                    }
+                    reject({code, data, message});
+                }
+            },
+            fail: (err) => {
+                if (showErrorToast) handleRequestError(err, url);
+                reject(err);
+            },
+        });
+    });
+}
+
+// 统一的错误处理函数
+function handleRequestError(err, url) {
+    console.log("请求失败:", {err, url});
+
+    // 根据错误类型显示不同提示
+    if (err.errMsg) {
+        if (err.errMsg.includes("timeout")) {
+            showCustomToast(t('request_timed_out_please_try_again'), "timeout");
+        } else if (err.errMsg.includes("fail")) {
+            // 检查网络状态
+            uni.getNetworkType({
+                success: (res) => {
+                    if (res.networkType === "none") {
+                        showCustomToast(t('network_disconnected_check_your_network_settings'), "network");
+                    } else {
+                        showCustomToast(t('cannot_connect_to_the_server_please_try_again'), "server");
+                    }
+                },
+                fail: () => {
+                    showCustomToast(t('network_error_check_your_connection'), "unknown");
+                },
+            });
+        } else {
+            showCustomToast(t('request_failed_please_try_again'), "general");
+        }
+    } else {
+        showCustomToast(t('network_error_please_try_again'), "unknown");
+    }
+}
+
+// 自定义提示函数
+function showCustomToast(message, type) {
+    const config = {
+        title: message,
+        icon: "none",
+        duration: 3000,
+    };
+
+    // 根据错误类型可以添加不同的处理逻辑
+    switch (type) {
+        case "timeout":
+            config.duration = 4000; // 超时提示显示更久
+            break;
+        case "network":
+            config.duration = 5000; // 网络问题提示显示更久
+            break;
+        default:
+            break;
+    }
+
+    uni.showToast(config);
+}
+
+// 获取全局配置
+export const getAppConfig = () => {
+    return request("GET", "/index/appConfig");
+};
+
+export const getDailyCountAPI = () => {
+    return request("GET", "/index/dailyCount", {}, ADDONS_BASE_URL);
+};
+
+export const getHomeData = async (seasonId) => {
+    const data = await request("GET", `/user/myHome?seasonId=${seasonId}`);
+    if (!data?.user) return data;
+
+    // 段位信息由 myHome 接口直接返回，统一并入用户数据供各页面展示。
+    return {
+        ...data,
+        user: {
+            ...data.user,
+            rankIcon: data.rankIcon,
+            rankName: data.rankName,
+        },
+    };
+};
+
+export const getProvinceData = () => {
+    return request("GET", "/index/provinces/list");
+};
+
+export const loginAPI = async (phone, nickName, avatarData, code) => {
+    const result = await request("POST", "/index/code", {
+        appName: "shoot",
+        appId: "wxa8f5989dcd45cc23",
+        nickName,
+        avatarData,
+        code,
+        phone,
+    });
+    uni.setStorageSync(
+        `${uni.getAccountInfoSync().miniProgram.envVersion}_token`,
+        result.token
+    );
+    return result;
+};
+
+export const silentLoginAPI = async (code) => {
+    const result = await request("POST", "/index/code", {
+        appName: "shoot",
+        appId: "wxa8f5989dcd45cc23",
+        code,
+    });
+    uni.setStorageSync(
+        `${uni.getAccountInfoSync().miniProgram.envVersion}_token`,
+        result.token
+    );
+    return result;
+};
+
+export const checkUserBindAPI = async (code) => {
+    return request("POST", "/index/checkBind", {
+        appName: "shoot",
+        appId: "wxa8f5989dcd45cc23",
+        code,
+    });
+};
+
+export const tempBindOrgAPI = (scene) => {
+    return request("POST", "/user/org/device/tempBind", {
+        scene,
+    });
+};
+
+export const bindDeviceAPI = (device) => {
+    return request("POST", "/user/device/bindDevice", {
+        device,
+    });
+};
+
+export const bindDeviceAPIV2 = (token) => {
+    return request("POST", "/user/device/bindDevice/v2", {
+        token: token,
+    });
+};
+
+export const unbindDeviceAPI = (deviceId) => {
+    return request("POST", "/user/device/unbindDevice", {
+        deviceId,
+    });
+};
+
+// 测试环境根据设备二维码编号解绑设备，不校验设备归属。
+export const unbindDeviceByQrcodeIdAPI = (id) => {
+    return request("POST", "/user/device/unbindByQrcodeId", {id});
+};
+
+export const getMyDevicesAPI = () => {
+    // "/user/device/getBinding?deviceId=9ZF9oVXs"
+    return request("GET", "/user/device/getBindings");
+};
+
+export const getDeviceDetailAPI = (deviceId) => {
+    return request("GET", `/user/device/getDetail?deviceId=${encodeURIComponent(deviceId)}`);
+};
+
+export const updateDeviceAliasAPI = (deviceId, alias) => {
+    return request("POST", "/user/device/updateAlias", {deviceId, alias});
+};
+
+export const createPractiseAPI = (arrows, time, target) => {
+    return request("POST", "/user/practice/create", {
+        shootNumber: arrows,
+        shootTime: time,
+        targetType: target * 20,
+    });
+};
+
+export const createPractiseV2API = (trainingType, difficultyLevel) => {
+    return request("POST", "/user/practice/create/v2", {
+        trainingType,
+        difficultyLevel,
+    });
+};
+
+export const getCurrentPractiseAPI = () => {
+    return request("GET", "/user/practice/current");
+};
+
+export const startPractiseAPI = (id) => {
+    return request("POST", "/user/practice/begin", { id });
+};
+
+export const endPractiseAPI = (id) => {
+    return request("POST", "/user/practice/stop", { id });
+};
+
+export const getPractiseAPI = async (id) => {
+    return request("GET", `/user/practice/get?id=${id}`);
+};
+
+export const getPractiseDetailAPI = async (id) => {
+    return request(
+        "GET",
+        `/user/practice/detail?id=${encodeURIComponent(id)}`
+    );
+};
+
+export const createRoomAPI = (gameType, teamSize, targetType) => {
+    return request("POST", "/user/createroom", {
+        gameType,
+        teamSize,
+        targetType,
+    });
+};
+
+export const getRoomAPI = (number) => {
+    return request("GET", `/user/room?number=${number}`);
+};
+
+export const joinRoomAPI = (number) => {
+    return request("POST", `/user/room/join`, {number});
+};
+
+export const destroyRoomAPI = (roomNumber) => {
+    return request("POST", "/user/room/destroyRoom", {
+        roomNumber,
+    });
+};
+
+export const exitRoomAPI = (number, userId) => {
+    return request("POST", "/user/room/exitRoom", {
+        number,
+        userId,
+    });
+};
+
+export const startRoomAPI = (number) => {
+    return request("POST", "/user/room/start", {number});
+};
+
+export const getPractiseResultListAPI = async (page = 1, pageSize = 15) => {
+    const result = await request(
+        "GET",
+        `/user/practice/mylist?page=${page}&pageSize=${pageSize}&status=0`
+    );
+    return Array.isArray(result?.list) ? result.list : [];
+};
+
+export const matchGameAPI = (match, gameType, teamSize) => {
+    return request("POST", "/user/game/match", {
+        match,
+        gameType,
+        teamSize,
+        readyTime: 15,
+        targetType: 20,
+    });
+};
+
+export const readyGameAPI = (battleId) => {
+    return request("POST", "/user/game/prepare", {
+        battleId,
+    });
+};
+
+export const simulShootAPI = (device_id, x, y, targetType = 40) => {
+    const data = {
+        device_id,
+        // 模拟射箭仅支持 20cm、40cm 靶纸，未传或传入无效值时默认使用 40cm。
+        targetType: Number(targetType) === 20 ? 20 : 40,
+    };
+    if (x !== undefined && y !== undefined) {
+        data.x = x;
+        data.y = y;
+    }
+    return request("POST", "/index/arrow", data);
+};
+
+export const getBattleListAPI = async (page, battleType) => {
+    const result = await request("POST", "/user/battle/details/list", {
+        page,
+        pageSize: 10,
+        battleType,
+    });
+    return result.list;
+};
+
+export const getRankListAPI = () => {
+    return request("GET", "/index/ranklist");
+};
+
+export const createOrderAPI = (vipId) => {
+    return request("POST", "/user/order/create", {
+        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,
+        tradeType: "mini",
+        payType: "wxpay",
+    });
+};
+
+export const getOrderListAPI = async (page) => {
+    const reuslt = await request("GET", `/user/order/list?page=${page}`);
+    return reuslt.items || [];
+};
+
+export const cancelOrderListAPI = async (id) => {
+    return request("POST", "/user/order/cancelOrder", {id});
+};
+
+export const getUserGameState = () => {
+    return request("GET", "/user/state");
+};
+
+export const getPointBookConfigAPI = async () => {
+    return request("GET", "/user/score/sheet/option");
+};
+
+export const savePointBookAPI = async (
+    bowType,
+    distance,
+    targetType,
+    groups,
+    arrows,
+    data = []
+) => {
+    return request("POST", "/user/score/sheet/report", {
+        bowType,
+        distance,
+        targetType,
+        groups,
+        arrows,
+        group_data: data.map((item) =>
+            item.map((i) => ({
+                ...i,
+                ring: i.ring === "M" ? -1 : i.ring === "X" ? 0 : Number(i.ring),
+            }))
+        ),
+    });
+};
+
+export const getPointBookListAPI = async (
+    page = 1,
+    bowType,
+    distance,
+    targetType
+) => {
+    let url = `/user/score/sheet/list?pageNum=${page}&pageSize=10`;
+    if (bowType) url += `&bowType=${bowType}`;
+    if (distance) url += `&distance=${distance}`;
+    if (targetType) url += `&targetType=${targetType}`;
+    const result = await request("GET", url);
+    return result.list || [];
+};
+
+export const getPointBookDetailAPI = async (id) => {
+    return request("GET", `/user/score/sheet/detail?id=${id}`);
+};
+
+export const getPointBookDataAPI = async () => {
+    return request("GET", "/user/score/sheet/statistics");
+};
+
+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");
+};
+
+export const chooseTeamAPI = async (number, group) => {
+    return request("POST", "/user/room/group", {number, group});
+};
+
+export const getVIPDescAPI = async () => {
+    return request("GET", "/index/memberVipDescribe");
+};
+
+export const getPointBookStatisticsAPI = async () => {
+    return request("GET", `/v2/user/score/sheet/statistics`);
+};
+
+export const donateAPI = async (amount, name, phone, organizer, advice) => {
+    return request("POST", `/user/donate`, {
+        amount,
+        name,
+        phone,
+        organizer,
+        advice,
+    });
+};
+
+export const laserAimAPI = async () => {
+    return request("POST", "/user/device/laserAim");
+};
+
+// 调瞄续期只负责发送请求，不等待或处理响应，避免阻塞下一次续期。
+export const aimRenewAPI = () => {
+    const token = uni.getStorageSync(
+        `${uni.getAccountInfoSync().miniProgram.envVersion}_token`
+    );
+    const header = {"Accept-Language": "en-US"};
+    if (token) header.Authorization = `Bearer ${token}`;
+
+    uni.request({
+        url: `${BASE_URL}/user/device/aimRenew`,
+        method: "POST",
+        header,
+        data: {},
+        timeout: 10000,
+        success: () => {},
+        fail: () => {},
+    });
+};
+
+export const laserCloseAPI = async () => {
+    return request("POST", "/user/device/closeAim");
+};
+
+// 设备连接指定 WiFi，只下发 WiFi 凭证，不触发 OTA 升级。
+export const connectDeviceWifiAPI = async (ssid, password) => {
+    return request(
+        "POST",
+        "/user/hardwareBox/connectWifi",
+        {ssid, password},
+        BASE_URL,
+        [0],
+        {timeout: 20000, showErrorToast: false}
+    );
+};
+
+// 查询设备当前联网类型及已连接的 WiFi 名称。
+export const getDeviceWifiStatusAPI = async () => {
+    return request("GET", "/user/device/wifiStatus", {}, BASE_URL, [0], {
+        showErrorToast: false,
+    });
+};
+
+// 发送硬件盒子 OTA 更新指令，服务端会返回后续轮询使用的任务 ID。
+export const sendHardwareBoxUpdateAPI = async ({versionNumber, wifiSsid, wifiPassword}) => {
+    return request("POST", "/user/hardwareBox/sendUpdate", {
+        versionNumber,
+        wifiSsid,
+        wifiPassword,
+    });
+};
+
+export const addNoteAPI = async (id, remark) => {
+    return request("POST", "/user/score/sheet/remark", {id, remark});
+};
+
+export const removePointRecord = async (id) => {
+    return request("DELETE", `/user/score/sheet/delete?id=${id}`);
+};
+
+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",
+        `/user/score/sheet/week/shoot/rank/list?pageNum=${page}&pageSize=100`
+    );
+};
+
+export const clickLikeAPI = (userId, ifLike) => {
+    return request("POST", "/user/score/sheet/week/shoot/rank/like", {
+        userId,
+        ifLike,
+    });
+};
+
+export const getMyLikeList = (page = 1, pageSize = 10) => {
+    return request(
+        "GET",
+        `/user/score/sheet/week/shoot/rank/like/list?pageNum=${page}&pageSize=${pageSize}`
+    );
+};
+
+export const getReadyAPI = (roomId) => {
+    return request("POST", `/user/room/ready`, {
+        roomId,
+    });
+};
+
+export const getBattleAPI = async (battleId) => {
+    const result = await request("POST", "/user/match/info", {
+        id: battleId,
+    });
+    return normalizeBattleApiResult(result);
+};
+
+export const kickPlayerAPI = (number, userId) => {
+    return request("POST", "/user/room/kicking", {
+        number,
+        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);
+};
+
+// 获取当前用户的金币统计，可按门店查询。
+export const getMyGoldAPI = (storeId) => {
+    const data = {};
+    if (storeId !== undefined && storeId !== null) data.storeId = storeId;
+    return request("GET", "/index/gold/my", data);
+};
+
+// 分页获取当前用户的金币流水，type：1=获得，2=兑换。
+export const getGoldLogAPI = ({page = 1, pageSize = 20, type, storeId} = {}) => {
+    const data = {page, pageSize};
+    if (type !== undefined && type !== null) data.type = type;
+    if (storeId !== undefined && storeId !== null) data.storeId = storeId;
+    return request("GET", "/index/gold/log", data);
+};
+
+// 前台礼品接口位于站点根路径，并使用 code=200 表示成功。
+export const getGiftListAPI = ({
+    page = 1,
+    pageSize = 20,
+    sort = "coin_desc",
+    storeId,
+} = {}) => {
+    const data = {page, page_size: pageSize, sort};
+    if (storeId !== undefined && storeId !== null && storeId !== "") {
+        data.store_id = storeId;
+    }
+    return request(
+        "GET",
+        "/gin/api/v1/gift/list",
+        data,
+        API_ROOT_URL,
+        [0, 200]
+    );
+};
+
+export const getGiftDetailAPI = (id) => {
+    return request(
+        "GET",
+        `/gin/api/v1/gift/${id}`,
+        {},
+        API_ROOT_URL,
+        [0, 200]
+    );
+};
+
+// 分页获取启用门店及当前用户在各店的会员状态。
+export const getStoreVipListAPI = ({page = 1, pageSize = 20} = {}) => {
+    return request("GET", "/store/list", {page, pageSize});
+};
+
+// 查询当前用户在指定门店的会员状态及权益剩余次数。
+export const getStoreBenefitAPI = (storeId) => {
+    return request("GET", "/store/benefit", {storeId});
+};
+
+// 获取体验中心 VIP 介绍纯文本，无需登录。
+export const getStoreVipIntroAPI = () => {
+    return request("GET", "/store/vip-intro");
+};
+
+// 根据用户定位分页获取附近门店。
+export const getNearbyStoresAPI = ({
+    longitude,
+    latitude,
+    radius = 65535,
+    page = 1,
+    pageSize = 20,
+} = {}) => {
+    return request("GET", "/store/nearby", {
+        longitude,
+        latitude,
+        radius,
+        page,
+        pageSize,
+    });
+};
+
+// 分页获取指定门店的公开金币规则。
+export const getStoreGoldRuleListAPI = ({storeId, page = 1, pageSize = 20} = {}) => {
+    return request(
+        "GET",
+        `/gin/api/v1/super-admin/gold-rule/store/${storeId}/list`,
+        {page, page_size: pageSize},
+        API_ROOT_URL,
+        [0, 200]
+    );
+};

src/components/AppBackground.vue

@@ -0,0 +1,128 @@
+<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"
+	/>
+  <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 === 12"
+      src="https://static.shelingxingqiu.com/shootmini/static/device-assets/my-device-unbound-background.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>
+
+<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/components/AppFooter.vue

@@ -1,34 +1,93 @@
 <script setup>
-function handleClickGithub() {
+import { t } from "@/locales";
-  if (typeof window !== 'undefined' && window.open) {
+
-    window.open('https://github.com/uni-helper/create-uni')
+const tabs = [
-  }
+  { image: "https://static.shelingxingqiu.com/shootmini/static/tab-vip.png" },
-  else {
+  { 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.showToast({
-      icon: 'none',
+        title: t('coming_soon'),
-      title: '请使用浏览器打开',
+        icon: "none",
-    })
+    });
+    // uni.navigateTo({
+    //   url: "/pages/member/be-vip",
+    // });
+  }
+  if (index === 1) {
+    uni.navigateTo({
+      url: "/pages/point-book",
+    });
+  }
+  if (index === 2) {
+    uni.navigateTo({
+      url: "/pages/device/device-intro",
+    });
   }
 }
 </script>
 
 <template>
-  <view class="footer" @click="handleClickGithub">
+  <view class="footer">
-    <image class="uni-helper-github__image" src="/static/github.svg" />
+    <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="$clickSound(() => handleTabClick(index))"
+      :style="{
+        width: index === 1 ? '36%' : '20%',
+      }"
+    >
+      <image :src="tab.image" mode="widthFix" />
+    </view>
   </view>
 </template>
 
-<style>
+<style scoped>
-.footer{
+.footer {
-  position: absolute;
+  /* height: 120px; */
-  bottom: 1rem;
+  height: 190rpx;
-  left: 50%;
+  width: 100vw;
-  transform: translateX(-50%);
+  /* position: relative; */
-  color: #888;
+  position: fixed;
+  bottom: 0;
+  left: 0;
+  display: flex;
+  justify-content: space-around;
+  align-items: center;
+  overflow: hidden;
 }
-.uni-helper-github__image {
+.footer-bg {
-  display: inline-block;
+  width: 100%;
-  height: 1em;
+  height: 100%;
-  width: 1em;
+  position: absolute;
+  z-index: 0;
+}
+.tab-item {
+  z-index: 1;
+  display: flex;
+  justify-content: center;
+}
+.tab-item > image {
+  width: 65rpx;
+}
+.tab-item:last-child > image {
+  width: 85rpx;
+}
+.tab-item:nth-child(2) {
+  transform: translate(10%, 40%);
+}
+.tab-item:nth-child(3) {
+  margin-bottom: 25rpx;
+}
+.tab-item:nth-child(3) > image {
+  width: 140rpx;
+}
+.tab-item:nth-child(4) {
+  transform: translate(-10%, 44%);
 }
 </style>

src/components/Avatar.vue

@@ -0,0 +1,136 @@
+<script setup>
+import { computed, ref, 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,
+  },
+  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],
+  () => {
+    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="avatarFrameStyle"
+      class="avatar-frame"
+    />
+    <image
+      v-if="rank === 1"
+      src="https://static.shelingxingqiu.com/shootmini/static/champ1.png"
+      mode="widthFix"
+      class="avatar-rank"
+    />
+    <image
+      v-if="rank === 2"
+      src="https://static.shelingxingqiu.com/shootmini/static/champ2.png"
+      mode="widthFix"
+      class="avatar-rank"
+    />
+    <image
+      v-if="rank === 3"
+      src="https://static.shelingxingqiu.com/shootmini/static/champ3.png"
+      mode="widthFix"
+      class="avatar-rank"
+    />
+    <view v-if="rank > 3" class="rank-view">{{ rank }}</view>
+    <image
+      :src="src || 'https://static.shelingxingqiu.com/shootmini/static/user-icon.png'"
+      :mode="imageMode"
+      :style="avatarImageStyle"
+      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/components/BackToGame.vue

@@ -0,0 +1,145 @@
+<script setup>
+import { t } from "@/locales";
+
+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>{{ t('return_to_your_current_match') }}</text>
+    </block>
+    <block v-else-if="game.roomID">
+      <text>{{ t('back_to_room') }}</text>
+    </block>
+    <image src="https://static.shelingxingqiu.com/shootmini/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/components/BattleFooter.vue

@@ -0,0 +1,205 @@
+=
+<script setup>
+import { t } from "@/locales";
+
+import { computed } from "vue";
+import BowPower from "@/components/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>{{ t('blue') }}{{ bluePoints }})</text>
+      <text>{{ t('red') }}{{ 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${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>{{ t('pts') }}</text>
+          </view>
+        </view>
+        <block v-if="roundResults.length < 3">
+          <view v-for="pendingRoundNumber in 3 - roundResults.length" :key="pendingRoundNumber">
+            <image
+              :src="RoundImages[`round${pendingRoundNumber + roundResults.length}`]"
+              mode="widthFix"
+            />
+            <view>
+              <text></text>
+              <text>{{ t('pts') }}</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${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>{{ t('pts') }}</text>
+          </view>
+        </view>
+        <block v-if="roundResults.length < 3">
+          <view v-for="pendingRoundNumber in 3 - roundResults.length" :key="pendingRoundNumber">
+            <image
+              :src="RoundImages[`round${pendingRoundNumber + roundResults.length}`]"
+              mode="widthFix"
+            />
+            <view>
+              <text></text>
+              <text>{{ t('pts') }}</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/components/BattleHeader.vue

@@ -0,0 +1,242 @@
+<script setup>
+import Avatar from "@/components/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">
+    <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 ? '48rpx' : '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="https://static.shelingxingqiu.com/shootmini/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="https://static.shelingxingqiu.com/shootmini/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
+      :show-scrollbar="false"
+      @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;
+  pointer-events: none;
+}
+.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%;
+  white-space: nowrap;
+}
+/* 小程序 scroll-view 不支持直接 flex，通过内层 wrapper 承载横向排列 */
+.players-melee-inner {
+  display: inline-flex;
+  min-width: 100%;
+  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/components/BowData.vue

@@ -0,0 +1,143 @@
+<script setup>
+import { t } from "@/locales";
+
+import { computed } from "vue";
+import AppBackground from "@/components/AppBackground.vue";
+import Avatar from "@/components/Avatar.vue";
+import BowTarget from "@/components/BowTarget.vue";
+import ScorePanel from "@/components/ScorePanel.vue";
+import useStore from "@/store";
+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,
+    default: false,
+  },
+  onClose: {
+    type: Function,
+    default: () => {},
+  },
+  arrows: {
+    type: Array,
+    default: () => [],
+  },
+  total: {
+    type: Number,
+    default: 0,
+  },
+});
+</script>
+
+<template>
+  <view class="container" :style="{ display: show ? 'flex' : 'none' }">
+    <AppBackground :type="1" />
+    <view class="header">
+      <view>
+        <Avatar :src="user.avatar" :rankLvl="user.rankLvl" :size="45" />
+        <view>
+          <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>
+      <view @click="onClose">
+        <image src="https://static.shelingxingqiu.com/shootmini/static/close-white.png" mode="widthFix" />
+      </view>
+    </view>
+    <view :style="{ width: '100%', marginBottom: '20px' }">
+      <BowTarget :scores="arrows" :isSvip="isSVip" />
+    </view>
+    <view class="desc">
+      <text>{{ arrows.length }}</text>
+      <text>{{ t('arrows_total') }}</text>
+      <text>{{ arrows.reduce((a, b) => a + (b.ring || 0), 0) }}</text>
+      <text>{{ t('pts') }}</text>
+    </view>
+    <ScorePanel
+      :completeEffect="false"
+      :rowCount="total === 12 ? 6 : 9"
+      :total="total"
+      :arrows="arrows"
+      :margin="total === 12 ? 4 : 1"
+      :fontSize="total === 12 ? 25 : 22"
+    />
+  </view>
+</template>
+
+<style scoped>
+.container {
+  width: 100vw;
+  height: 100vh;
+  position: fixed;
+  top: 0;
+  left: 0;
+  background-color: #232323;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  z-index: 10;
+}
+.header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  width: calc(100% - 20px);
+  padding: 10px;
+}
+.header > view:first-child {
+  display: flex;
+  align-items: center;
+  margin-left: 10px;
+}
+.header > view:first-child > view:last-child {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  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;
+  padding: 2px 5px;
+  border-radius: 10px;
+  margin-top: 5px;
+}
+.header > view:last-child > image {
+  width: 40px;
+}
+.desc {
+  color: #fff;
+  margin-bottom: 40px;
+}
+.desc > text:nth-child(2),
+.desc > text:nth-child(4) {
+  color: #fed847;
+}
+</style>

src/components/BowPower.vue

@@ -0,0 +1,29 @@
+<script setup>
+import { t } from "@/locales";
+
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+
+const store = useStore();
+const { deviceBattery: power } = storeToRefs(store);
+</script>
+
+<template>
+  <view class="container">
+    <image src="https://static.shelingxingqiu.com/shootmini/static/b-power.png" mode="widthFix" />
+    <view>{{ power === null ? t('battery') : t('battery_value', { p0: power }) }}</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/components/BowShotEffect.vue

@@ -0,0 +1,519 @@
+<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,
+  },
+  viewportMode: {
+    type: Boolean,
+    default: false,
+  },
+});
+
+const emit = defineEmits(["complete", "impact"]);
+
+const phase = ref("idle");
+const activePlayKey = ref("");
+const animationKey = ref("");
+const impactEmitted = ref(false);
+const activeShot = ref(null);
+const activeLayout = ref(null);
+let timers = [];
+
+const isActive = computed(() => phase.value !== "idle");
+const ARROW_IMPACT_MS = 340;
+const COMPLETE_FALLBACK_MS = 980;
+// 箭头尖端统一从屏幕中下区域出发，箭身自然延伸到屏幕底部之外。
+const SHOT_START_VIEWPORT_Y_RATIO = 0.82;
+
+const safeTargetRadius = computed(() => {
+  const radius = Number(props.targetRadius);
+  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 effectiveTargetSize = computed(
+  () => activeLayout.value?.target || safeTargetSize.value
+);
+const effectiveWindowSize = computed(
+  () => activeLayout.value?.window || getWindowSize()
+);
+const isViewportMode = computed(() =>
+  activeLayout.value
+    ? activeLayout.value.viewportMode
+    : props.viewportMode === true
+);
+
+const shotPoint = computed(() => {
+  const x = Number(effectiveShot.value?.x);
+  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 = effectiveTargetSize.value;
+  const windowSize = effectiveWindowSize.value;
+
+  if (
+    isViewportMode.value &&
+    size.width > 0 &&
+    size.height > 0 &&
+    windowSize.width > 0 &&
+    windowSize.height > 0
+  ) {
+    const startX = windowSize.width * 0.5;
+    const endX =
+      size.left +
+      size.width * (hitPercent.value.left / 100) +
+      hitOffset.value.x;
+    const endY =
+      size.top +
+      size.height * (hitPercent.value.top / 100) +
+      hitOffset.value.y;
+    // 常规情况下从视口底部进入；靶面局部超出视口时仍保证起点在命中点下方。
+    const startY = Math.max(windowSize.height + 16, endY + 80);
+    const dx = endX - startX;
+    const dy = endY - startY;
+
+    return {
+      startX,
+      startY,
+      endX,
+      endY,
+      translateX: dx,
+      translateY: dy,
+      angle: Math.atan2(dx, -dy) * (180 / Math.PI),
+    };
+  }
+
+  const 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,
+    endX,
+    endY,
+    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(() => {
+  if (isViewportMode.value) {
+    return {
+      left: `${flightPath.value.endX}px`,
+      top: `${flightPath.value.endY}px`,
+    };
+  }
+
+  return {
+    left: formatTargetPosition(hitPercent.value.left, hitOffset.value.x),
+    top: formatTargetPosition(hitPercent.value.top, hitOffset.value.y),
+  };
+});
+
+function getTargetTranslate(percent) {
+  const absPercent = Math.abs(percent);
+  const operator = percent >= 0 ? "-" : "+";
+  return `calc(${percent}vw ${operator} ${absPercent * 0.5}px)`;
+}
+
+const arrowMoveStyle = computed(() => {
+  const size = effectiveTargetSize.value;
+  const path = flightPath.value;
+  let x = getTargetTranslate(hitPercent.value.left - 50);
+  let y = getTargetTranslate(hitPercent.value.top - 114);
+
+  if (isViewportMode.value || (size.width && size.height)) {
+    x = `${path.translateX}px`;
+    y = `${path.translateY}px`;
+  }
+
+  return {
+    "--shot-start-x":
+      isViewportMode.value || size.width ? `${path.startX}px` : "50%",
+    "--shot-start-y":
+      isViewportMode.value || size.height ? `${path.startY}px` : "114%",
+    "--shot-tx": x,
+    "--shot-ty": y,
+    "--shot-angle": `${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;
+  activeLayout.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 };
+  activeLayout.value = {
+    target: { ...safeTargetSize.value },
+    window: getWindowSize(),
+    viewportMode: props.viewportMode === true,
+  };
+  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}`,
+      { 'shot-effect--viewport': isViewportMode },
+    ]"
+    :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-effect--viewport {
+  position: fixed;
+  width: 100vw;
+  height: 100vh;
+}
+
+.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

@@ -0,0 +1,929 @@
+<script setup>
+import { t } from "@/locales";
+
+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, 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: () => [],
+  },
+  isSvip: {
+    type: Boolean,
+    default: false,
+  },
+  mode: {
+    type: String,
+    default: "solo", // solo 单排，team 双排
+  },
+  missAsZero: {
+    type: Boolean,
+    default: false,
+  },
+  stop: {
+    type: Boolean,
+    default: false,
+  },
+  targetType: {
+    type: [Number, String],
+    default: 40,
+  },
+  targetRadius: {
+    type: Number,
+    default: 20,
+  },
+  hitRadiusPx: {
+    type: Number,
+    default: 2,
+  },
+  zoomHitRadiusPx: {
+    type: Number,
+    default: 5,
+  },
+  stableShotEffect: {
+    type: Boolean,
+    default: false,
+  },
+  enableShotEffect: {
+    type: Boolean,
+    default: true,
+  },
+});
+
+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 pendingShotEffect = 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();
+let shotEffectRequestGeneration = 0;
+const ROUND_TIP_OFFSET_Y = -32;
+const EXPERIENCE_TIP_OFFSET_Y = -68;
+
+function getRoundText(shot) {
+  if (shot?.ringX) return t('x');
+  if (shot?.ring) return t('value_pts', { p0: shot.ring });
+  return props.missAsZero ? t('0_pts') : t('miss');
+}
+
+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.enableShotEffect &&
+    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, viewportMode = false) {
+  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, viewportMode };
+}
+
+async function prepareShotEffect(team, shot, index) {
+  const requestGeneration = ++shotEffectRequestGeneration;
+  const key = buildShotEffectKey(team, shot, index);
+  pendingShotEffect.value = { generation: requestGeneration, team, key };
+  clearTipTimer();
+  if (team === "red") latestOne.value = null;
+  if (team === "blue") bluelatestOne.value = null;
+
+  const viewportMode = props.stableShotEffect
+    ? await updateTargetRect()
+    : false;
+
+  if (requestGeneration !== shotEffectRequestGeneration) {
+    if (pendingShotEffect.value?.generation === requestGeneration) {
+      pendingShotEffect.value = null;
+    }
+    return;
+  }
+  pendingShotEffect.value = null;
+  triggerShotEffect(team, shot, index, viewportMode);
+}
+
+function completeShotEffect(key) {
+  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 hasValidTargetRect(rect = targetRect.value) {
+  return (
+    Number.isFinite(Number(rect?.left)) &&
+    Number.isFinite(Number(rect?.top)) &&
+    Number(rect?.width) > 0 &&
+    Number(rect?.height) > 0
+  );
+}
+
+async function updateTargetRect() {
+  await nextTick();
+
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (rect) => {
+      if (settled) return;
+      settled = true;
+
+      const isValid = hasValidTargetRect(rect);
+      if (isValid) {
+        targetRect.value = {
+          left: Number(rect.left),
+          top: Number(rect.top),
+          width: Number(rect.width),
+          height: Number(rect.height),
+        };
+      }
+      resolve(isValid);
+    };
+
+    try {
+      const query = instance?.proxy
+        ? uni.createSelectorQuery().in(instance.proxy)
+        : uni.createSelectorQuery();
+
+      query
+        .select(".target")
+        .boundingClientRect()
+        .exec((result) => finish(Array.isArray(result) ? result[0] : null));
+    } catch {
+      finish(null);
+    }
+  });
+}
+
+function handleWindowResize() {
+  void updateTargetRect();
+}
+
+function shouldHideRedHit(index) {
+  return (
+    (!!hiddenRedLatestKey.value || pendingShotEffect.value?.team === "red") &&
+    index === props.scores.length - 1
+  );
+}
+
+function shouldHideBlueHit(index) {
+  return (
+    (!!hiddenBlueLatestKey.value || pendingShotEffect.value?.team === "blue") &&
+    index === props.blueScores.length - 1
+  );
+}
+
+watch(
+  () => props.scores.length,
+  (newLen, oldLen) => {
+    if (newLen === oldLen + 1) {
+      const latestShot = props.scores[newLen - 1];
+      if (shouldPlayShotEffect(latestShot)) {
+        void prepareShotEffect("red", latestShot, newLen - 1);
+      } else if (props.enableShotEffect) {
+        shotEffectRequestGeneration += 1;
+        pendingShotEffect.value = null;
+        showShotTip("red", latestShot);
+      }
+      return;
+    }
+
+    if (newLen < oldLen) {
+      shotEffectRequestGeneration += 1;
+      pendingShotEffect.value = null;
+      latestOne.value = null;
+      hiddenRedLatestKey.value = "";
+      if (shotEffect.value?.team === "red") shotEffect.value = null;
+    }
+  }
+);
+
+watch(
+  () => props.blueScores.length,
+  (newLen, oldLen) => {
+    if (newLen === oldLen + 1) {
+      const latestShot = props.blueScores[newLen - 1];
+      if (shouldPlayShotEffect(latestShot)) {
+        void prepareShotEffect("blue", latestShot, newLen - 1);
+      } else if (props.enableShotEffect) {
+        shotEffectRequestGeneration += 1;
+        pendingShotEffect.value = null;
+        showShotTip("blue", latestShot);
+      }
+      return;
+    }
+
+    if (newLen < oldLen) {
+      shotEffectRequestGeneration += 1;
+      pendingShotEffect.value = null;
+      bluelatestOne.value = null;
+      hiddenBlueLatestKey.value = "";
+      if (shotEffect.value?.team === "blue") shotEffect.value = null;
+    }
+  }
+);
+
+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,
+      undefined,
+      undefined,
+      props.targetType
+    );
+  }
+};
+const simulShoot2 = async () => {
+  if (device.value.deviceId) {
+    const r1 = Math.random() > 0.5 ? 0.01 : 0.02;
+    await simulShootAPI(device.value.deviceId, r1, r1, props.targetType);
+  }
+};
+
+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);
+  void updateTargetRect();
+  if (uni.onWindowResize) uni.onWindowResize(handleWindowResize);
+});
+
+onBeforeUnmount(() => {
+  shotEffectRequestGeneration += 1;
+  pendingShotEffect.value = null;
+  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="https://static.shelingxingqiu.com/shootmini/static/dot-circle.png" mode="widthFix" />
+        </view>
+      </view>
+      <view v-if="stop" class="stop-sign">{{ t('halftime') }}</view>
+      <view
+        v-if="latestOne && latestOne.ring && user.id === latestOne.playerId"
+        class="e-value fade-in-out"
+        :style="getExperienceTipStyle(latestOne)"
+      >{{ t('xp_1') }}</view>
+      <view
+        v-if="latestOne"
+        class="round-tip fade-in-out"
+        :style="getRoundTipStyle(latestOne)"
+        >{{ getRoundText(latestOne) }}
+      </view>
+      <view
+        v-if="
+          bluelatestOne &&
+          bluelatestOne.ring &&
+          user.id === bluelatestOne.playerId
+        "
+        class="e-value fade-in-out"
+        :style="getExperienceTipStyle(bluelatestOne)"
+      >{{ t('xp_1') }}</view>
+      <view
+        v-if="bluelatestOne"
+        class="round-tip fade-in-out"
+        :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="https://static.shelingxingqiu.com/shootmini/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 && isSvip && bow.ring > 0 && !shouldHideBlueHit(index)"
+          class="svip-hit-bg"
+          src="https://static.shelingxingqiu.com/shootmini/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
+        v-if="!shotEffect || !shotEffect.viewportMode"
+        :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>
+    <BowShotEffect
+      v-if="shotEffect && shotEffect.viewportMode"
+      :shot="shotEffect.shot"
+      :playKey="shotEffect.key"
+      :targetRadius="safeTargetRadius"
+      :targetLeft="targetRect.left"
+      :targetTop="targetRect.top"
+      :targetWidth="targetRect.width"
+      :targetHeight="targetRect.height"
+      :hitOffsetPx="currentHitRadiusPx"
+      :viewportMode="true"
+      @impact="shakeTarget"
+      @complete="completeShotEffect"
+    />
+    <view class="footer">
+      <PointSwitcher
+        :onChange="(val) => (pMode = val)"
+        :style="{ zIndex: 999 }"
+      />
+    </view>
+    <view class="simul" v-if="env !== 'release'">
+      <button @click="simulShoot">{{ t('simulate') }}</button>
+      <button @click="simulShoot2">{{ t('shoot') }}</button>
+      <button @click="openAim">{{ t('sight_on') }}</button>
+      <button @click="closeAim">{{ t('sight_off') }}</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;
+}
+.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/components/BowTarget/HalfRingTarget.vue

@@ -0,0 +1,111 @@
+<script setup>
+import { ref, computed } from "vue";
+
+const props = defineProps({
+  diameter: {
+    type: Number,
+    default: 90,
+  },
+});
+
+const side = computed(() => {
+  return props.diameter / 10;
+});
+
+const rings = ["X", "10", "9", "8", "7", "6"];
+</script>
+
+<template>
+  <view
+    class="container circle"
+    :style="{
+      width: diameter + 'vw',
+      height: diameter + 'vw',
+      background: '#00BAE9',
+    }"
+  >
+    <view
+      class="circle"
+      :style="{
+        background: '#FF5665',
+        width: side * 8 + 'vw',
+        height: side * 8 + 'vw',
+      }"
+    >
+      <view class="rings" :style="{ transform: `translateX(-${side}vw)` }">
+        <text
+          v-for="(ring, index) in rings"
+          :key="ring"
+          :style="{
+            width: side + 'vw',
+            transform: `translateX(${
+              index === 0 ? side / 2 : index === 1 ? side / 4.5 : 0
+            }vw)`,
+          }"
+          >{{ ring }}</text
+        >
+      </view>
+      <view
+        class="circle"
+        :style="{
+          background: '#FF5665',
+          width: side * 6 + 'vw',
+          height: side * 6 + 'vw',
+        }"
+      >
+        <view
+          class="circle"
+          :style="{
+            background: '#FDDC61',
+            width: side * 4 + 'vw',
+            height: side * 4 + 'vw',
+          }"
+        >
+          <view
+            class="circle"
+            :style="{
+              background: '#FDDC61',
+              width: side * 2 + 'vw',
+              height: side * 2 + 'vw',
+            }"
+          >
+            <view
+              class="circle"
+              :style="{
+                background: '#FDDC61',
+                width: side + 'vw',
+                height: side + 'vw',
+              }"
+            >
+            </view>
+          </view>
+        </view>
+      </view>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  position: relative;
+}
+.rings {
+  position: absolute;
+  display: flex;
+  align-items: center;
+  left: 50%;
+}
+.rings > text {
+  font-size: 24rpx;
+  color: #333;
+  text-align: center;
+}
+.circle {
+  border: 1rpx solid #3e3e3e66;
+  box-sizing: border-box;
+  border-radius: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+</style>

src/components/BowTargetEdit.vue

@@ -0,0 +1,438 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref, onMounted, onBeforeUnmount } from "vue";
+import { getElementRect, calcRing, capsuleHeight } from "@/util";
+
+const props = defineProps({
+  id: {
+    type: Number,
+    default: 0,
+  },
+  src: {
+    type: String,
+    default: "",
+  },
+  arrows: {
+    type: Array,
+    default: () => [],
+  },
+  onChange: {
+    type: Function,
+    default: null,
+  },
+});
+
+const rect = ref({});
+const arrow = ref(null);
+const isDragging = ref(false);
+const dragStartPos = ref({ x: 0, y: 0 });
+const scale = ref(1);
+const scrollTop = ref(0);
+const selected = ref(null);
+let lastMoveTime = 0;
+
+// 点击靶纸创建新的点
+const onClick = async (e) => {
+  if (
+    arrow.value !== null ||
+    !props.onChange ||
+    Date.now() - lastMoveTime < 300
+  ) {
+    return;
+  }
+  if (props.id === 7 || props.id === 9) {
+    if (
+      e.detail.x < rect.value.width * 0.2 ||
+      e.detail.x > rect.value.width * 0.8
+    )
+      return;
+    // 放大并通过滚动将点击位置置于视窗中心
+    scale.value = 1.4;
+    const viewportH = rect.value.width; // 容器高度等于宽度（100vw）
+    const contentH = scale.value * rect.value.width; // 内容高度
+    const clickYInContainer = e.detail.y - rect.value.top;
+    let target = clickYInContainer * scale.value - viewportH / 2;
+    target = Math.max(0, Math.min(contentH - viewportH, target));
+    setTimeout(() => {
+      scrollTop.value = target > 180 ? target + 10 : target;
+    }, 200);
+  }
+  const newArrow = {
+    x: (e.detail.x - 6) * scale.value,
+    y: (e.detail.y - rect.value.top - capsuleHeight - 6) * scale.value,
+  };
+
+  const side = rect.value.width;
+  newArrow.ring = calcRing(
+    props.id,
+    newArrow.x / scale.value - side * 0.05,
+    newArrow.y / scale.value - side * 0.05,
+    side * 0.9
+  );
+  arrow.value = {
+    ...newArrow,
+    x: newArrow.x / side,
+    y: newArrow.y / side,
+  };
+};
+
+// 确认添加箭矢
+const confirmAdd = () => {
+  if (props.onChange) {
+    props.onChange({
+      x: arrow.value.x / scale.value,
+      y: arrow.value.y / scale.value,
+      ring: arrow.value.ring || "M",
+    });
+  }
+  arrow.value = null;
+  scale.value = 1;
+  scrollTop.value = 0;
+};
+
+// 删除箭矢
+const deleteArrow = () => {
+  arrow.value = null;
+  scale.value = 1;
+  scrollTop.value = 0;
+};
+
+// 开始拖拽 - 同样修复坐标获取
+const startDrag = async (e) => {
+  if (!e.touches[0]) return;
+  isDragging.value = true;
+  dragStartPos.value = {
+    x: e.touches[0].clientX,
+    y: e.touches[0].clientY,
+  };
+};
+
+// 拖拽移动 - 同样修复坐标获取
+const onDrag = async (e) => {
+  lastMoveTime = Date.now();
+  if (!isDragging.value || !e.touches[0] || !arrow.value) return;
+  let clientX = e.touches[0].clientX;
+  let clientY = e.touches[0].clientY;
+
+  // 计算移动距离
+  const deltaX = clientX - dragStartPos.value.x;
+  const deltaY = clientY - dragStartPos.value.y;
+  const side = rect.value.width;
+  // 更新坐标
+  arrow.value.x = Math.max(
+    0,
+    Math.min(side * scale.value, arrow.value.x * side + deltaX)
+  );
+  arrow.value.y = Math.max(
+    0,
+    Math.min(side * scale.value, arrow.value.y * side + deltaY)
+  );
+  arrow.value.ring = calcRing(
+    props.id,
+    arrow.value.x / scale.value - side * 0.05,
+    arrow.value.y / scale.value - side * 0.05,
+    side * 0.9
+  );
+
+  arrow.value.x = arrow.value.x / side;
+  arrow.value.y = arrow.value.y / side;
+
+  // 更新拖拽起始位置
+  dragStartPos.value = { x: clientX, y: clientY };
+};
+
+// 结束拖拽
+const endDrag = (e) => {
+  isDragging.value = false;
+};
+
+const getNewPos = () => {
+  if (props.id === 7 || props.id === 9) {
+    if (arrow.value.y >= 1.33)
+      return { left: "-12px", bottom: "calc(50% - 12px)" };
+  } else {
+    if (arrow.value.y > 0.88) {
+      if (arrow.value.x < 0.05) {
+        return { left: "calc(100% - 12px)", bottom: "calc(100% - 12px)" };
+      }
+      return { left: "-12px", bottom: "calc(50% - 12px)" };
+    }
+  }
+  return { left: "calc(50% - 12px)", bottom: "-12px" };
+};
+
+const setEditArrow = (data) => {
+  selected.value = data;
+  // if (data === null) {
+  //   arrow.value = null;
+  //   scale.value = 1;
+  //   scrollTop.value = 0;
+  //   return;
+  // }
+  // if (props.id === 7 || props.id === 9) {
+  //   scale.value = 1.4;
+  //   const viewportH = rect.value.width; // 容器高度等于宽度（100vw）
+  //   const contentH = scale.value * rect.value.width; // 内容高度
+  //   const clickYInContainer = contentH * data.y - rect.value.top;
+  //   let target = clickYInContainer * scale.value - viewportH / 2;
+  //   target = Math.max(0, Math.min(contentH - viewportH, target));
+  //   setTimeout(() => {
+  //     scrollTop.value = target > 180 ? target + 10 : target;
+  //   }, 200);
+  // }
+  // arrow.value = {
+  //   ...data,
+  //   x: data.x * scale.value,
+  //   y: data.y * scale.value,
+  // };
+};
+
+onMounted(async () => {
+  const result = await getElementRect(".container");
+  rect.value = result;
+  uni.$on("set-edit-arrow", setEditArrow);
+});
+
+onBeforeUnmount(() => {
+  uni.$off("set-edit-arrow", setEditArrow);
+});
+</script>
+
+<template>
+  <scroll-view
+    :scroll-y="scale > 1"
+    scroll-with-animation
+    :scroll-top="scrollTop"
+    :show-scrollbar="false"
+    :enhanced="true"
+    class="container"
+    @tap="onClick"
+    @touchmove="onDrag"
+    @touchend="endDrag"
+  >
+    <movable-area
+      class="move-area"
+      :style="{
+        width: scale * 100 + 'vw',
+        height: scale * 100 + 'vw',
+        transform: `translateX(${(100 - scale * 100) / 2}vw)`,
+      }"
+    >
+      <image :src="src" mode="widthFix" />
+      <view
+        v-for="(arrow, index) in arrows"
+        :key="index"
+        :class="`arrow-point ${
+          selected !== null && index === selected ? 'selected-arrow-point' : ''
+        }`"
+        :style="{
+          left: (arrow.x !== undefined ? arrow.x : 0) * 100 + '%',
+          top: (arrow.y !== undefined ? arrow.y : 0) * 100 + '%',
+        }"
+      >
+        <view
+          v-if="arrow.x !== undefined && arrow.y !== undefined"
+          class="point"
+        >
+          <text>{{ index + 1 }}</text>
+        </view>
+      </view>
+      <movable-view
+        v-if="arrow"
+        class="arrow-point"
+        direction="all"
+        :animation="false"
+        :out-of-bounds="true"
+        :x="arrow ? rect.width * arrow.x : 0"
+        :y="arrow ? rect.width * arrow.y : 0"
+      >
+        <view
+          class="point"
+          :style="{ minWidth: 10 * scale + 'px', minHeight: 10 * scale + 'px' }"
+        >
+          <view v-if="arrow" class="edit-buttons" @touchstart.stop>
+            <view class="edit-btn-text">
+              <text>{{ arrow.ring === 0 ? "M" : arrow.ring }}</text>
+              <text
+                v-if="arrow.ring > 0"
+                :style="{
+                  fontSize: '16px',
+                  marginLeft: '2px',
+                }"
+                >{{ t('pts') }}</text
+              >
+            </view>
+            <view
+              class="edit-btn confirm-btn"
+              @touchstart.stop="confirmAdd"
+              :style="{ ...getNewPos() }"
+            >
+              <image src="https://static.shelingxingqiu.com/shootmini/static/arrow-edit-save.png" mode="widthFix" />
+            </view>
+            <view class="edit-btn delete-btn" @touchstart.stop="deleteArrow">
+              <image src="https://static.shelingxingqiu.com/shootmini/static/arrow-edit-delete.png" mode="widthFix" />
+            </view>
+            <view
+              class="edit-btn drag-btn"
+              @touchstart.stop="startDrag($event)"
+            >
+              <image src="https://static.shelingxingqiu.com/shootmini/static/arrow-edit-move.png" mode="widthFix" />
+            </view>
+          </view>
+        </view>
+      </movable-view>
+      <!-- <view class="test-view"></view> -->
+    </movable-area>
+  </scroll-view>
+</template>
+
+<style scoped>
+.container {
+  width: 100vw;
+  height: 100vw;
+  overflow-x: hidden;
+}
+.container::-webkit-scrollbar {
+  width: 0;
+  height: 0;
+  color: transparent;
+}
+
+.move-area {
+  width: 100%;
+  height: 100%;
+  transition: all 0.3s ease;
+}
+
+.move-area > image {
+  width: 90%;
+  height: 90%;
+  margin: 5%;
+}
+
+.move-view {
+  width: 90vw;
+  height: 90vw;
+  padding: 5vw;
+  position: relative;
+}
+
+.move-view > image {
+  width: 100%;
+}
+
+.arrow-point {
+  position: absolute;
+}
+
+.point {
+  min-width: 10px;
+  min-height: 10px;
+  border-radius: 50%;
+  border: 1px solid #fff;
+  color: #fff;
+  text-align: center;
+  line-height: 10px;
+  box-sizing: border-box;
+  background-color: #00bf04;
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.2);
+  transition: all 0.1s linear;
+  position: relative;
+  transform: translate(-50%, -50%);
+}
+
+.point > text {
+  display: block;
+  font-size: 16rpx;
+  line-height: 10px;
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  font-family: "DINCondensed", "PingFang SC", "Helvetica Neue", Arial,
+    sans-serif;
+  transform: translate(-50%, -50%);
+  margin-top: 1px;
+}
+
+.edit-buttons {
+  position: absolute;
+  top: calc(50% - 44px);
+  left: calc(50% - 44px);
+  background: #18ff6899;
+  width: 88px;
+  height: 88px;
+  display: flex;
+  align-items: flex-end;
+  transition: all 0.1s linear;
+}
+
+.edit-btn-text {
+  width: 100%;
+  display: flex;
+  justify-content: center;
+}
+
+.edit-btn-text > text {
+  line-height: 50px;
+  font-size: 24px;
+  font-weight: bold;
+  color: #fff;
+  text-align: center;
+}
+
+.edit-btn {
+  width: 24px;
+  height: 24px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  position: absolute;
+}
+
+.edit-btn > image {
+  width: 24px;
+  height: 24px;
+}
+
+.confirm-btn {
+  transition: all 0.3s ease;
+}
+
+.delete-btn {
+  left: calc(50% - 12px);
+  top: -12px;
+}
+
+.drag-btn {
+  right: -12px;
+  bottom: -12px;
+}
+.test-view {
+  position: absolute;
+  top: 29px;
+  left: 138px;
+  width: 115px;
+  height: 115px;
+  background-color: #ff000055;
+}
+.selected-arrow-point .point {
+  background: linear-gradient(180deg, #ffdaa6 0%, #e9a333 100%) !important;
+  box-shadow: 0rpx 2rpx 4rpx 0rpx rgba(0, 0, 0, 0.18);
+  animation: duang 0.35s ease-out;
+}
+@keyframes duang {
+  0% {
+    transform: translate(-50%, -50%) scale(0.7);
+  }
+  45% {
+    transform: translate(-50%, -50%) scale(1.4);
+  }
+  70% {
+    transform: translate(-50%, -50%) scale(0.9);
+  }
+  100% {
+    transform: translate(-50%, -50%) scale(1);
+  }
+}
+</style>

src/components/BubbleTip.vue

@@ -0,0 +1,62 @@
+<script setup>
+const props = defineProps({
+  type: {
+    type: String,
+    default: "normal",
+  },
+  location: {
+    type: Object,
+    default: () => ({}),
+  },
+});
+</script>
+
+<template>
+  <view :class="`container ${type}`" :style="{ ...location }">
+    <slot />
+  </view>
+</template>
+
+<style scoped>
+.container {
+  position: absolute;
+  color: #fff;
+  display: flex;
+  flex-direction: column;
+  background-size: contain;
+  background-repeat: no-repeat;
+  background-position: center;
+  font-size: 24rpx;
+}
+.normal {
+  background-image: url("https://static.shelingxingqiu.com/shootmini/static/bubble-tip.png");
+  width: 157rpx;
+  height: 105rpx;
+  padding-top: 10px;
+  padding-left: 30rpx;
+}
+.normal2 {
+  background-image: url("https://static.shelingxingqiu.com/shootmini/static/bubble-tip4.png");
+  width: 190rpx;
+  height: 105rpx;
+  padding-top: 10px;
+  padding-left: 20rpx;
+  top: 0;
+  left: 15%;
+  z-index: 1;
+}
+.long {
+  background-image: url("https://static.shelingxingqiu.com/shootmini/static/bubble-tip2.png");
+  width: 370rpx;
+  height: 70rpx;
+  top: -50%;
+  left: 49%;
+}
+.short {
+  background-image: url("https://static.shelingxingqiu.com/shootmini/static/bubble-tip3.png");
+  width: 300rpx;
+  height: 70rpx;
+  top: -50%;
+  right: -1%;
+}
+</style>

src/components/Container.vue

@@ -0,0 +1,321 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref } from "vue";
+import { onShow } from "@dcloudio/uni-app";
+import AppBackground from "@/components/AppBackground.vue";
+import Header from "@/components/Header.vue";
+import ScreenHint from "@/components/ScreenHint.vue";
+import BackToGame from "@/components/BackToGame.vue";
+import DeviceChargingDialog from "@/components/DeviceChargingDialog.vue";
+import {laserAimAPI, getBattleAPI, matchGameAPI} from "@/apis";
+import { capsuleHeight, debounce } from "@/util";
+import { returnToBattle } from "@/utils/matchReturn";
+const emit = defineEmits(["scrolltolower"]);
+const props = defineProps({
+  title: {
+    type: String,
+    default: "",
+  },
+  bgType: {
+    type: Number,
+    default: 0,
+  },
+  onBack: {
+    type: Function,
+    default: null,
+  },
+  scroll: {
+    type: Boolean,
+    default: true,
+  },
+  usePageScroll: {
+    type: Boolean,
+    default: false,
+  },
+  isHome: {
+    type: Boolean,
+    default: false,
+  },
+  showBackToGame: {
+    type: Boolean,
+    default: false,
+  },
+  bgColor: {
+    type: String,
+    default: "#050b19",
+  },
+  whiteBackArrow: {
+    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 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/device/calibration",
+  });
+};
+</script>
+
+<template>
+  <view :style="{ paddingTop: capsuleHeight + 'px' }">
+    <AppBackground :type="bgType" :bgColor="bgColor" />
+    <slot v-if="$slots.header" name="header"></slot>
+    <Header
+      v-else-if="!isHome"
+      :class="headerClass"
+      :title="title"
+      :onBack="onBack"
+      :whiteBackArrow="whiteBackArrow"
+      :titleStyle="titleStyle"
+      :style="
+        usePageScroll
+          ? {
+              position: 'sticky',
+              top: capsuleHeight + 'px',
+              zIndex: 10,
+            }
+          : undefined
+      "
+    />
+    <BackToGame v-if="showBackToGame" />
+    <view v-if="usePageScroll">
+      <slot></slot>
+    </view>
+    <scroll-view
+      v-else
+      :scroll-y="scroll"
+      :enhanced="true"
+      :bounces="false"
+      :show-scrollbar="false"
+      :lower-threshold="120"
+      @scrolltolower="emit('scrolltolower')"
+      :style="{
+        height: `calc(100vh - ${capsuleHeight + (($slots.header || !isHome) ? 50 : 0)}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>{{ t('finish_your_current_match_before_starting_a_new_one') }}</text>
+        <text>{{ t('you_have_a_match_in_progress_join_it') }}</text>
+        <view>
+          <button hover-class="none" @click="() => (showHint = false)">{{ t('stay_out') }}</button>
+          <button hover-class="none" @click="backToGame" :disabled="isLoading">
+            {{ isLoading ? t('loading') : t('join') }}
+          </button>
+        </view>
+      </view>
+      <view v-if="hintType === 2" class="tip-content">
+        <text>{{ t('leaving_may_result_in_a_loss') }}</text>
+        <text>{{ t('are_you_sure_you_want_to_leave') }}</text>
+        <view>
+          <button hover-class="none" @click="goBack">{{ t('leave_match') }}</button>
+          <button hover-class="none" @click="() => (showHint = false)">{{ t('continue_match') }}</button>
+        </view>
+      </view>
+      <view v-if="hintType === 3" class="tip-content">
+        <text>{{ t('done_playing_for_today') }}</text>
+        <view>
+          <button hover-class="none" @click="() => (showHint = false)">{{ t('cancel') }}</button>
+          <button hover-class="none" @click="$clickSound(cancelMatching)">{{ t('confirm') }}</button>
+        </view>
+      </view>
+      <view v-if="hintType === 4" class="tip-content">
+        <text>{{ t('calibrate_your_smart_bow_to_unlock_all_features') }}</text>
+        <view>
+          <button hover-class="none" @click="() => (showHint = false)">{{ t('cancel') }}</button>
+          <button hover-class="none" @click="goCalibration">{{ t('calibrate') }}</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%' }"></view>
+      </view>
+      <view>
+        <text>{{ loadingText || t('loading') }}</text>
+      </view>
+    </view>
+    <DeviceChargingDialog />
+  </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 {
+  width: 100%;
+  min-height: 6rpx;
+  background: #ffe431;
+  border-radius: 4rpx;
+}
+
+.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;
+}
+</style>

src/components/CreateRoom.vue

@@ -0,0 +1,210 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref } from "vue";
+import SButton from "@/components/SButton.vue";
+
+import { joinRoomAPI, createRoomAPI } from "@/apis";
+import { debounce } from "@/util";
+
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+const store = useStore();
+const { user, game } = storeToRefs(store);
+
+const props = defineProps({
+  onConfirm: {
+    type: Function,
+    default: () => {},
+  },
+});
+
+/** 对战模式：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: t('please_complete_the_room_settings'), 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;
+  if (battleMode.value === 4) size = 6;
+  try {
+    const result = await createRoomAPI(
+      battleMode.value === 2 ? 2 : 1,
+      battleMode.value === 2 ? 10 : size,
+        targetMode.value*20,
+    );
+    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 {
+    if (!keepLoading) loading.value = false;
+  }
+});
+</script>
+<template>
+  <view class="container">
+    <view class="target-options-header">
+      <view class="target-options-header-line-left"></view>
+      <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">
+      <view
+        :class="{ 'battle-btn': true, 'battle-choosen': battleMode === 1 }"
+        @click="() => (battleMode = 1)"
+      >
+        <text>{{ t('versus_1v1') }}</text>
+      </view>
+      <view
+        :class="{ 'battle-btn': true, 'battle-choosen': battleMode === 3 }"
+        @click="() => (battleMode = 3)"
+      >
+        <text>{{ t('versus_2v2') }}</text>
+      </view>
+      <view
+        :class="{ 'battle-btn': true, 'battle-choosen': battleMode === 4 }"
+        @click="() => (battleMode = 4)"
+      >
+        <text>{{ t('versus_3v3') }}</text>
+      </view>
+      <view
+        :class="{ 'battle-btn': true, 'battle-choosen': battleMode === 2 }"
+        @click="() => (battleMode = 2)"
+      >
+        <text>{{ t('free_for_all_3_10_players') }}</text>
+      </view>
+    </view>
+    <view class="target-options-header">
+      <view class="target-options-header-line-left"></view>
+      <view class="target-options-header-title">{{ t('select_target_face') }}</view>
+      <view class="target-options-header-line-right"></view>
+    </view>
+    <view class="target-options">
+      <view
+        :class="{ 'battle-btn': true, 'battle-choosen': targetMode === 1 }"
+        @click="() => (targetMode = 1)"
+      >
+        <text>{{ t('20_cm_full_ring_target') }}</text>
+      </view>
+      <view
+        :class="{ 'battle-btn': true, 'battle-choosen': targetMode === 2 }"
+        @click="() => (targetMode = 2)"
+      >
+        <text>{{ t('40_cm_full_ring_target') }}</text>
+      </view>
+    </view>
+    <SButton :disabled="loading" :onClick="() => { $clickSound(); return createRoom(); }">{{ t('create_room') }}</SButton>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  width: 100%;
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  padding-top: 44rpx;
+}
+.container > image:first-child {
+  width: 45%;
+  margin: 5px 0;
+}
+.create-options {
+  width: 100%;
+  padding: 0 10px;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 12px;
+  justify-content: center;
+  margin-bottom: 15px;
+}
+.target-options-header{
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin-bottom: 24rpx;
+}
+.target-options-header-title-img{
+  width: 196rpx;
+  height: 40rpx;
+}
+.target-options-header-title{
+  width: 112rpx;
+  height: 40rpx;
+  font-family: PingFang SC, PingFang SC;
+  font-weight: 400;
+  font-size: 28rpx;
+  text-align: center;
+  font-style: normal;
+  text-transform: none;
+  color: #FFEFBA;
+  margin: 0 18rpx;
+}
+.target-options-header-line-left{
+  width: 214rpx;
+  height: 0rpx;
+  border-radius: 0rpx 0rpx 0rpx 0rpx;
+  border: 1rpx solid;
+  border-image: linear-gradient(90deg, rgba(133, 119, 96, 0), rgba(133, 119, 96, 1)) 1 1;
+}
+.target-options-header-line-right{
+  width: 214rpx;
+  height: 0rpx;
+  border-radius: 0rpx 0rpx 0rpx 0rpx;
+  border: 1rpx solid;
+  border-image: linear-gradient(90deg, rgba(133, 119, 96, 1), rgba(133, 119, 96, 0)) 1 1;
+}
+.target-options {
+  width: 100%;
+  padding: 0 10px;
+  display: flex;
+  gap: 12px;
+  justify-content: center;
+  margin-bottom: 15px;
+}
+.battle-btn {
+  width: 45%;
+  height: 55px;
+  text-align: center;
+  border-radius: 10px;
+  border: 2rpx solid #fff3;
+  box-sizing: border-box;
+  color: #fff;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+}
+.battle-choosen {
+  color: #fed847;
+  border: 4rpx solid #fff3;
+  border-color: #fed847;
+}
+</style>

src/components/DeviceChargingDialog.vue

@@ -0,0 +1,24 @@
+<script setup>
+import { t } from "@/locales";
+
+import { storeToRefs } from "pinia";
+import ModalDialog from "@/components/ModalDialog.vue";
+import useStore from "@/store";
+
+const chargingNotice =
+  t('your_smart_bow_is_charging_and_will_shut_down_automatically_to_p');
+
+const store = useStore();
+const { deviceChargingDialogVisible } = storeToRefs(store);
+const { hideDeviceChargingDialog } = store;
+</script>
+
+<template>
+  <ModalDialog
+    :show="deviceChargingDialogVisible"
+    :content="chargingNotice"
+    :show-cancel="false"
+    :confirm-text="t('got_it')"
+    :on-confirm="hideDeviceChargingDialog"
+  />
+</template>

src/components/DeviceOnlineEffects.vue

@@ -0,0 +1,399 @@
+<script setup>
+import { computed } from "vue";
+
+const props = defineProps({
+  variant: {
+    type: String,
+    default: "home",
+    validator: (value) => ["home", "detail"].includes(value),
+  },
+});
+
+// 固定粒子分布营造随机感，避免每次进入页面时因运行时随机数产生位置跳变。
+const sparkSeeds = [
+  [1, "dot", 18, 98, -28, 5, 5, 2.3, 0.4],
+  [2, "streak", 23, 90, -38, 4, 18, 2, 1.1, true],
+  [3, "dot", 28, 112, -17, 6, 6, 2.8, 1.9, true],
+  [4, "dot", 32, 104, -12, 12, 12, 2.6, 0.7, true, true],
+  [5, "dot", 36, 88, -24, 4, 4, 1.8, 1.4],
+  [6, "streak", 40, 116, -8, 4, 20, 2.4, 2.2, true],
+  [7, "dot", 44, 96, -16, 7, 7, 2.1, 0.2],
+  [8, "dot", 48, 120, -4, 5, 5, 2.9, 1.3, true],
+  [9, "dot", 51, 110, 3, 14, 14, 3, 2.7, true, true],
+  [10, "streak", 54, 92, 8, 4, 22, 1.9, 0.8],
+  [11, "dot", 58, 105, 14, 6, 6, 2.5, 1.6, true],
+  [12, "dot", 62, 86, 21, 4, 4, 2, 0.5],
+  [13, "dot", 66, 114, 10, 7, 7, 2.7, 2.1, true],
+  [14, "streak", 70, 96, 28, 4, 18, 2.2, 1],
+  [15, "dot", 74, 108, 20, 11, 11, 2.8, 2.4, true, true],
+  [16, "dot", 80, 90, 35, 5, 5, 2.3, 0.3, true],
+  [17, "dot", 21, 118, -8, 4, 4, 2.6, 1.7],
+  [18, "streak", 27, 84, -31, 3, 16, 1.8, 0.6, true],
+  [19, "dot", 34, 122, -3, 6, 6, 2.9, 2.3, true],
+  [20, "dot", 42, 102, 5, 5, 5, 2.2, 0.9],
+  [21, "dot", 47, 88, -10, 13, 13, 2.7, 1.5, true, true],
+  [22, "streak", 56, 120, 16, 4, 21, 2.5, 2.6, true],
+  [23, "dot", 64, 100, 24, 7, 7, 2.4, 0.1],
+  [24, "dot", 72, 84, 38, 5, 5, 2, 1.2, true],
+  [25, "dot", 82, 116, 12, 4, 4, 2.8, 2],
+  [26, "dot", 68, 124, 7, 10, 10, 3.1, 2.9, true, true],
+  [27, "streak", 77, 98, 33, 4, 19, 2.1, 0.7, true],
+  [28, "dot", 29, 94, -20, 7, 7, 2.5, 1.4],
+  [29, "dot", 53, 126, 0, 5, 5, 2.3, 2.2, true],
+  [30, "dot", 60, 108, 18, 6, 6, 2.6, 0.4],
+];
+
+const deviceSparks = computed(() => {
+  const isDetail = props.variant === "detail";
+  const sizeScale = isDetail ? 1.25 : 1;
+  const bottomOffset = isDetail ? 120 : 0;
+
+  return sparkSeeds.map(([
+    id,
+    type,
+    left,
+    bottom,
+    angle,
+    width,
+    height,
+    duration,
+    delay,
+    long = false,
+    large = false,
+  ]) => ({
+    id,
+    type,
+    long,
+    large,
+    trackStyle: {
+      left: `${left}%`,
+      bottom: `${bottom + bottomOffset}rpx`,
+      transform: `rotate(${angle}deg)`,
+    },
+    sparkStyle: {
+      width: `${width * sizeScale}rpx`,
+      height: `${height * sizeScale}rpx`,
+      marginLeft: `${-(width * sizeScale) / 2}rpx`,
+      animationDuration: `${duration}s`,
+      animationDelay: `-${delay}s`,
+    },
+  }));
+});
+</script>
+
+<template>
+  <view
+    class="device-online-effects"
+    :class="`device-online-effects--${variant}`"
+  >
+    <view class="device-online-rays-stage">
+      <view class="device-online-rays-orbit">
+        <view class="device-online-ray device-online-ray--1" />
+        <view class="device-online-ray device-online-ray--2" />
+        <view class="device-online-ray device-online-ray--3" />
+        <view class="device-online-ray device-online-ray--4" />
+        <view class="device-online-ray device-online-ray--5" />
+        <view class="device-online-ray device-online-ray--6" />
+        <view class="device-online-ray device-online-ray--7" />
+      </view>
+    </view>
+
+    <view class="device-online-particles">
+      <view
+        v-for="spark in deviceSparks"
+        :key="spark.id"
+        class="device-online-spark-track"
+        :style="spark.trackStyle"
+      >
+        <view
+          class="device-online-spark"
+          :class="[
+            `device-online-spark--${spark.type}`,
+            {
+              'device-online-spark--long': spark.long,
+              'device-online-spark--large': spark.large,
+            }
+          ]"
+          :style="spark.sparkStyle"
+        />
+      </view>
+    </view>
+  </view>
+</template>
+
+<style scoped lang="scss">
+.device-online-effects {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  z-index: 3;
+  overflow: hidden;
+  pointer-events: none;
+}
+
+/* 光束沿底座椭圆轨迹扫动，用位移、明暗和横向缩放表达前后纵深。 */
+.device-online-rays-stage {
+  position: absolute;
+  left: 0;
+  bottom: 112rpx;
+  width: 100%;
+  height: 140rpx;
+  overflow: hidden;
+  transform-origin: 50% 100%;
+}
+
+.device-online-rays-orbit {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  transform-origin: 50% 100%;
+  animation: device-rays-rotate 6s ease-in-out infinite;
+}
+
+.device-online-ray {
+  position: absolute;
+  bottom: 0;
+  left: 50%;
+  width: 48rpx;
+  height: 132rpx;
+  margin-left: -24rpx;
+  transform-origin: 50% 100%;
+  border-radius: 50% 50% 12% 12%;
+  background: linear-gradient(
+    180deg,
+    rgba(255, 255, 244, 0) 0%,
+    rgba(255, 254, 239, 0.1) 36%,
+    rgba(255, 248, 215, 0.22) 72%,
+    rgba(255, 232, 151, 0.36) 100%
+  );
+}
+
+.device-online-ray--1 {
+  opacity: 0.55;
+  transform: rotate(-55deg);
+}
+
+.device-online-ray--2 {
+  width: 68rpx;
+  margin-left: -34rpx;
+  opacity: 0.72;
+  transform: rotate(-36deg);
+}
+
+.device-online-ray--3 {
+  width: 42rpx;
+  margin-left: -21rpx;
+  opacity: 0.6;
+  transform: rotate(-18deg);
+}
+
+.device-online-ray--4 {
+  width: 76rpx;
+  margin-left: -38rpx;
+  opacity: 0.82;
+}
+
+.device-online-ray--5 {
+  width: 46rpx;
+  margin-left: -23rpx;
+  opacity: 0.64;
+  transform: rotate(19deg);
+}
+
+.device-online-ray--6 {
+  width: 64rpx;
+  margin-left: -32rpx;
+  opacity: 0.7;
+  transform: rotate(38deg);
+}
+
+.device-online-ray--7 {
+  width: 44rpx;
+  margin-left: -22rpx;
+  opacity: 0.56;
+  transform: rotate(56deg);
+}
+
+.device-online-particles {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+}
+
+.device-online-spark-track {
+  position: absolute;
+  width: 0;
+  height: 0;
+  transform-origin: center bottom;
+}
+
+.device-online-spark {
+  position: absolute;
+  bottom: 0;
+  left: 0;
+  background: #fff6bd;
+  box-shadow: 0 0 6rpx rgba(255, 225, 112, 0.65);
+  animation: device-spark-rise 2.4s linear infinite;
+}
+
+.device-online-spark--dot {
+  border-radius: 50%;
+}
+
+.device-online-spark--streak {
+  border-radius: 50%;
+  background: linear-gradient(
+    180deg,
+    rgba(255, 255, 235, 0) 0%,
+    rgba(255, 250, 205, 0.75) 45%,
+    #ffe379 100%
+  );
+}
+
+.device-online-spark--long {
+  animation-name: device-spark-rise-long;
+}
+
+.device-online-spark--large {
+  background: #fffbdc;
+  box-shadow:
+    0 0 10rpx rgba(255, 243, 174, 0.95),
+    0 0 20rpx rgba(255, 207, 74, 0.72);
+}
+
+.device-online-effects--detail .device-online-rays-stage {
+  bottom: 215rpx;
+  height: 190rpx;
+  transform: scaleX(1.35);
+}
+
+.device-online-effects--detail .device-online-ray {
+  height: 180rpx;
+}
+
+.device-online-effects--detail .device-online-rays-orbit {
+  animation-name: device-rays-rotate-detail;
+}
+
+.device-online-effects--detail .device-online-spark {
+  animation-name: device-spark-rise-detail;
+}
+
+.device-online-effects--detail .device-online-spark--long {
+  animation-name: device-spark-rise-detail-long;
+}
+
+@keyframes device-spark-rise {
+  0% {
+    opacity: 0;
+    transform: translateY(8rpx) scale(0.45);
+  }
+  16% {
+    opacity: 1;
+  }
+  72% {
+    opacity: 0.62;
+  }
+  100% {
+    opacity: 0;
+    transform: translateY(-148rpx) scale(1);
+  }
+}
+
+@keyframes device-spark-rise-long {
+  0% {
+    opacity: 0;
+    transform: translateY(8rpx) scale(0.4);
+  }
+  16% {
+    opacity: 1;
+  }
+  72% {
+    opacity: 0.55;
+  }
+  100% {
+    opacity: 0;
+    transform: translateY(-176rpx) scale(1);
+  }
+}
+
+@keyframes device-spark-rise-detail {
+  0% {
+    opacity: 0;
+    transform: translateY(12rpx) scale(0.45);
+  }
+  16% {
+    opacity: 1;
+  }
+  72% {
+    opacity: 0.62;
+  }
+  100% {
+    opacity: 0;
+    transform: translateY(-225rpx) scale(1);
+  }
+}
+
+@keyframes device-spark-rise-detail-long {
+  0% {
+    opacity: 0;
+    transform: translateY(12rpx) scale(0.4);
+  }
+  16% {
+    opacity: 1;
+  }
+  72% {
+    opacity: 0.55;
+  }
+  100% {
+    opacity: 0;
+    transform: translateY(-270rpx) scale(1);
+  }
+}
+
+@keyframes device-rays-rotate {
+  0%,
+  100% {
+    opacity: 0.48;
+    transform: translate(-42rpx, 4rpx) skewX(-8deg) scaleX(0.82);
+  }
+  25% {
+    opacity: 0.88;
+    transform: translate(0, 0) skewX(0deg) scaleX(1.05);
+  }
+  50% {
+    opacity: 0.48;
+    transform: translate(42rpx, 4rpx) skewX(8deg) scaleX(0.82);
+  }
+  75% {
+    opacity: 0.24;
+    transform: translate(0, 10rpx) skewX(0deg) scaleX(0.68);
+  }
+}
+
+@keyframes device-rays-rotate-detail {
+  0%,
+  100% {
+    opacity: 0.48;
+    transform: translate(-62rpx, 6rpx) skewX(-8deg) scaleX(0.82);
+  }
+  25% {
+    opacity: 0.88;
+    transform: translate(0, 0) skewX(0deg) scaleX(1.05);
+  }
+  50% {
+    opacity: 0.48;
+    transform: translate(62rpx, 6rpx) skewX(8deg) scaleX(0.82);
+  }
+  75% {
+    opacity: 0.24;
+    transform: translate(0, 14rpx) skewX(0deg) scaleX(0.68);
+  }
+}
+</style>

src/components/EditOption.vue

@@ -0,0 +1,445 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref, watch, onMounted, computed } from "vue";
+import { getPointBookConfigAPI } from "@/apis";
+const props = defineProps({
+  itemIndex: {
+    type: Number,
+    default: 0,
+  },
+  expand: {
+    type: Boolean,
+    default: false,
+  },
+  onExpand: {
+    type: Function,
+    default: () => {},
+  },
+  onSelect: {
+    type: Function,
+    default: () => {},
+  },
+  noArrow: {
+    type: Boolean,
+    default: false,
+  },
+  value: {
+    type: String,
+    default: "",
+  },
+});
+const itemTexts = [t('select_bow_type'), t('select_shooting_distance'), t('select_target_face'), t('select_ends_arrows')];
+const distances = [5, 8, 10, 18, 25, 30, 50, 60, 70];
+const groupArrows = [3, 6, 12, 18];
+
+const data = ref([]);
+const selectedIndex = ref(-1);
+const secondSelectIndex = ref(-1);
+
+const meter = ref("");
+const sets = ref("");
+const arrowAmount = ref("");
+
+const onSelectItem = (index) => {
+  selectedIndex.value = index;
+  if (props.itemIndex === 0) {
+    props.onSelect(props.itemIndex, data.value[index]);
+  } else if (props.itemIndex === 1) {
+    props.onSelect(props.itemIndex, distances[index]);
+  } else if (props.itemIndex === 2) {
+    props.onSelect(props.itemIndex, data.value[index]);
+  } else if (props.itemIndex === 3) {
+    if (secondSelectIndex.value !== -1) {
+      props.onSelect(
+        props.itemIndex,
+        `${selectedIndex.value}/${groupArrows[secondSelectIndex.value]}`
+      );
+    }
+  }
+};
+const onSelectSecondItem = (index) => {
+  secondSelectIndex.value = index;
+  if (selectedIndex.value !== -1) {
+    props.onSelect(
+      props.itemIndex,
+      `${selectedIndex.value < 5 ? selectedIndex.value : sets.value}/${
+        groupArrows[secondSelectIndex.value]
+      }`
+    );
+  }
+};
+const onMeterChange = (e) => {
+  meter.value = e.detail.value;
+  props.onSelect(props.itemIndex, e.detail.value);
+};
+const onSetsChange = (e) => {
+  if (!e.detail.value) return;
+  sets.value = Math.min(30, Math.max(1, Number(e.detail.value)));
+  if (!sets.value) return;
+  if (secondSelectIndex.value !== -1) {
+    props.onSelect(
+      props.itemIndex,
+      `${sets.value}/${
+        secondSelectIndex.value === 99
+          ? arrowAmount.value
+          : groupArrows[secondSelectIndex.value]
+      }`
+    );
+  }
+};
+const onArrowAmountChange = (e) => {
+  if (!e.detail.value) return;
+  arrowAmount.value = Math.min(60, Math.max(1, Number(e.detail.value)));
+  if (!arrowAmount.value) return;
+  if (selectedIndex.value !== -1) {
+    props.onSelect(
+      props.itemIndex,
+      `${selectedIndex.value === 99 ? sets.value : selectedIndex.value}/${
+        arrowAmount.value
+      }`
+    );
+  }
+};
+watch(
+  () => props.value,
+  (newValue) => {
+    if (!newValue) {
+      selectedIndex.value = -1;
+      return;
+    }
+    if (props.itemIndex === 0 || props.itemIndex === 2) {
+      data.value.forEach((item, index) => {
+        if (item.name === newValue) {
+          selectedIndex.value = index;
+        }
+      });
+    }
+    if (props.itemIndex === 1) {
+      distances.forEach((item, index) => {
+        if (item == newValue) {
+          selectedIndex.value = index;
+        }
+        if (selectedIndex.value === -1) {
+          meter.value = newValue;
+        }
+      });
+    }
+  }
+);
+const loadConfig = () => {
+  const config = uni.getStorageSync("point-book-config");
+  if (config) {
+    if (props.itemIndex === 0) {
+      data.value = config.bowOption;
+    } else if (props.itemIndex === 2) {
+      data.value = config.targetOption;
+    }
+    if (props.value) {
+      if (props.itemIndex === 0 || props.itemIndex === 2) {
+        selectedIndex.value = data.value.findIndex(
+          (item) => item.name === props.value
+        );
+      }
+      if (props.itemIndex === 1) {
+        selectedIndex.value = distances.findIndex(
+          (item) => item.name === props.value
+        );
+        if (selectedIndex.value === -1) {
+          selectedIndex.value = 9;
+        }
+      }
+    }
+  }
+};
+const formatSetAndAmount = computed(() => {
+  if (selectedIndex.value === -1 || secondSelectIndex.value === -1)
+    return itemTexts[props.itemIndex];
+  if (selectedIndex.value === 99 && !sets.value)
+    return itemTexts[props.itemIndex];
+  if (secondSelectIndex.value === 99 && !arrowAmount.value)
+    return itemTexts[props.itemIndex];
+  return t('value_ends_value_arrows', { p0: selectedIndex.value === 99 ? sets.value : selectedIndex.value, p1: secondSelectIndex.value === 99
+      ? arrowAmount.value
+      : groupArrows[secondSelectIndex.value] });
+});
+onMounted(async () => {
+  const config = uni.getStorageSync("point-book-config");
+  if (config) {
+    loadConfig();
+  } else {
+    const config = await getPointBookConfigAPI();
+    uni.setStorageSync("point-book-config", config);
+    loadConfig();
+  }
+});
+</script>
+
+<template>
+  <view
+    class="container"
+    :style="{
+      maxHeight: expand ? '500px' : '50px',
+      marginTop: noArrow ? '0' : '10px',
+    }"
+  >
+    <view @click="() => onExpand(itemIndex, !expand)">
+      <view></view>
+      <block>
+        <text v-if="expand" :style="{ color: '#999', fontWeight: 'normal' }">{{
+          itemIndex !== 3 ? itemTexts[itemIndex] : t('select_ends')
+        }}</text>
+        <text v-if="!expand && itemIndex === 0">{{
+          value || itemTexts[itemIndex]
+        }}</text>
+        <text v-if="!expand && itemIndex === 1">{{
+          value && value > 0 ? value + t('m_92') : itemTexts[itemIndex]
+        }}</text>
+        <text v-if="!expand && itemIndex === 2">{{
+          value || itemTexts[itemIndex]
+        }}</text>
+        <text v-if="!expand && itemIndex === 3">{{ formatSetAndAmount }}</text>
+      </block>
+      <button hover-class="none">
+        <image
+          v-if="!noArrow"
+          src="https://static.shelingxingqiu.com/shootmini/static/arrow-grey.png"
+          mode="widthFix"
+          :style="{ transform: expand ? 'rotateX(180deg)' : 'rotateX(0deg)' }"
+        />
+      </button>
+    </view>
+    <view v-if="itemIndex === 0" class="bow-items">
+      <view
+        v-for="(item, index) in data"
+        :key="index"
+        :style="{
+          borderColor: selectedIndex === index ? '#fed847' : '#eeeeee',
+        }"
+        @click="onSelectItem(index)"
+      >
+        <image :src="item.icon" mode="widthFix" />
+        <text>{{ item.name }}</text>
+      </view>
+    </view>
+    <view v-if="itemIndex === 1" class="distance-items">
+      <view
+        v-for="(item, index) in distances"
+        :key="index"
+        :style="{
+          borderColor: selectedIndex === index ? '#fed847' : '#eeeeee',
+        }"
+        @click="onSelectItem(index)"
+      >
+        <text>{{ item }}</text>
+        <text>{{ t('m_92') }}</text>
+      </view>
+      <view
+        :style="{
+          borderColor: selectedIndex === 9 ? '#fed847' : '#eeeeee',
+        }"
+      >
+        <input
+          v-model="meter"
+          type="number"
+          :placeholder="t('custom')"
+          placeholder-style="color: #DDDDDD"
+          @focus="() => (selectedIndex = 9)"
+          @blur="onMeterChange"
+        />
+        <text>{{ t('m_92') }}</text>
+      </view>
+    </view>
+    <view v-if="itemIndex === 2" class="bowtarget-items">
+      <view
+        v-for="(item, index) in data"
+        :key="index"
+        :style="{
+          borderColor: selectedIndex === index ? '#fed847' : '#eeeeee',
+        }"
+        @click="onSelectItem(index)"
+      >
+        <text>{{ item.name.substring(0, item.name.length - 3) }}</text>
+        <text>{{ item.name.substring(item.name.length - 3) }}</text>
+      </view>
+    </view>
+    <view v-if="itemIndex === 3">
+      <view class="amount-items">
+        <view
+          v-for="i in 4"
+          :key="i"
+          :style="{
+            borderColor: selectedIndex === i ? '#fed847' : '#eeeeee',
+          }"
+          @click="onSelectItem(i)"
+        >
+          <text>{{ i }}</text>
+          <text>{{ t('ends') }}</text>
+        </view>
+        <view
+          :style="{
+            borderColor: selectedIndex === 99 ? '#fed847' : '#eeeeee',
+          }"
+        >
+          <input
+            placeholder="1 ~ 30"
+            type="number"
+            placeholder-style="color: #DDDDDD"
+            v-model="sets"
+            @focus="() => (selectedIndex = 99)"
+            @blur="onSetsChange"
+          />
+          <text>{{ t('ends') }}</text>
+        </view>
+      </view>
+      <view
+        :style="{
+          marginTop: '5px',
+          marginBottom: '10px',
+          color: '#999999',
+          textAlign: 'center',
+        }"
+        >{{ t('select_arrows_per_end') }}</view
+      >
+      <view class="amount-items">
+        <view
+          v-for="(item, index) in groupArrows"
+          :key="index"
+          :style="{
+            borderColor: secondSelectIndex === index ? '#fed847' : '#eeeeee',
+          }"
+          @click="onSelectSecondItem(index)"
+        >
+          <text>{{ item }}</text>
+          <text>{{ t('arrows') }}</text>
+        </view>
+        <view
+          :style="{
+            borderColor: secondSelectIndex === 99 ? '#fed847' : '#eeeeee',
+          }"
+        >
+          <input
+            placeholder="1 ~ 60"
+            type="number"
+            placeholder-style="color: #DDDDDD"
+            v-model="arrowAmount"
+            maxlength="99"
+            @focus="() => (secondSelectIndex = 99)"
+            @blur="onArrowAmountChange"
+          />
+          <text>{{ t('arrows') }}</text>
+        </view>
+      </view>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  width: calc(100% - 20px);
+  background-color: #fff;
+  border-radius: 10px;
+  padding: 0 10px;
+  font-size: 14px;
+  overflow: hidden;
+  transition: all 0.3s ease;
+  color: #333;
+}
+.container > view:first-child {
+  width: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  height: 50px;
+}
+.container > view:first-child > view:first-child {
+  width: 85px;
+}
+.container > view:first-child > text:nth-child(2) {
+  font-weight: 500;
+}
+.container > view:first-child > button {
+  width: 85px;
+  display: flex;
+  justify-content: flex-end;
+}
+.container > view:first-child > button > image {
+  transition: all 0.5s ease;
+  width: 16px;
+  height: 16px;
+  padding-right: 5px;
+}
+.bow-items {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  column-gap: 2vw;
+}
+.bow-items > view {
+  width: 27vw;
+  height: 27vw;
+  border-radius: 10px;
+  border: 2px solid #eeeeee;
+  margin-bottom: 2vw;
+}
+.bow-items > view > image {
+  width: 100%;
+}
+.bow-items > view > text {
+  width: 100%;
+  display: block;
+  text-align: center;
+  transform: translateY(-30px);
+}
+.distance-items,
+.bowtarget-items,
+.amount-items {
+  display: grid;
+  grid-template-columns: repeat(4, 1fr);
+  column-gap: 2vw;
+  position: relative;
+}
+.distance-items > view,
+.bowtarget-items > view,
+.amount-items > view {
+  width: 20vw;
+  height: 12vw;
+  border-radius: 10px;
+  border: 2px solid #eeeeee;
+  margin-bottom: 2vw;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+.distance-items > view > text:first-child,
+.amount-items > view > text:first-child {
+  width: 25px;
+  display: block;
+  text-align: center;
+}
+.distance-items > view:last-child {
+  width: 65.5vw;
+  position: absolute;
+  bottom: 0;
+  right: 0;
+}
+.distance-items > view:last-child > input {
+  width: 80%;
+  text-align: center;
+}
+.bowtarget-items > view {
+  flex-direction: column;
+  height: 16vw;
+}
+.bowtarget-items > view > text {
+  width: 100%;
+  text-align: center;
+}
+.amount-items > view:last-child {
+  grid-column: 1 / -1;
+  width: 100%;
+}
+.amount-items > view:last-child > input {
+  width: 85%;
+  text-align: center;
+}
+</style>

src/components/Guide.vue

@@ -0,0 +1,60 @@
+<script setup>
+defineProps({
+  noBg: {
+    type: Boolean,
+    default: false,
+  },
+  type: {
+    type: Number,
+    default: 0,
+  },
+});
+const bubbleTypes = [
+  "https://static.shelingxingqiu.com/shootmini/static/long-bubble.png",
+  "https://static.shelingxingqiu.com/shootmini/static/long-bubble-middle.png",
+  "https://static.shelingxingqiu.com/shootmini/static/long-bubble-tall.png",
+];
+</script>
+
+<template>
+  <view class="container">
+    <image src="https://static.shelingxingqiu.com/shootmini/static/shooter.png" mode="widthFix" />
+    <view>
+      <image
+        v-if="!noBg"
+        :src="bubbleTypes[type]"
+        :style="{ top: type === 2 ? '-6%' : '-13%' }"
+        mode="widthFix"
+      />
+      <slot />
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  display: flex;
+  align-items: center;
+  padding: 0 15px;
+  width: clac(100% - 30px);
+}
+.container > image {
+  width: 20%;
+}
+.container > view {
+  position: relative;
+  width: 80%;
+  min-height: 55px;
+  display: flex;
+  flex-direction: column;
+}
+.container > view > image {
+  position: absolute;
+  left: -7%;
+  width: 108%;
+}
+.container > view {
+  color: #fff;
+  font-size: 28rpx;
+}
+</style>

src/components/GuideTwo.vue

@@ -0,0 +1,55 @@
+<script setup>
+defineProps({
+  noBg: {
+    type: Boolean,
+    default: false,
+  }
+});
+</script>
+
+<template>
+  <view class="container">
+    <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="https://static.shelingxingqiu.com/shootmini/static/long-bubble-border.png"
+        mode="widthFix"
+      />
+      <slot />
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  display: flex;
+  align-items: center;
+  padding: 0 26rpx 0 28rpx;
+  margin-bottom: 14rpx;
+  width: clac(100% - 54rpx);
+}
+.container .shooter2 {
+  display: block;
+  width: 133rpx;
+  height: 144rpx;
+}
+.container .bg-box {
+  color: #fff;
+  font-size: 28rpx;
+  position: relative;
+  flex: 1;
+  height: 128rpx;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-direction: column;
+}
+.container .bg-box .bg {
+  position: absolute;
+  left: 0;
+  right: 0;
+  width: 100%;
+}
+</style>

src/components/Header.vue

@@ -0,0 +1,357 @@
+<script setup>
+import { t, translateStatic } from "@/locales";
+
+import { ref, computed, onMounted, onBeforeUnmount } from "vue";
+import HeaderProgress from "@/components/HeaderProgress.vue";
+import Avatar from "@/components/Avatar.vue";
+
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+const store = useStore();
+const { user, game } = storeToRefs(store);
+
+const currentPage = computed(() => {
+  const pages = getCurrentPages();
+  return pages[pages.length - 1].route;
+});
+
+const props = defineProps({
+  title: {
+    type: String,
+    default: "",
+  },
+  onBack: {
+    type: Function,
+    default: null,
+  },
+  whiteBackArrow: {
+    type: Boolean,
+    default: true,
+  },
+  titleStyle: {
+    type: [String, Object, Array],
+    default: () => ({}),
+  },
+});
+
+const onClick = () => {
+  if (props.onBack) {
+    props.onBack();
+  } else {
+    const pages = getCurrentPages();
+    if (pages.length > 1) {
+      uni.navigateBack();
+    } else {
+      uni.redirectTo({
+        url: "/pages/index",
+      });
+    }
+  }
+};
+
+const toUserPage = () => {
+  uni.navigateTo({
+    url: "/pages/user",
+  });
+};
+
+const signin = () => {
+  if (!user.value.id) {
+    uni.$emit("point-book-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 heat = ref(0);
+/** 房间号按钮动态定位样式（position: fixed，根据胶囊真实位置计算，脱离 flex 流避免挤压标题） */
+const battleRoomBtnStyle = ref({});
+
+const updateLoading = (value) => {
+  loading.value = value;
+};
+
+const updateHot = (value) => {
+  heat.value = value;
+};
+
+onMounted(() => {
+  const pages = getCurrentPages();
+  const currentPage = pages[pages.length - 1];
+  if (
+    currentPage.route === "pages/point-book-edit" ||
+    currentPage.route === "pages/point-book-detail"
+  ) {
+    pointBook.value = uni.getStorageSync("point-book");
+    if (!pointBook.value) {
+      pointBook.value = uni.getStorageSync("last-point-book");
+    }
+  }
+  // 仅在对战房间页获取胶囊位置，按钮用 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);
+});
+onBeforeUnmount(() => {
+  uni.$off("update-hot", updateHot);
+});
+</script>
+
+<template>
+  <view class="container">
+    <view class="back-btn" @click="onClick">
+      <image v-if="whiteBackArrow" src="https://static.shelingxingqiu.com/shootmini/static/back.png" mode="widthFix" />
+      <image
+        v-if="!whiteBackArrow"
+        src="https://static.shelingxingqiu.com/shootmini/static/back-black.png"
+        mode="widthFix"
+      />
+    </view>
+    <view
+      :style="[{ color: whiteBackArrow ? '#fff' : '#000' }, titleStyle]"
+    >
+      <slot v-if="$slots.title" name="title"></slot>
+      <template v-else>
+      <view
+        v-if="currentPage === 'pages/point-book'"
+        class="user-header"
+        @click="signin"
+      >
+        <block v-if="user.id">
+          <Avatar
+            :src="user.avatar"
+            :onClick="toUserPage"
+            :size="40"
+            borderColor="#333"
+          />
+          <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="`https://static.shelingxingqiu.com/shootmini/static/hot${heat}.png`"
+            mode="widthFix"
+          />
+        </block>
+        <block v-else>
+          <image src="https://static.shelingxingqiu.com/shootmini/static/user-icon.png" mode="widthFix" />
+          <text>{{ t('welcome_new_archer') }}</text>
+        </block>
+      </view>
+      <block
+        v-if="
+          '-箭前准备-感知距离-小试牛刀'.indexOf(title) === -1 ||
+          '-箭前准备-感知距离-小试牛刀'.indexOf(title) === 11
+        "
+      >
+        <text>{{ ['-箭前准备', '-感知距离', '-小试牛刀', '小试牛刀'].includes(title) ? translateStatic(title) : title }}</text>
+      </block>
+      <block
+        v-if="
+          title &&
+          '-箭前准备-感知距离-小试牛刀'.indexOf(title) !== -1 &&
+          '-箭前准备-感知距离-小试牛刀'.indexOf(title) !== 11
+        "
+      >
+        <view class="first-try-steps">
+          <text :class="title === '-箭前准备' ? 'current-step' : ''">{{ t('get_ready') }}</text>
+          <text>-</text>
+          <text :class="title === '-感知距离' ? 'current-step' : ''"
+            >{{ t('find_your_distance') }}</text
+          >
+          <text>-</text>
+          <text :class="title === '-小试牛刀' ? 'current-step' : ''"
+            >{{ t('first_challenge') }}</text
+          >
+        </view>
+      </block>
+      </template>
+    </view>
+    <view v-if="pointBook" class="point-book-info">
+      <text>{{ pointBook.bowType.name }}</text>
+      <text>{{ pointBook.distance }}{{ t('m') }}</text>
+      <text
+        >{{
+          pointBook.bowtargetType.name.substring(
+            0,
+            pointBook.bowtargetType.name.length - 3
+          )
+        }}
+        {{
+          pointBook.bowtargetType.name.substring(
+            pointBook.bowtargetType.name.length - 3
+          )
+        }}</text
+      >
+    </view>
+    <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' && game.roomNumber"
+      open-type="share"
+      hover-class="none"
+      class="battle-room-number"
+      :style="battleRoomBtnStyle"
+    >
+      <text class="battle-room-number__text">{{ t('room') }}{{ game.roomNumber }}</text>
+      <image src="https://static.shelingxingqiu.com/shootmini/static/share2.png" mode="widthFix" class="battle-room-number__icon" />
+    </button>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  display: flex;
+  justify-content: flex-start;
+  align-items: center;
+  width: 72vw;
+  height: 50px;
+  /* margin-top: var(--status-bar-height); */
+  padding-left: 15px;
+}
+.container > view:nth-child(2) {
+  font-size: 16px;
+  font-weight: bold;
+}
+.back-btn {
+  display: flex;
+  align-items: center;
+}
+.back-btn > image {
+  width: 22px;
+  height: 22px;
+  margin-right: 10px;
+}
+.first-try-steps {
+  display: flex;
+  align-items: center;
+  color: #fff6;
+  font-size: 14px;
+}
+.first-try-steps > text {
+  transition: all 0.3s ease;
+}
+.first-try-steps > text:nth-child(2),
+.first-try-steps > text:nth-child(4) {
+  margin: 0 5px;
+}
+.current-step {
+  font-size: 16px;
+  color: #fff;
+}
+.point-book-info {
+  color: #333;
+  position: fixed;
+  width: 60%;
+  left: 20%;
+  display: flex;
+  justify-content: center;
+}
+.point-book-info > text {
+  border-radius: 6px;
+  background-color: #fff;
+  font-size: 10px;
+  padding: 5px 10px;
+  margin: 3px;
+}
+.battle-progress {
+  position: fixed;
+  width: 60%;
+  left: 20%;
+  display: flex;
+  justify-content: center;
+}
+.user-header {
+  display: flex;
+  align-items: center;
+  justify-content: flex-start;
+}
+.user-header > image:first-child {
+  width: 40px;
+  height: 40px;
+  border-radius: 50%;
+  border: 2rpx solid #333;
+}
+.user-header > image:last-child {
+  width: 36rpx;
+  height: 36rpx;
+}
+.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 {
+  position: fixed;
+  /* 兜底定位（JS 获取胶囊位置失败时生效）：约 28vw 对应胶囊区域左边缘 */
+  right: calc(28vw + 4px);
+  top: 8px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 240rpx;
+  height: 64rpx;
+  background: rgba(0, 0, 0, 0.15);
+  border-radius: 96rpx;
+  border: 1rpx solid #5b5758;
+  padding: 0;
+}
+/* 重置 button 默认边框 */
+.battle-room-number::after {
+  border: none;
+}
+.battle-room-number__text {
+  width: 156rpx;
+  height: 28rpx;
+  font-weight: 400;
+  font-size: 24rpx;
+  color: #ffffff;
+  text-align: center;
+  line-height: 28rpx;
+}
+.battle-room-number__icon {
+  width: 25rpx;
+  height: 26rpx;
+}
+</style>

src/components/HeaderProgress.vue

@@ -0,0 +1,174 @@
+<script setup>
+import { formatBattleTip } from "@/locales";
+import { ref, watch, onMounted, onBeforeUnmount } from "vue";
+import audioManager from "@/audioManager";
+import { MESSAGETYPESV2 } from "@/constants";
+import {
+  getDirectionText,
+  getInvalidShotAudioKey,
+  getInvalidShotText,
+} from "@/util";
+
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+const store = useStore();
+const { user } = storeToRefs(store);
+
+const tips = ref("");
+const melee = ref(false);
+const timer = ref(null);
+const sound = ref(true);
+const currentRound = ref(0);
+const currentRoundEnded = ref(false);
+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 (currentRoundEnded.value) {
+      // 播放当前轮次语音
+      key.push(`第${["一", "二", "三", "四", "五"][currentRound.value]}轮`);
+    }
+    key.push(
+      newVal.includes("你")
+        ? "轮到你了"
+        : newVal.includes("红队")
+          ? "请红方射箭"
+          : "请蓝方射箭"
+    );
+    audioManager.play(key, false);
+    currentRoundEnded.value = false;
+  }
+);
+
+const updateSound = () => {
+  sound.value = !sound.value;
+  audioManager.setMuted(!sound.value);
+};
+
+async function onReceiveMessage(message) {
+  if (ended.value) return;
+  if (Array.isArray(message)) return;
+  const { type, mode, current, shootData } = message;
+  if (type === MESSAGETYPESV2.BattleStart) {
+    melee.value = Boolean(mode > 3);
+    // 优先使用后端返回的 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;
+    // 从 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(
+        shootData.ring
+          ? `${shootData.ringX ? "X" : shootData.ring}环`
+          : "未上靶"
+      );
+      if (shootData.angle !== null)
+        key.push(`向${getDirectionText(shootData.angle)}调整`);
+      audioManager.play(key, false);
+    }
+  } else if (type === MESSAGETYPESV2.NewRound) {
+    currentShot.value = 0;
+    currentRound.value = current.round;
+    currentRoundEnded.value = true;
+  } else if (type === MESSAGETYPESV2.InvalidShot) {
+    uni.showToast({
+      title: getInvalidShotText(shootData),
+      icon: "none",
+    });
+    audioManager.play(getInvalidShotAudioKey(shootData));
+  }
+}
+
+const playSound = (key) => {
+  audioManager.play(key);
+};
+
+const onUpdateTips = (newVal) => {
+  tips.value = newVal;
+};
+
+// 监听 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(() => {
+  isMounted.value = true;
+  uni.$on("update-tips", onUpdateTips);
+  uni.$on("socket-inbox", onReceiveMessage);
+  uni.$on("play-sound", playSound);
+});
+
+onBeforeUnmount(() => {
+  uni.$off("socket-inbox", onReceiveMessage);
+  uni.$off("play-sound", playSound);
+  // 补充取消 update-tips 监听，防止页面重建时监听器叠加
+  uni.$off("update-tips", onUpdateTips);
+  if (timer.value) clearInterval(timer.value);
+});
+</script>
+
+<template>
+  <view class="container">
+    <text>{{ formatBattleTip(tips) }}</text>
+    <text v-if="totalShot > 0"> ({{ currentShot }}/{{ totalShot }}) </text>
+    <button v-if="!!tips" hover-class="none" @click="updateSound">
+      <image :src="`https://static.shelingxingqiu.com/shootmini/static/sound${sound ? '' : '-off'}-yellow.png`" mode="widthFix" />
+    </button>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  width: 50vw;
+  color: #fed847;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-weight: 500;
+}
+
+.container>button:last-child {
+  width: 36px;
+  height: 36px;
+}
+
+.container>button:last-child>image {
+  width: 36px;
+  min-height: 36px;
+}
+</style>

src/components/IconButton.vue

@@ -0,0 +1,39 @@
+<script setup>
+const props = defineProps({
+  name: {
+    type: String,
+    default: "",
+  },
+  src: {
+    type: String,
+    default: "",
+  },
+  onClick: {
+    type: Function,
+    default: () => {},
+  },
+  width: {
+    type: Number,
+    default: 22,
+  },
+});
+</script>
+<template>
+  <view class="container" @click="onClick">
+    <image :src="src" mode="widthFix" :style="{ width: width + 'px' }" />
+    <text>{{ name }}</text>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+.container > text {
+  color: #666666;
+  font-size: 12px;
+  margin-top: 5px;
+}
+</style>

src/components/InputEntry.vue

@@ -1,47 +0,0 @@
-<script setup>
-import { ref } from "vue";
-
-const name = ref("");
-const show = ref(false);
-
-function handleClick() {
-  show.value = true;
-  setTimeout(() => {
-    show.value = false;
-  }, 3000);
-}
-</script>
-
-<template>
-  <view>
-    <view class="input-box">
-      <input v-model="name" placeholder="What's your name?" />
-    </view>
-    <view>
-      <button :disabled="!name" @click="handleClick">Hello</button>
-    </view>
-
-    <view v-show="show" class="popup">
-      <text class="popup_label"> Hello{{ `  ${name}` }} 👏 </text>
-    </view>
-  </view>
-</template>
-
-<style scoped lang="scss">
-.input-box {
-  margin: 1rem;
-  padding: 0.5rem;
-  border-bottom: 1px solid gray;
-}
-.popup {
-  position: fixed;
-  top: 2rem;
-  left: 0px;
-  right: 0px;
-  .popup_label {
-    padding: 0.5rem 2rem;
-    background: gray;
-    border-radius: 8px;
-  }
-}
-</style>

src/components/Matching.vue

@@ -0,0 +1,177 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref, onMounted, onBeforeUnmount, watch } from "vue";
+const props = defineProps({
+  stopMatch: {
+    type: Function,
+    default: () => {},
+  },
+  onComplete: {
+    type: Function,
+    default: null,
+  },
+});
+const playerNames = [
+  t('yuezheng_qingshan'),
+  t('yuwen_yulan'),
+  t('cen_siyu'),
+  t('wu_ziyu'),
+  t('fan_zijin'),
+  t('a_worthy_opponent'),
+  t('le_zirui'),
+  t('shi_chunxiao'),
+  t('bai_guhong'),
+  t('donggong_jinse'),
+  t('duangan_liuyun'),
+];
+const textStyles = [
+  {
+    color: "#fff9",
+    fontSize: "18px",
+  },
+  {
+    color: "#fff",
+    fontSize: "22px",
+  },
+  {
+    color: "#fed847",
+    fontSize: "30px",
+  },
+];
+
+const rowHeight = 100 / 7;
+const totalHeight = (playerNames.length / 7) * 100 + 7;
+
+const currentTop = ref(-totalHeight + rowHeight * 0);
+const timer = ref(null);
+
+const getTextStyle = (top, index) => {
+  const count = Math.floor(
+    ((totalHeight + (top + rowHeight / 3)) / rowHeight).toFixed(1)
+  );
+  if (index === 12 - count) return textStyles[0];
+  else if (index === 13 - count) return textStyles[1];
+  else if (index === 14 - count) return textStyles[2];
+  else if (index === 15 - count) return textStyles[1];
+  else if (index === 16 - count) return textStyles[0];
+  return {
+    color: "#fff6",
+    fontSize: "14px",
+  };
+};
+watch(
+  () => props.onComplete,
+  (newVal) => {
+    if (timer.value) {
+      clearInterval(timer.value);
+      timer.value = null;
+    }
+    timer.value = setInterval(() => {
+      const count = Math.round(
+        (
+          (totalHeight + (currentTop.value + rowHeight / 3)) /
+          rowHeight
+        ).toFixed(1)
+      );
+      if (count === 10) {
+        clearInterval(timer.value);
+        timer.value = null;
+        setTimeout(newVal, 1500);
+        return;
+      }
+      // 这里不重置，如果运行超13秒，就不会循环了
+      if (currentTop.value >= -4) {
+        currentTop.value = -totalHeight;
+      } else {
+        currentTop.value += 2;
+      }
+    }, 40);
+  }
+);
+onMounted(() => {
+  timer.value = setInterval(() => {
+    if (currentTop.value >= -4) {
+      currentTop.value = -totalHeight;
+    } else {
+      currentTop.value += 2;
+    }
+  }, 40);
+});
+onBeforeUnmount(() => {
+  if (timer.value) clearInterval(timer.value);
+  timer.value = null;
+});
+</script>
+
+<template>
+  <view class="matching">
+    <image
+      src="https://static.shelingxingqiu.com/shootmini/static/matching-bg.png"
+      mode="widthFix"
+      class="matching-bg"
+    />
+    <view>
+      <view class="player-names" :style="{ top: `${currentTop}%` }">
+        <text
+          v-for="(name, index) in [...playerNames, ...playerNames]"
+          :key="index"
+          :style="{
+            lineHeight: `${rowHeight}vw`,
+            ...getTextStyle(currentTop, index),
+          }"
+        >
+          {{ name }}
+        </text>
+      </view>
+    </view>
+    <button hover-class="none" @click="$clickSound(stopMatch)">{{ t('cancel_matchmaking') }}</button>
+  </view>
+</template>
+
+<style scoped>
+.matching {
+  width: 100%;
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  position: relative;
+}
+.matching > view {
+  width: 70vw;
+  height: 95vw;
+  overflow: hidden;
+  position: absolute;
+  top: 30vw;
+}
+.matching-bg {
+  position: absolute;
+  width: 70vw;
+  height: 102vw;
+  top: 27vw;
+}
+.matching > button {
+  width: 55%;
+  padding: 18px;
+  color: #000;
+  background-color: #fed847;
+  font-size: 18px;
+  border-radius: 30px;
+  position: absolute;
+  top: 142vw;
+}
+.player-names {
+  width: 100%;
+  display: flex;
+  flex-direction: column;
+  position: absolute;
+  top: 0;
+}
+.player-names > text {
+  width: 100%;
+  text-align: center;
+  transition: all 0.3s ease;
+}
+</style>

src/components/ModalDialog.vue

@@ -0,0 +1,285 @@
+<script setup>
+import { t } from "@/locales";
+
+import IconButton from "./IconButton.vue";
+
+const props = defineProps({
+  show: {
+    type: Boolean,
+    default: false,
+  },
+  title: {
+    type: String,
+    default: "",
+  },
+  content: {
+    type: String,
+    default: "",
+  },
+  cancelText: {
+    type: String,
+    default: t('cancel_133'),
+  },
+  confirmText: {
+    type: String,
+    default: t('confirm_134'),
+  },
+  showCancel: {
+    type: Boolean,
+    default: true,
+  },
+  showConfirm: {
+    type: Boolean,
+    default: true,
+  },
+  confirmDisabled: {
+    type: Boolean,
+    default: false,
+  },
+  showClose: {
+    type: Boolean,
+    default: false,
+  },
+  onCancel: {
+    type: Function,
+    default: null,
+  },
+  onConfirm: {
+    type: Function,
+    default: null,
+  },
+  onClose: {
+    type: Function,
+    default: null,
+  },
+});
+
+const handleCancel = () => {
+  props.onCancel?.();
+};
+
+const handleConfirm = () => {
+  if (props.confirmDisabled) return;
+  props.onConfirm?.();
+};
+
+const handleClose = () => {
+  props.onClose?.();
+};
+</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"
+            :class="{ disabled: confirmDisabled }"
+            @click="handleConfirm"
+          >
+            <text>{{ confirmText }}</text>
+          </view>
+          
+        </view>
+      </view>
+      <view v-if="showClose" class="dialog-close">
+        <IconButton
+          src="https://static.shelingxingqiu.com/shootmini/static/close-gold-outline.png"
+          :width="30"
+          :onClick="handleClose"
+        />
+      </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);
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  z-index: 999;
+}
+
+.modal-wrap {
+  position: relative;
+  display: flex;
+  flex-direction: column;
+  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 {
+  max-height: 45vh;
+  overflow-y: auto;
+  overflow-wrap: break-word;
+  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 {
+  width: 100%;
+  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-actions.single .dialog-button {
+  flex: 0 1 232rpx;
+}
+
+.dialog-button {
+  display: flex;
+  flex: 1;
+  min-width: 0;
+  min-height: 70rpx;
+  padding: 12rpx 20rpx;
+  box-sizing: border-box;
+  line-height: 1.3;
+  text-align: center;
+  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;
+}
+
+.dialog-button.confirm.disabled {
+  opacity: 0.62;
+}
+
+.dialog-close {
+  margin-top: 28rpx;
+}
+
+@keyframes rotateLight {
+  from {
+    transform: translateX(-50%) rotate(0deg);
+  }
+
+  to {
+    transform: translateX(-50%) rotate(360deg);
+  }
+}
+</style>

src/components/OtaModal.vue

@@ -0,0 +1,460 @@
+<script setup>
+import { t } from "@/locales";
+
+import { computed } from "vue";
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+
+const OTA_OFFLINE_TEXT = t('please_turn_on_your_smart_bow_first');
+const store = useStore();
+const { deviceStatus } = storeToRefs(store);
+
+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,
+  },
+  phase: {
+    type: String,
+    default: "",
+  },
+  // 副标题：如“新版本将优化智能弓体验”
+  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 progressPhaseText = computed(() => {
+  const phaseText = {
+    started: t('preparing_firmware_update'),
+    downloading: t('downloading_firmware'),
+    installing: t('installing_firmware'),
+  };
+  return phaseText[props.phase] || t('updating_firmware');
+});
+
+// 点击立即更新前先校验设备在线状态。
+const handleUpdateClick = () => {
+  if (deviceStatus.value?.online !== true) {
+    uni.showToast({
+      title: OTA_OFFLINE_TEXT,
+      icon: "none",
+    });
+    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">{{ t('update_now') }}</text>
+              </view>
+              <text v-if="!forceUpdate" class="skip-text" @click="emit('skip')">{{ t('later') }}</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">{{ t('firmware_update_complete') }}</text>
+            <view class="btn-group-result">
+              <view class="primary-btn" @click="emit('done')">
+                <text class="primary-btn-text">{{ t('close') }}</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-meta">
+                <text class="progress-phase">{{ progressPhaseText }}</text>
+                <text class="progress-value">{{ Math.floor(progressValue) }}%</text>
+              </view>
+              <view class="progress-track">
+                <view class="progress-fill" :style="{ width: `${progressValue}%` }"></view>
+              </view>
+              <text class="progress-warning">{{ t('please_stay_on_this_page') }}</text>
+            </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">{{ t('please_make_sure') }}</text>
+            <text class="dialog-desc">{{ t('1_your_smart_bow_is_on') }}</text>
+            <text class="dialog-desc">{{ t('2_your_network_connection_is_stable') }}</text>
+            <view class="btn-group-result">
+              <view class="primary-btn" @click="emit('retry')">
+                <text class="primary-btn-text">{{ t('retry') }}</text>
+              </view>
+            </view>
+          </block>
+
+        </view>
+      </view>
+    </view>
+
+    <!-- 关闭按钮（仅新版本状态，非强制更新时，位于弹窗下方） -->
+    <view
+      v-if="(isNewVersion || isFailure) && !forceUpdate"
+      class="ota-close-below"
+      @click="emit('close')"
+    >
+      <image src="https://static.shelingxingqiu.com/shootmini/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: 28rpx;
+  margin-left: 44rpx;
+}
+.progress-meta {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  margin-bottom: 16rpx;
+  color: #ffffff;
+  font-size: 24rpx;
+  line-height: 34rpx;
+}
+.progress-phase {
+  flex: 1;
+}
+.progress-value {
+  flex-shrink: 0;
+  margin-left: 16rpx;
+  color: #fed847;
+}
+.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;
+}
+.progress-warning {
+  display: block;
+  margin-top: 16rpx;
+  color: rgba(255, 255, 255, 0.88);
+  font-size: 22rpx;
+  line-height: 32rpx;
+  text-align: center;
+}
+
+/* 关闭按钮（位于弹窗下方） */
+.ota-close-below {
+  margin-top: 40rpx;
+  display: flex;
+  justify-content: center;
+}
+</style>

src/components/PlayerScore.vue

@@ -0,0 +1,147 @@
+<script setup>
+import { t } from "@/locales";
+
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+const { user } = storeToRefs(useStore());
+
+const props = defineProps({
+  player: {
+    type: Object,
+    default: () => ({}),
+  },
+  scores: {
+    type: Array,
+    default: () => [],
+  },
+});
+
+const rowCount = new Array(6).fill(0);
+
+const getRingText = (arrow) => {
+  if (!arrow) return "-";
+  if (arrow.ringX && arrow.ring) return t('x');
+  return t('value_pts', { p0: 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>
+  <view
+    class="container"
+    :style="{ borderColor: player.id === user.id ? '#FED847' : '#fff3' }"
+  >
+    <image
+      :style="{
+        opacity:
+          (scores[0] || []).length + (scores[1] || []).length === 12 ? 1 : 0,
+      }"
+      src="https://static.shelingxingqiu.com/shootmini/static/checked-green.png"
+      mode="widthFix"
+    />
+    <image :src="player.avatar || 'https://static.shelingxingqiu.com/shootmini/static/user-icon.png'" mode="widthFix" />
+    <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>{{ getRingText(scores[0]?.[index]) }}</text>
+        </view>
+      </view>
+      <view>
+        <view v-for="(_, index) in rowCount" :key="index">
+          <text>{{ getRingText(scores[1]?.[index]) }}</text>
+        </view>
+      </view>
+    </view>
+    <text
+      >{{
+        scores
+          .map((s) => (s || []).reduce((last, next) => last + next.ring, 0))
+          .reduce((last, next) => last + next, 0)
+      }}{{ t('pts') }}</text
+    >
+  </view>
+</template>
+
+<style scoped>
+.container {
+  width: calc(100% - 70px);
+  display: flex;
+  align-items: center;
+  border: 1px solid #fff3;
+  margin: 10px 0;
+  margin-left: 35px;
+  border-radius: 15px;
+  padding: 10px;
+  color: #fff9;
+  font-size: 14px;
+  position: relative;
+}
+.container > image:nth-child(1) {
+  position: absolute;
+  width: 15px;
+  height: 15px;
+  top: 30%;
+  left: 0;
+}
+.container > image:nth-child(2) {
+  width: 30px;
+  height: 30px;
+  min-height: 30px;
+  border: 1px solid #fff;
+  border-radius: 50%;
+  margin-right: 10px;
+  margin-left: -30px;
+  flex: 0 0 auto;
+}
+.container > text:nth-child(3) {
+  font-size: 14px;
+  white-space: nowrap;
+  overflow: hidden;
+  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;
+}
+.container > view:nth-child(4) > view {
+  display: flex;
+  padding: 5px 0;
+}
+.container > view:nth-child(4) > view text {
+  width: 34px;
+  text-align: center;
+  display: block;
+}
+.container > view:nth-child(4) > view:first-child {
+  border-bottom: 1px solid #fff3;
+}
+.container > text:nth-child(5) {
+  width: 40px;
+  text-align: right;
+  word-break: keep-all;
+}
+</style>

src/components/PlayerScore2.vue

@@ -0,0 +1,156 @@
+<script setup>
+import { t } from "@/locales";
+
+import { topThreeColors } from "@/constants";
+defineProps({
+  avatar: {
+    type: String,
+    default: "",
+  },
+  name: {
+    type: String,
+    default: "",
+  },
+  arrows: {
+    type: Array,
+    default: () => [],
+  },
+  rank: {
+    type: Number,
+    default: 0,
+  },
+  totalScore: {
+    type: Number,
+    default: 0,
+  },
+});
+const rowCount = new Array(6).fill(0);
+</script>
+
+<template>
+  <view class="container">
+    <view>
+      <image
+        v-if="rank === 1"
+        src="https://static.shelingxingqiu.com/shootmini/static/champ1.png"
+        mode="widthFix"
+        class="avatar-rank"
+      />
+      <image
+        v-if="rank === 2"
+        src="https://static.shelingxingqiu.com/shootmini/static/champ2.png"
+        mode="widthFix"
+        class="avatar-rank"
+      />
+      <image
+        v-if="rank === 3"
+        src="https://static.shelingxingqiu.com/shootmini/static/champ3.png"
+        mode="widthFix"
+        class="avatar-rank"
+      />
+      <view v-if="rank > 3" class="rank-view">{{ rank }}</view>
+      <image
+        :src="avatar || 'https://static.shelingxingqiu.com/shootmini/static/user-icon.png'"
+        mode="widthFix"
+        :style="{ borderColor: topThreeColors[rank - 1] || '#fff' }"
+      />
+    </view>
+    <view>
+      <view>
+        <view v-for="(_, index) in rowCount" :key="index">
+          <text>{{ arrows[index] ? t('value_pts', { p0: arrows[index].ring }) : "-" }}</text>
+        </view>
+      </view>
+      <view>
+        <view v-for="(_, index) in rowCount" :key="index">
+          <text>{{
+            arrows[index + 6] ? t('value_pts', { p0: arrows[index + 6].ring }) : "-"
+          }}</text>
+        </view>
+      </view>
+    </view>
+    <view>
+      <text>{{ arrows.reduce((last, next) => last + next.ring, 0) }}{{ t('pts') }}</text>
+      <text>{{ t('points') }}{{ totalScore }}</text>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  width: calc(100% - 65px);
+  display: flex;
+  align-items: center;
+  border: 1px solid #fff3;
+  margin: 10px 0;
+  margin-left: 30px;
+  border-radius: 15px;
+  padding: 10px;
+  color: #fff9;
+  font-size: 28rpx;
+  position: relative;
+}
+.container > view:first-child {
+  position: absolute;
+  width: 30px;
+  height: 30px;
+  top: 30%;
+  left: -17px;
+}
+.container > view:first-child > image:last-child {
+  width: 30px;
+  max-height: 30px;
+  min-height: 30px;
+  border-radius: 50%;
+  border: 1px solid #fff;
+}
+.avatar-rank,
+.rank-view {
+  position: absolute;
+  width: 16px;
+  height: 17px;
+  top: -9px;
+  right: 5px;
+}
+.rank-view {
+  background-color: #6d6d6d;
+  text-align: center;
+  line-height: 15px;
+  font-size: 10px;
+  border-radius: 50%;
+  color: #fff;
+}
+.container > view:nth-child(2) {
+  display: flex;
+  flex-direction: column;
+  margin-left: 15px;
+  border-right: 1px solid #fff3;
+  padding-right: 10px;
+}
+.container > view:nth-child(2) > view {
+  display: flex;
+}
+.container > view:nth-child(2) > view text {
+  width: 36px;
+  text-align: center;
+  display: block;
+}
+.container > view:nth-child(2) > view:first-child {
+  border-bottom: 1px solid #fff3;
+  padding-bottom: 10px;
+}
+.container > view:nth-child(2) > view:last-child {
+  padding-top: 10px;
+}
+.container > view:nth-child(3) {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  padding-left: 10px;
+  width: 100%;
+}
+.container > view:nth-child(3) > text {
+  text-align: center;
+  margin: 5px 0;
+}
+</style>

src/components/PlayerSeats.vue

@@ -0,0 +1,190 @@
+<script setup>
+import { t } from "@/locales";
+
+import Avatar from "@/components/Avatar.vue";
+
+const props = defineProps({
+  total: {
+    type: Number,
+    default: 10,
+  },
+  players: {
+    type: Array,
+    default: () => [],
+  },
+  removePlayer: {
+    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="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 || 'https://static.shelingxingqiu.com/shootmini/static/user-icon.png'"
+          :size="40"
+        />
+        <text
+          :style="{ opacity: players[index] && !!players[index].state ? 1 : 0 }"
+          >{{ t('ready') }}</text
+        >
+      </view>
+      <view v-else class="player-unknow">
+        <image src="https://static.shelingxingqiu.com/shootmini/static/question-mark.png" mode="widthFix" />
+      </view>
+      <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' }">{{ t('waiting_for_a_player') }}</text>
+      <view v-if="index === 0" class="founder">{{ t('host') }}</view>
+      <!-- <image
+        :src="`https://static.shelingxingqiu.com/shootmini/static/player-${index + 1}.png`"
+        mode="widthFix"
+        class="player-bg"
+      /> -->
+      <!-- 仅房主（isOwner=true）且非空座位时展示踢人按钮 -->
+      <button
+        v-if="index > 0 && players[index] && isOwner"
+        hover-class="none"
+        class="remove-player"
+        @click="() => removePlayer(players[index])"
+      >
+        <image src="https://static.shelingxingqiu.com/shootmini/static/close-white.png" mode="widthFix" />
+      </button>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.players {
+  display: grid;
+  grid-template-columns: repeat(2, 1fr);
+  row-gap: 20rpx;
+  column-gap: 25rpx;
+  margin-bottom: 20px;
+  font-size: 14px;
+  padding: 0 14px;
+}
+.players > view {
+  display: flex;
+  align-items: center;
+  position: relative;
+  color: #fff;
+  height: 176rpx;
+  overflow: hidden;
+}
+.players > view > image:first-child {
+  width: 100%;
+  height: 100%;
+  position: absolute;
+  z-index: -1;
+  top: 0;
+}
+.avatar {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  padding: 0 24rpx;
+  margin-top: 16rpx;
+}
+.avatar > text {
+  background-color: #2c261fb3;
+  border: 1rpx solid #a3793f66;
+  color: #fed847;
+  font-size: 16rpx;
+  border-radius: 20rpx;
+  width: 70rpx;
+  text-align: center;
+  margin-top: -16rpx;
+  position: relative;
+  height: 28rpx;
+  line-height: 28rpx;
+}
+.player-seat-name {
+  width: 20vw;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.founder {
+  position: absolute;
+  background-color: #fed847;
+  top: 0;
+  left: 0;
+  color: #000;
+  font-size: 10px;
+  padding: 2px 5px;
+  border-top-left-radius: 10px;
+  border-bottom-right-radius: 10px;
+}
+/* .player-bg {
+  position: absolute;
+  width: 52px;
+  right: 0;
+} */
+.player-unknow {
+  width: 84rpx;
+  height: 84rpx;
+  margin: 0 24rpx;
+  border: 1rpx solid #fff3;
+  border-radius: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background-color: #69686866;
+  box-sizing: border-box;
+}
+.player-unknow > image {
+  width: 40%;
+}
+.remove-player {
+  width: 48rpx;
+  height: 48rpx;
+  border-radius: 50%;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  position: absolute;
+  top: 10rpx;
+  right: 0;
+}
+.remove-player > image {
+  width: 100%;
+  height: 100%;
+  opacity: 0.6;
+}
+</style>

src/components/PointRankItem.vue

@@ -0,0 +1,184 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref, watch } from "vue";
+import Avatar from "@/components/Avatar.vue";
+
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+const { user, device, online } = storeToRefs(useStore());
+
+import { clickLikeAPI } from "@/apis";
+
+const props = defineProps({
+  data: {
+    type: Object,
+    default: () => {},
+  },
+  borderWidth: {
+    type: Number,
+    default: 1,
+  },
+});
+
+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) => {
+    like.value = newVal.ifLike;
+    likeCount.value = newVal.likeTotal || 0;
+  }
+);
+
+const onClick = async () => {
+  if (!user.value.id) return;
+  if (user.value.id === props.data.id) {
+    return uni.navigateTo({
+      url: "/pages/my-like-list",
+    });
+  }
+  like.value = !like.value;
+  await clickLikeAPI(props.data.id, like.value);
+  if (like.value) likeCount.value++;
+  else likeCount.value--;
+};
+</script>
+
+<template>
+  <view class="rank-item" :style="{ borderWidth: borderWidth + 'rpx' }">
+    <image v-if="data.rank === 1" src="https://static.shelingxingqiu.com/shootmini/static/point-no1.png" />
+    <image v-else-if="data.rank === 2" src="https://static.shelingxingqiu.com/shootmini/static/point-no2.png" />
+    <image v-else-if="data.rank === 3" src="https://static.shelingxingqiu.com/shootmini/static/point-no3.png" />
+    <text v-else>{{ data.rank || "" }}</text>
+    <view>
+      <Avatar :src="data.avatar || 'https://static.shelingxingqiu.com/shootmini/static/user-icon.png'" :size="36" />
+      <view>
+        <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 }}{{ t('days') }}</text>
+          <view />
+          <text>{{ t('average') }}{{ Number(data.averageRing.toFixed(1)) }}{{ t('pts') }}</text>
+        </view>
+      </view>
+    </view>
+    <view class="item-info">
+      <text>{{ data.weekArrow }}</text>
+      <text>{{ t('arrows') }}</text>
+    </view>
+    <view class="item-info">
+      <text>{{ Math.round(data.weekArrow * 1.6) }}</text>
+      <text>{{ t('kcal') }}</text>
+    </view>
+    <button hover-class="none" @click="onClick">
+      <text>{{ likeCount }}</text>
+      <image
+        :src="`https://static.shelingxingqiu.com/shootmini/static/like-${like ? 'on' : 'off'}.png`"
+        mode="widthFix"
+      />
+    </button>
+  </view>
+</template>
+
+<style scoped lang="scss">
+.rank-item {
+  margin: 0 20rpx;
+  border-bottom: $uni-border;
+  display: flex;
+  align-items: center;
+  background: $uni-white;
+  height: 120rpx;
+}
+.rank-item > text:nth-child(1) {
+  width: 52rpx;
+  font-size: 28rpx;
+  color: #333333;
+  text-align: center;
+}
+.rank-item > image:nth-child(1) {
+  width: 52rpx;
+  height: 56rpx;
+}
+.rank-item > view:nth-child(2) {
+  flex: 1;
+  display: flex;
+  align-items: center;
+  margin-left: 20rpx;
+}
+.rank-item > view:nth-child(2) > view:last-child {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  font-size: 22rpx;
+  color: #aaaaaa;
+  margin-left: 20rpx;
+}
+.rank-item > view:nth-child(2) > view:last-child > text:first-child {
+  width: 200rpx;
+  font-size: 28rpx;
+  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;
+}
+.rank-item > view:nth-child(2) > view:last-child > view > view {
+  height: 20rpx;
+  width: 1rpx;
+  margin: 0 10rpx;
+  background-color: #b3b3b3;
+}
+.item-info {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  font-size: 20rpx;
+  color: #777777;
+  width: 20%;
+}
+.item-info > text:first-child {
+  font-size: 28rpx;
+  color: #333333;
+  margin-right: 5rpx;
+}
+.rank-item > button:nth-child(5) {
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  font-size: 22rpx;
+  color: #777777;
+  padding-left: 20rpx;
+  padding-right: 10rpx;
+}
+.rank-item > button:nth-child(5) > image {
+  width: 24rpx;
+  height: 22rpx;
+  margin-top: 10rpx;
+}
+</style>

src/components/PointRecord.vue

@@ -0,0 +1,154 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref, onMounted, computed } from "vue";
+
+const props = defineProps({
+  data: {
+    type: Object,
+    default: () => {},
+  },
+});
+const bowOptions = ref({});
+const targetOptions = ref({});
+
+const toDetailPage = () => {
+  const config = uni.getStorageSync("point-book-config");
+  const bowType = config.bowOption.find(
+    (item) => item.id === props.data.bowType
+  );
+  const bowtargetType = config.targetOption.find(
+    (item) => item.id === props.data.targetType
+  );
+  uni.setStorageSync("point-book", {
+    bowType,
+    bowtargetType,
+    distance: props.data.distance,
+    amountGroup: props.data.groups,
+  });
+  uni.navigateTo({
+    url: `/pages/point-book-detail?id=${props.data.id}`,
+  });
+};
+
+onMounted(() => {
+  const result = uni.getStorageSync("point-book-config");
+  (result.bowOption || []).forEach((item) => {
+    bowOptions.value[item.id] = item;
+  });
+  (result.targetOption || []).forEach((item) => {
+    targetOptions.value[item.id] = item;
+  });
+});
+</script>
+
+<template>
+  <view class="container" @click="toDetailPage">
+    <view class="left-part">
+      <view class="labels">
+        <view></view>
+        <text>{{
+          bowOptions[data.bowType] ? bowOptions[data.bowType].name : ""
+        }}</text>
+        <text>{{ data.distance }}{{ t('m') }}</text>
+        <text>{{
+          targetOptions[data.targetType]
+            ? targetOptions[data.targetType].name
+            : ""
+        }}</text>
+      </view>
+      <view>
+        <text>{{ data.createAt }}</text>
+      </view>
+      <view>
+        <text>{{ t('gold_hit_rate_156') }}{{ Number((data.yellowRate * 100).toFixed(2)) }}%</text>
+        <text>{{ t('10s_157') }}{{ data.tenRings }}</text>
+        <text>{{ t('average_158') }}{{ data.averageRing }}</text>
+      </view>
+    </view>
+    <view class="right-part">
+      <image src="https://static.shelingxingqiu.com/shootmini/static/bow-target.png" mode="widthFix" />
+      <view class="arrow-amount">
+        <text>{{ data.actualTotalRing }}</text>
+        <text>/</text>
+        <text>{{ data.totalRing }}</text>
+      </view>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  background-color: #fff;
+  display: flex;
+  align-items: center;
+  border-radius: 25rpx;
+  height: 200rpx;
+  border: 2rpx solid #fed848;
+  padding-left: 30rpx;
+  padding-right: 10rpx;
+}
+.container > view {
+  position: relative;
+}
+.left-part {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  justify-content: space-between;
+  height: calc(100% - 50rpx);
+  color: #333333;
+}
+.left-part > view {
+  width: 100%;
+  display: flex;
+  position: relative;
+}
+.left-part > view:nth-child(3) {
+  display: flex;
+  align-items: center;
+  font-size: 20rpx;
+  color: #666;
+}
+.left-part > view:nth-child(3) > text {
+  margin-right: 10rpx;
+}
+.right-part > image {
+  width: 180rpx;
+  height: 180rpx;
+}
+.labels {
+  align-items: flex-end !important;
+}
+.labels > view:first-child {
+  position: absolute;
+  bottom: 0;
+  height: 10rpx;
+  background: #fee947;
+  border-radius: 5rpx;
+  width: 300rpx;
+}
+.labels > text {
+  font-size: 26rpx;
+  margin-right: 10px;
+  position: relative;
+  color: #333;
+}
+.arrow-amount {
+  position: absolute;
+  background-color: #0009;
+  border-radius: 12px;
+  color: #fffc;
+  font-size: 24rpx;
+  line-height: 26px;
+  width: 64px;
+  display: flex;
+  justify-content: center;
+  top: calc(50% - 15px);
+  left: calc(50% - 32px);
+}
+.arrow-amount > text:nth-child(1) {
+  font-size: 30rpx;
+  color: #fff;
+}
+</style>

src/components/PointSwitcher.vue

@@ -0,0 +1,73 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref } from "vue";
+
+const props = defineProps({
+  onChange: {
+    type: Function,
+    default: () => {},
+  },
+});
+
+const mode = ref(true);
+
+const onClick = () => {
+  mode.value = !mode.value;
+  props.onChange(mode.value);
+};
+</script>
+
+<template>
+  <view
+    class="point-switcher"
+    :style="{ borderColor: mode ? '#D8D8D8' : '#53EF56' }"
+  >
+    <view
+      @click="onClick"
+      :style="{ transform: 'translateX(' + (mode ? '-58' : '4') + 'rpx)' }"
+    >
+      <text>{{ t('zoom') }}</text>
+      <view :style="{ background: mode ? '#D8D8D8' : '#53EF56' }"></view>
+      <text>{{ t('actual_size') }}</text>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.point-switcher {
+  width: 100rpx;
+  height: 40rpx;
+  border-radius: 22rpx;
+  border: 2rpx solid;
+  display: flex;
+  overflow: hidden;
+}
+.point-switcher > view {
+  position: relative;
+  display: flex;
+  align-items: center;
+  line-height: 40rpx;
+  color: #ffffff;
+  font-weight: 500;
+  font-size: 20rpx;
+  word-break: keep-all;
+  padding: 0 12rpx;
+  transition: all 0.3s ease;
+  transform: translateX(-58rpx);
+}
+.point-switcher > view > text:first-child {
+  color: #53ef56;
+}
+.point-switcher > view > view {
+  width: 36rpx;
+  height: 36rpx;
+  flex: 0 0 auto;
+  border-radius: 50%;
+  margin: 0 10rpx;
+  transition: all 0.3s ease;
+}
+.point-switcher > view > text:last-child {
+  color: #d8d8d8;
+}
+</style>

src/components/RewardUs.vue

@@ -0,0 +1,248 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref, reactive, watch, onMounted } from "vue";
+import { getAppConfig, donateAPI } from "@/apis";
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+const store = useStore();
+const { config } = storeToRefs(store);
+const { updateConfig } = store;
+
+const props = defineProps({
+  show: {
+    type: Boolean,
+    default: false,
+  },
+  onClose: {
+    type: Function,
+    default: null,
+  },
+});
+const amounts = ref([]);
+const selected = ref(null);
+const checked = ref(false);
+
+const formData = reactive({
+  name: "",
+  account: "",
+  organization: "",
+  suggestion: "",
+});
+
+const onPay = async (index) => {
+  selected.value = index;
+  const result = await donateAPI(
+    amounts.value[index],
+    formData.name,
+    formData.account,
+    formData.organization,
+    formData.suggestion
+  );
+  const params = result.order.jsApi.params;
+  if (params) {
+    wx.requestPayment({
+      timeStamp: params.timeStamp,
+      nonceStr: params.nonceStr,
+      package: params.package,
+      paySign: params.paySign,
+      signType: "RSA",
+      async success(res) {
+        uni.showToast({
+          title: t('thank_you_for_your_support'),
+          icon: "none",
+        });
+        props.onClose();
+      },
+      fail(res) {
+        console.log("pay error", res);
+        uni.showToast({
+          title: t('payment_canceled'),
+          icon: "none",
+        });
+        props.onClose();
+      },
+    });
+  }
+};
+
+watch(
+  () => config.value.donateAmount,
+  (value) => {
+    amounts.value = value || [];
+  },
+  { immediate: true }
+);
+
+watch(
+  () => props.show,
+  () => {
+    selected.value = null;
+    formData.name = "";
+    formData.account = "";
+    formData.organization = "";
+    formData.suggestion = "";
+  }
+);
+
+onMounted(async () => {
+  if (!config.value.donateAmount) {
+    const config = await getAppConfig();
+    updateConfig(config);
+  }
+});
+</script>
+
+<template>
+  <view class="container">
+    <image src="https://static.shelingxingqiu.com/shootmini/static/donate.png" mode="widthFix" />
+    <text>{{ t('thank_you_for_supporting_our_community_project') }}</text>
+    <view class="amounts">
+      <button
+        v-for="(item, index) in amounts"
+        :key="index"
+        hover-class="none"
+        @click="onPay(index)"
+        :style="{
+          background: selected === index ? '#fed848' : 'white',
+        }"
+      >
+        <text>￥</text>
+        <text>{{ item }}</text>
+      </button>
+    </view>
+    <view
+      @click="checked = !checked"
+      :style="{ marginBottom: !checked ? '20rpx' : '0' }"
+    >
+      <image v-if="checked" src="https://static.shelingxingqiu.com/shootmini/static/checked.png" mode="widthFix" />
+      <view v-else></view>
+      <text>{{ t('i_have_a_suggestion_optional') }}</text>
+    </view>
+    <view v-if="checked">
+      <view>
+        <text>{{ t('your_name') }}</text>
+        <input v-model="formData.name" />
+      </view>
+      <view>
+        <text>{{ t('phone_wechat_id') }}</text>
+        <input v-model="formData.account" />
+      </view>
+      <view>
+        <text>{{ t('organization') }}</text>
+        <input v-model="formData.organization" />
+      </view>
+      <view>
+        <text>{{ t('suggestion') }}</text>
+        <textarea v-model="formData.suggestion" />
+      </view>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  transition: all 0.3s ease-in-out;
+}
+.container > image:first-child {
+  width: 200rpx;
+  position: absolute;
+  top: -112rpx;
+}
+.container > text:nth-child(2) {
+  font-weight: 500;
+  font-size: 28rpx;
+  color: #333333;
+  margin: 40rpx 0;
+}
+.amounts {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  row-gap: 20rpx;
+  column-gap: 20rpx;
+}
+.amounts > button {
+  width: 150rpx;
+  height: 88rpx;
+  background-color: #ffffff;
+  border-radius: 20rpx;
+  border: 1rpx solid #fed848;
+  color: #333;
+  font-weight: 500;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+.amounts > button > text:first-child {
+  font-size: 20rpx;
+  margin-right: 3rpx;
+}
+.amounts > button > text:last-child {
+  font-size: 34rpx;
+}
+.container > view:nth-child(4) {
+  width: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: flex-start;
+  margin-top: 20rpx;
+}
+.container > view:nth-child(4) > view {
+  width: 32rpx;
+  height: 32rpx;
+  margin: 0 10rpx;
+  border: 1rpx solid #e3e3e3;
+  border-radius: 50%;
+}
+.container > view:nth-child(4) > image {
+  width: 32rpx;
+  height: 32rpx;
+  margin: 0 10rpx;
+}
+.container > view:nth-child(4) > text {
+  font-size: 24rpx;
+  color: #333333;
+  margin: 20rpx 0;
+}
+.container > view:nth-child(5) {
+  margin-bottom: 25rpx;
+}
+.container > view:nth-child(5) > view {
+  width: 100%;
+  display: flex;
+  justify-content: flex-start;
+  margin-bottom: 20rpx;
+}
+.container > view:nth-child(5) > view > text {
+  font-size: 24rpx;
+  color: #333333;
+  width: 30%;
+  text-align: right;
+  padding-right: 20rpx;
+  height: 60rpx;
+  line-height: 60rpx;
+}
+.container > view:nth-child(5) > view > input {
+  border-radius: 12rpx;
+  border: 1rpx solid #fed848;
+  height: 40rpx;
+  line-height: 40rpx;
+  padding: 10rpx 20rpx;
+  font-size: 30rpx;
+  margin-right: 10rpx;
+  width: 55%;
+}
+.container > view:nth-child(5) > view > textarea {
+  width: 55%;
+  border-radius: 12rpx;
+  border: 1rpx solid #fed848;
+  height: 100rpx;
+  line-height: 40rpx;
+  padding: 10rpx 20rpx;
+  font-size: 30rpx;
+  margin-right: 10rpx;
+}
+</style>

src/components/RingBarChart.vue

@@ -0,0 +1,113 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref, computed, onMounted } from "vue";
+
+const props = defineProps({
+  data: {
+    type: Object,
+    default: () => ({}),
+  },
+});
+
+const barColor = (rate) => {
+  if (rate >= 0.4) return "#FDC540";
+  if (rate >= 0.2) return "#FED847";
+  return "#ffe88f";
+};
+
+const bars = computed(() => {
+  const newList = new Array(12).fill({ ring: 0, rate: 0 }).map((_, index) => {
+    let ring = index;
+    if (ring === 11) ring = "M";
+    if (ring === 0) ring = "X";
+    return {
+      ring: ring,
+      rate: props.data[index] || 0,
+    };
+  });
+  [newList[0], newList[11]] = [newList[11], newList[0]];
+  return newList.reverse();
+});
+
+const ringText = (ring) => {
+  if (ring === 11) return "X";
+  if (ring === 0) return "M";
+  return ring;
+};
+</script>
+
+<template>
+  <view class="container">
+    <view>
+      <view v-for="(b, index) in bars" :key="index">
+        <text v-if="b && b.rate">
+          {{ `${Number((b.rate * 100).toFixed(1))}%` }}
+        </text>
+        <view
+          :style="{
+            background: barColor(b.rate),
+            height: (b.rate === 1 ? 150 : b.rate * 240) + 'rpx',
+          }"
+        >
+        </view>
+      </view>
+    </view>
+    <view>
+      <text v-for="(b, index) in bars" :key="index">
+        {{ b && b.ring !== undefined ? b.ring : "" }}
+      </text>
+    </view>
+    <text>{{ t('score') }}</text>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  display: flex;
+  flex-direction: column;
+  justify-content: flex-end;
+  position: relative;
+}
+.container > text {
+  position: absolute;
+  bottom: 2rpx;
+  left: 0;
+  font-size: 18rpx;
+  color: #999999;
+}
+.container > view {
+  padding-left: 40rpx;
+  padding-right: 10rpx;
+}
+.container > view:first-child {
+  display: flex;
+  align-items: flex-end;
+  justify-content: space-around;
+  min-height: 50rpx;
+}
+.container > view:first-child > view {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  font-size: 18rpx;
+  color: #333;
+  width: 5vw;
+}
+.container > view:first-child > view > view {
+  width: 100%;
+  transition: all 0.3s ease;
+  height: 0;
+}
+.container > view:nth-child(2) {
+  display: grid;
+  grid-template-columns: repeat(12, 1fr);
+  border-top: 1rpx solid #333;
+  font-size: 22rpx;
+  color: #333333;
+  padding-top: 2rpx;
+}
+.container > view:nth-child(2) > text {
+  text-align: center;
+}
+</style>

src/components/RoundEndTip.vue

@@ -0,0 +1,166 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref, onMounted, onBeforeUnmount } from "vue";
+const props = defineProps({
+  isFinal: {
+    type: Boolean,
+    default: false,
+  },
+  round: {
+    type: Number,
+    default: 0,
+  },
+  bluePoint: {
+    type: Number,
+    default: 0,
+  },
+  redPoint: {
+    type: Number,
+    default: 0,
+  },
+  roundData: {
+    type: Object,
+    default: () => ({}),
+  },
+  onAutoClose: {
+    type: Function,
+    default: () => {},
+  },
+});
+const count = ref(props.isFinal ? 10 : 3);
+const tiemr = ref(null);
+function startCount() {
+  if (tiemr.value) clearInterval(tiemr.value);
+  tiemr.value = setInterval(() => {
+    if (count.value === 0) {
+      clearInterval(tiemr.value);
+      props.onAutoClose();
+    } else count.value -= 1;
+  }, 1000);
+}
+onMounted(() => {
+  startCount();
+});
+onBeforeUnmount(() => {
+  if (tiemr.value) clearInterval(tiemr.value);
+});
+</script>
+
+<template>
+  <view class="round-end-tip">
+    <text>{{ t('round') }}{{ round }}{{ t('shooting_complete') }}</text>
+    <block v-if="!isFinal">
+      <view class="point-view1" v-if="bluePoint !== 0 || redPoint !== 0">
+        <text>{{ t('blue_team_this_round') }}</text>
+        <text>{{
+          (roundData.shoots[1] || []).reduce(
+            (last, next) => last + next.ring,
+            0
+          )
+        }}</text>
+        <text>{{ t('pts_red_team') }}</text>
+        <text>{{
+          (roundData.shoots[2] || []).reduce(
+            (last, next) => last + next.ring,
+            0
+          )
+        }}</text>
+        <text>{{ t('pts') }}</text>
+      </view>
+      <text
+        v-if="bluePoint === 0 && redPoint === 0"
+        :style="{ marginTop: '20px' }"
+      >{{ t('no_arrows_were_shot_by_either_team_for_3_consecutive_turns_match') }}</text>
+      <text v-if="bluePoint !== 0 && bluePoint === redPoint">{{ t('red_and_blue_teams_each_earn') }}<text :style="{ color: '#fed847', margin: '0 5px' }">{{
+          redPoint
+        }}</text
+        >{{ t('pts_175') }}</text>
+      <text v-if="bluePoint > redPoint">{{ t('blue_team_wins_and_earns') }}<text :style="{ color: '#fed847', margin: '0 5px' }">{{
+          bluePoint
+        }}</text
+        >{{ t('pts_175') }}</text>
+      <text v-if="bluePoint < redPoint">{{ t('red_team_wins_and_earns') }}<text :style="{ color: '#fed847', margin: '0 5px' }">{{
+          redPoint
+        }}</text
+        >{{ t('pts_175') }}</text>
+    </block>
+    <block v-if="isFinal">
+      <view class="point-view2">
+        <text>{{ t('blue_team') }}</text>
+        <text>{{ bluePoint }}</text>
+        <text>{{ t('pts_red_team_179') }}</text>
+        <text>{{ redPoint }}</text>
+        <text>{{ t('pts_180') }}</text>
+      </view>
+      <text>{{ t('a_tie_one_final_arrow_decides_the_winner') }}</text>
+      <view class="final-shoot">
+        <text>{{ count }}</text>
+        <text>{{ t('s_until_both_teams_shoot') }}</text>
+        <text>{{ t('golden_arrow') }}</text>
+        <text>{{ t('one_arrow_decides_it_all') }}</text>
+      </view>
+    </block>
+  </view>
+</template>
+
+<style scoped>
+.round-end-tip {
+  width: 100%;
+  color: #fff9;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  font-size: 32rpx;
+}
+.round-end-tip > text:first-child {
+  font-size: 36rpx;
+  color: #fff;
+}
+.point-view1 {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin-top: 20px;
+  margin-bottom: 3px;
+}
+.point-view1 > text:nth-child(2),
+.point-view1 > text:nth-child(4) {
+  color: #fed847;
+  margin: 0 5px;
+}
+.point-view2 {
+  margin: 12px 0;
+  font-size: 48rpx;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: #fff;
+}
+.point-view2 > text:nth-child(2),
+.point-view2 > text:nth-child(4) {
+  color: #fed847;
+  width: 30px;
+  text-align: center;
+  font-size: 30px;
+}
+.final-shoot {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin-top: 10px;
+  font-size: 28rpx;
+  word-break: keep-all;
+}
+.final-shoot > text:nth-child(1) {
+  width: 20px;
+  text-align: right;
+}
+.final-shoot > text:nth-child(1),
+.final-shoot > text:nth-child(3) {
+  font-size: 32rpx;
+  color: #fed847;
+  margin-left: 10px;
+  margin-right: 5px;
+}
+</style>

src/components/SButton.vue

@@ -0,0 +1,101 @@
+<script setup>
+import { ref } from "vue";
+import { debounce } from "@/util";
+const props = defineProps({
+  width: {
+    type: String,
+    default: "calc(100vw - 20px)",
+  },
+  rounded: {
+    type: Number,
+    default: 10,
+  },
+  onClick: {
+    type: Function,
+    default: async () => {},
+  },
+  disabled: {
+    type: Boolean,
+    default: false,
+  },
+  backgroundColor: {
+    type: String,
+    default: "#fed847",
+  },
+  color: {
+    type: String,
+    default: "#000",
+  },
+  disabledColor:{
+    type: String,
+    default: "#757575",
+  }
+});
+
+const loading = ref(false);
+const timer = ref(null);
+
+const onBtnClick = debounce(async () => {
+  if (props.disabled || loading.value) return;
+
+  let loadingTimer = null;
+  loadingTimer = setTimeout(() => {
+    loading.value = true;
+  }, 300);
+
+  try {
+    await props.onClick();
+  } finally {
+    clearTimeout(loadingTimer);
+    loading.value = false;
+  }
+});
+</script>
+
+<template>
+  <button
+    class="sbtn"
+    hover-class="none"
+    :style="{
+      width: width,
+      borderRadius: rounded + 'px',
+      backgroundColor: disabled ? disabledColor : backgroundColor,
+      color,
+    }"
+    open-type="getUserInfo"
+    @click="onBtnClick"
+  >
+    <block v-if="!loading">
+      <slot />
+    </block>
+    <block v-else>
+      <image src="https://static.shelingxingqiu.com/shootmini/static/btn-loading.png" mode="widthFix" class="loading" />
+    </block>
+  </button>
+</template>
+
+<style scoped>
+.sbtn {
+  margin: 0 auto;
+  min-height: 88rpx;
+  height: auto;
+  line-height: 1.3;
+  padding: 20rpx 24rpx;
+  box-sizing: border-box;
+  white-space: normal;
+  overflow-wrap: break-word;
+  font-weight: bold;
+  font-size: 15px;
+  display: flex;
+  text-align: center;
+  justify-content: center;
+  align-items: center;
+  overflow: initial;
+}
+.loading {
+  width: 25px;
+  height: 25px;
+  background-blend-mode: darken;
+  animation: rotate 1s linear infinite;
+}
+</style>

src/components/SModal.vue

@@ -0,0 +1,108 @@
+<script setup>
+import { ref, watch } from "vue";
+const props = defineProps({
+  show: {
+    type: Boolean,
+    default: false,
+  },
+  height: {
+    type: String,
+    default: "650rpx",
+  },
+  onClose: {
+    type: Function,
+    default: () => {},
+  },
+  noBg: {
+    type: Boolean,
+    default: false,
+  },
+});
+const showContainer = ref(false);
+const showContent = ref(false);
+watch(
+  () => props.show,
+  (newValue) => {
+    if (newValue) {
+      showContainer.value = true;
+      setTimeout(() => {
+        showContent.value = true;
+      }, 100);
+    } else {
+      showContent.value = false;
+      setTimeout(() => {
+        showContainer.value = false;
+      }, 100);
+    }
+  },
+  {}
+);
+</script>
+
+<template>
+  <view
+    class="container"
+    v-if="showContainer"
+    :style="{ opacity: show ? 1 : 0 }"
+    @click="onClose"
+  >
+    <view
+      class="modal-content"
+      :style="{
+        transform: `translateY(${showContent ? '0%' : '100%'})`,
+        height,
+      }"
+      @click.stop=""
+    >
+      <image
+        v-if="!noBg"
+        src="https://static.shelingxingqiu.com/attachment/2025-12-04/dep11770wzxg6o2alo.png"
+        mode="widthFix"
+      />
+      <view class="close-btn" @click="onClose" v-if="!noBg">
+        <image src="https://static.shelingxingqiu.com/shootmini/static/close-yellow.png" mode="widthFix" />
+      </view>
+      <slot></slot>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  position: fixed;
+  top: 0;
+  left: 0;
+  background-color: #00000099;
+  width: 100vw;
+  height: 100vh;
+  display: flex;
+  flex-direction: column;
+  justify-content: flex-end;
+  align-items: center;
+  opacity: 0;
+  transition: all 0.3s ease;
+  z-index: 999;
+}
+.modal-content {
+  width: 100%;
+  transform: translateY(100%);
+  transition: all 0.3s ease;
+  position: relative;
+  background-color: #372E1D;
+}
+.modal-content > image:first-child {
+  width: 100%;
+  position: absolute;
+  z-index: -1;
+}
+.close-btn {
+  display: flex;
+  justify-content: flex-end;
+  position: absolute;
+  right: 0;
+}
+.close-btn > image {
+  width: 40px;
+  height: 40px;
+}
+</style>

src/components/ScorePanel.vue

@@ -0,0 +1,144 @@
+<script setup>
+import { ref, watch } from "vue";
+const props = defineProps({
+  rowCount: {
+    type: Number,
+    default: 0,
+  },
+  total: {
+    type: Number,
+    default: 0,
+  },
+  arrows: {
+    type: Array,
+    default: () => [],
+  },
+  fontSize: {
+    type: Number,
+    default: 25,
+  },
+  completeEffect: {
+    type: Boolean,
+    default: true,
+  },
+});
+const items = ref(new Array(props.total).fill(9));
+const width = ref(92);
+const itemWidth = ref(0);
+const bgImages = [
+  "https://static.shelingxingqiu.com/shootmini/static/complete-light1.png",
+  "https://static.shelingxingqiu.com/shootmini/static/complete-light2.png",
+];
+watch(
+  () => props.total,
+  (newValue) => {
+    items.value = new Array(newValue).fill(9);
+  }
+);
+</script>
+<template>
+  <view class="container">
+    <template v-if="total > 0 && arrows.length === total && completeEffect">
+      <image
+        v-for="(image, index) in bgImages"
+        :key="image"
+        :src="image"
+        :class="[
+          'complete-light',
+          index === 0 ? 'complete-light--first' : 'complete-light--second',
+        ]"
+        :style="{
+          width: `calc(${(100 / (rowCount + 2)) * rowCount}vw + ${
+            (100 / (total * 2)) * (rowCount * 2 + (total === 12 ? 8 : 24))
+          }px)`,
+          height: `calc(${(100 / (rowCount + 2)) * (total / rowCount)}vw + ${
+            (100 / (total * 2)) *
+            ((total / rowCount) * 2 + (total === 12 ? 7 : 24))
+          }px)`,
+          top: `${total === 12 ? -2 : -3}vw`,
+        }"
+      />
+    </template>
+    <view
+      v-for="(_, index) in items"
+      :key="index"
+      class="score-item"
+      :style="{
+        width: 100 / (rowCount + 2) + 'vw',
+        height: 100 / (rowCount + 2) + 'vw',
+        lineHeight: 100 / (rowCount + 2) + 'vw',
+        fontSize: fontSize + 'px',
+        margin: 100 / (total * 2) + 'px',
+      }"
+    >
+      <image src="https://static.shelingxingqiu.com/shootmini/static/score-bg.png" mode="widthFix" />
+      <text
+        :style="{ fontWeight: arrows[index] !== undefined ? 'bold' : 'normal' }"
+        >{{
+          !arrows[index] ? "-" : arrows[index].ringX ? "X" : arrows[index].ring
+        }}</text
+      >
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  width: 92vw;
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: center;
+  margin: 0 4vw;
+  position: relative;
+  padding: 1vw 0;
+}
+.score-item {
+  /* background-image: url("https://static.shelingxingqiu.com/shootmini/static/score-bg.png");
+  background-size: cover;
+  background-repeat: no-repeat;
+  background-position: center; */
+  color: #fed847;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  position: relative;
+}
+.score-item > image {
+  position: absolute;
+  width: 100%;
+  top: 5%;
+}
+.score-item > text {
+  position: relative;
+  margin-top: 2px;
+}
+.complete-light {
+  position: absolute;
+}
+.complete-light--first {
+  animation: complete-light-first 400ms steps(1, end) infinite;
+}
+.complete-light--second {
+  animation: complete-light-second 400ms steps(1, end) infinite;
+}
+@keyframes complete-light-first {
+  0%,
+  49.9% {
+    opacity: 1;
+  }
+  50%,
+  100% {
+    opacity: 0;
+  }
+}
+@keyframes complete-light-second {
+  0%,
+  49.9% {
+    opacity: 0;
+  }
+  50%,
+  100% {
+    opacity: 1;
+  }
+}
+</style>

src/components/ScorePanel2.vue

@@ -0,0 +1,81 @@
+<script setup>
+import { t } from "@/locales";
+
+const props = defineProps({
+  arrows: {
+    type: Array,
+    default: () => [],
+  },
+});
+const getSum = (...arrows) => {
+  const recordedArrows = arrows.filter(Boolean);
+  if (!recordedArrows.length) return "-";
+  const sum = recordedArrows.reduce(
+    (total, arrow) => total + (Number(arrow.ring) || 0),
+    0
+  );
+  return t('value_pts', { p0: sum });
+};
+const roundsName = [t('round_1'), t('round_2'), t('round_3'), t('round_4')];
+const getShowText = (arrow) => {
+  if (!arrow) return "-";
+  return arrow.ringX ? "X" : t('value_pts', { p0: Number(arrow.ring) || 0 });
+};
+</script>
+<template>
+  <view class="container">
+    <view>
+      <text :style="{ transform: 'translateX(-10%)' }">{{ t('final_score') }}</text>
+      <text>{{ arrows.reduce((last, next) => last + next.ring, 0) }}{{ t('pts') }}</text>
+    </view>
+    <view
+      v-for="(_, index) in new Array(
+        Math.min(
+          Math.ceil(arrows.length / 3) + (arrows.length % 3 === 0 ? 1 : 0),
+          4
+        )
+      ).fill(1)"
+      :key="index"
+    >
+      <text>{{ roundsName[index] }}</text>
+      <text>{{ getShowText(arrows[index * 3 + 0]) }}</text>
+      <text>{{ getShowText(arrows[index * 3 + 1]) }}</text>
+      <text>{{ getShowText(arrows[index * 3 + 2]) }}</text>
+      <text :style="{ width: '40%', transform: 'translateX(20%)' }">{{
+        getSum(
+          arrows[index * 3 + 0],
+          arrows[index * 3 + 1],
+          arrows[index * 3 + 2]
+        )
+      }}</text>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  width: 100vw;
+  display: flex;
+  flex-direction: column;
+  overflow-x: hidden;
+}
+.container > view {
+  width: calc(100% - 30px);
+  color: aliceblue;
+  display: flex;
+  justify-content: space-between;
+  padding: 12px 15px;
+  border-bottom: 1px solid #ffffff66;
+  font-size: 14px;
+  color: #fffc;
+}
+.container > view:first-child {
+  color: #fed847;
+  background-color: #ffffff33;
+}
+.container text {
+  display: block;
+  width: 20%;
+  text-align: center;
+}
+</style>

src/components/ScoreResult.vue

@@ -0,0 +1,283 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref, onMounted, computed } from "vue";
+import IconButton from "@/components/IconButton.vue";
+import SButton from "@/components/SButton.vue";
+import ScreenHint from "@/components/ScreenHint.vue";
+import BowData from "@/components/BowData.vue";
+import UserUpgrade from "@/components/UserUpgrade.vue";
+import { directionAdjusts } from "@/constants";
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+const store = useStore();
+const { user } = storeToRefs(store);
+const props = defineProps({
+  onClose: {
+    type: Function,
+    default: () => {},
+  },
+  total: {
+    type: Number,
+    default: 0,
+  },
+  rowCount: {
+    type: Number,
+    default: 0,
+  },
+  result: {
+    type: Object,
+    default: () => ({}),
+  },
+  tipSrc: {
+    type: String,
+    default: "",
+  },
+});
+const showPanel = ref(true);
+const showComment = ref(false);
+const showBowData = ref(false);
+const showUpgrade = ref(false);
+const totalRing = ref(0);
+const closePanel = () => {
+  showPanel.value = false;
+  setTimeout(() => {
+    props.onClose();
+  }, 300);
+};
+function onClickShare() {
+  uni.$emit("share-image");
+}
+onMounted(() => {
+  if (props.result.lvl > user.value.lvl) {
+    showUpgrade.value = true;
+  }
+  totalRing.value = (props.result.details || []).reduce(
+    (last, next) => last + next.ring,
+    0
+  );
+});
+
+const getRing = (arrow) => {
+  if (!arrow) return "-";
+  if (arrow.ringX) return "X";
+  return Number(arrow.ring) || 0;
+};
+
+const arrows = computed(() => {
+  const data = new Array(props.total).fill(null);
+  (props.result.details || []).forEach((arrow, index) => {
+    data[index] = arrow;
+  });
+  return data;
+});
+
+const validArrows = computed(
+  () => arrows.value.filter((a) => Number(a?.ring) > 0).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="https://static.shelingxingqiu.com/shootmini/static/finish-frame.png" mode="widthFix" />
+      <text
+        >{{ t('completed') }}<text class="gold-text">{{ validArrows }}</text
+        >{{ t('arrows_earned') }}<text class="gold-text">{{ validArrows }}</text
+        >{{ t('xp') }}</text
+      >
+    </view>
+    <view
+      class="container-content"
+      :style="{ transform: `translateY(${showPanel ? '0%' : '100%'})` }"
+    >
+      <view>
+        <text>{{ t('score_this_match_total') }}{{ totalRing }}{{ t('pts_194') }}</text>
+        <button @click="() => (showBowData = true)">
+          <text>{{ t('view_target') }}</text>
+          <image
+            src="https://static.shelingxingqiu.com/shootmini/static/enter-arrow-blue.png"
+            mode="widthFix"
+            :style="{ width: '20px' }"
+          />
+        </button>
+      </view>
+      <view :style="{ gridTemplateColumns: `repeat(${rowCount}, 1fr)` }">
+        <view v-for="(_, index) in new Array(total).fill(0)" :key="index">
+          {{ getRing(arrows[index])
+          }}<text v-if="getRing(arrows[index]) !== '-'">{{ t('pts') }}</text>
+        </view>
+      </view>
+      <view>
+        <block v-if="validArrows === total">
+          <IconButton
+            :name="t('share')"
+            src="https://static.shelingxingqiu.com/shootmini/static/share.png"
+            :onClick="onClickShare"
+          />
+          <IconButton
+            v-if="isMember"
+            :name="t('coach_feedback')"
+            src="https://static.shelingxingqiu.com/shootmini/static/review.png"
+            :onClick="openCoachComment"
+          />
+        </block>
+        <SButton
+          :width="validArrows === total ? '70vw' : 'calc(100vw - 20px)'"
+          :rounded="30"
+          :onClick="closePanel"
+          >{{ validArrows === total ? t('completed') : t('back') }}</SButton
+        >
+      </view>
+    </view>
+    <ScreenHint
+      :show="showComment"
+      :onClose="() => (showComment = false)"
+      mode="tall"
+    >
+      <view class="coach-comment">
+        <text>{{ t('your_score_for_this_session_is') }}<text :style="{ color: '#fed847' }">{{
+            totalRing
+          }}</text
+          >{{ t('pts_the_average_distance_between_your_arrow_impacts_is') }}<text
+            :style="{ color: '#fed847' }"
+            >{{ Number((result?.interpretation?.spreadStability || 0).toFixed(2)) }}</text
+          >，{{
+            result.spreadEvaluation === "Dispersed"
+              ? t('keep_practicing')
+              : t('excellent_performance')
+          }}
+        </text>
+        <view>
+          <image
+            src="https://static.shelingxingqiu.com/attachment/2025-11-26/deihtj15xjwcz3c1tx.png"
+            mode="widthFix"
+          />
+          <text :style="{ marginTop: '12px' }"
+            >{{ t('for_this_session') }}{{
+              result.spreadEvaluation === "Dispersed"
+                ? t('we_recommend_practicing_consistency_in_your_bow_arm_anchor_point')
+                : totalRing >= 100
+                ? t('we_recommend_keeping_up_the_good_work')
+                : t('we_recommend_adjusting_your_sight_value', { p0: directionAdjusts[result.adjustmentHint] })
+            }}</text
+          >
+        </view>
+      </view>
+    </ScreenHint>
+    <BowData
+      :total="arrows.length"
+      :arrows="result.details"
+      :show="showBowData"
+      :onClose="() => (showBowData = false)"
+    />
+    <UserUpgrade
+      :show="showUpgrade"
+      :onClose="() => (showUpgrade = false)"
+      :lvl="result.lvl"
+    />
+  </view>
+</template>
+
+<style scoped>
+.container {
+  width: 100vw;
+  height: 100vh;
+  position: fixed;
+  top: 0;
+  left: 0;
+  background-color: rgba(0, 0, 0, 0.8);
+  z-index: 999;
+}
+.container-header {
+  margin-top: 20vh;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  opacity: 0;
+}
+.container-header > text:last-child {
+  color: #fff;
+  text-align: center;
+  margin-top: -85px;
+}
+.container-content {
+  width: calc(100vw - 20px);
+  background-color: #fff;
+  position: absolute;
+  bottom: 0;
+  border-top-left-radius: 10px;
+  border-top-right-radius: 10px;
+  display: flex;
+  flex-direction: column;
+  justify-content: space-between;
+  padding: 15px 10px;
+  transition: all 0.3s ease;
+  transform: translateY(0);
+}
+.container-content > view:first-child {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+.container-content > view:first-child > text:first-child {
+  color: #000;
+}
+.container-content > view:first-child > button {
+  display: flex;
+  align-items: center;
+  color: #287fff;
+  font-size: 14px;
+}
+.container-content > view:nth-child(2) {
+  display: grid;
+  row-gap: 10px;
+  column-gap: 5px;
+  justify-content: flex-start;
+  margin-top: 10px;
+  margin-bottom: 15px;
+}
+.container-content > view:nth-child(2) > view {
+  background: linear-gradient(#fbfbfb, #f5f5f5);
+  border: 1px solid #e5e5e5;
+  border-radius: 5px;
+  text-align: center;
+  line-height: 27px;
+  color: #333333;
+  font-size: 28rpx;
+}
+.container-content > view:nth-child(2) > view > text {
+  font-size: 20rpx;
+  color: #666666;
+  margin-left: 5rpx;
+}
+.container-content > view:nth-child(3) {
+  width: 100%;
+  display: flex;
+  justify-content: space-around;
+}
+.gold-text {
+  color: #fed847;
+  font-size: 20px;
+  margin: 0 2px;
+}
+.coach-comment {
+  display: flex;
+  flex-direction: column;
+  font-size: 14px;
+}
+.coach-comment > view {
+  display: flex;
+}
+.coach-comment > view > image {
+  width: 420rpx;
+  height: 420rpx;
+  margin-right: 20rpx;
+}
+</style>

src/components/ScreenHint.vue

@@ -0,0 +1,100 @@
+<script setup>
+import IconButton from "./IconButton.vue";
+
+const props = defineProps({
+  show: {
+    type: Boolean,
+    default: false,
+  },
+  onClose: {
+    type: Function,
+    default: null,
+  },
+  mode: {
+    type: String,
+    default: "normal",
+  },
+  contentHeight: {
+    type: String,
+    default: "",
+  },
+});
+const getContentHeight = () => {
+  if (props.contentHeight) return props.contentHeight;
+  if (props.mode === "tall") return "50vw";
+  if (props.mode === "square") return "74vw";
+  return "36vw";
+};
+</script>
+
+<template>
+  <view class="container" :style="{ display: show ? 'flex' : 'none' }">
+    <view class="scale-in" :style="{ height: getContentHeight() }">
+      <image
+        v-if="mode === 'normal'"
+        src="https://static.shelingxingqiu.com/shootmini/static/screen-hint-bg.png"
+        mode="widthFix"
+      />
+      <image
+        v-if="mode === 'tall'"
+        src="https://static.shelingxingqiu.com/shootmini/static/coach-comment.png"
+        mode="widthFix"
+      />
+      <image
+        v-if="mode === 'square'"
+        src="https://static.shelingxingqiu.com/shootmini/static/prompt-bg-square.png"
+        mode="widthFix"
+      />
+      <image
+        v-if="mode === 'small'"
+        src="https://static.shelingxingqiu.com/shootmini/static/finish-frame.png"
+        mode="widthFix"
+      />
+      <slot />
+    </view>
+    <IconButton
+      v-if="!!onClose"
+      src="https://static.shelingxingqiu.com/shootmini/static/close-gold-outline.png"
+      :width="30"
+      :onClick="onClose"
+    />
+  </view>
+</template>
+
+<style scoped>
+.container {
+  width: 100vw;
+  height: 100vh;
+  position: fixed;
+  top: 0;
+  left: 0;
+  background-color: rgba(0, 0, 0, 0.8);
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  z-index: 999;
+}
+.container > view:first-child {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  position: relative;
+  width: 70vw;
+  color: #fff;
+  margin-bottom: 15px;
+}
+.container > view:first-child > image {
+  position: absolute;
+  width: 80vw;
+  left: -7%;
+  bottom: -8rpx;
+  z-index: -1;
+}
+
+/* 英文教练点评较长，保持弹窗按钮可见。 */
+.container :deep(.coach-comment) {
+  max-height: 100%;
+  overflow-y: auto;
+  overflow-wrap: break-word;
+}
+</style>

src/components/ScreenHint2.vue

@@ -0,0 +1,67 @@
+<script setup>
+import IconButton from "./IconButton.vue";
+
+const props = defineProps({
+  show: {
+    type: Boolean,
+    default: false,
+  },
+  onClose: {
+    type: Function,
+    default: null,
+  },
+  height: {
+    type: Number,
+    default: 100,
+  },
+});
+</script>
+
+<template>
+  <view class="container" :style="{ display: show ? 'flex' : 'none' }">
+    <view class="scale-in">
+      <image src="https://static.shelingxingqiu.com/shootmini/static/point-book-tip-bg.png" mode="widthFix" />
+      <slot />
+    </view>
+    <IconButton
+      v-if="!!onClose"
+      src="https://static.shelingxingqiu.com/shootmini/static/close-white-outline.png"
+      :width="30"
+      :onClick="onClose"
+    />
+  </view>
+</template>
+
+<style scoped>
+.container {
+  width: 100vw;
+  height: 100vh;
+  position: fixed;
+  top: 0;
+  left: 0;
+  background-color: rgba(0, 0, 0, 0.8);
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  z-index: 999;
+}
+.container > view:first-child {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  position: relative;
+  width: 75vw;
+  margin-bottom: 15px;
+  border-radius: 30rpx;
+  background: #fff;
+}
+.container > view:first-child > image {
+  position: absolute;
+  width: 100%;
+  z-index: -1;
+  top: 0;
+  border-top-left-radius: 30rpx;
+  border-top-right-radius: 30rpx;
+}
+</style>

src/components/ScrollList.vue

@@ -0,0 +1,99 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref } from "vue";
+import { onShow } from "@dcloudio/uni-app";
+const props = defineProps({
+  show: {
+    type: Boolean,
+    default: true,
+  },
+  onLoading: {
+    type: Function,
+    default: async (page) => [],
+  },
+  pageSize: {
+    type: Number,
+    default: 10,
+  },
+});
+const refreshing = ref(true);
+const loading = ref(false);
+const noMore = ref(false);
+const count = ref(0);
+const page = ref(1);
+const refresherrefresh = async () => {
+  if (refreshing.value) return;
+  try {
+    refreshing.value = true;
+    page.value = 1;
+    const length = await props.onLoading(page.value);
+    count.value = length;
+    if (length < props.pageSize) noMore.value = true;
+  } finally {
+    refreshing.value = false;
+  }
+};
+const scrolltolower = async () => {
+  if (loading.value || noMore.value) return;
+  try {
+    loading.value = true;
+    page.value += 1;
+    const length = await props.onLoading(page.value);
+    count.value += length;
+    if (length < props.pageSize) noMore.value = true;
+  } finally {
+    loading.value = false;
+  }
+};
+onShow(async () => {
+  try {
+    const length = await props.onLoading(page.value);
+    count.value = length;
+    if (length < props.pageSize) noMore.value = true;
+  } finally {
+    refreshing.value = false;
+  }
+});
+</script>
+
+<template>
+  <scroll-view
+    class="scroll-list"
+    scroll-y
+    :show-scrollbar="false"
+    :enhanced="true"
+    :bounces="false"
+    refresher-default-style="white"
+    :refresher-enabled="true"
+    :refresher-triggered="refreshing"
+    @refresherrefresh="refresherrefresh"
+    @scrolltolower="scrolltolower"
+    :style="{
+      display: show ? 'flex' : 'none',
+    }"
+  >
+    <slot></slot>
+    <view class="tips">
+      <text v-if="loading">{{ t('loading') }}</text>
+      <text v-if="noMore">{{ count === 0 ? t('no_data_yet') : t('no_more_results') }}</text>
+    </view>
+  </scroll-view>
+</template>
+
+<style scoped>
+.scroll-list {
+  width: 100%;
+  height: 100%;
+}
+.tips {
+  height: 50rpx;
+}
+.tips > text {
+  color: #d0d0d0;
+  display: block;
+  text-align: center;
+  font-size: 12px;
+  margin: 10px;
+}
+</style>

src/components/ShootProgress.vue

@@ -0,0 +1,285 @@
+<script setup>
+import { t, formatBattleTip } from "@/locales";
+
+import { ref, watch, onMounted, onBeforeUnmount, computed } from "vue";
+import audioManager from "@/audioManager";
+import { MESSAGETYPESV2 } from "@/constants";
+import {
+  getDirectionText,
+  getInvalidShotAudioKey,
+  getInvalidShotText,
+} from "@/util";
+
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+const store = useStore();
+const { user } = storeToRefs(store);
+
+const props = defineProps({
+  show: {
+    type: Boolean,
+    default: true,
+  },
+  start: {
+    type: Boolean,
+    default: false,
+  },
+  tips: {
+    type: String,
+    default: "",
+  },
+  total: {
+    type: Number,
+    default: 120,
+  },
+  currentRound: {
+    type: Number,
+    default: 0,
+  },
+  battleId: {
+    type: String,
+    default: "",
+  },
+  melee: {
+    type: Boolean,
+    default: false,
+  },
+  halfRest: {
+    type: Boolean,
+    default: false,
+  },
+  onStop: {
+    type: Function,
+    default: () => {},
+  },
+  endAudioKey: {
+    type: String,
+    default: "比赛结束",
+  },
+});
+
+const barColor = ref("#fed847");
+const remain = ref(props.total);
+const timer = ref(null);
+const sound = ref(true);
+const currentRound = ref(props.currentRound);
+const currentRoundEnded = ref(false);
+const ended = ref(false);
+const halfTime = ref(false);
+const wait = ref(0);
+const transitionStyle = ref("all 1s linear");
+
+watch(
+  () => props.tips,
+  (newVal) => {
+    let key = "";
+    if (newVal.includes("红队")) key = "请红方射箭";
+    if (newVal.includes("蓝队")) key = "请蓝方射箭";
+    if (key) {
+      if (currentRoundEnded.value) {
+        currentRound.value += 1;
+        currentRoundEnded.value = false;
+        if (currentRound.value === 1) audioManager.play("第一轮");
+        if (currentRound.value === 2) audioManager.play("第二轮");
+        if (currentRound.value === 3) audioManager.play("第三轮");
+        if (currentRound.value === 4) audioManager.play("第四轮");
+        if (currentRound.value === 5) audioManager.play("第五轮");
+        setTimeout(() => {
+          audioManager.play(key);
+        }, 1000);
+      } else {
+        audioManager.play(key);
+      }
+    }
+  }
+);
+
+const resetTimer = (count) => {
+  if (timer.value) clearInterval(timer.value);
+  const newVal = Math.round(count);
+  
+  // 如果剩余时间增加（如重置），瞬间变化无动画
+  if (newVal >= remain.value) {
+    transitionStyle.value = "none";
+    remain.value = newVal;
+    setTimeout(() => {
+      transitionStyle.value = "all 1s linear";
+    }, 50);
+  } else {
+    remain.value = newVal;
+  }
+  
+  if (remain.value > 0) {
+    timer.value = setInterval(() => {
+      if (remain.value === 0) {
+        clearInterval(timer.value);
+        props.onStop();
+      }
+      if (remain.value > 0) remain.value--;
+    }, 1000);
+  }
+};
+
+watch(
+  () => props.start,
+  (newVal) => {
+    if (newVal) {
+      resetTimer(props.total);
+    } else {
+      remain.value = 0;
+      clearInterval(timer.value);
+    }
+  },
+  {
+    immediate: true,
+  }
+);
+
+const tipContent = computed(() => {
+  if (halfTime.value) {
+    return props.battleId ? t('halftime') : t('halftime_values', { p0: wait.value });
+  }
+  return props.start && remain.value === 0 ? t('time_s_up') : props.tips;
+});
+
+const updateSound = () => {
+  sound.value = !sound.value;
+  audioManager.setMuted(!sound.value);
+};
+
+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(audioKey);
+  } else if (msg.type === MESSAGETYPESV2.BattleEnd) {
+    audioManager.play(props.endAudioKey, false);
+  } else if (msg.type === MESSAGETYPESV2.ShootResult) {
+    let arrow = {};
+    if (msg.details && Array.isArray(msg.details)) {
+      arrow = msg.details[msg.details.length - 1];
+    } else {
+      if (!msg.shootData || 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)
+      key.push(`向${getDirectionText(arrow.angle)}调整`);
+    const shouldPlayTententen =
+      arrow.threeConsecutive10Rings === true ||
+      msg.shootData?.threeConsecutive10Rings === true;
+    if (!props.melee && shouldPlayTententen) key.push("tententen");
+    audioManager.play(key, false);
+  } else if (msg.type === MESSAGETYPESV2.HalfRest) {
+    halfTime.value = true;
+    audioManager.play("中场休息");
+  } else if (msg.type === MESSAGETYPESV2.InvalidShot) {
+    uni.showToast({
+      title: getInvalidShotText(msg.shootData),
+      icon: "none",
+    });
+    audioManager.play(getInvalidShotAudioKey(msg.shootData));
+  }
+}
+
+const playSound = (key) => {
+  audioManager.play(key);
+};
+
+onMounted(() => {
+  uni.$on("update-remain", resetTimer);
+  uni.$on("socket-inbox", onReceiveMessage);
+  uni.$on("play-sound", playSound);
+});
+
+onBeforeUnmount(() => {
+  uni.$off("update-remain", resetTimer);
+  uni.$off("socket-inbox", onReceiveMessage);
+  uni.$off("play-sound", playSound);
+  if (timer.value) clearInterval(timer.value);
+});
+</script>
+
+<template>
+  <view class="container" :style="{ display: show ? 'block' : 'none' }">
+    <view>
+      <image src="https://static.shelingxingqiu.com/shootmini/static/shooter.png" mode="widthFix" />
+      <text>{{ formatBattleTip(tipContent) }}</text>
+      <button hover-class="none" @click="updateSound">
+        <image
+          :src="`https://static.shelingxingqiu.com/shootmini/static/sound${sound ? '' : '-off'}-yellow.png`"
+          mode="widthFix"
+        />
+      </button>
+    </view>
+    <view>
+      <view
+        :style="{
+          width: `${(remain / total) * 100}%`,
+          backgroundColor: barColor,
+          right: tips.includes('红队') ? 0 : 'unset',
+          transition: transitionStyle,
+        }"
+      />
+      <text>{{ t('remaining') }}{{ remain }}{{ t('s') }}</text>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  width: 100vw;
+}
+.container > view:first-child {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0 15px;
+  z-index: 1;
+  transform: translateX(-10px);
+}
+.container > view:first-child > image:first-child {
+  width: 20vw;
+  transform: translateX(10px);
+}
+.container > view:first-child > text {
+  color: #fed847;
+  font-size: 18px;
+  transform: translateY(-10px) translateX(-10px);
+}
+.container > view:first-child > button:last-child {
+  overflow: visible;
+}
+.container > view:first-child > button:last-child > image {
+  width: 40px;
+  transform: translateX(10px) translateY(-10px);
+}
+.container > view:last-child {
+  z-index: -1;
+  width: calc(100% - 30px);
+  margin: 0 15px;
+  text-align: center;
+  background-color: #ffffff80;
+  border-radius: 20px;
+  margin-top: -16px;
+  font-size: 12px;
+  height: 15px;
+  line-height: 15px;
+  position: relative;
+  overflow: hidden;
+}
+.container > view:last-child > view {
+  position: absolute;
+  height: 15px;
+  border-radius: 15px;
+  z-index: -1;
+}
+.container > view:last-child > text {
+  font-size: 10px;
+  line-height: 15px;
+  z-index: 1;
+  color: #000;
+}
+</style>

src/components/ShootProgress2.vue

@@ -0,0 +1,179 @@
+<script setup>
+import { t } from "@/locales";
+
+import {ref, watch, onMounted, onBeforeUnmount} from "vue";
+import {RoundGoldImages} from "@/constants";
+
+const props = defineProps({
+  tips: {
+    type: String,
+    default: "",
+  },
+  total: {
+    type: Number,
+    default: 15,
+  },
+  currentRound: {
+    type: String,
+    default: "round1",
+  },
+});
+
+const barColor = ref("");
+const remain = ref(15);
+const timer = ref(null);
+const loading = ref(false);
+const transitionStyle = ref("all 1s linear");
+const currentTeam = ref(null);
+
+const updateRemain = (value) => {
+  if (value.stop) {
+    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')
+    barColor.value = "linear-gradient( 180deg, #FFA0A0 0%, #FF6060 100%)";
+  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);
+  // 如果剩余时间增加（如轮次切换重置），瞬间变化无动画；否则保持动画
+  if (newVal >= remain.value) {
+    transitionStyle.value = "none";
+    remain.value = newVal;
+    setTimeout(() => {
+      transitionStyle.value = "all 1s linear";
+    }, 50);
+  } else {
+    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--;
+  }, 1000);
+};
+
+watch(
+    () => props.tips,
+    (newVal) => {
+
+    },
+    {
+      immediate: true,
+    }
+);
+
+onMounted(() => {
+  uni.$on("update-remain", updateRemain);
+});
+
+onBeforeUnmount(() => {
+  uni.$off("update-remain", updateRemain);
+  if (timer.value) clearInterval(timer.value);
+});
+</script>
+
+<template>
+  <view class="container">
+    <image :src="RoundGoldImages[props.currentRound]" mode="widthFix"/>
+    <view
+        :style="{
+        justifyContent: currentTeam==='red' ? 'flex-end' : 'flex-start',
+      }"
+    >
+      <view
+          :style="{
+          width: `${(remain / total) * 100}%`,
+          background: barColor,
+          right: currentTeam==='red' ? 0 : 'unset',
+          transition: transitionStyle,
+        }"
+      />
+      <text v-if="!loading">{{ t('remaining') }}{{ remain }}{{ t('s') }}</text>
+      <text v-else>···</text>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  width: 50vw;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+
+.container > image {
+  width: 380rpx;
+  height: 80rpx;
+  transform: translateY(18rpx);
+}
+
+.container > view:last-child {
+  width: 100%;
+  text-align: center;
+  background-color: #444444;
+  border-radius: 20px;
+  height: 24rpx;
+  position: relative;
+  overflow: hidden;
+  display: flex;
+  align-items: center;
+}
+
+.container > view:last-child > view {
+  height: 24rpx;
+  border-radius: 15px;
+}
+
+.container > view:last-child > text {
+  font-size: 18rpx;
+  color: #fff;
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+}
+</style>

src/components/Signin.vue

@@ -0,0 +1,337 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref, watch } from "vue";
+import { onShow } from "@dcloudio/uni-app";
+import SModal from "@/components/SModal.vue";
+import Avatar from "@/components/Avatar.vue";
+import SButton from "@/components/SButton.vue";
+
+import { wxLogin } from "@/util";
+import {
+  getMyDevicesAPI,
+  loginAPI,
+  getHomeData,
+  getPhoneNumberAPI,
+  getPhoneNumberAPIv2,
+} from "@/apis";
+
+import useStore from "@/store";
+const store = useStore();
+const { updateUser, updateDevice, clearDevice } = store;
+
+const props = defineProps({
+  show: {
+    type: Boolean,
+    default: false,
+  },
+  noBg: {
+    type: Boolean,
+    default: false,
+  },
+  onClose: {
+    type: Function,
+    default: () => {},
+  },
+  onSuccess: {
+    type: Function,
+    default: () => {},
+  },
+});
+const agree = ref(false);
+const phone = ref("");
+const avatarUrl = ref("");
+const nickName = ref("");
+const loading = ref(false);
+const handleAgree = () => {
+  agree.value = !agree.value;
+};
+
+async function getphonenumber(e) {
+  if (e.detail.code) {
+    // const wxResult = await wxLogin();
+    const result = await getPhoneNumberAPIv2({
+      // ...e.detail,
+      code: e.detail.code,
+    });
+    if (result.purePhoneNumber) phone.value = result.purePhoneNumber;
+  }
+}
+
+function onChooseAvatar(e) {
+  avatarUrl.value = e.detail.avatarUrl;
+}
+
+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) {
+    return uni.showToast({
+      title: t('please_authorize_your_phone_number'),
+      icon: "none",
+    });
+  }
+  if (!avatarUrl.value) {
+    return uni.showToast({
+      title: t('please_select_an_avatar'),
+      icon: "none",
+    });
+  }
+  if (!nickName.value) {
+    return uni.showToast({
+      title: t('please_enter_a_nickname'),
+      icon: "none",
+    });
+  }
+  if (!agree.value) {
+    return uni.showToast({
+      title: t('please_agree_to_the_agreements_first'),
+      icon: "none",
+    });
+  }
+  await doLogin();
+};
+
+async function doLogin() {
+  loading.value = true;
+  try {
+    const wxResult = await wxLogin();
+    const fileManager = uni.getFileSystemManager();
+    const avatarBase64 = fileManager.readFileSync(avatarUrl.value, "base64");
+    const base64Url = `data:image/png;base64,${avatarBase64}`;
+    await loginAPI(phone.value, nickName.value, base64Url, wxResult.code);
+    const data = await getHomeData();
+    if (data.user) updateUser(data.user);
+    const devices = await getMyDevicesAPI();
+    if (devices.bindings && devices.bindings.length) {
+      updateDevice(
+        devices.bindings[0].deviceId,
+        devices.bindings[0].deviceName
+      );
+    } else {
+      clearDevice();
+    }
+    props.onClose();
+    await props.onSuccess();
+  } catch (error) {
+    console.log("login error", error);
+  } finally {
+    loading.value = false;
+  }
+};
+
+const openServiceLink = () => {
+  uni.navigateTo({
+    url:
+      "/pages/webview?url=" +
+      encodeURIComponent(
+        "https://static.shelingxingqiu.com/shootServiceAgreement.html"
+      ),
+  });
+};
+
+const openPrivacyLink = () => {
+  uni.navigateTo({
+    url:
+      "/pages/webview?url=" +
+      encodeURIComponent(
+        "https://static.shelingxingqiu.com/shootPrivacyPolicy.html"
+      ),
+  });
+};
+
+onShow(() => {
+  resetForm();
+});
+</script>
+
+<template>
+  <SModal :show="show" :onClose="onClose" :noBg="noBg">
+    <view class="container" :style="{ background: noBg ? '#fff' : 'none' }">
+      <view class="avatar" :style="{ borderColor: noBg ? '#E3E3E3' : '#fff3' }">
+        <text :style="{ color: noBg ? '#666' : '#fff' }">{{ t('phone') }}</text>
+        <button
+          :open-type="!phone ? 'getPhoneNumber' : ''"
+          @getphonenumber="getphonenumber"
+          class="login-btn"
+          hover-class="none"
+        >
+          <text v-if="phone" :style="{ color: noBg ? '#333' : '#fff' }">{{
+            phone
+          }}</text>
+          <text v-else :style="{ color: noBg ? '#666' : '#fff9' }"
+            >{{ t('authorize') }}</text
+          >
+          <image src="https://static.shelingxingqiu.com/shootmini/static/enter.png" mode="widthFix" />
+        </button>
+      </view>
+      <view class="avatar" :style="{ borderColor: noBg ? '#E3E3E3' : '#fff3' }">
+        <text :style="{ color: noBg ? '#666' : '#fff' }">{{ t('avatar') }}</text>
+        <button
+          open-type="chooseAvatar"
+          @chooseavatar="onChooseAvatar"
+          class="login-btn"
+          hover-class="none"
+        >
+          <Avatar v-if="avatarUrl" :src="avatarUrl" :size="30" />
+          <text v-else :style="{ color: noBg ? '#666' : '#fff9' }"
+            >{{ t('authorize') }}</text
+          >
+          <image src="https://static.shelingxingqiu.com/shootmini/static/enter.png" mode="widthFix" />
+        </button>
+      </view>
+      <view
+        class="nickname"
+        :style="{ borderColor: noBg ? '#E3E3E3' : '#fff3' }"
+      >
+        <text :style="{ color: noBg ? '#666' : '#fff' }">{{ t('nickname') }}</text>
+        <input
+          type="nickname"
+          :value="nickName"
+          :placeholder="t('please_enter_a_nickname')"
+          :placeholder-style="`color: ${noBg ? '#666' : '#fff9'} `"
+          @input="onNicknameChange"
+          @change="onNicknameChange"
+          :style="{ color: noBg ? '#333' : '#fff' }"
+        />
+      </view>
+      <SButton :rounded="20" width="80vw" :onClick="handleLogin">
+        <block v-if="!loading">
+          <text :style="{ color: '#000' }">{{ t('sign_in_with_phone_number') }}</text>
+        </block>
+        <block v-else>
+          <image
+            src="https://static.shelingxingqiu.com/shootmini/static/btn-loading.png"
+            mode="widthFix"
+            class="loading"
+          />
+        </block>
+      </SButton>
+      <view class="protocol" @click="handleAgree">
+        <view
+          v-if="!agree"
+          :style="{ borderColor: noBg ? '#E3E3E3' : '#fff' }"
+        />
+        <image v-if="agree" src="https://static.shelingxingqiu.com/shootmini/static/checked.png" mode="widthFix" />
+        <view>
+          <text>{{ t('i_have_read_and_agree_to_the') }}</text>
+          <view
+            @click.stop="openServiceLink"
+            :style="{ color: noBg ? '#333' : '#ffffff99' }"
+            >{{ t('user_agreement') }}</view
+          >
+          <text>{{ t('and') }}</text>
+          <view
+            @click.stop="openPrivacyLink"
+            :style="{ color: noBg ? '#333' : '#ffffff99' }"
+            >{{ t('privacy_policy') }}</view
+          >
+          <text>{{ t('terms') }}</text>
+        </view>
+      </view>
+    </view>
+  </SModal>
+</template>
+
+<style scoped>
+.container {
+  width: 100%;
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  border-top-left-radius: 24rpx;
+  border-top-right-radius: 24rpx;
+}
+.avatar,
+.nickname {
+  width: 80%;
+  display: flex;
+  align-items: center;
+  margin-bottom: 20px;
+  border-bottom: 1rpx solid #ffffff1a;
+}
+.avatar {
+  margin: 0;
+}
+.avatar > text,
+.nickname > text {
+  width: 20%;
+  font-size: 14px;
+  line-height: 120rpx;
+}
+.avatar > button > text {
+  color: #fff9;
+  font-size: 14px;
+}
+.nickname > input {
+  flex: 1;
+  font-size: 14px;
+  line-height: 120rpx;
+}
+.wechat-icon {
+  width: 24px;
+  height: 24px;
+  margin-right: 20px;
+}
+.protocol {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  font-size: 22rpx;
+  margin: 30rpx 0;
+  color: #8a8a8a;
+}
+.protocol > image {
+  width: 16px;
+  height: 16px;
+  margin-right: 10px;
+}
+.protocol > view:first-child {
+  width: 14px;
+  height: 14px;
+  border-radius: 50%;
+  margin-right: 10px;
+  border: 1px solid #fff;
+}
+.protocol > view:last-child {
+  display: flex;
+  align-items: center;
+}
+.login-btn {
+  line-height: 55px;
+  width: 80%;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+.login-btn > image {
+  width: 28rpx;
+  height: 28rpx;
+}
+.loading {
+  width: 25px;
+  height: 25px;
+  background-blend-mode: darken;
+  animation: rotate 1s linear infinite;
+}
+</style>

src/components/Swiper.vue

@@ -0,0 +1,106 @@
+<script setup>
+import { ref, watch } from "vue";
+
+const props = defineProps({
+  interval: {
+    type: Number,
+    default: 3000,
+  },
+  autoplay: {
+    type: Boolean,
+    default: false,
+  },
+  data: {
+    type: Array,
+    default: () => [],
+  },
+  current: {
+    type: Number,
+    default: 0,
+  },
+  onChange: {
+    type: Function,
+    default: (index) => {},
+  },
+});
+
+const currentIndex = ref(props.current);
+
+watch(
+  () => props.current,
+  (index) => {
+    currentIndex.value = index;
+  }
+);
+
+const handleChange = (e) => {
+  currentIndex.value = e.detail.current;
+  props.onChange(e.detail.current);
+};
+</script>
+
+<template>
+  <view>
+    <swiper
+      class="swiper-container"
+      v-if="data.length > 0"
+      :current="currentIndex"
+      @change="handleChange"
+      :autoplay="autoplay"
+      :interval="interval"
+    >
+      <swiper-item v-for="(imgSrc, index) in data" :key="index">
+        <image :src="imgSrc" mode="widthFix" />
+      </swiper-item>
+    </swiper>
+    <view class="dots">
+      <view
+        v-for="index in data.length"
+        :key="index"
+        class="dot"
+        :class="{ active: currentIndex === index - 1 }"
+      />
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.swiper-container {
+  width: 100%;
+  height: 570px;
+  position: relative;
+  border-radius: 10px;
+  overflow: hidden;
+}
+
+.swiper-container > swiper {
+  width: 100%;
+  height: 100%;
+}
+
+.swiper-container image {
+  width: calc(100% - 20px);
+  margin: 0 10px;
+  border-radius: 10px;
+}
+
+.dots {
+  position: absolute;
+  bottom: 2%;
+  left: 50%;
+  transform: translateX(-50%);
+  display: flex;
+  gap: 8px;
+}
+
+.dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  background-color: #ccc;
+}
+
+.dot.active {
+  background-color: #fed847;
+}
+</style>

src/components/TargetCanvas.vue

@@ -0,0 +1,676 @@
+<script setup>
+import {
+  computed,
+  getCurrentInstance,
+  nextTick,
+  onBeforeUnmount,
+  onMounted,
+  ref,
+  watch,
+} from "vue";
+
+const defaultCanvasSize = 300;
+const defaultRingCount = 10;
+const highlightRevealProgressFrames = [0.08, 0.2, 0.38, 0.6, 0.82, 1];
+const highlightRevealFrameInterval = 60;
+
+const props = defineProps({
+  // canvas 唯一标识；不传时组件内部自动生成，避免多个靶面 canvas-id 冲突。
+  canvasId: {
+    type: String,
+    default: "",
+  },
+  // 业务坐标半径，例如 20 表示命中点坐标范围为 -20 到 20。
+  // 当前组件主要用它参与重绘判断，外层命中点定位也应使用同一半径。
+  coordinateRadius: {
+    type: Number,
+    default: 20,
+  },
+  // 是否显示靶心十字辅助线。
+  showCrosshair: {
+    type: Boolean,
+    default: false,
+  },
+  // 是否显示环数文字。
+  showRingLabels: {
+    type: Boolean,
+    default: true,
+  },
+  // 从正上方开始顺时针等分的区域数量。
+  sectorCount: {
+    type: Number,
+    default: 0,
+  },
+  // 当前高亮区域，范围为 1 到 sectorCount。
+  activeSector: {
+    type: Number,
+    default: 0,
+  },
+  // 指定一个或多个环数，空数组表示高亮整个区域。
+  activeRings: {
+    type: Array,
+    default: () => [],
+  },
+  // 每次变化时以固定低帧数重新展开当前高亮扇区；默认关闭。
+  highlightRefreshToken: {
+    type: Number,
+    default: 0,
+  },
+  showSectorLabels: {
+    type: Boolean,
+    default: false,
+  },
+  // 只绘制透明高亮层，不绘制完整靶纸；用于叠加在靶纸图片上。
+  highlightOnly: {
+    type: Boolean,
+    default: false,
+  },
+  // 外部指定 canvas 绘制尺寸；用于让高亮层跟随靶图真实显示区域。
+  canvasWidth: {
+    type: Number,
+    default: 0,
+  },
+  canvasHeight: {
+    type: Number,
+    default: 0,
+  },
+  // 靶纸样式覆盖配置，例如环数、环色、环线颜色、环数字体等。
+  targetStyleConfig: {
+    type: Object,
+    default: () => ({}),
+  },
+  // 十字辅助线样式覆盖配置。
+  crosshairStyle: {
+    type: Object,
+    default: () => ({}),
+  },
+  // 区域分割线样式覆盖配置。
+  sectorStyle: {
+    type: Object,
+    default: () => ({}),
+  },
+  // 区域数字样式覆盖配置。
+  sectorLabelStyle: {
+    type: Object,
+    default: () => ({}),
+  },
+  // 高亮样式覆盖配置。
+  highlightStyle: {
+    type: Object,
+    default: () => ({}),
+  },
+});
+
+const instance = getCurrentInstance();
+const localCanvasId = `target-canvas-${Math.random().toString(36).slice(2, 10)}`;
+const currentCanvasId = computed(() => props.canvasId || localCanvasId);
+const lastDrawKey = ref("");
+const canvasSize = ref({
+  width: defaultCanvasSize,
+  height: defaultCanvasSize,
+});
+let drawRequestGeneration = 0;
+let highlightAnimationGeneration = 0;
+let highlightAnimationTimer = null;
+let mountDrawTimer = null;
+
+// 完整靶纸默认样式，调用方可以通过 targetStyleConfig 局部覆盖。
+const defaultTargetStyleConfig = {
+  ringCount: defaultRingCount,
+  ringColors: {
+    1: "#f8f8f3",
+    2: "#f8f8f3",
+    3: "#595959",
+    4: "#595959",
+    5: "#24aee0",
+    6: "#24aee0",
+    7: "#ff1f35",
+    8: "#ff1f35",
+    9: "#f7d34a",
+    10: "#f7d34a",
+  },
+  ringLineColor: "rgba(150, 150, 150, 0.55)",
+  ringLineWidthRatio: 0.0022,
+  centerDotColor: "#ffffff",
+  centerDotRadiusRatio: 0.0048,
+  ringLabelFontRatio: 0.032,
+  ringLabelDarkColor: "#111111",
+  ringLabelLightColor: "#ffffff",
+};
+
+// 十字辅助线默认样式。
+const defaultCrosshairStyle = {
+  color: "rgba(20, 20, 20, 0.38)",
+  lineWidthRatio: 0.0025,
+};
+
+// 顺时针等分线默认样式。
+const defaultSectorStyle = {
+  color: "rgba(255, 255, 255, 0.82)",
+  lineWidthRatio: 0.004,
+};
+
+// 区域数字默认样式。
+const defaultSectorLabelStyle = {
+  color: "#ffffff",
+  backgroundColor: "rgba(0, 0, 0, 0.62)",
+  fontSizeRatio: 0.075,
+  radiusRatio: 0.76,
+  badgeRadiusRatio: 0.07,
+};
+
+// 高亮区域默认样式。
+const defaultHighlightStyle = {
+  color: "rgba(255, 228, 0, 0.6)",
+  strokeColor: "rgba(254, 216, 71, 0.82)",
+  lineWidthRatio: 0.003,
+  // 在最小线宽计算后应用倍数，确保不同靶面尺寸下按比例加粗。
+  lineWidthScale: 1,
+};
+
+// 合并默认靶纸样式和外部传入样式，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;
+};
+
+// 过滤、去重并合并连续环，避免 3、4 环同时高亮时绘制中间描边。
+const getActiveRingRanges = (ringCount) => {
+  const rings = [...new Set(
+    (Array.isArray(props.activeRings) ? props.activeRings : [])
+      .map(getPositiveInteger)
+      .filter((ring) => ring >= 1 && ring <= ringCount)
+  )].sort((first, second) => first - second);
+
+  return rings.reduce((ranges, ring) => {
+    const lastRange = ranges[ranges.length - 1];
+    if (lastRange && ring === lastRange.end + 1) {
+      lastRange.end = ring;
+    } else {
+      ranges.push({ start: ring, end: ring });
+    }
+    return ranges;
+  }, []);
+};
+
+// 正上方作为第一区起始边界，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));
+  }
+};
+
+// 高亮后端指定区域；activeRings 非空时高亮该区域内的一个或多个环。
+const drawSectorHighlight = (
+  ctx,
+  centerX,
+  centerY,
+  targetRadius,
+  config,
+  revealProgress = 1
+) => {
+  const angles = getSectorAngles(props.activeSector, props.sectorCount);
+  if (!angles) return;
+
+  const safeRevealProgress = Math.min(
+    Math.max(getNumber(revealProgress, 1), 0),
+    1
+  );
+  if (safeRevealProgress <= 0) return;
+
+  const ringRanges = getActiveRingRanges(config.ringCount);
+  const highlightRanges = ringRanges.length > 0
+    ? ringRanges
+    : [{ start: 1, end: config.ringCount }];
+  const style = {
+    ...defaultHighlightStyle,
+    ...props.highlightStyle,
+  };
+
+  highlightRanges.forEach((range) => {
+    const innerRadius =
+      targetRadius * ((config.ringCount - range.end) / config.ringCount);
+    const outerRadius =
+      targetRadius * ((config.ringCount + 1 - range.start) / config.ringCount);
+
+    drawAnnularSector(
+      ctx,
+      centerX,
+      centerY,
+      innerRadius,
+      outerRadius,
+      angles.startAngle,
+      angles.startAngle +
+        (angles.endAngle - angles.startAngle) * safeRevealProgress,
+      style.color,
+      style.strokeColor,
+      Math.max(1, targetRadius * style.lineWidthRatio) * style.lineWidthScale
+    );
+  });
+};
+
+// 从正上方开始顺时针绘制所有区域边界。
+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,
+    activeRings: props.activeRings,
+    showSectorLabels: props.showSectorLabels,
+    targetStyleConfig: props.targetStyleConfig,
+    crosshairStyle: props.crosshairStyle,
+    sectorStyle: props.sectorStyle,
+    sectorLabelStyle: props.sectorLabelStyle,
+    highlightStyle: props.highlightStyle,
+    highlightOnly: props.highlightOnly,
+  });
+};
+
+// 主绘制入口：根据 highlightOnly 决定画完整靶纸，还是只画透明高亮层。
+const drawTarget = ({ force = false, highlightProgress = 1 } = {}) => {
+  const width = Math.max(getNumber(canvasSize.value.width, defaultCanvasSize), 1);
+  const height = Math.max(getNumber(canvasSize.value.height, defaultCanvasSize), 1);
+  const drawKey = getDrawKey(width, height);
+
+  if (!force && drawKey === lastDrawKey.value) {
+    return;
+  }
+
+  const size = Math.min(width, height);
+  const centerX = width / 2;
+  const centerY = height / 2;
+  const targetRadius = size / 2;
+  const config = mergeTargetStyleConfig();
+  const ctx = uni.createCanvasContext(currentCanvasId.value, instance?.proxy);
+
+  ctx.clearRect(0, 0, width, height);
+
+  if (!props.highlightOnly) {
+    drawTargetRings(ctx, centerX, centerY, targetRadius, config);
+  }
+
+  drawSectorHighlight(
+    ctx,
+    centerX,
+    centerY,
+    targetRadius,
+    config,
+    highlightProgress
+  );
+
+  if (!props.highlightOnly) {
+    drawRingLines(ctx, centerX, centerY, targetRadius, config);
+    drawCircle(
+      ctx,
+      centerX,
+      centerY,
+      Math.max(1, targetRadius * config.centerDotRadiusRatio),
+      config.centerDotColor
+    );
+    drawCrosshair(ctx, centerX, centerY, targetRadius);
+    drawRingLabels(ctx, centerX, centerY, targetRadius, config);
+  }
+
+  // 高亮先画，等分线和编号后画，避免高亮覆盖区域边界。
+  drawSectorLines(ctx, centerX, centerY, targetRadius);
+  drawSectorLabels(ctx, centerX, centerY, targetRadius);
+
+  ctx.draw();
+  lastDrawKey.value = highlightProgress >= 1 ? drawKey : "";
+};
+
+const cancelHighlightAnimation = () => {
+  highlightAnimationGeneration += 1;
+  if (highlightAnimationTimer) {
+    clearTimeout(highlightAnimationTimer);
+    highlightAnimationTimer = null;
+  }
+};
+
+// 固定 6 帧展开黄色扇区，避免对原生 canvas 节点做缩放导致低端机错位。
+const runHighlightRevealAnimation = () => {
+  cancelHighlightAnimation();
+  const generation = highlightAnimationGeneration;
+  let frameIndex = 0;
+
+  const drawNextFrame = () => {
+    if (generation !== highlightAnimationGeneration) return;
+
+    drawTarget({
+      force: true,
+      highlightProgress: highlightRevealProgressFrames[frameIndex],
+    });
+    frameIndex += 1;
+
+    if (frameIndex < highlightRevealProgressFrames.length) {
+      highlightAnimationTimer = setTimeout(
+        drawNextFrame,
+        highlightRevealFrameInterval
+      );
+    } else {
+      highlightAnimationTimer = null;
+    }
+  };
+
+  drawNextFrame();
+};
+
+const setCanvasSizeAndDraw = async (
+  width,
+  height,
+  { animateHighlight = false, requestGeneration } = {}
+) => {
+  canvasSize.value = {
+    width: width > 0 ? width : defaultCanvasSize,
+    height: height > 0 ? height : width || defaultCanvasSize,
+  };
+
+  await nextTick();
+  if (requestGeneration !== drawRequestGeneration) return;
+
+  const canAnimateHighlight =
+    animateHighlight &&
+    props.highlightOnly &&
+    !!getSectorAngles(props.activeSector, props.sectorCount);
+
+  if (canAnimateHighlight) {
+    runHighlightRevealAnimation();
+  } else {
+    cancelHighlightAnimation();
+    drawTarget();
+  }
+};
+
+// 读取 canvas 实际渲染尺寸后再绘制，保证小程序真机尺寸和坐标一致。
+const measureAndDraw = ({ animateHighlight = false } = {}) => {
+  const requestGeneration = ++drawRequestGeneration;
+  const propWidth = Math.round(getNumber(props.canvasWidth, 0));
+  const propHeight = Math.round(getNumber(props.canvasHeight, 0));
+
+  if (propWidth > 0 && propHeight > 0) {
+    setCanvasSizeAndDraw(propWidth, propHeight, {
+      animateHighlight,
+      requestGeneration,
+    });
+    return;
+  }
+
+  const query = uni.createSelectorQuery().in(instance?.proxy);
+
+  query
+    .select(`#${currentCanvasId.value}`)
+    .boundingClientRect(async (rect) => {
+      if (requestGeneration !== drawRequestGeneration) return;
+
+      const width = Math.round(getNumber(rect?.width, defaultCanvasSize));
+      const height = Math.round(getNumber(rect?.height, width || defaultCanvasSize));
+
+      await setCanvasSizeAndDraw(width, height, {
+        animateHighlight,
+        requestGeneration,
+      });
+    })
+    .exec();
+};
+
+// 等待 Vue 完成 DOM 更新后重新测量和绘制。
+const scheduleDraw = async ({ animateHighlight = false } = {}) => {
+  await nextTick();
+  measureAndDraw({ animateHighlight });
+};
+
+watch(
+  () => [
+    props.coordinateRadius,
+    props.showCrosshair,
+    props.showRingLabels,
+    props.sectorCount,
+    props.activeSector,
+    props.activeRings,
+    props.highlightRefreshToken,
+    props.showSectorLabels,
+    props.highlightOnly,
+    props.canvasWidth,
+    props.canvasHeight,
+    props.targetStyleConfig,
+    props.crosshairStyle,
+    props.sectorStyle,
+    props.sectorLabelStyle,
+    props.highlightStyle,
+  ],
+  (currentValues, previousValues = []) => {
+    const refreshTokenIndex = 6;
+    const refreshToken = Number(currentValues[refreshTokenIndex]);
+    const previousRefreshToken = Number(previousValues[refreshTokenIndex]);
+    const animateHighlight =
+      Number.isFinite(refreshToken) &&
+      refreshToken > 0 &&
+      refreshToken !== previousRefreshToken;
+
+    return scheduleDraw({ animateHighlight });
+  },
+  {
+    deep: true,
+  }
+);
+
+onMounted(() => {
+  mountDrawTimer = setTimeout(measureAndDraw, 30);
+});
+
+onBeforeUnmount(() => {
+  drawRequestGeneration += 1;
+  cancelHighlightAnimation();
+  if (mountDrawTimer) {
+    clearTimeout(mountDrawTimer);
+    mountDrawTimer = null;
+  }
+});
+</script>
+
+<template>
+  <canvas
+    :id="currentCanvasId"
+    class="target-canvas"
+    :canvas-id="currentCanvasId"
+    :width="canvasSize.width"
+    :height="canvasSize.height"
+  />
+</template>
+
+<style scoped>
+.target-canvas {
+  display: block;
+  width: 100%;
+  height: 100%;
+}
+</style>

src/components/TargetPicker.vue

@@ -0,0 +1,216 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref, watch } from "vue";
+import SButton from "@/components/SButton.vue";
+import audioManager from "@/audioManager";
+
+const props = defineProps({
+  show: {
+    type: Boolean,
+    default: false,
+  },
+  clickSound: {
+    type: Boolean,
+    default: false,
+  },
+  onClose: {
+    type: Function,
+    default: () => {},
+  },
+  onConfirm: {
+    type: Function,
+    default: () => {},
+  },
+});
+
+const selectedTarget = ref(2);
+const showContainer = ref(false);
+const showContent = ref(false);
+
+watch(
+  () => props.show,
+  (newValue) => {
+    if (newValue) {
+      showContainer.value = true;
+      setTimeout(() => {
+        showContent.value = true;
+      }, 100);
+    } else {
+      showContent.value = false;
+      setTimeout(() => {
+        showContainer.value = false;
+      }, 100);
+    }
+  },
+  {}
+);
+
+const playClickSound = () => {
+  if (props.clickSound) {
+    audioManager.play("点击按钮");
+  }
+};
+
+const handleSelectTarget = (target) => {
+  playClickSound();
+  selectedTarget.value = target;
+};
+
+const handleConfirm = () => {
+  playClickSound();
+  props.onConfirm(selectedTarget.value);
+  props.onClose();
+};
+</script>
+
+<template>
+  <view
+    class="container"
+    v-if="showContainer"
+    :class="{ 'container-show': showContent }"
+    @click="onClose"
+  >
+    <view
+      class="modal-content"
+      :class="{ 'modal-show': showContent }"
+      @click.stop=""
+    >
+      <view class="header">
+        <view class="header-title">
+          <view class="header-title-line-left"></view>
+          <text>{{ t('select_target_type') }}</text>
+          <view class="header-title-line-right"></view>
+        </view>
+        <view class="close-btn" @click="onClose">
+          <image src="https://static.shelingxingqiu.com/shootmini/static/close-yellow.png" mode="widthFix" />
+        </view>
+      </view>
+      <view class="target-options">
+        <view
+          :class="{ 'target-btn': true, 'target-choosen': selectedTarget === 1 }"
+          @click="handleSelectTarget(1)"
+        >
+          <text>{{ t('20_cm_full_ring_target') }}</text>
+        </view>
+        <view style="width: 30rpx"></view>
+        <view
+          :class="{ 'target-btn': true, 'target-choosen': selectedTarget === 2 }"
+          @click="handleSelectTarget(2)"
+        >
+          <text>{{ t('40_cm_full_ring_target') }}</text>
+        </view>
+      </view>
+      <SButton width="694rpx" :onClick="handleConfirm">{{ t('confirm_134') }}</SButton>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  position: fixed;
+  top: 0;
+  left: 0;
+  background-color: #00000099;
+  width: 100vw;
+  height: 100vh;
+  display: flex;
+  flex-direction: column;
+  justify-content: flex-end;
+  align-items: center;
+  opacity: 0;
+  transition: all 0.3s ease;
+  z-index: 999;
+}
+.container-show {
+  opacity: 1;
+}
+.modal-content {
+  width: 100%;
+  transform: translateY(100%);
+  transition: all 0.3s ease;
+  background: url("https://static.shelingxingqiu.com/attachment/2025-12-04/dep11770wzxg6o2alo.png")
+    no-repeat center top;
+  background-size: 100% auto;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  box-sizing: border-box;
+  padding-bottom: 68rpx;
+  padding-top: 44rpx;
+}
+.modal-show {
+  transform: translateY(0%);
+}
+.header {
+  width: 100%;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  position: relative;
+  margin-bottom: 44rpx;
+}
+.header-title{
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+.header-title text{
+  width: 196rpx;
+  height: 40rpx;
+  font-family: PingFang SC, PingFang SC;
+  font-weight: 400;
+  font-size: 28rpx;
+  text-align: center;
+  font-style: normal;
+  text-transform: none;
+  color: #FFEFBA;
+}
+.header-title-line-left{
+  width: 214rpx;
+  height: 0rpx;
+  border-radius: 0rpx 0rpx 0rpx 0rpx;
+  border: 1rpx solid;
+  border-image: linear-gradient(90deg, rgba(133, 119, 96, 1), rgba(133, 119, 96, 0)) 1 1;
+}
+.header-title-line-right{
+  width: 214rpx;
+  height: 0rpx;
+  border-radius: 0rpx 0rpx 0rpx 0rpx;
+  border: 1rpx solid;
+  border-image: linear-gradient(90deg, rgba(133, 119, 96, 1), rgba(133, 119, 96, 0)) 1 1;
+ }
+.close-btn {
+  position: absolute;
+  right: 0;
+  top: -10px;
+}
+.close-btn > image {
+  width: 40px;
+  height: 40px;
+}
+.target-options {
+  width: 750rpx;
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: center;
+  margin-bottom: 38rpx;
+}
+.target-btn {
+  width: 332rpx;
+  height: 92rpx;
+  text-align: center;
+  border-radius: 10px;
+  border: 2rpx solid #fff3;
+  box-sizing: border-box;
+  color: #fff;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+}
+.target-choosen {
+  color: #fed847;
+  border: 4rpx solid #fed847;
+}
+</style>

src/components/TeamAvatars.vue

@@ -0,0 +1,152 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref, watch } from "vue";
+const props = defineProps({
+  isRed: {
+    type: Boolean,
+    default: true,
+  },
+  team: {
+    type: Array,
+    default: () => [],
+  },
+  currentShooterId: {
+    type: [Number, String],
+    default: "",
+  },
+});
+const players = ref({});
+const currentTeam = ref(false);
+const firstName = ref("");
+
+// 抽出判断：当前队伍且该玩家排序为 0（队伍首位）
+const isFirst = (id) =>
+  currentTeam.value && ((players.value[id] || {}).sort || 0) === 0;
+
+const getPos = (id) => {
+  const sort = (players.value[id] || {}).sort || 0;
+  if (currentTeam.value) {
+    return 30 * (sort + Math.ceil(sort / 2));
+  }
+  return sort * 40;
+};
+
+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.team, () => props.currentShooterId],
+  syncPlayers,
+  { immediate: true, deep: true }
+);
+</script>
+
+<template>
+  <view class="container">
+    <image
+      :src="isRed ? 'https://static.shelingxingqiu.com/shootmini/static/flag-red.png' : 'https://static.shelingxingqiu.com/shootmini/static/flag-blue.png'"
+      class="flag"
+      :style="{
+        [isRed ? 'left' : 'right']: '10rpx',
+        top: currentTeam ? '-36rpx' : '-24rpx',
+      }"
+    />
+    <view
+      v-for="(item, index) in team"
+      :key="item.id || index"
+      class="player"
+      :style="{
+        width: (isFirst(item.id) ? 80 : 60) + 'rpx',
+        height: (isFirst(item.id) ? 80 : 60) + 'rpx',
+        zIndex: team.length - ((players[item.id] || {}).sort || 0),
+        border: isFirst(item.id) ? '3.5rpx solid' : '2rpx solid',
+        borderColor: isRed ? '#ff6060' : '#5fadff',
+        top: isFirst(item.id) ? '0rpx' : '12rpx',
+        [isRed ? 'left' : 'right']: getPos(item.id) + 'rpx',
+      }"
+    >
+      <image :src="item.avatar || 'https://static.shelingxingqiu.com/shootmini/static/user-icon.png'" mode="widthFix" />
+      <text
+        v-if="isFirst(item.id)"
+        :style="{ backgroundColor: isRed ? '#ff6060' : '#5fadff' }"
+        >{{ isRed ? t('red_team') : t('blue_team') }}</text
+      >
+    </view>
+    <text
+      v-if="currentTeam"
+      class="truncate"
+      :style="{
+        color: isRed ? '#ff6060' : '#5fadff',
+        [isRed ? 'left' : 'right']: '-4rpx',
+      }"
+      >{{ firstName }}</text
+    >
+  </view>
+</template>
+
+<style scoped>
+.container {
+  display: flex;
+  align-items: center;
+  position: relative;
+  width: 20vw;
+  height: 10rpx;
+  margin: 0 20rpx;
+}
+.container > text {
+  position: absolute;
+  font-size: 20rpx;
+  text-align: center;
+  width: 80rpx;
+  bottom: -100rpx;
+}
+.player {
+  transition: all 0.3s ease;
+  position: absolute;
+  border-radius: 50%;
+  overflow: hidden;
+  box-sizing: border-box;
+}
+.player > image {
+  width: 100%;
+  min-height: 100%;
+}
+.player > text {
+  position: absolute;
+  font-size: 15rpx;
+  text-align: center;
+  width: 76rpx;
+  left: 0;
+  bottom: 0;
+  color: #fff;
+}
+.flag {
+  position: absolute;
+  width: 45rpx;
+  height: 45rpx;
+  transition: all 0.3s ease;
+}
+</style>

src/components/TestDistance.vue

@@ -0,0 +1,249 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref, onMounted, onBeforeUnmount } from "vue";
+import Guide from "@/components/Guide.vue";
+import BowPower from "@/components/BowPower.vue";
+import Avatar from "@/components/Avatar.vue";
+import audioManager from "@/audioManager";
+import { simulShootAPI } from "@/apis";
+import { MESSAGETYPESV2 } from "@/constants";
+import {
+  getDistanceCheckAudioKey,
+  getDistanceCheckText,
+  getShootValidation,
+} from "@/util";
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+const store = useStore();
+const { user, device } = storeToRefs(store);
+const emit = defineEmits(["passed"]);
+const props = defineProps({
+  guide: {
+    type: Boolean,
+    default: true,
+  },
+  isBattle: {
+    type: Boolean,
+    default: false,
+  },
+  count: {
+    type: Number,
+    default: 15,
+  },
+  targetType: {
+    type: [Number, String],
+    default: 40,
+  },
+  autoStart: {
+    type: Boolean,
+    default: false,
+  },
+});
+const arrow = ref({});
+const distance = ref(0);
+const statusText = ref("");
+const showsimul = ref(false);
+const count = ref(props.count);
+const timer = ref(null);
+const autoStartPending = ref(false);
+const autoStartTriggered = ref(false);
+let autoStartTimer = null;
+const DISTANCE_PASSED_AUDIO_KEY = "站距合格，靶纸正确";
+const AUTO_START_TIMEOUT_MS = 6000;
+
+const clearAutoStartTimer = () => {
+  if (!autoStartTimer) return;
+  clearTimeout(autoStartTimer);
+  autoStartTimer = null;
+};
+
+const triggerAutoStart = () => {
+  if (!autoStartPending.value || autoStartTriggered.value) return;
+  clearAutoStartTimer();
+  autoStartPending.value = false;
+  autoStartTriggered.value = true;
+  emit("passed");
+};
+
+const onAudioEnded = (key) => {
+  if (key === DISTANCE_PASSED_AUDIO_KEY) triggerAutoStart();
+};
+
+const updateTimer = (value) => {
+  count.value = Math.round(value);
+};
+onMounted(() => {
+  audioManager.play("请射箭！测试站距与靶纸");
+  if (props.isBattle) {
+    timer.value = setInterval(() => {
+      count.value -= 1;
+      if (count.value < 0) clearInterval(timer.value);
+    }, 1000);
+  }
+  uni.$on("update-timer", updateTimer);
+  uni.$on("audioEnded", onAudioEnded);
+});
+onBeforeUnmount(() => {
+  if (timer.value) clearInterval(timer.value);
+  clearAutoStartTimer();
+  uni.$off("update-timer", updateTimer);
+  uni.$off("audioEnded", onAudioEnded);
+});
+
+async function onReceiveMessage(msg) {
+  if (Array.isArray(msg)) return;
+  if (msg.type === MESSAGETYPESV2.TestDistance) {
+    if (autoStartPending.value || autoStartTriggered.value) return;
+    const rawDistance = Number(msg.shootData?.distance ?? msg.shootData?.dst);
+    distance.value = Number.isFinite(rawDistance)
+      ? Number((rawDistance / 100).toFixed(2))
+      : 0;
+    statusText.value = getDistanceCheckText(msg.shootData);
+    const audioKey = getDistanceCheckAudioKey(msg.shootData);
+    const validation = getShootValidation(msg.shootData);
+    if (props.autoStart && validation.distanceOk && validation.targetOk) {
+      autoStartPending.value = true;
+      autoStartTimer = setTimeout(triggerAutoStart, AUTO_START_TIMEOUT_MS);
+    }
+    audioManager.play(audioKey);
+  }
+}
+
+const simulShoot = async () => {
+  if (device.value.deviceId) {
+    await simulShootAPI(
+      device.value.deviceId,
+      undefined,
+      undefined,
+      props.targetType
+    );
+  }
+};
+
+onMounted(() => {
+  uni.$on("socket-inbox", onReceiveMessage);
+  const accountInfo = uni.getAccountInfoSync();
+  const envVersion = accountInfo.miniProgram.envVersion;
+  if (envVersion !== "release") showsimul.value = true;
+});
+
+onBeforeUnmount(() => {
+  uni.$off("socket-inbox", onReceiveMessage);
+});
+</script>
+
+<template>
+  <view class="container">
+    <Guide v-show="guide">
+      <view class="guide-tips">
+        <text>{{ t('stand_at_least_5_m_from_the_target') }}</text>
+        <text>{{ t('shots_from_under_5_m_do_not_count') }}</text>
+      </view>
+    </Guide>
+    <view class="test-area">
+      <image
+        class="text-bg"
+        src="https://static.shelingxingqiu.com/attachment/2025-07-05/db3skuq1n9rj4fmld4.png"
+        mode="widthFix"
+      />
+      <button
+        class="simul"
+        @click="simulShoot"
+        hover-class="none"
+        v-if="showsimul"
+      >{{ t('simulate_shot') }}</button>
+      <view class="warnning-text">
+        <block v-if="statusText">
+          <text>{{ statusText }}</text>
+        </block>
+        <block v-else>
+          <text>{{ t('shoot_to_check_distance_and_target_face') }}</text>
+        </block>
+      </view>
+      <view class="user-row">
+        <Avatar :src="user.avatar" :size="35" />
+        <BowPower />
+      </view>
+    </view>
+    <view v-if="isBattle" class="ready-timer">
+      <image src="https://static.shelingxingqiu.com/shootmini/static/test-tip.png" mode="widthFix" />
+      <view v-if="count >= 0">
+        <text>{{ t('match_starts_in') }}</text>
+        <text>{{ count }}</text>
+        <text>{{ t('s') }}</text>
+      </view>
+      <view v-else>{{ t('joining') }}</view>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  width: 100vw;
+  max-height: 70vh;
+}
+.ready-timer {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  transform: translateY(-10vw);
+}
+.ready-timer > image:first-child {
+  width: 40%;
+}
+.ready-timer > view {
+  width: 80%;
+  height: 45px;
+  background-color: #545454;
+  border-radius: 30px;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  transform: translateY(-8vw);
+  color: #bebebe;
+  font-size: 15px;
+}
+.ready-timer > view > text:nth-child(2) {
+  color: #fed847;
+  font-size: 20px;
+  width: 22px;
+  text-align: center;
+}
+.test-area {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: space-between;
+  width: 100%;
+  height: 112vw;
+  position: relative;
+}
+.test-area > view:last-child {
+  padding: 15px;
+  width: calc(100% - 30px);
+}
+.text-bg {
+  width: 100%;
+  position: absolute;
+  top: -14.4%;
+  left: 0;
+}
+.warnning-text {
+  color: #fed847;
+  font-size: 27px;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  height: 40%;
+}
+.warnning-text > text {
+  width: 70vw;
+  text-align: center;
+}
+.simul {
+  position: absolute;
+  color: #fff;
+  right: 10px;
+}
+</style>

src/components/Timer.vue

@@ -0,0 +1,83 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref, watch, onMounted, onBeforeUnmount } from "vue";
+const props = defineProps({
+  countdown: {
+    type: Number,
+    default: 15,
+  },
+});
+const show = ref(false);
+const count = ref(props.countdown);
+const timer = ref(null);
+const showTimer = ref(null);
+const updateTimer = (value) => {
+  count.value = Math.round(value);
+};
+onMounted(() => {
+  showTimer.value = setTimeout(() => {
+    showTimer.value = null;
+    show.value = true;
+    timer.value = setInterval(() => {
+      if (count.value === 0) {
+        show.value = false;
+        clearInterval(timer.value);
+      } else {
+        count.value -= 1;
+      }
+    }, 1000);
+  }, 300);
+  uni.$on("update-timer", updateTimer);
+});
+onBeforeUnmount(() => {
+  if (showTimer.value) clearTimeout(showTimer.value);
+  showTimer.value = null;
+  if (timer.value) clearInterval(timer.value);
+  timer.value = null;
+  uni.$off("update-timer", updateTimer);
+});
+</script>
+
+<template>
+  <view
+    class="container"
+    :style="{ transform: `translateX(${show ? '0' : '100'}%)` }"
+  >
+    <view>{{ t('match') }}</view>
+    <view>
+      <text>{{ t('starts_in') }}</text>
+      <text>{{ count }}</text>
+      <text>{{ t('s') }}</text>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  transform: translateX(100%);
+  position: fixed;
+  bottom: 20%;
+  right: 0;
+  transition: all 0.3s ease;
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  color: #fff9;
+  font-size: 14px;
+  padding: 10px;
+  background-color: #00000066;
+  border-top-left-radius: 10px;
+  border-bottom-left-radius: 10px;
+}
+.container > view {
+  display: flex;
+  align-items: center;
+}
+.container > view:last-child > text:nth-child(2) {
+  color: #fed847;
+  font-size: 16px;
+  width: 18px;
+  text-align: center;
+}
+</style>

src/components/TrainingScorePanel.vue

@@ -0,0 +1,170 @@
+<script setup>
+import { t } from "@/locales";
+
+import { computed } from "vue";
+
+const MAX_VISIBLE_SCORE_CARDS = 60;
+
+const props = defineProps({
+  arrows: {
+    type: Array,
+    default: () => [],
+  },
+  total: {
+    type: Number,
+    default: 0,
+  },
+  trainingType: {
+    type: String,
+    default: "",
+  },
+  recordMode: {
+    type: Boolean,
+    default: false,
+  },
+});
+
+const getDisplayText = (arrow = {}) => {
+  if (!arrow) return "";
+  if (!arrow.ring) return props.trainingType === "stability" ? "-" : "0";
+  return arrow.ringX ? "X" : String(arrow.ring);
+};
+
+const isFailed = (arrow = {}) => {
+  if (!arrow) return false;
+  if (
+    props.recordMode &&
+    props.trainingType !== "precision" &&
+    props.trainingType !== "rhythm" &&
+    props.trainingType !== "stability"
+  ) {
+    return false;
+  }
+  return arrow.ok !== true;
+};
+
+const hiddenScoreCount = computed(() =>
+  props.recordMode
+    ? 0
+    : Math.max(props.arrows.length - MAX_VISIBLE_SCORE_CARDS, 0)
+);
+
+const displayArrows = computed(() => {
+  const list = props.recordMode
+    ? [...props.arrows]
+    : props.arrows.slice(-MAX_VISIBLE_SCORE_CARDS);
+  // total 是达标箭数，不是实际射箭上限；训练中始终预留下一箭空框。
+  if (!props.recordMode) list.push(null);
+  return list;
+});
+</script>
+
+<template>
+  <view v-if="displayArrows.length" class="score-panel">
+    <text v-if="hiddenScoreCount" class="score-window-tip">{{ t('earlier') }}{{ hiddenScoreCount }}{{ t('arrows_hidden_showing_the_latest') }}{{ MAX_VISIBLE_SCORE_CARDS }}{{ t('arrows_241') }}</text>
+    <view class="score-grid">
+      <view
+        v-for="(arrow, index) in displayArrows"
+        :key="index"
+        class="score-card"
+      >
+        <image
+          class="score-card-bg"
+          :src="
+            isFailed(arrow)
+              ? 'https://static.shelingxingqiu.com/shootmini/static/training-difficulty-design/block-gray.png'
+              : 'https://static.shelingxingqiu.com/shootmini/static/training-difficulty-design/block-gold.png'
+          "
+        />
+        <image
+          v-if="trainingType === 'precision' && arrow"
+          class="score-result-icon"
+          :src="
+            arrow.ok === true
+              ? 'https://static.shelingxingqiu.com/shootmini/static/training-difficulty-design/gou.png'
+              : 'https://static.shelingxingqiu.com/shootmini/static/training-difficulty-design/cha.png'
+          "
+          mode="aspectFit"
+        />
+        <text
+          v-else
+          class="score-value"
+          :class="{ 'score-value--low': isFailed(arrow) }"
+        >
+          {{ getDisplayText(arrow) }}
+        </text>
+      </view>
+    </view>
+  </view>
+</template>
+
+<style scoped lang="scss">
+.score-panel {
+  width: 100%;
+  padding: 30rpx 40rpx 0 40rpx;
+  box-sizing: border-box;
+}
+
+.score-grid {
+  display: flex;
+  flex-wrap: wrap;
+}
+
+.score-window-tip {
+  display: block;
+  margin-bottom: 18rpx;
+  color: rgba(255, 255, 255, 0.6);
+  font-size: 22rpx;
+  line-height: 1.4;
+}
+
+.score-card {
+  position: relative;
+  width: 100rpx;
+  height: 56rpx;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  overflow: hidden;
+  margin-right: 14rpx;
+  margin-bottom: 14rpx;
+}
+
+.score-card:nth-child(6n) {
+  margin-right: 0;
+}
+
+.score-card-bg {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100rpx;
+  height: 56rpx;
+}
+
+.score-result-icon {
+  position: relative;
+  z-index: 1;
+  width: 30rpx;
+  height: 30rpx;
+}
+
+.score-value {
+  position: relative;
+  z-index: 1;
+  min-width: 28rpx;
+  text-align: center;
+  font-size: 34rpx;
+  line-height: 1;
+  font-weight: 700;
+  font-style: italic;
+  color: #f6e3b2;
+  text-shadow: 0 2rpx 0 rgba(36, 36, 48, 0.5);
+  margin-left: -10rpx;
+}
+
+.score-value--low {
+  color: #cfcfcf;
+  text-shadow: 0 2rpx 0 rgba(0, 0, 0, 0.5);
+}
+</style>

src/components/UserHeader.vue

@@ -0,0 +1,305 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref, computed, watch } from "vue";
+import Avatar from "@/components/Avatar.vue";
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+const store = useStore();
+const { user, config, rankData } = storeToRefs(store);
+const props = defineProps({
+  showRank: {
+    type: Boolean,
+    default: false,
+  },
+  fullNickname: {
+    type: Boolean,
+    default: false,
+  },
+  onSignin: {
+    type: Function,
+    default: () => {},
+  },
+});
+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();
+  const currentPage = pages[pages.length - 1];
+
+  // 如果当前不是用户页面才进行跳转
+  if (currentPage.route !== "pages/user") {
+    uni.navigateTo({
+      url: "/pages/user",
+    });
+  }
+};
+const toRankListPage = () => {
+  uni.navigateTo({
+    url: "/pages/rank-list",
+  });
+};
+
+watch(
+  () => [config.value, user.value],
+  ([n_config, n_user]) => {
+    const rankInfos = n_config.randInfos || [];
+    if (n_user.id && rankInfos.length) {
+      rankInfos.some((r, index) => {
+        if (r.upgrade_scores && r.upgrade_scores > n_user.scores) {
+          nextLvlPoints.value = r.upgrade_scores;
+          return true;
+        }
+        return false;
+      });
+    }
+  },
+  {
+    immediate: true,
+    deep: true,
+  }
+);
+</script>
+
+<template>
+  <view
+    :class="[
+      'container',
+      fullNickname ? 'container--full-nickname' : '',
+    ]"
+    :style="{ width: containerWidth }"
+  >
+    <block v-if="user.id">
+      <Avatar
+        :rankLvl="user.rankLvl"
+        :src="user.avatar"
+        :onClick="toUserPage"
+        :size="42"
+      />
+      <view class="user-details" @click="toUserPage">
+        <view class="user-name">
+          <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="https://static.shelingxingqiu.com/shootmini/static/vip1.png"
+            mode="widthFix"
+          /> -->
+        </view>
+        <view class="user-stats">
+          <text class="level-tag level-tag-first">{{ t('rank_points') }}</text>
+          <view class="rank-tag">
+            <view
+              class="rank-tag-progress"
+              :style="{
+                width: `${(Math.max(user.scores, 0) / nextLvlPoints) * 100}%`,
+              }"
+            />
+            <text class="rank-tag-text">
+              {{ Math.max(user.scores, 0) }}/{{ nextLvlPoints }}
+            </text>
+          </view>
+        </view>
+      </view>
+      <view v-if="showRank === true" class="rank-info" @click="toRankListPage">
+        <image
+          class="rank-info-image"
+          src="https://static.shelingxingqiu.com/shootmini/static/global-rank.png"
+          mode="widthFix"
+        />
+        <block v-if="user.ranking > 0 && rankData.rank.length">
+          <text>{{ t('national_rank_this_season') }}</text>
+          <text class="rank-number"
+            >{{ t('round') }}<text :style="{ color: '#ffd700' }"
+              >{{ user.ranking }}/{{ rankData.rank.length }}</text
+            >{{ t('empty') }}</text
+          >
+        </block>
+        <block v-else>
+          <text>{{ t('this_season') }}</text>
+          <text>{{ t('unranked') }}</text>
+        </block>
+      </view>
+    </block>
+    <block v-else>
+      <view class="signin" @click="onSignin">
+        <image src="https://static.shelingxingqiu.com/shootmini/static/user-icon.png" mode="widthFix" />
+        <view>
+          <text>{{ t('welcome_new_archer') }}</text>
+          <view>
+            <text>{{ t('sign_in') }}</text>
+            <image src="https://static.shelingxingqiu.com/shootmini/static/enter-arrow-blue.png" mode="widthFix" />
+          </view>
+        </view>
+      </view>
+    </block>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  display: flex;
+  align-items: center;
+  width: 72vw;
+  height: 50px;
+  padding-left: 15px;
+  color: #fff;
+}
+
+.user-details {
+  display: flex;
+  flex-direction: column;
+  padding-left: 10px;
+}
+
+.user-name {
+  display: flex;
+  align-items: center;
+  margin-bottom: 5px;
+}
+
+.user-name .member-nickname {
+  max-width: 180rpx;
+}
+
+.container--full-nickname .user-details {
+  flex: 1;
+  min-width: 0;
+}
+
+.container--full-nickname .user-name {
+  width: 100%;
+}
+
+.container--full-nickname .user-name .member-nickname {
+  max-width: 80%;
+}
+
+.user-name .member-nickname__text,
+.user-name .member-nickname__shine {
+  font-size: 13px;
+}
+
+.user-name-image {
+  margin-left: 5px;
+  width: 40rpx;
+  height: 40rpx;
+}
+
+.user-stats {
+  display: flex;
+  gap: 5px;
+}
+
+.level-tag {
+  text-align: center;
+  line-height: 16px;
+}
+
+.level-tag-first {
+  padding: 0 10rpx;
+  background: #5f51ff;
+  word-break: keep-all;
+}
+
+.level-tag,
+.rank-tag {
+  border-radius: 12px;
+  font-size: 9px;
+}
+
+.rank-tag {
+  position: relative;
+  background-color: #00000038;
+  width: 140rpx;
+  overflow: hidden;
+  word-break: keep-all;
+}
+
+.rank-tag-progress {
+  background: #ffa711;
+  height: 100%;
+  border-radius: 12px;
+  width: 0;
+  transition: width 0.3s ease;
+}
+
+.rank-tag-text {
+  position: absolute;
+  top: 0;
+  left: 0;
+  line-height: 16px;
+  width: 100%;
+  text-align: center;
+}
+
+.rank-info {
+  width: 95px;
+  height: 50px;
+  font-size: 24rpx;
+  position: relative;
+  color: #b3b3b3;
+  padding-left: 12px;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+}
+.rank-info-image {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 95px;
+}
+.rank-info > text {
+  text-align: center;
+  word-break: keep-all;
+  width: 83px;
+}
+.rank-number {
+  display: block;
+}
+.signin {
+  display: flex;
+  align-items: center;
+}
+.signin > image {
+  border-radius: 50%;
+  width: 40px;
+  height: 40px;
+}
+.signin > view {
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: flex-start;
+  margin-left: 12px;
+  font-size: 14px;
+}
+.signin > view > view:last-child {
+  display: flex;
+  align-items: center;
+}
+.signin > view > view:last-child > text {
+  color: #39a8ff;
+  margin-top: 2px;
+}
+.signin > view > view:last-child > image {
+  width: 15px;
+  margin-top: 2px;
+}
+</style>

src/components/UserItem.vue

@@ -0,0 +1,62 @@
+<script setup>
+defineProps({
+  title: {
+    type: String,
+    default: "",
+  },
+  value: {
+    type: String,
+    default: "",
+  },
+  customStyle: {
+    type: Object,
+    default: () => ({}),
+  },
+  onClick: {
+    type: Function,
+    default: null,
+  },
+});
+</script>
+
+<template>
+  <view class="user-item" :style="customStyle" @click="onClick">
+    <text>{{ title }}</text>
+    <view>
+      <slot></slot>
+      <view v-if="onClick !== null">
+        <image src="https://static.shelingxingqiu.com/shootmini/static/enter.png" mode="widthFix" />
+      </view>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.user-item {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  background-color: #fff;
+  height: 55px;
+  border-bottom: 1px solid #f5f5f5;
+}
+.user-item > text {
+  margin-left: 15px;
+  font-size: 14px;
+  color: #000;
+}
+.user-item > view {
+  display: flex;
+  align-items: center;
+  font-size: 13px;
+  color: #999;
+  margin-right: 10px;
+}
+.user-item > view image {
+  width: 24px;
+  height: 24px;
+}
+.user-item > view button {
+  margin-left: 5px;
+}
+</style>

src/components/UserUpgrade.vue

@@ -0,0 +1,167 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref, onMounted, onBeforeUnmount } from "vue";
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+const store = useStore();
+const { user } = storeToRefs(store);
+const { updateUser, getLvlName, getLvlImage } = store;
+const show = ref(false);
+const showRank = ref(false);
+const showGrade = ref(false);
+const nextRankTitle = ref("");
+const nextRankImage = ref("");
+const lvl = ref(0);
+const timer = ref(null);
+
+onMounted(async () => {
+  timer.value = setTimeout(() => {
+    let latestRank = 0;
+    let latestLvl = 0;
+    latestRank = parseInt(uni.getStorageSync("latestRank") || 0);
+    latestLvl = parseInt(uni.getStorageSync("latestLvl") || 0);
+    let timeout = 0;
+    if (latestRank > user.value.rankLvl) {
+      nextRankTitle.value = getLvlName(latestRank);
+      nextRankImage.value = getLvlImage(latestRank);
+      show.value = true;
+      showRank.value = true;
+      timeout += 2000;
+      updateUser({ ...user.value, rankLvl: latestRank });
+    }
+    if (latestLvl > user.value.lvl) {
+      lvl.value = latestLvl;
+      show.value = true;
+      setTimeout(() => {
+        showRank.value = false;
+        showGrade.value = true;
+      }, timeout);
+      timeout += 2000;
+      updateUser({ ...user.value, lvl: latestLvl });
+    }
+    setTimeout(() => {
+      show.value = false;
+    }, timeout);
+  }, 1000);
+});
+
+onBeforeUnmount(() => {
+  if (timer.value) clearTimeout(timer.value);
+});
+</script>
+
+<template>
+  <view class="content" :style="{ display: show ? 'flex' : 'none' }">
+    <view v-if="showRank" class="up-rank">
+      <image :src="user.avatar || 'https://static.shelingxingqiu.com/shootmini/static/user-icon.png'" mode="widthFix" />
+      <image :src="nextRankImage" mode="widthFix" />
+      <image class="bg-effect" src="https://static.shelingxingqiu.com/shootmini/static/shining-bg.png" mode="widthFix" />
+      <image
+        class="bg-effect"
+        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="https://static.shelingxingqiu.com/shootmini/static/user-upgrade.png"
+        mode="widthFix"
+      />
+      <image class="bg-effect" src="https://static.shelingxingqiu.com/shootmini/static/shining-bg.png" mode="widthFix" />
+      <image
+        class="bg-effect"
+        src="https://static.shelingxingqiu.com/shootmini/static/gold-shining.png"
+        mode="widthFix"
+      />
+    </view>
+    <view class="text-content">
+      <image src="https://static.shelingxingqiu.com/shootmini/static/update-text-bg.png" />
+      <text>{{ t('congratulations_you_reached') }}</text>
+      <text>{{ showRank ? nextRankTitle : t('sheling_level_value', { p0: lvl }) }}</text>
+      <text>!</text>
+    </view>
+    <!-- <button @click="onClose" hover-class="none">关闭</button> -->
+  </view>
+</template>
+
+<style scoped>
+.content {
+  width: 100vw;
+  height: 100vh;
+  position: fixed;
+  top: 0;
+  left: 0;
+  background-color: #232323;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  z-index: 10;
+  color: red;
+}
+.up-rank {
+  position: relative;
+  height: 50vw;
+  height: 80vw;
+}
+.up-rank > image:first-child {
+  position: absolute;
+  width: 36vw;
+  left: calc(50% - 18vw);
+  top: calc(50% - 18vw);
+  border-radius: 50%;
+}
+.up-rank > image:nth-child(2) {
+  position: absolute;
+  width: 44vw;
+  left: calc(50% - 22vw);
+  top: calc(50% - 22vw);
+}
+.up-grade {
+  position: relative;
+}
+.up-grade > image:first-child {
+  animation: scaleIn 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275) forwards;
+}
+.up-grade > image:first-child {
+  width: 50vw;
+  margin: 18vw;
+}
+.bg-effect {
+  position: absolute;
+  width: 80vw;
+  left: calc(50% - 40vw);
+  z-index: -1;
+  /* transform: scale(0); */
+  /* opacity: 0; */
+  animation: rotate 10s linear infinite;
+}
+.text-content {
+  color: #fff;
+  display: flex;
+  font-size: 20px;
+  font-weight: bold;
+  position: relative;
+  line-height: 60px;
+  margin-bottom: 20vw;
+}
+.text-content > image:first-child {
+  position: absolute;
+  width: 80vw;
+  left: calc(50% - 40vw);
+  height: 60px;
+}
+.text-content > text:nth-child(3) {
+  color: #fed847;
+}
+.content > button:last-child {
+  color: #fff9;
+  font-size: 20px;
+  border: 1px solid #fff;
+  padding: 10px;
+  width: 50vw;
+  border-radius: 20px;
+  margin-top: 10vw;
+}
+</style>

src/composables/useOtaUpdate.js

@@ -0,0 +1,242 @@
+import { t } from "@/locales";
+import { computed, ref } from "vue";
+import { sendHardwareBoxUpdateAPI } from "@/apis";
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+
+const OTA_PROGRESS_EVENT = "/addons/shoot/otaProgress";
+const OTA_RESULT_EVENT = "/addons/shoot/otaResult";
+const UPDATE_TIMEOUT = 10 * 60 * 1000;
+
+const phaseTextMap = {
+  started: t('preparing_firmware_update'),
+  downloading: t('downloading_firmware'),
+  installing: t('installing_firmware'),
+};
+
+// 设备详情中的 latestVersion 是升级目标，version 是当前固件版本。
+export const getOtaInfoFromDetail = (detail) => ({
+  versionNumber: String(detail?.latestVersion ?? "").trim(),
+  currentVersion: String(detail?.version ?? "").trim(),
+  versionInfo: String(detail?.versionInfo ?? "").trim(),
+  needUpdate: detail?.needUpdate === true || Number(detail?.needUpdate) === 1,
+  forceUpdate: detail?.forceUpdate === true || Number(detail?.forceUpdate) === 1,
+});
+
+// OTA 状态由首页、WiFi 设置页和我的设备页共享，页面切换后仍可继续接收进度。
+const updating = ref(false);
+const progress = ref(0);
+const phase = ref("started");
+const resultVisible = ref(false);
+const resultStatus = ref("");
+const resultReason = ref("");
+
+let deviceRef = null;
+let updateRunId = 0;
+let targetVersion = "";
+let lastFinishedVersion = "";
+let timeoutTimer = null;
+let successCallback = null;
+let socketListening = false;
+
+const phaseText = computed(
+  () => phaseTextMap[phase.value] || t('updating_firmware')
+);
+const resultTitle = computed(() =>
+  resultStatus.value === "success" ? t('firmware_update_complete_250') : t('firmware_update_failed')
+);
+const resultContent = computed(() => {
+  if (resultStatus.value === "success") return t('firmware_update_complete');
+  return resultReason.value || t('update_failed_check_your_device_and_network_then_retry');
+});
+
+const clearTimers = () => {
+  clearTimeout(timeoutTimer);
+  timeoutTimer = null;
+};
+
+const resetActiveUpdate = () => {
+  clearTimers();
+  successCallback = null;
+};
+
+const finishUpdate = (status, reason = "", runId = updateRunId) => {
+  if (runId !== updateRunId || !updating.value) return;
+  const onSuccess = successCallback;
+  resetActiveUpdate();
+  updating.value = false;
+  resultStatus.value = status;
+  resultReason.value = reason;
+  lastFinishedVersion = targetVersion;
+  if (status === "success") {
+    progress.value = 100;
+    phase.value = "installing";
+    onSuccess?.();
+  }
+  resultVisible.value = true;
+};
+
+const isCurrentDeviceMessage = (data) => {
+  const messageDeviceId = String(data?.deviceId || "");
+  const currentDeviceId = String(deviceRef?.value?.deviceId || "");
+  return !messageDeviceId || !currentDeviceId || messageDeviceId === currentDeviceId;
+};
+
+const isCurrentVersionMessage = (data) => {
+  const messageVersion = String(data?.versionNumber || "");
+  return !messageVersion || !targetVersion || messageVersion === targetVersion;
+};
+
+// 页面切换导致弹窗关闭后，使用下一条进度消息恢复当前 OTA 会话。
+const recoverUpdateFromMessage = (data) => {
+  updateRunId += 1;
+  const runId = updateRunId;
+  targetVersion = String(data?.versionNumber || "");
+  lastFinishedVersion = "";
+  successCallback = null;
+  resultVisible.value = false;
+  resultStatus.value = "";
+  resultReason.value = "";
+  progress.value = 0;
+  phase.value = "started";
+  updating.value = true;
+  clearTimers();
+  timeoutTimer = setTimeout(() => {
+    finishUpdate("failed", t('firmware_update_timed_out_please_try_again'), runId);
+  }, UPDATE_TIMEOUT);
+};
+
+function handleSocketMessage(message) {
+  if (Number(message?.code ?? 0) !== 0) return;
+  if (![OTA_PROGRESS_EVENT, OTA_RESULT_EVENT].includes(message?.event)) return;
+  if (!isCurrentDeviceMessage(message.data)) return;
+
+  const messageVersion = String(message.data?.versionNumber || "");
+
+  if (message.event === OTA_PROGRESS_EVENT) {
+    if (!updating.value) {
+      if (
+        lastFinishedVersion &&
+        (!messageVersion || messageVersion === lastFinishedVersion)
+      ) {
+        return;
+      }
+      recoverUpdateFromMessage(message.data);
+    } else if (!isCurrentVersionMessage(message.data)) {
+      return;
+    }
+    if (!targetVersion && messageVersion) targetVersion = messageVersion;
+
+    const nextProgress = Math.min(
+      100,
+      Math.max(0, Number(message.data?.progress) || 0)
+    );
+    progress.value = Math.max(progress.value, nextProgress);
+    if (phaseTextMap[message.data?.phase]) {
+      phase.value = message.data.phase;
+    }
+    return;
+  }
+
+  if (!updating.value) {
+    if (
+      lastFinishedVersion &&
+      (!messageVersion || messageVersion === lastFinishedVersion)
+    ) {
+      return;
+    }
+    recoverUpdateFromMessage(message.data);
+  } else if (!isCurrentVersionMessage(message.data)) {
+    return;
+  }
+  if (!targetVersion && messageVersion) targetVersion = messageVersion;
+
+  if (message.data?.status === "success") {
+    finishUpdate("success");
+  } else if (message.data?.status === "failed") {
+    finishUpdate("failed", message.data?.reason || "");
+  }
+}
+
+const startSocketListening = () => {
+  if (socketListening) return;
+  uni.$on("socket-inbox", handleSocketMessage);
+  socketListening = true;
+};
+
+export const useOtaUpdate = () => {
+  const store = useStore();
+  const { device } = storeToRefs(store);
+  deviceRef = device;
+  startSocketListening();
+
+  const startUpdate = async ({
+    versionNumber,
+    wifiSsid = "",
+    wifiPassword = "",
+    onSuccess,
+  }) => {
+    if (updating.value) return false;
+    const nextVersion = String(versionNumber || "").trim();
+    if (!nextVersion) {
+      uni.showToast({ title: t('target_firmware_version_is_missing'), icon: "none" });
+      return false;
+    }
+
+    updateRunId += 1;
+    const runId = updateRunId;
+    targetVersion = nextVersion;
+    lastFinishedVersion = "";
+    successCallback = onSuccess || null;
+    resultVisible.value = false;
+    resultStatus.value = "";
+    resultReason.value = "";
+    progress.value = 0;
+    phase.value = "started";
+    updating.value = true;
+    clearTimers();
+    timeoutTimer = setTimeout(() => {
+      finishUpdate("failed", t('firmware_update_timed_out_please_try_again'), runId);
+    }, UPDATE_TIMEOUT);
+
+    try {
+      const updateResult = await sendHardwareBoxUpdateAPI({
+        versionNumber: targetVersion,
+        wifiSsid,
+        wifiPassword,
+      });
+      if (runId !== updateRunId || !updating.value) return false;
+      if (!updateResult?.taskId) {
+        finishUpdate("failed", t('could_not_create_the_firmware_update_task_please_retry'), runId);
+        return false;
+      }
+      return true;
+    } catch (error) {
+      if (runId === updateRunId) {
+        finishUpdate(
+          "failed",
+          error?.message || t('firmware_update_request_failed_please_retry'),
+          runId
+        );
+      }
+      return false;
+    }
+  };
+
+  const closeResult = () => {
+    resultVisible.value = false;
+  };
+
+  return {
+    updating,
+    progress,
+    phase,
+    phaseText,
+    resultVisible,
+    resultStatus,
+    resultTitle,
+    resultContent,
+    startUpdate,
+    closeResult,
+  };
+};

src/constants.js

@@ -0,0 +1,237 @@
+import { t } from "@/locales";
+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
+  ShootResult: parseInt("0xAA0795E2"), // 2852623842
+  CurrentRoundEnded: parseInt("0x3E2CE041"), // 1043128385
+  ToSomeoneShoot: parseInt("0x077ACD1A"), // 125488410
+  SomeGuyIsReady: parseInt("0xAEE8C236"), // 2934489654
+  MatchOver: parseInt("0xB7815EEF"), // 3078708975
+  StartCount: parseInt("0xD7B0DD2F"), // 3618692399
+  FinalShoot: parseInt("0x5953C8A1"), // 1498663073
+  RoundPoint: 4061248646,
+  UserEnterRoom: 2133805521,
+  UserExitRoom: 3896523333,
+  RoomDestroy: 3617539277,
+  SomeoneComplete: 2921416944,
+  HalfTimeOver: 388606440,
+  BackToGame: 1899960424,
+  FinalShootResult: 3813452544,
+  PaySuccess: 3793388244,
+  RankUpdate: 1121669910,
+  LvlUpdate: 3958625354,
+  TeamUpdate: 4168086616,
+  InvalidShot: 4168086617,
+  Calibration: 4168086625,
+  DeviceOnline: 4168086626,
+  DeviceOffline: 4168086627,
+  SomeoneIsReady: 4168086628,
+  DeviceCharging: 4168086631, // 设备充电中
+};
+
+export const MESSAGETYPESV2 = {
+  AboutToStart: 1,
+  BattleStart: 2,
+  ToSomeoneShoot: 3,
+  ShootResult: 4,
+  NewRound: 5,
+  BattleEnd: 6,
+  HalfRest: 7,
+  TestDistance: 8,
+  MatchSuccess: 9,
+  InvalidShot: 10,
+};
+
+export const topThreeColors = ["#FFD947", "#D2D2D2", "#FFA515"];
+
+export const getMessageTypeName = (id) => {
+  for (let key in MESSAGETYPES) {
+    if (MESSAGETYPES[key] === id) return key;
+  }
+  for (let key in MESSAGETYPESV2) {
+    if (MESSAGETYPESV2[key] === id) return key;
+  }
+  return id;
+};
+
+export const roundsName = {
+  0: "一",
+  1: "一",
+  2: "二",
+  3: "三",
+  4: "四",
+  5: "五",
+};
+
+export const meleeAvatarColors = [
+  "#364469",
+  "#692735",
+  "#934B4B",
+  "#A98B69",
+  "#8268A2",
+  "#9C538F",
+  "#6870BB",
+  "#4B8593",
+  "#9BA969",
+  "#DCCE6D",
+];
+
+export const orderStatusNames = {
+  1: t('awaiting_payment'),
+  2: t('paid'),
+  3: t('shipped'),
+  4: t('completed_260'),
+  5: t('closed'),
+  6: t('refund_requested'),
+  7: t('refund_in_progress'),
+  8: t('refunded'),
+  9: t('refund_declined'),
+};
+
+export const getStatusColor = (status) => {
+  switch (status) {
+    case 1:
+      return "#EF4848";
+    case 4:
+      return "#35CD67";
+    default:
+      return "#999999";
+  }
+};
+
+export const directionAdjusts = {
+  AdjustLowerRight: t('down_and_right'),
+  AdjustDown: t('down'),
+  AdjustLowerLeft: t('down_and_left'),
+  AdjustLeft: t('left'),
+  AdjustUpperLeft: t('up_and_left'),
+  AdjustUp: t('up'),
+  AdjustUpperRight: t('up_and_right'),
+  AdjustRight: t('right'),
+};
+
+export const getBattleResultTips = (
+  gameMode,
+  mode,
+  { rank = 0, score = 0, win = false }
+) => {
+  const getRandomIndex = (len) => Math.floor(Math.random() * len);
+  if (gameMode === 1) {
+    if (mode <= 3) {
+      if (win) {
+        const tests = [
+          "https://static.shelingxingqiu.com/attachment/2025-08-01/dbqq1fglywucyoh9zn.png",
+          "https://static.shelingxingqiu.com/attachment/2025-08-01/dbqq1fgls1trzqneeh.png",
+          "https://static.shelingxingqiu.com/attachment/2025-08-01/dbqq1fgm4fmv0tqico.png",
+          // "你是朋友中的佼佼者哟!",
+          // "你成功击败好友，成为大赢家!",
+          // "你将好友“一举拿下”，超神无疑!",
+        ];
+        return tests[getRandomIndex(3)];
+      } else {
+        const tests = [
+          "https://static.shelingxingqiu.com/attachment/2025-08-01/dbqq0gmb12vjkonvzm.png",
+          "https://static.shelingxingqiu.com/attachment/2025-08-01/dbqq0gmo5gpiecqqgu.png",
+          "https://static.shelingxingqiu.com/attachment/2025-08-01/dbqq0gmtk8hjwqoecz.png",
+          // "失误啦失误啦，再多来几局吧~",
+          // "惜败好友，下次再战定能反超!",
+          // "友谊第一，下场胜利属于你!",
+        ];
+        return tests[getRandomIndex(3)];
+      }
+    } else {
+      if (rank <= 3) {
+        const tests = [
+          t('great_score_the_national_ranked_matches_await'),
+          t('keep_practicing_for_more_moments_to_shine'),
+        ];
+        return tests[getRandomIndex(2)];
+      } else {
+        return t('practice_daily_and_stand_out_next_time');
+      }
+    }
+  } else if (gameMode === 2) {
+    if (mode <= 3) {
+      if (win) {
+        const tests = [
+          "https://static.shelingxingqiu.com/attachment/2025-08-01/dbqq1fgtb29jbdus4g.png",
+          "https://static.shelingxingqiu.com/attachment/2025-08-01/dbqq1fgtbu8fzpbh3z.png",
+          "https://static.shelingxingqiu.com/attachment/2025-08-01/dbqq1fgtbu8fzpbh3z.png",
+          // "你已经奔跑在通向王者的路上了!",
+          // "射灵星球最闪耀的前进者!",
+          // "赞!你真是越战越勇",
+        ];
+        return tests[getRandomIndex(3)];
+      } else {
+        const tests = [
+          "https://static.shelingxingqiu.com/attachment/2025-08-01/dbqq0gmovnd33hz5yj.png",
+          "https://static.shelingxingqiu.com/attachment/2025-08-01/dbqq0gmtu558juplj9.png",
+          "https://static.shelingxingqiu.com/attachment/2025-08-01/dbqq0gmuhb5aofghg4.png",
+          // "失败是成功之母，儿子在等你!",
+          // "人生得意须尽欢，不过此关心不甘!",
+          // "这回一定是打开方式不对。再来!",
+        ];
+        return tests[getRandomIndex(3)];
+      }
+    } else {
+      if (score > 0) {
+        const tests = [
+          t('the_top_rank_is_within_your_reach'),
+          t('a_moment_to_shine_keep_it_up'),
+          t('one_of_the_best_in_the_sheling_world'),
+        ];
+        return tests[getRandomIndex(3)];
+      } else {
+        const tests = [
+          t('try_again_and_make_your_mark'),
+          t('practice_more_and_come_back_stronger'),
+          t('every_step_you_take_counts'),
+        ];
+        return tests[getRandomIndex(3)];
+      }
+    }
+  }
+  return "";
+};
+
+export const RoundImages = {
+  round1:
+    "https://static.shelingxingqiu.com/attachment/2025-08-13/dc12slggifbnw9snvs.png",
+  round2:
+    "https://static.shelingxingqiu.com/attachment/2025-08-13/dc12slgf0swue5xzpd.png",
+  round3:
+    "https://static.shelingxingqiu.com/attachment/2025-08-13/dc12slglkylhmq8beb.png",
+  round4:
+    "https://static.shelingxingqiu.com/attachment/2025-08-13/dc12slggc88nasmxf5.png",
+  round5:
+    "https://static.shelingxingqiu.com/attachment/2025-08-13/dc12slgeloitb8mixf.png",
+  gold1:
+    "https://static.shelingxingqiu.com/attachment/2025-08-13/dc12slgsjbyyuu1des.png",
+  gold2:
+    "https://static.shelingxingqiu.com/attachment/2025-08-13/dc12slgdysd1wqulj5.png",
+  gold3:
+    "https://static.shelingxingqiu.com/attachment/2025-08-13/dc12slgm82ny3qjd8m.png",
+};
+
+export const RoundGoldImages = {
+  round1:
+    "https://static.shelingxingqiu.com/attachment/2025-08-13/dc12slg7kfzzwwiwcb.png",
+  round2:
+    "https://static.shelingxingqiu.com/attachment/2025-08-13/dc12slgs5htghfh3a9.png",
+  round3:
+    "https://static.shelingxingqiu.com/attachment/2025-08-13/dc12slgc9ge3paqkba.png",
+  round4:
+    "https://static.shelingxingqiu.com/attachment/2025-08-13/dc12slgehduk96yurp.png",
+  round5:
+    "https://static.shelingxingqiu.com/attachment/2025-08-13/dc12slgefz3hdmwbnz.png",
+  gold1:
+    "https://static.shelingxingqiu.com/attachment/2025-08-13/dc12slgeyb4cqwezgc.png",
+  gold2:
+    "https://static.shelingxingqiu.com/attachment/2025-08-13/dc12slggu3tlh97v5p.png",
+  gold3:
+    "https://static.shelingxingqiu.com/attachment/2025-08-13/dc12slgszmdtmaotch.png",
+};

src/heatmap.js

@@ -0,0 +1,105 @@
+/**
+ * 在 uni-app 小程序里画弓箭热力图
+ * @param {String} canvasId   画布 id
+ * @param {Number} width      画布宽（px）
+ * @param {Number} height     画布高（px）
+ * @param {Array}  arrowData  [{x, y, count}, ...]
+ */
+export function generateHeatmapImage(canvasId, width, height, arrowData) {
+  return new Promise((resolve, reject) => {
+    // 1. 创建绘图上下文
+    const ctx = uni.createCanvasContext(canvasId);
+
+    // 3. 计算最大 count，用于归一化
+    const maxCount = Math.max(...arrowData.map((p) => p.count), 1);
+    // 4. 热点半径：可按实际靶子大小调，这里取画布短边的 6%
+    const radius = Math.min(width, height) * 0.12;
+
+    // 5. 按count从小到大排序，count越大越后面
+    arrowData.sort((a, b) => a.count - b.count);
+
+    // 6. 画每个点
+    arrowData.forEach((item) => {
+      const intensity = item.count / maxCount; // 0-1
+      // console.log(item.count, maxCount, intensity);
+      const r = radius * (1.2 - intensity * 0.8);
+      // 创建径向渐变
+      const grd = ctx.createCircularGradient(
+        item.x * width,
+        item.y * height,
+        r
+      );
+      grd.addColorStop(0, heatColor(intensity, 1));
+      grd.addColorStop(0.5, heatColor(intensity, 0.6));
+      grd.addColorStop(1, "rgba(0,0,0,0)");
+
+      ctx.save();
+      ctx.fillStyle = grd;
+      ctx.globalCompositeOperation = "screen"; // 叠加变亮
+      ctx.beginPath();
+      ctx.arc(item.x * width, item.y * height, r, 0, Math.PI * 2);
+      ctx.fill();
+      ctx.restore();
+    });
+
+    // 6. 可选：整体蒙版，让非热点区域暗下去
+    // ctx.save()
+    // ctx.fillStyle = 'rgba(0,0,0,0.35)'
+    // ctx.fillRect(0, 0, width, height)
+    // ctx.restore()
+
+    // 7. 把指令一次性推送到 canvas
+    ctx.draw(false, () => {
+      // Canvas绘制完成后生成图片
+      uni.canvasToTempFilePath({
+        canvasId: "heatMapCanvas",
+        width: width,
+        height: height,
+        destWidth: width * 2, // 提高图片质量
+        destHeight: height * 2,
+        success: (res) => {
+          console.log("热力图图片生成成功:", res.tempFilePath);
+          resolve(res.tempFilePath);
+        },
+        fail: (error) => {
+          console.error("热力图图片生成失败:", error);
+          reject(error);
+        },
+      });
+    });
+  });
+}
+
+/**
+ * 把强度 0-1 映射成红-黄-绿渐变，返回 rgba 字符串
+ * @param {Number} v 0-1
+ * @param {Number} a 透明度 0-1
+ */
+function heatColor(v, a) {
+  // v 从 0→1，重新映射：极低值绿色，低值黄色，中到高值红色
+  let red, green;
+
+  if (v < 0.2) {
+    // 极低值：纯绿色
+    red = 0;
+    green = 200; // 柔和的绿
+  } else if (v < 0.4) {
+    // 低值：绿色到黄色
+    const t = (v - 0.2) / 0.2;
+    red = Math.round(255 * t);
+    green = 255;
+  } else if (v < 0.6) {
+    // 中低值：黄色到橙色
+    const t = (v - 0.4) / 0.2;
+    red = 255;
+    green = Math.round(255 * (1 - t * 0.5));
+  } else {
+    // 中到高值：橙色到红色
+    const t = (v - 0.6) / 0.4;
+    red = 255;
+    green = Math.round(128 * (1 - t));
+  }
+
+  const blue = 0;
+  return `rgba(${red}, ${green}, ${blue}, ${a})`;
+}

src/kde-heatmap.js

@@ -0,0 +1,277 @@
+/**
+ * 基于小程序Canvas API的核密度估计热力图
+ * 实现类似test.html中的效果，但适配uni-app小程序环境
+ */
+
+/**
+ * Epanechnikov核函数
+ * @param {Number} bandwidth 带宽参数
+ * @returns {Function} 核函数
+ */
+function kernelEpanechnikov(bandwidth) {
+  return function (v) {
+    const r = Math.sqrt(v[0] * v[0] + v[1] * v[1]);
+    return r <= bandwidth
+      ? (3 / (Math.PI * bandwidth * bandwidth)) *
+          (1 - (r * r) / (bandwidth * bandwidth))
+      : 0;
+  };
+}
+
+/**
+ * 核密度估计器
+ * @param {Function} kernel 核函数
+ * @param {Array} range 范围[xmin, xmax]
+ * @param {Number} samples 采样点数
+ * @returns {Function} 密度估计函数
+ */
+function kernelDensityEstimator(kernel, range, samples) {
+  return function (data) {
+    const gridSize = (range[1] - range[0]) / samples;
+    const densityData = [];
+
+    for (let x = range[0]; x <= range[1]; x += gridSize) {
+      for (let y = range[0]; y <= range[1]; y += gridSize) {
+        let sum = 0;
+        for (const point of data) {
+          sum += kernel([x - point[0], y - point[1]]);
+        }
+        densityData.push([x, y, sum / data.length]);
+      }
+    }
+
+    // 归一化
+    const maxDensity = Math.max(...densityData.map((d) => d[2]));
+    densityData.forEach((d) => {
+      if (maxDensity > 0) d[2] /= maxDensity;
+    });
+
+    return densityData;
+  };
+}
+
+/**
+ * 生成随机射箭数据点
+ * @param {Number} centerCount 中心点数量
+ * @param {Number} pointsPerCenter 每个中心点的箭数
+ * @returns {Array} 箭矢坐标数组
+ */
+export function generateArcheryPoints(centerCount = 2, pointsPerCenter = 100) {
+  const points = [];
+  const range = 8; // 坐标范围 -4 到 4
+  const spread = 3; // 分散度
+
+  for (let i = 0; i < centerCount; i++) {
+    const centerX = Math.random() * range - range / 2;
+    const centerY = Math.random() * range - range / 2;
+
+    for (let j = 0; j < pointsPerCenter; j++) {
+      points.push([
+        centerX + (Math.random() - 0.5) * spread,
+        centerY + (Math.random() - 0.5) * spread,
+      ]);
+    }
+  }
+
+  return points;
+}
+
+/**
+ * 颜色映射函数 - 将密度值映射到颜色
+ * @param {Number} density 密度值 0-1
+ * @returns {String} RGBA颜色字符串
+ */
+function getHeatColor(density) {
+  // 绿色系热力图：从浅绿到深绿
+  if (density < 0.1) return "rgba(0, 255, 0, 0)";
+
+  const alpha = Math.min(density * 1.2, 1); // 增强透明度
+  const intensity = density;
+
+  if (intensity < 0.5) {
+    // 低密度：浅绿色
+    const green = Math.round(200 + 55 * intensity);
+    const blue = Math.round(50 + 100 * intensity);
+    return `rgba(${Math.round(50 * intensity)}, ${green}, ${blue}, ${
+      alpha * 0.7
+    })`;
+  } else {
+    // 高密度：深绿色
+    const red = Math.round(50 * (intensity - 0.5) * 2);
+    const green = Math.round(180 + 75 * (1 - intensity));
+    const blue = Math.round(30 * (1 - intensity));
+    return `rgba(${red}, ${green}, ${blue}, ${alpha * 0.7})`;
+  }
+}
+
+/**
+ * 基于小程序Canvas API绘制核密度估计热力图
+ * @param {String} canvasId 画布ID
+ * @param {Number} width 画布宽度
+ * @param {Number} height 画布高度
+ * @param {Array} points 箭矢坐标数组 [[x, y], ...]
+ * @param {Object} options 可选参数
+ * @returns {Promise} 绘制完成的Promise
+ */
+export function drawKDEHeatmap(canvasId, width, height, points, options = {}) {
+  const {
+    bandwidth = 0.8,
+    gridSize = 100,
+    range = [-4, 4],
+    showPoints = true,
+    pointColor = "rgba(255, 255, 255, 0.9)",
+  } = options;
+
+  // 微信小程序使用 Canvas 2D
+  return new Promise((resolve, reject) => {
+    try {
+      wx.createSelectorQuery()
+        .select(`#${canvasId}`)
+        .fields({ node: true, size: true })
+        .exec((res) => {
+          try {
+            const { node: canvas, width: w, height: h } = res[0] || {};
+            if (!canvas) return resolve();
+
+            // 设置画布尺寸
+            const cw = width || w || 300;
+            const ch = height || h || 300;
+            canvas.width = cw;
+            canvas.height = ch;
+
+            const ctx = canvas.getContext("2d");
+            ctx.clearRect(0, 0, cw, ch);
+
+            if (!points || points.length === 0) return resolve();
+
+            // 计算核密度估计
+            const kernel = kernelEpanechnikov(bandwidth);
+            const kde = kernelDensityEstimator(kernel, range, gridSize);
+            const densityData = kde(points);
+
+            // 计算网格大小
+            const cellWidth = cw / gridSize;
+            const cellHeight = ch / gridSize;
+            const xRange = range[1] - range[0];
+            const yRange = range[1] - range[0];
+
+            // 绘制热力图网格
+            densityData.forEach(([x, y, density]) => {
+              const normalizedX = (x - range[0]) / xRange;
+              const normalizedY = (y - range[0]) / yRange;
+              const canvasX = normalizedX * cw;
+              const canvasY = normalizedY * ch;
+
+              const color = getHeatColor(density);
+              ctx.fillStyle = color;
+              ctx.beginPath();
+              ctx.arc(
+                canvasX,
+                canvasY,
+                Math.min(cellWidth, cellHeight) * 0.6,
+                0,
+                2 * Math.PI
+              );
+              ctx.fill();
+            });
+
+            // 绘制原始数据点
+            if (showPoints) {
+              ctx.fillStyle = pointColor;
+              points.forEach(([x, y]) => {
+                const normalizedX = (x - range[0]) / xRange;
+                const normalizedY = (y - range[0]) / yRange;
+                const canvasX = normalizedX * cw;
+                const canvasY = normalizedY * ch;
+                ctx.beginPath();
+                ctx.arc(canvasX, canvasY, 2.5, 0, 2 * Math.PI);
+                ctx.fill();
+              });
+            }
+
+            resolve();
+          } catch (err) {
+            reject(err);
+          }
+        });
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+/**
+ * 生成热力图图片（类似原有的generateHeatmapImage函数）
+ * 但使用核密度估计算法
+ */
+export function generateKDEHeatmapImage(
+  canvasId,
+  width,
+  height,
+  points,
+  options = {}
+) {
+  // Canvas 2D 导出（传入 canvas 对象）
+  return new Promise((resolve, reject) => {
+    drawKDEHeatmap(canvasId, width, height, points, options)
+      .then(() => {
+        try {
+          wx.createSelectorQuery()
+            .select(`#${canvasId}`)
+            .fields({ node: true, size: true })
+            .exec((res) => {
+              const { node: canvas, width: w, height: h } = res[0] || {};
+              if (!canvas) return reject(new Error("canvas 为空"));
+              const cw = width || w || 300;
+              const ch = height || h || 300;
+              uni.canvasToTempFilePath({
+                canvas,
+                width: cw,
+                height: ch,
+                destWidth: cw * 3,
+                destHeight: ch * 3,
+                success: (r) => resolve(r.tempFilePath),
+                fail: reject,
+              });
+            });
+        } catch (e) {
+          reject(e);
+        }
+      })
+      .catch(reject);
+  });
+}
+
+export const generateHeatMapData = (width, height, amount = 100) => {
+  const data = [];
+  const centerX = 0.5; // 中心点X坐标
+  const centerY = 0.5; // 中心点Y坐标
+
+  for (let i = 0; i < amount; i++) {
+    let x, y;
+
+    // 30%的数据集中在中心区域（高斯分布）
+    if (Math.random() < 0.3) {
+      // 使用正态分布生成中心区域的数据
+      const angle = Math.random() * 2 * Math.PI;
+      const radius = Math.sqrt(-2 * Math.log(Math.random())) * 0.15; // 标准差0.15
+      x = centerX + radius * Math.cos(angle);
+      y = centerY + radius * Math.sin(angle);
+    } else {
+      x = Math.random() * 0.8 + 0.1; // 0.1-0.9范围
+      y = Math.random() * 0.8 + 0.1;
+    }
+
+    // 确保坐标在0-1范围内
+    x = Math.max(0.05, Math.min(0.95, x));
+    y = Math.max(0.05, Math.min(0.95, y));
+
+    data.push({
+      x: parseFloat(x.toFixed(3)),
+      y: parseFloat(y.toFixed(3)),
+      ring: Math.floor(Math.random() * 5) + 6, // 6-10环
+    });
+  }
+
+  return data;
+};

src/locales/index.js

@@ -0,0 +1,40 @@
+import { createI18n } from "vue-i18n";
+import en from "./en.json";
+import sourceKeys from "./source-keys.json";
+
+// 英文构建固定使用英文，不读取或写入用户语言与业务缓存。
+export const i18n = createI18n({
+  legacy: false,
+  locale: "en",
+  fallbackLocale: "en",
+  messages: { en },
+});
+
+// uni-app 的小程序运行库可能直接返回原始文案，参数在此统一替换一次。
+// 从固定英文词条读取，避免完整版运行库先插值后再次处理参数值里的花括号。
+export const t = (key, params = {}) => {
+  const message = Object.prototype.hasOwnProperty.call(en, key)
+    ? en[key]
+    : i18n.global.t(key);
+  return message.replace(/\{(p\d+)\}/g, (placeholder, name) =>
+    params != null && Object.prototype.hasOwnProperty.call(params, name)
+      ? String(params[name] ?? "")
+      : placeholder
+  );
+};
+
+// 仅用于明确来自前端静态配置的双用途原值；禁止用于接口响应或用户输入。
+export const translateStatic = (value) => {
+  const key = Object.prototype.hasOwnProperty.call(sourceKeys, value) ? sourceKeys[value] : null;
+  return key ? t(key) : value;
+};
+
+// 比赛提示保留中文原值供语音与状态判断使用，只在渲染时转换。
+export const formatBattleTip = (value) => {
+  const text = String(value || "").replace(/你/g, "").replace(/重回/g, "");
+  const half = text.match(/^(上|下)半场：请先射6箭$/);
+  if (half) return `${half[1] === "上" ? "First" : "Second"} half: shoot 6 arrows first`;
+  const round = text.match(/^请开始射箭第(.+)轮$/);
+  if (round) return t(sourceKeys["请开始射箭第{p0}轮"], { p0: translateStatic(round[1]) });
+  return translateStatic(text);
+};

src/main.js

@@ -1,9 +1,29 @@
 import { createSSRApp } from 'vue'
+import { createPinia } from 'pinia'
+import piniaPluginPersistedstate from 'pinia-plugin-persistedstate'
 import App from './App.vue'
+import { i18n } from './locales'
+import audioManager from './audioManager'
 
 export function createApp() {
   const app = createSSRApp(App)
+  const pinia = createPinia()
+  pinia.use(piniaPluginPersistedstate)
+  app.use(pinia)
+  app.use(i18n)
+
+  /**
+   * 全局点击音效工具函数，用于在任意按钮/元素点击时自动播放音效。
+   * 用法：@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,
+    app
   }
 }

src/manifest.json

@@ -1,70 +1,329 @@
 {
-  "name": "shoot-miniprograms",
+    "name" : "shoot-miniprograms",
-  "appid": "",
+    "appid" : "__UNI__B03E251",
-  "description": "",
+    "description" : "",
-  "versionName": "1.0.0",
+    "versionName" : "1.0.0",
-  "versionCode": "100",
+    "versionCode" : "100",
-  "transformPx": false,
+    "transformPx" : false,
-  "uniStatistics": {
+    "uniStatistics" : {
-    "enable": false
+        "enable" : false
-  },
-  "app-plus": {
-    "usingComponents": true,
-    "nvueStyleCompiler": "uni-app",
-    "compilerVersion": 3,
-    "splashscreen": {
-      "alwaysShowBeforeRender": true,
-      "waiting": true,
-      "autoclose": true,
-      "delay": 0
     },
-    "modules": {},
+    "app-plus" : {
-    "distribute": {
+        "bounce" : "none",
-      "android": {
+        "usingComponents" : true,
-        "permissions": [
+        "nvueStyleCompiler" : "uni-app",
-          "<uses-permission android:name=\"android.permission.CHANGE_NETWORK_STATE\"/>",
+        "compilerVersion" : 3,
-          "<uses-permission android:name=\"android.permission.MOUNT_UNMOUNT_FILESYSTEMS\"/>",
+        "splashscreen" : {
-          "<uses-permission android:name=\"android.permission.VIBRATE\"/>",
+            "alwaysShowBeforeRender" : true,
-          "<uses-permission android:name=\"android.permission.READ_LOGS\"/>",
+            "waiting" : true,
-          "<uses-permission android:name=\"android.permission.ACCESS_WIFI_STATE\"/>",
+            "autoclose" : true,
-          "<uses-feature android:name=\"android.hardware.camera.autofocus\"/>",
+            "delay" : 0
-          "<uses-permission android:name=\"android.permission.ACCESS_NETWORK_STATE\"/>",
+        },
-          "<uses-permission android:name=\"android.permission.CAMERA\"/>",
+        "modules" : {},
-          "<uses-permission android:name=\"android.permission.GET_ACCOUNTS\"/>",
+        "distribute" : {
-          "<uses-permission android:name=\"android.permission.READ_PHONE_STATE\"/>",
+            "android" : {
-          "<uses-permission android:name=\"android.permission.CHANGE_WIFI_STATE\"/>",
+                "permissions" : [
-          "<uses-permission android:name=\"android.permission.WAKE_LOCK\"/>",
+                    "<uses-permission android:name=\"android.permission.CHANGE_NETWORK_STATE\"/>",
-          "<uses-permission android:name=\"android.permission.FLASHLIGHT\"/>",
+                    "<uses-permission android:name=\"android.permission.MOUNT_UNMOUNT_FILESYSTEMS\"/>",
-          "<uses-feature android:name=\"android.hardware.camera\"/>",
+                    "<uses-permission android:name=\"android.permission.VIBRATE\"/>",
-          "<uses-permission android:name=\"android.permission.WRITE_SETTINGS\"/>"
+                    "<uses-permission android:name=\"android.permission.READ_LOGS\"/>",
-        ]
+                    "<uses-permission android:name=\"android.permission.ACCESS_WIFI_STATE\"/>",
-      },
+                    "<uses-feature android:name=\"android.hardware.camera.autofocus\"/>",
-      "ios": {},
+                    "<uses-permission android:name=\"android.permission.ACCESS_NETWORK_STATE\"/>",
-      "sdkConfigs": {}
+                    "<uses-permission android:name=\"android.permission.CAMERA\"/>",
+                    "<uses-permission android:name=\"android.permission.GET_ACCOUNTS\"/>",
+                    "<uses-permission android:name=\"android.permission.READ_PHONE_STATE\"/>",
+                    "<uses-permission android:name=\"android.permission.CHANGE_WIFI_STATE\"/>",
+                    "<uses-permission android:name=\"android.permission.WAKE_LOCK\"/>",
+                    "<uses-permission android:name=\"android.permission.FLASHLIGHT\"/>",
+                    "<uses-feature android:name=\"android.hardware.camera\"/>",
+                    "<uses-permission android:name=\"android.permission.WRITE_SETTINGS\"/>"
+                ]
+            },
+            "ios" : {
+                "dSYMs" : false
+            },
+            "sdkConfigs" : {}
+        }
+    },
+    "h5" : {
+        "darkmode" : true,
+        "themeLocation" : "theme.json"
+    },
+    "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"
+                },
+                {
+                    "type" : "folder",
+                    "value" : "static/coin"
+                },
+                {
+                    "type" : "folder",
+                    "value" : "static/home-device"
+                }
+            ]
+        },
+        "optimization" : {
+            "subPackages" : true
+        },
+        "setting" : {
+            "urlCheck" : false,
+            "minified" : true,
+            "uglifyFileName" : true,
+            "useCompilerModule" : true,
+            "useIsolateContext" : true
+        },
+        "lazyCodeLoading" : "requiredComponents",
+        "usingComponents" : true,
+        "darkmode" : true,
+        "themeLocation" : "theme.json",
+        "permission" : {
+          "scope.userLocation": {
+            "desc": "Find Wi-Fi for device updates"
+          }
+        },
+        "requiredPrivateInfos" : [ "getLocation", "chooseLocation" ]
     }
-  },
+}
-  "h5": {
-    "darkmode": true,
-    "themeLocation": "theme.json"
-  },
-  "quickapp": {},
-  "mp-weixin": {
-    "appid": "",
-    "setting": {
-      "urlCheck": false
-    },
-    "usingComponents": true,
-    "darkmode": true,
-    "themeLocation": "theme.json"
-  },
-  "mp-alipay": {
-    "usingComponents": true
-  },
-  "mp-baidu": {
-    "usingComponents": true
-  },
-  "mp-toutiao": {
-    "usingComponents": true
-  },
-  "vueVersion": "3"
-}

src/pages.json

@@ -1,19 +1,228 @@
-{
+{
-  "pages": [
+  "pages": [
-    {
+    {
-      "path": "pages/index",
+      "path": "pages/index"
-      "type": "home"
+    },
-    }
+    {
-  ],
+      "path": "pages/org-bind"
-  "globalStyle": {
+    },
-    "backgroundColor": "@bgColor",
+    {
-    "backgroundColorBottom": "@bgColorBottom",
+      "path": "pages/friend-battle"
-    "backgroundColorTop": "@bgColorTop",
+    },
-    "backgroundTextStyle": "@bgTxtStyle",
+    {
-    "navigationBarBackgroundColor": "#000000",
+      "path": "pages/point-book"
-    "navigationBarTextStyle": "@navTxtStyle",
+    },
-    "navigationBarTitleText": "Uni Creator",
+    {
-    "navigationStyle": "custom"
+      "path": "pages/point-book-rank"
-  },
+    },
-  "subPackages": []
+    {
-}
+      "path": "pages/my-like-list"
+    },
+    {
+      "path": "pages/audio-test"
+    },
+    {
+      "path": "pages/about-us"
+    },
+    {
+      "path": "pages/webview",
+      "style": {
+        "navigationBarTitleText": ""
+      }
+    },
+    {
+      "path": "pages/melee-battle"
+    },
+    {
+      "path": "pages/battle-result"
+    },
+    {
+      "path": "pages/friend-battle-result"
+    },
+    {
+      "path": "pages/point-book-edit"
+    },
+    {
+      "path": "pages/point-book-create"
+    },
+    {
+      "path": "pages/point-book-list"
+    },
+    {
+      "path": "pages/point-book-detail"
+    },
+    {
+      "path": "pages/point-book-detail-share"
+    },
+    {
+      "path": "pages/match-page"
+    },
+    {
+      "path": "pages/user"
+    },
+    {
+      "path": "pages/grade-intro"
+    },
+    {
+      "path": "pages/rank-intro"
+    },
+    {
+      "path": "pages/my-growth"
+    },
+    {
+      "path": "pages/first-try"
+    },
+    {
+      "path": "pages/practise"
+    },
+    {
+      "path": "pages/practise-one"
+    },
+    {
+      "path": "pages/practise-two"
+    },
+    {
+      "path": "pages/battle-room"
+    },
+    {
+      "path": "pages/ranking"
+    },
+    {
+      "path": "pages/rank-list"
+    },
+    {
+      "path": "pages/match-detail"
+    },
+    {
+      "path": "pages/melee-bow-data"
+    },
+    {
+      "path": "pages/mine-bow-data"
+    }
+  ],
+  "globalStyle": {
+    "backgroundColor": "@bgColor",
+    "backgroundColorBottom": "@bgColorBottom",
+    "backgroundColorTop": "@bgColorTop",
+    "backgroundTextStyle": "@bgTxtStyle",
+    "navigationBarBackgroundColor": "#000000",
+    "navigationBarTextStyle": "@navTxtStyle",
+    "navigationBarTitleText": "Uni Creator",
+    "navigationStyle": "custom",
+    "enablePullDownRefresh": false
+  },
+  "easycom": {
+    "autoscan": true,
+    "custom": {
+      "^uni-(.*)": "@dcloudio/uni-ui/lib/uni-$1/uni-$1.vue"
+    }
+  },
+  "subPackages": [
+    {
+      "root": "pages/coin",
+      "pages": [
+        {
+          "path": "vip-intro"
+        },
+        {
+          "path": "index"
+        },
+        {
+          "path": "rules"
+        },
+        {
+          "path": "earning-records"
+        },
+        {
+          "path": "exchange-records"
+        },
+        {
+          "path": "nearby-stores"
+        },
+        {
+          "path": "product-detail"
+        }
+      ]
+    },
+    {
+      "root": "pages/device",
+      "pages": [
+        {
+          "path": "my-device"
+        },
+        {
+          "path": "device-qrcode"
+        },
+        {
+          "path": "device-bind-success"
+        },
+        {
+          "path": "device-bind-failure"
+        },
+        {
+          "path": "device-already-bound"
+        },
+        {
+          "path": "device-intro"
+        },
+        {
+          "path": "ota-wifi",
+          "style": {
+            "navigationStyle": "custom"
+          }
+        },
+        {
+          "path": "calibration"
+        },
+        {
+          "path": "unbind-device"
+        }
+      ]
+    },
+    {
+      "root": "pages/member",
+      "pages": [
+        {
+          "path": "orders"
+        },
+        {
+          "path": "order-detail"
+        },
+        {
+          "path": "be-vip"
+        },
+        {
+          "path": "vip-intro"
+        },
+        {
+          "path": "agreement"
+        }
+      ]
+    },
+    {
+      "root": "pages/team-battle",
+      "pages": [
+        {
+          "path": "index"
+        },
+        {
+          "path": "team-bow-data"
+        }
+      ]
+    },
+    {
+      "root": "pages/training",
+      "pages": [
+        {
+          "path": "index"
+        },
+        {
+          "path": "difficulty"
+        },
+        {
+          "path": "practise-one"
+        }
+      ]
+    }
+  ]
+}

src/pages/about-us.vue

@@ -0,0 +1,67 @@
+<script setup>
+import { t } from "@/locales";
+
+import Container from "@/components/Container.vue";
+
+const isIOS = uni.getDeviceInfo().osName === "ios";
+</script>
+
+<template>
+  <Container :title="t('about_us')">
+    <view class="container">
+      <view class="text">{{ t('sheling_planet_is_a_platform_for_professional_archers_and_archer') }}</view>
+
+      <view class="text">{{ t('we_explore_and_apply_smart_archery_technology_through_innovation') }}</view>
+
+      <view
+        class="copyright"
+        :style="{ paddingBottom: isIOS ? '40rpx' : '20rpx' }"
+      >
+        <text>{{ t('guangdong_icp_no_2025421150_2x') }}</text>
+      </view>
+    </view>
+  </Container>
+</template>
+
+<style scoped>
+.container {
+  width: calc(100% - 50rpx);
+  height: calc(100% - 50rpx);
+  padding: 25rpx;
+  background-color: #ffffff;
+  position: relative;
+}
+
+.intro-text {
+  font-size: 14px;
+  color: #333333;
+  line-height: 1.6;
+  margin-bottom: 20px;
+}
+
+.title {
+  font-size: 16px;
+  font-weight: bold;
+  color: #333333;
+  margin-bottom: 10px;
+}
+
+.text {
+  font-size: 14px;
+  color: #666666;
+  line-height: 1.6;
+  margin-bottom: 10px;
+  text-align: justify;
+}
+
+.copyright {
+  position: absolute;
+  bottom: 0;
+  display: flex;
+  flex-direction: column;
+  width: calc(100% - 50rpx);
+  align-items: center;
+  font-size: 24rpx;
+  color: #afafaf;
+}
+</style>

src/pages/audio-test.vue

@@ -0,0 +1,74 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref, onMounted, onBeforeUnmount } from "vue";
+import Container from "@/components/Container.vue";
+import audioManager, { audioFils } from "@/audioManager";
+
+const loaded = ref({});
+
+const playAudio = (key) => {
+  audioManager.play(key);
+};
+
+const onAudioLoaded = (key) => {
+  loaded.value = {
+    ...loaded.value,
+    [key]: true,
+  };
+};
+
+onMounted(() => {
+  const loadedAudioKeys = uni.getStorageSync("loadedAudioKeys") || {};
+  loaded.value = loadedAudioKeys;
+
+  uni.$on("audioLoaded", onAudioLoaded);
+  void audioManager.initAudios();
+});
+
+onBeforeUnmount(() => {
+  uni.$off("audioLoaded", onAudioLoaded);
+});
+</script>
+
+<template>
+  <Container :title="t('audio_test')">
+    <view class="container">
+      <view>
+        <text>{{ t('continuous_playback_1') }}</text>
+        <button hover-class="none" @click="playAudio(['第一轮', '请蓝方射箭'])">{{ t('play') }}</button>
+      </view>
+      <view>
+        <text>{{ t('continuous_playback_2') }}</text>
+        <button hover-class="none" @click="playAudio(['第二轮', '请红方射箭'])">{{ t('play') }}</button>
+      </view>
+      <view v-for="key in Object.keys(audioFils)" :key="key">
+        <text>{{ key }}</text>
+        <text>{{ loaded[key] ? t('loaded') : t('not_loaded') }}</text>
+        <button hover-class="none" @click="playAudio(key)">
+          {{ loaded[key] ? t('play_301') : t('load_and_play') }}
+        </button>
+      </view>
+    </view>
+  </Container>
+</template>
+
+<style scoped>
+.container {
+  display: flex;
+  flex-direction: column;
+  width: 100%;
+}
+.container > view {
+  width: calc(100% - 50rpx);
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 25rpx;
+  color: #fff;
+  border-bottom: 1rpx solid #fff9;
+}
+.container > view > button {
+  color: #fff;
+}
+</style>

src/pages/battle-result.vue

@@ -0,0 +1,540 @@
+<script setup>
+import { t } from "@/locales";
+
+import { ref, computed, onMounted } from "vue";
+import { onLoad } from "@dcloudio/uni-app";
+import Avatar from "@/components/Avatar.vue";
+import UserUpgrade from "@/components/UserUpgrade.vue";
+import DeviceChargingDialog from "@/components/DeviceChargingDialog.vue";
+import { getBattleAPI } from "@/apis";
+import { topThreeColors, getBattleResultTips } from "@/constants";
+import audioManager from "@/audioManager";
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+const store = useStore();
+const { user } = storeToRefs(store);
+const { getLvlName } = store;
+
+const ifWin = ref(false);
+const data = ref({});
+const totalPoints = ref(0);
+const rank = ref(0);
+const players = ref([]);
+
+function exit() {
+  if (data.value.roomId) {
+    uni.redirectTo({
+      url: `/pages/battle-room?roomNumber=${data.value.roomId}`,
+    });
+  } else {
+    uni.navigateBack();
+  }
+}
+
+onLoad(async (options) => {
+  if (!options.battleId) return;
+  const myId = user.value.id;
+  const result = await getBattleAPI(options.battleId || "60049406950510592");
+  data.value = result;
+  if (result.winTeam) {
+    ifWin.value = result.teams[result.winTeam].players.some(
+      (p) => p.id === myId
+    );
+  }
+  if (result.mode <= 3) {
+    audioManager.play(ifWin.value ? "胜利" : "失败");
+  } else {
+    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);
+      if (p.id === user.value.id) {
+        totalPoints.value = p.score;
+        rank.value = index + 1;
+      }
+      return {
+        ...item,
+        rank: index + 1,
+        name: p.name,
+        avatar: p.avatar || "",
+      };
+    });
+    if (rank.value <= players.value * 0.3) {
+      audioManager.play("胜利");
+    } else {
+      audioManager.play("胜利");
+    }
+  }
+});
+
+const myTeam = computed(() => {
+  const teams = data.value.teams;
+  if (teams && teams.length) {
+    if (teams[1].players.some((p) => p.id === user.value.id)) return 1;
+  }
+  return 2;
+});
+
+const checkBowData = () => {
+  uni.navigateTo({
+    url: `/pages/match-detail?battleId=${data.value.matchId}`,
+  });
+};
+</script>
+
+<template>
+  <view class="container">
+    <block v-if="data.mode <= 3">
+      <view class="header-team" :style="{ marginTop: '25%' }">
+        <image src="https://static.shelingxingqiu.com/shootmini/static/battle-result.png" mode="widthFix" />
+        <view class="header-solo" v-if="data.mode === 1">
+          <text
+            :style="{
+              background:
+                data.winTeam === 1
+                  ? 'linear-gradient(270deg, #3597ff 0%, rgba(0,0,0,0) 100%);'
+                  : 'linear-gradient(270deg, #fd4444 0%, rgba(0, 0, 0, 0) 100%)',
+            }"
+            >{{ data.winTeam === 1 ? t('blue_team') : t('red_team') }}{{ t('win') }}</text
+          >
+          <Avatar
+            :size="32"
+            :src="
+              data.winTeam === 1
+                ? data.teams[1].players[0].avatar
+                : data.teams[2].players[0].avatar
+            "
+            :borderColor="data.winTeam === 1 ? '#5FADFF' : '#FF5656'"
+            mode="widthFix"
+          />
+        </view>
+      </view>
+      <view class="header-mvp" v-if="data.mode === 2 || data.mode === 3">
+        <image
+          :src="`https://static.shelingxingqiu.com/shootmini/static/${data.winTeam === 1 ? 'blue' : 'red'}-team-win.png`"
+          mode="widthFix"
+        />
+        <view
+          :style="{
+            transform: `translateY(50px) rotate(-${
+              5 + (data.mvp || []).length
+            }deg)`,
+          }"
+        >
+          <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
+              >{{ t('scored') }}<text
+                :style="{
+                  color: '#fed847',
+                  fontSize: '18px',
+                  margin: '0 3px',
+                  fontWeight: '600',
+                }"
+                >{{ data.mvp.player_match_result.total_ring }}</text
+              >{{ t('pts') }}</text
+            >
+          </view>
+          <view v-if="data.mvp && data.mvp.length">
+            <view v-for="(player, index) in data.mvp" :key="index">
+              <view class="team-avatar">
+                <Avatar
+                  :src="player.avatar"
+                  :size="40"
+                  :borderColor="myTeam === 1 ? '#5fadff' : '#ff6060'"
+                />
+                <text
+                  v-if="player.id === user.id"
+                  :style="{
+                    backgroundColor: myTeam === 1 ? '#5fadff' : '#ff6060',
+                  }"
+                  >{{ t('me') }}</text
+                >
+              </view>
+              <text class="truncate">{{ player.name }}</text>
+            </view>
+          </view>
+        </view>
+      </view>
+      <view class="battle-winner">
+        <image src="https://static.shelingxingqiu.com/shootmini/static/shining-bg.png" mode="widthFix" />
+        <image
+          :src="ifWin ? 'https://static.shelingxingqiu.com/shootmini/static/you-win.png' : 'https://static.shelingxingqiu.com/shootmini/static/you-lost.png'"
+          mode="widthFix"
+          class="scale-in"
+        />
+        <image
+          :src="
+            getBattleResultTips(data.way, data.mode, {
+              win: ifWin,
+            })
+          "
+          class="scale-in"
+          mode="widthFix"
+        />
+      </view>
+    </block>
+    <block v-else>
+      <view class="header-melee">
+        <view />
+        <image src="https://static.shelingxingqiu.com/shootmini/static/battle-result.png" mode="widthFix" />
+        <view />
+      </view>
+      <view
+        class="players"
+        :style="{
+          height: `${Math.max(players.length > 5 ? '330' : '300')}px`,
+        }"
+      >
+        <view
+          v-for="(player, index) in players"
+          :key="index"
+          :style="{
+            border: player.id === user.id ? '1px solid #B04630' : 'none',
+          }"
+        >
+          <image
+            v-if="player.rank === 1"
+            class="player-bg"
+            src="https://static.shelingxingqiu.com/shootmini/static/melee-player-bg1.png"
+            mode="aspectFill"
+          />
+          <image
+            v-if="player.rank === 2"
+            class="player-bg"
+            src="https://static.shelingxingqiu.com/shootmini/static/melee-player-bg2.png"
+            mode="aspectFill"
+          />
+          <image
+            v-if="player.rank === 3"
+            class="player-bg"
+            src="https://static.shelingxingqiu.com/shootmini/static/melee-player-bg3.png"
+            mode="aspectFill"
+          />
+          <image
+            v-if="player.rank === 1"
+            class="player-crown"
+            src="https://static.shelingxingqiu.com/shootmini/static/champ1.png"
+            mode="widthFix"
+          />
+          <image
+            v-if="player.rank === 2"
+            class="player-crown"
+            src="https://static.shelingxingqiu.com/shootmini/static/champ2.png"
+            mode="widthFix"
+          />
+          <image
+            v-if="player.rank === 3"
+            class="player-crown"
+            src="https://static.shelingxingqiu.com/shootmini/static/champ3.png"
+            mode="widthFix"
+          />
+          <view v-if="player.rank > 3" class="view-crown">{{
+            player.rank
+          }}</view>
+          <Avatar
+            :src="player.avatar"
+            :size="36"
+            :borderColor="topThreeColors[index] || ''"
+          />
+          <view class="player-title">
+            <text class="truncate">{{ player.name }}</text>
+            <text>{{ getLvlName(player.rank_lvl) }}</text>
+          </view>
+          <text
+            ><text :style="{ color: '#fff' }">{{ player.totalRing }}</text>{{ t('pts_308') }}</text
+          >
+        </view>
+      </view>
+    </block>
+    <view
+      class="battle-e"
+      :style="{ marginTop: data.mode > 3 ? '20px' : '20vw' }"
+    >
+      <image src="https://static.shelingxingqiu.com/shootmini/static/row-yellow-bg.png" mode="widthFix" />
+      <view class="team-avatar">
+        <Avatar
+          :src="user.avatar"
+          :size="40"
+          :borderColor="myTeam === 1 ? '#5fadff' : '#ff6060'"
+        />
+        <text
+          :style="{ backgroundColor: '#5fadff' }"
+          v-if="data.mode <= 3 && myTeam === 1"
+          >{{ t('blue_team') }}</text
+        >
+        <text
+          :style="{ backgroundColor: '#ff6060' }"
+          v-if="data.mode <= 3 && myTeam === 2"
+          >{{ t('red_team') }}</text
+        >
+      </view>
+      <text v-if="data.way === 1">{{ t('your_xp') }}{{ totalPoints > 0 ? "+" + totalPoints : totalPoints }}
+      </text>
+      <text v-if="data.way === 2">{{ t('your_points') }}{{ totalPoints > 0 ? "+" + totalPoints : totalPoints }}
+      </text>
+    </view>
+    <text v-if="data.mode > 3" class="description">
+      {{
+        getBattleResultTips(data.way, data.mode, {
+          win: ifWin,
+          score: totalPoints,
+          rank,
+        })
+      }}
+    </text>
+    <view class="op-btn">
+      <view @click="checkBowData">{{ t('view_results') }}</view>
+      <view @click="exit">{{ t('back') }}</view>
+    </view>
+    <UserUpgrade />
+    <DeviceChargingDialog />
+  </view>
+</template>
+
+<style scoped>
+.container {
+  width: 100vw;
+  height: 100vh;
+  background-color: #292929;
+  position: relative;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: flex-start;
+}
+.tag {
+  position: absolute;
+  width: 32vw;
+  top: 0;
+  right: 0;
+}
+.container > view {
+  position: relative;
+}
+.header-team {
+  width: 82%;
+  margin: 10px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  color: #fff;
+}
+.header-team > image {
+  width: 20vw;
+}
+.header-solo {
+  font-size: 14px;
+  display: flex;
+  align-items: flex-end;
+}
+.header-solo > text {
+  padding: 5px 20px;
+  padding-left: 24px;
+  transform: translateX(15px);
+}
+.battle-winner {
+  width: 100%;
+  height: 38%;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: flex-end;
+  color: #fff9;
+  font-size: 14px;
+}
+.battle-winner > image {
+  position: absolute;
+  width: 100vw;
+  top: 0;
+  left: 0;
+}
+.battle-winner > image:first-child {
+  animation: rotate 10s linear infinite;
+}
+.battle-winner > image:nth-child(2) {
+  top: 10%;
+}
+.battle-winner > image:nth-child(3) {
+  top: 75%;
+}
+.battle-e {
+  width: 100%;
+  height: 60px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+.battle-e > image {
+  position: absolute;
+  width: 100vw;
+}
+.battle-e > text {
+  position: relative;
+  font-size: 30px;
+  color: #fff;
+  margin-left: 10px;
+}
+.description {
+  margin-top: 50px;
+  font-size: 14px;
+  color: #fed847;
+  width: 100%;
+  text-align: center;
+  margin-bottom: 10px;
+}
+.op-btn {
+  width: 100%;
+  display: flex;
+  justify-content: center;
+  margin-top: 30px;
+}
+.op-btn > view {
+  width: 36%;
+  margin: 0 10px;
+  background-color: #fed847;
+  border-radius: 20px;
+  padding: 10px 0;
+  text-align: center;
+  color: #000;
+}
+.op-btn > view:last-child {
+  color: #fff;
+  background-color: #757575;
+}
+.header-melee {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 100%;
+  margin-bottom: 30px;
+  margin-top: 25%;
+}
+.header-melee > view {
+  height: 1px;
+  background-color: #fff3;
+  width: 18%;
+}
+.header-melee > image {
+  width: 27%;
+  margin: 0 20px;
+}
+.players {
+  display: flex;
+  flex-direction: column;
+  overflow: auto;
+  width: calc(100% - 60px);
+  color: #fff6;
+  margin: 0 30px;
+}
+.players > view {
+  width: 100%;
+  height: 60px;
+  flex: 0 0 auto;
+  overflow: hidden;
+  position: relative;
+  background-color: #ffffff1a;
+  display: flex;
+  align-items: center;
+  box-sizing: border-box;
+}
+.player-bg {
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  top: 0;
+  left: 0;
+}
+.player-crown {
+  position: relative;
+  width: 27px;
+  height: 27px;
+  margin: 0 15px;
+}
+.view-crown {
+  width: 27px;
+  height: 27px;
+  line-height: 27px;
+  text-align: center;
+  border-radius: 50%;
+  margin: 0 15px;
+  color: #fff;
+  background-color: #676767;
+  position: relative;
+}
+.player-title {
+  position: relative;
+  display: flex;
+  flex-direction: column;
+  margin-left: 15px;
+  width: calc(100% - 160px);
+}
+.player-title > text:first-child {
+  color: #fff;
+  margin-bottom: 3px;
+  width: 40vw;
+}
+.player-title > text:last-child {
+  font-size: 13px;
+}
+.team-avatar {
+  position: relative;
+  overflow: hidden;
+  width: 40px;
+  height: 40px;
+  box-sizing: border-box;
+  border-radius: 50%;
+}
+.team-avatar > text {
+  font-size: 7px;
+  text-align: center;
+  width: 100%;
+  position: absolute;
+  left: 0;
+  bottom: 0;
+  color: #fff;
+  padding-bottom: 1px;
+}
+.header-mvp {
+  position: relative;
+  width: 100%;
+}
+.header-mvp > image:first-child {
+  position: absolute;
+  width: 100%;
+}
+.header-mvp > view {
+  display: flex;
+  justify-content: center;
+}
+.header-mvp > view > view:first-child {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+.header-mvp > view > view:first-child > image {
+  width: 24vw;
+}
+.header-mvp > view > view:first-child > text {
+  color: #fff;
+  font-size: 14px;
+  transform: skewX(-10deg);
+}
+.header-mvp > view > view:last-child {
+  display: flex;
+  align-items: center;
+  color: #fff;
+  font-size: 9px;
+  text-align: center;
+  transform: translateY(-4px);
+}
+.header-mvp > view > view:last-child > view {
+  margin-left: 4vw;
+  display: flex;
+  flex-direction: column;
+}
+.header-mvp > view > view:last-child > view > text {
+  margin-top: 4px;
+  width: 40px;
+  transform: skewX(-10deg) translateX(-3px);
+}
+</style>

src/pages/coin/components/CoinBalancePanel.vue

@@ -0,0 +1,77 @@
+<script setup>
+import { t } from "@/locales";
+
+defineProps({
+  cumulative: {
+    type: [Number, String],
+    default: 0,
+  },
+  available: {
+    type: [Number, String],
+    default: 0,
+  },
+});
+</script>
+
+<template>
+  <view class="balance-panel">
+    <view class="balance-list">
+      <view class="balance-item">
+        <text class="balance-item__label">{{ t('total_coins') }}</text>
+        <text class="balance-item__value">{{ cumulative }}</text>
+      </view>
+      <view class="balance-list__line" />
+      <view class="balance-item">
+        <text class="balance-item__label">{{ t('redeemable_coins') }}</text>
+        <text class="balance-item__value">{{ available }}</text>
+      </view>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.balance-panel {
+  width: 100%;
+  padding: 8rpx 28rpx 0;
+  box-sizing: border-box;
+}
+
+.balance-list {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 100%;
+  height: 60rpx;
+  margin-top: 0;
+  border-radius: 12rpx;
+  box-sizing: border-box;
+  background: linear-gradient(90deg, transparent, rgba(4, 4, 4, 0.7), transparent);
+}
+
+.balance-item {
+  width: auto;
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  justify-content: center;
+}
+
+.balance-item__label {
+  color: #ffffff;
+  font-size: 24rpx;
+  line-height: 34rpx;
+}
+
+.balance-item__value {
+  color: #ffd947;
+  font-size: 30rpx;
+  line-height: 42rpx;
+}
+
+.balance-list__line {
+  width: 2rpx;
+  height: 16rpx;
+  background-color: rgba(255, 255, 255, 0.5);
+  margin: 0 22rpx;
+}
+</style>

src/pages/coin/components/CoinEmptyState.vue

@@ -0,0 +1,39 @@
+<script setup>
+import { t } from "@/locales";
+
+defineProps({
+  text: {
+    type: String,
+    default: t('no_coin_earnings_yet'),
+  },
+});
+</script>
+
+<template>
+  <view class="empty-state">
+    <image
+      src="https://static.shelingxingqiu.com/shootmini/static/coin/empty-coin-record.png"
+      mode="aspectFit"
+    />
+    <text>{{ text }}</text>
+  </view>
+</template>
+
+<style scoped>
+.empty-state {
+  width: 100%;
+  padding-top: 280rpx;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  color: #ffffff;
+  font-size: 26rpx;
+  line-height: 36rpx;
+}
+
+.empty-state > image {
+  width: 162rpx;
+  height: 190rpx;
+  margin-bottom: 26rpx;
+}
+</style>

src/pages/coin/components/CoinHeader.vue

@@ -0,0 +1,92 @@
+<script setup>
+import Header from "@/components/Header.vue";
+
+const props = defineProps({
+  title: {
+    type: String,
+    default: "",
+  },
+  subtitle: {
+    type: String,
+    default: "",
+  },
+  switchable: { type: Boolean, default: false },
+  onBack: {
+    type: Function,
+    default: null,
+  },
+});
+const emit = defineEmits(["select-store"]);
+</script>
+
+<template>
+  <view class="coin-header">
+    <Header title="" :onBack="onBack">
+      <template #title>
+        <view class="coin-header__title-group">
+          <text
+            :class="[
+              'coin-header__title',
+              subtitle ? 'coin-header__title--with-subtitle' : '',
+            ]"
+          >
+            {{ title }}
+          </text>
+          <view v-if="subtitle" class="coin-header__store" @click="switchable && emit('select-store')">
+            <text class="coin-header__subtitle">{{ subtitle }}</text>
+            <image v-if="switchable" class="coin-header__switch" src="https://static.shelingxingqiu.com/shootmini/static/coin/store-switch.png" mode="aspectFit" />
+          </view>
+        </view>
+      </template>
+    </Header>
+  </view>
+</template>
+
+<style scoped lang="scss">
+.coin-header__store { display: flex; align-items: center; max-width: 430rpx; }
+.coin-header__store .coin-header__subtitle { overflow: hidden; text-overflow: ellipsis; }
+.coin-header__switch { flex-shrink: 0; width: 28rpx; height: 28rpx; margin-left: 10rpx; }
+.coin-header {
+  position: sticky;
+  top: 0;
+  z-index: 20;
+  width: 100%;
+  height: 50px;
+  display: flex;
+  align-items: center;
+  flex-shrink: 0;
+}
+
+.coin-header__title-group {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  width: 430rpx;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  transform: translate(-50%, -50%);
+  text-align: center;
+}
+
+.coin-header__title {
+  color: #e7ba80;
+  font-size: 30rpx;
+  line-height: 42rpx;
+  font-weight: 500;
+  white-space: nowrap;
+}
+
+.coin-header__title--with-subtitle {
+  font-size: 28rpx;
+}
+
+.coin-header__subtitle {
+  color: #ffffff;
+  font-size: 20rpx;
+  line-height: 28rpx;
+  font-weight: 400;
+  white-space: nowrap;
+}
+</style>

src/pages/coin/components/CoinQuickMenu.vue

@@ -0,0 +1,50 @@
+<script setup>
+defineProps({
+  menus: {
+    type: Array,
+    default: () => [],
+  },
+});
+
+const emit = defineEmits(["select"]);
+</script>
+
+<template>
+  <view class="quick-menu">
+    <view
+      v-for="item in menus"
+      :key="item.key"
+      class="quick-menu__item"
+      @click="emit('select', item)"
+    >
+      <image class="quick-menu__icon" :src="item.icon" mode="aspectFit" />
+      <text>{{ item.label }}</text>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.quick-menu {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  width: 100%;
+  padding: 26rpx 46rpx 30rpx;
+  box-sizing: border-box;
+}
+
+.quick-menu__item {
+  width: 142rpx;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  color: #fae6bc;
+  font-size: 24rpx;
+  line-height: 34rpx;
+}
+
+.quick-menu__icon {
+  width: 116rpx;
+  height: 116rpx;
+}
+</style>

src/pages/coin/components/CoinRecordList.vue

@@ -0,0 +1,190 @@
+<script setup>
+import { t } from "@/locales";
+
+defineProps({
+  records: {
+    type: Array,
+    default: () => [],
+  },
+  mode: {
+    type: String,
+    default: "earning",
+  },
+});
+</script>
+
+<template>
+  <view
+    class="record-table"
+    :class="{ 'record-table--exchange': mode === 'exchange' }"
+  >
+    <view class="record-table__header">
+      <template v-if="mode === 'exchange'">
+        <text>{{ t('redeemed_item') }}</text>
+        <text>{{ t('redemption_type') }}</text>
+        <text>{{ t('time') }}</text>
+        <text>{{ t('coins_used') }}</text>
+      </template>
+      <template v-else>
+        <text>{{ t('time') }}</text>
+        <text>{{ t('type') }}</text>
+        <text>{{ t('coins_earned') }}</text>
+      </template>
+    </view>
+    <view
+      v-for="item in records"
+      :key="item.id"
+      class="record-table__row"
+    >
+      <template v-if="mode === 'exchange'">
+        <text class="record-table__exchange-content">{{ item.content }}</text>
+        <text class="record-table__exchange-type">{{ item.type }}</text>
+        <view class="record-table__time record-table__exchange-time">
+          <text>{{ item.date }}</text>
+          <text>{{ item.time }}</text>
+        </view>
+        <text class="record-table__amount record-table__exchange-amount">
+          {{ item.amount }}
+        </text>
+      </template>
+      <template v-else>
+        <view class="record-table__time">
+          <text>{{ item.date }}</text>
+          <text>{{ item.time }}</text>
+        </view>
+        <text class="record-table__type">{{ item.type }}</text>
+        <text class="record-table__amount">{{ item.amount }}</text>
+      </template>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.record-table {
+  width: 670rpx;
+  margin: 20rpx auto 0;
+  box-sizing: border-box;
+  border: 2rpx solid rgba(255, 255, 255, 0.35);
+}
+
+.record-table__header,
+.record-table__row {
+  display: flex;
+  align-items: center;
+}
+
+.record-table__header {
+  height: 66rpx;
+  color: #ffffff;
+  font-size: 24rpx;
+  line-height: 34rpx;
+}
+
+.record-table__header > text {
+  height: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  box-sizing: border-box;
+  border-right: 2rpx solid rgba(255, 255, 255, 0.35);
+}
+
+.record-table__header > text:nth-child(1),
+.record-table__time {
+  width: 182rpx;
+  flex: 0 0 182rpx;
+}
+
+.record-table__header > text:nth-child(2),
+.record-table__type {
+  width: 304rpx;
+  flex: 0 0 304rpx;
+}
+
+.record-table__header > text:nth-child(3),
+.record-table__amount {
+  width: 180rpx;
+  flex: 0 0 180rpx;
+  border-right: none;
+}
+
+.record-table__row {
+  height: 86rpx;
+  border-top: 2rpx solid rgba(255, 255, 255, 0.35);
+  color: #ffffff;
+  font-size: 24rpx;
+  line-height: 34rpx;
+}
+
+.record-table__row > view,
+.record-table__row > text {
+  height: 100%;
+  box-sizing: border-box;
+  border-right: 2rpx solid rgba(255, 255, 255, 0.35);
+}
+
+.record-table__time {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+}
+
+.record-table__time > text:last-child {
+  color: #ffffff;
+  font-size: 24rpx;
+  line-height: 34rpx;
+}
+
+.record-table__type {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: #ffffff;
+}
+
+.record-table__row > .record-table__amount {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: #ffffff;
+  text-align: center;
+  font-size: 24rpx;
+  border-right: none;
+}
+
+.record-table__exchange-content,
+.record-table__exchange-type {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0 8rpx;
+  color: #ffffff;
+  text-align: center;
+}
+
+.record-table--exchange .record-table__header > text:nth-child(1),
+.record-table__exchange-content {
+  width: 286rpx;
+  flex: 0 0 286rpx;
+}
+
+.record-table--exchange .record-table__header > text:nth-child(2),
+.record-table__exchange-type {
+  width: 110rpx;
+  flex: 0 0 110rpx;
+}
+
+.record-table--exchange .record-table__header > text:nth-child(3),
+.record-table__exchange-time {
+  width: 160rpx;
+  flex: 0 0 160rpx;
+}
+
+.record-table--exchange .record-table__header > text:nth-child(4),
+.record-table__exchange-amount {
+  width: 110rpx;
+  flex: 0 0 110rpx;
+  border-right: none;
+}
+</style>

src/pages/coin/components/LocationPermissionState.vue

@@ -0,0 +1,56 @@
+<script setup>
+import { t } from "@/locales";
+
+const emit = defineEmits(["authorize"]);
+</script>
+
+<template>
+  <view class="location-state">
+    <image
+      src="https://static.shelingxingqiu.com/shootmini/static/coin/location-permission.png"
+      mode="aspectFit"
+    />
+    <text>{{ t('allow_location_access_to_find_nearby_stores') }}</text>
+    <button hover-class="none" @click="emit('authorize')">{{ t('allow_access') }}</button>
+  </view>
+</template>
+
+<style scoped>
+.location-state {
+  width: 100%;
+  padding-top: 190rpx;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  color: #ffffff;
+  font-size: 32rpx;
+  line-height: 44rpx;
+  font-weight: 600;
+}
+
+.location-state > image {
+  width: 168rpx;
+  height: 190rpx;
+  margin-bottom: 52rpx;
+}
+
+.location-state > button {
+  width: 360rpx;
+  height: 72rpx;
+  margin-top: 44rpx;
+  padding: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: 36rpx;
+  background-color: #ffd947;
+  color: #22222e;
+  font-size: 26rpx;
+  line-height: 72rpx;
+  font-weight: 500;
+}
+
+.location-state > button::after {
+  border: none;
+}
+</style>

src/pages/coin/components/OfflineExchangeNotice.vue

@@ -0,0 +1,58 @@
+<script setup>
+import { t } from "@/locales";
+
+defineProps({
+  variant: {
+    type: String,
+    default: "gold",
+  },
+});
+</script>
+
+<template>
+  <view class="exchange-notice" :class="`exchange-notice--${variant}`">
+    <image
+      src="https://static.shelingxingqiu.com/shootmini/static/coin/icon-notice.png"
+      mode="aspectFit"
+    />
+    <text>{{ t('online_redemption_is_not_available_please_redeem_at_a_store') }}</text>
+  </view>
+</template>
+
+<style scoped>
+.exchange-notice {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 504rpx;
+  height: 40rpx;
+  margin: 0 auto;
+  padding: 0 16rpx;
+  box-sizing: border-box;
+  color: rgba(255, 255, 255, 0.65);
+  font-size: 20rpx;
+  line-height: 28rpx;
+  border-radius: 24rpx;
+}
+
+.exchange-notice--gold {
+  border: 2rpx solid rgba(255, 217, 71, 0.28);
+  background-color: rgba(255, 217, 71, 0.05);
+}
+
+.exchange-notice--red {
+  width: 492rpx;
+  height: 44rpx;
+  margin: 0 0 0 40rpx;
+  border: none;
+  background-color: rgba(255, 96, 96, 0.3);
+  color: #ffffff;
+}
+
+.exchange-notice > image {
+  width: 24rpx;
+  height: 24rpx;
+  margin-right: 8rpx;
+  flex-shrink: 0;
+}
+</style>

src/pages/coin/components/ProductHeroSwiper.vue

@@ -0,0 +1,90 @@
+<script setup>
+import { computed, ref } from "vue";
+
+const DEFAULT_PRODUCT_IMAGE =
+  "https://static.shelingxingqiu.com/shootmini/static/coin/product-hero-bg.png";
+const props = defineProps({
+  images: {
+    type: Array,
+    default: () => [],
+  },
+});
+
+const current = ref(0);
+const slideImages = computed(() => {
+  const images = props.images.filter(
+    (image) => typeof image === "string" && image.trim()
+  );
+  return images.length ? images : [DEFAULT_PRODUCT_IMAGE];
+});
+
+const onChange = (event) => {
+  current.value = event.detail.current;
+};
+</script>
+
+<template>
+  <view class="hero-swiper">
+    <swiper class="hero-swiper__body" :duration="260" @change="onChange">
+      <swiper-item v-for="(image, index) in slideImages" :key="index">
+        <view class="hero-swiper__item">
+          <image
+            class="hero-swiper__background"
+            src="https://static.shelingxingqiu.com/shootmini/static/coin/product-hero-bg.png"
+            mode="scaleToFill"
+          />
+          <image class="hero-swiper__product" :src="image" mode="aspectFit" />
+        </view>
+      </swiper-item>
+    </swiper>
+    <view class="hero-swiper__dots">
+      <view
+        v-for="(_, index) in slideImages"
+        :key="index"
+        class="hero-swiper__dot"
+        :class="{ 'hero-swiper__dot--active': current === index }"
+      />
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.hero-swiper,
+.hero-swiper__body,
+.hero-swiper__item {
+  position: relative;
+  width: 750rpx;
+  height: 750rpx;
+}
+
+.hero-swiper__background,
+.hero-swiper__product {
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 100%;
+  height: 100%;
+}
+
+.hero-swiper__dots {
+  position: absolute;
+  left: 0;
+  bottom: 20rpx;
+  width: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.hero-swiper__dot {
+  width: 12rpx;
+  height: 12rpx;
+  margin: 0 6rpx;
+  border-radius: 50%;
+  background-color: rgba(34, 34, 46, 0.55);
+}
+
+.hero-swiper__dot--active {
+  background-color: #ffd947;
+}
+</style>

src/pages/coin/components/RewardProductCard.vue

@@ -0,0 +1,102 @@
+<script setup>
+import { t } from "@/locales";
+
+import { computed } from "vue";
+
+const DEFAULT_PRODUCT_IMAGE =
+  "https://static.shelingxingqiu.com/shootmini/static/coin/product-hero-bg.png";
+
+const props = defineProps({
+  product: {
+    type: Object,
+    required: true,
+  },
+});
+
+const productImage = computed(() => {
+  const image = props.product?.image;
+  return typeof image === "string" && image.trim()
+    ? image
+    : DEFAULT_PRODUCT_IMAGE;
+});
+</script>
+
+<template>
+  <view class="product-card">
+    <view class="product-card__image-wrap">
+      <image class="product-card__image" :src="productImage" mode="aspectFit" />
+    </view>
+    <text class="product-card__name">{{ product.name }}</text>
+    <view class="product-card__footer">
+      <text>{{ product.cost }}{{ t('coins') }}</text>
+      <text class="product-card__divider">|</text>
+      <text>{{ t('remaining') }}{{ product.stock }}{{ t('empty_352') }}</text>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.product-card {
+  width: 336rpx;
+  height: 418rpx;
+  padding: 10rpx 10rpx 14rpx;
+  box-sizing: border-box;
+  border: 2rpx solid rgba(255, 217, 71, 0.1);
+  border-radius: 12rpx;
+  background-color: rgba(84, 67, 29, 0.2);
+  overflow: hidden;
+}
+
+.product-card__image-wrap {
+  position: relative;
+  width: 312rpx;
+  height: 312rpx;
+  overflow: hidden;
+  border-radius: 12rpx;
+  background-image: url("https://static.shelingxingqiu.com/shootmini/static/coin/product-card-bg.png");
+  background-size: 100% 100%;
+  background-repeat: no-repeat;
+}
+
+.product-card__image {
+  display: block;
+  width: 100%;
+  height: 100%;
+}
+
+.product-card__name {
+  display: block;
+  margin-top: 12rpx;
+  color: #fff0c9;
+  font-size: 26rpx;
+  line-height: 36rpx;
+  font-weight: 600;
+  text-align: center;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.product-card__footer {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin-top: 4rpx;
+  color: rgba(255, 255, 255, 0.85);
+  font-size: 22rpx;
+  line-height: 32rpx;
+}
+
+.product-card__footer > text:first-child {
+  color: #ffffff;
+}
+
+.product-card__footer > text:last-child {
+  color: rgba(255, 255, 255, 0.78);
+}
+
+.product-card__divider {
+  margin: 0 10rpx;
+  color: rgba(255, 255, 255, 0.45);
+}
+</style>