Merge branch 'test' into feat-prac

update:新增匹配跳转幂等
update:优化10人乱斗测距页
2026-07-20 17:58:40 +08:00 · 2026-07-20 16:46:04 +08:00 · 2026-07-17 18:26:14 +08:00 · 2026-07-16 16:40:32 +08:00 · 2026-07-16 11:38:17 +08:00 · 2026-07-15 16:57:48 +08:00
133 changed files with 12680 additions and 1381 deletions
@@ -1,3 +1,9 @@
 {
-    "i18n-ally.localesPaths": []
-}
+  "i18n-ally.localesPaths": [],
+  "files.watcherExclude": {
+    "**/dist/**": true
+  },
+  "search.exclude": {
+    "**/dist/**": true
+  }
+}
@@ -264,6 +264,7 @@ AI 应主动：
 * 少解释
 * 优先 patch
 * 优先 diff
+* 写好中文注释

 除非用户明确要求：
 否则不要输出完整项目。
@@ -12,5 +12,6 @@
  },
  "vueCompilerOptions": {
    "plugins": ["@uni-helper/uni-types/volar-plugin"]
-  }
+  },
+  "exclude": ["node_modules", "dist"]
 }
@@ -26,6 +26,8 @@
        "@dcloudio/uni-quickapp-webview": "3.0.0-4060620250520001",
        "@dcloudio/uni-ui": "^1.5.11",
        "pinia": "2.0.36",
+        "pinia-plugin-persistedstate": "3.2.1",
+        "protobufjs": "^8.7.0",
        "vue": "^3.4.21",
        "vue-i18n": "^9.1.9"
      },
@@ -2422,6 +2424,70 @@
        "vite": "^5.2.8"
      }
    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.20.2.tgz",
+      "integrity": "sha512-D+EBOJHXdNZcLJRBkhENNG8Wji2kgc9AZ9KiPr1JuZjsNtyHzrsfLRrY0tk2H2aoFu6RANO1y1iPPUCDYWkb5g==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.20.2.tgz",
+      "integrity": "sha512-t98Ra6pw2VaDhqNWO2Oph2LXbz/EJcnLmKLGBJwEwXX/JAN83Fym1rU8l0JUWK6HkIbWONCSSatf4sf2NBRx/w==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.20.2.tgz",
+      "integrity": "sha512-mRzjLacRtl/tWU0SvD8lUEwb61yP9cqQo6noDZP/O8VkwafSYwZ4yWy24kan8jE/IMERpYncRt2dw438LP3Xmg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.20.2.tgz",
+      "integrity": "sha512-btzExgV+/lMGDDa194CcUQm53ncxzeBrWJcncOBxuC6ndBkKxnHdFJn86mCIgTELsooUmwUm9FkhSp5HYu00Rg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
    "node_modules/@esbuild/darwin-arm64": {
      "version": "0.20.2",
      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.20.2.tgz",
@@ -2438,6 +2504,294 @@
        "node": ">=12"
      }
    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.20.2.tgz",
+      "integrity": "sha512-tBcXp9KNphnNH0dfhv8KYkZhjc+H3XBkF5DKtswJblV7KlT9EI2+jeA8DgBjp908WEuYll6pF+UStUCfEpdysA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.20.2.tgz",
+      "integrity": "sha512-d3qI41G4SuLiCGCFGUrKsSeTXyWG6yem1KcGZVS+3FYlYhtNoNgYrWcvkOoaqMhwXSMrZRl69ArHsGJ9mYdbbw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.20.2.tgz",
+      "integrity": "sha512-d+DipyvHRuqEeM5zDivKV1KuXn9WeRX6vqSqIDgwIfPQtwMP4jaDsQsDncjTDDsExT4lR/91OLjRo8bmC1e+Cw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.20.2.tgz",
+      "integrity": "sha512-VhLPeR8HTMPccbuWWcEUD1Az68TqaTYyj6nfE4QByZIQEQVWBB8vup8PpR7y1QHL3CpcF6xd5WVBU/+SBEvGTg==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.20.2.tgz",
+      "integrity": "sha512-9pb6rBjGvTFNira2FLIWqDk/uaf42sSyLE8j1rnUpuzsODBq7FvpwHYZxQ/It/8b+QOS1RYfqgGFNLRI+qlq2A==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.20.2.tgz",
+      "integrity": "sha512-o10utieEkNPFDZFQm9CoP7Tvb33UutoJqg3qKf1PWVeeJhJw0Q347PxMvBgVVFgouYLGIhFYG0UGdBumROyiig==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.20.2.tgz",
+      "integrity": "sha512-PR7sp6R/UC4CFVomVINKJ80pMFlfDfMQMYynX7t1tNTeivQ6XdX5r2XovMmha/VjR1YN/HgHWsVcTRIMkymrgQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.20.2.tgz",
+      "integrity": "sha512-4BlTqeutE/KnOiTG5Y6Sb/Hw6hsBOZapOVF6njAESHInhlQAghVVZL1ZpIctBOoTFbQyGW+LsVYZ8lSSB3wkjA==",
+      "cpu": [
+        "mips64el"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.20.2.tgz",
+      "integrity": "sha512-rD3KsaDprDcfajSKdn25ooz5J5/fWBylaaXkuotBDGnMnDP1Uv5DLAN/45qfnf3JDYyJv/ytGHQaziHUdyzaAg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.20.2.tgz",
+      "integrity": "sha512-snwmBKacKmwTMmhLlz/3aH1Q9T8v45bKYGE3j26TsaOVtjIag4wLfWSiZykXzXuE1kbCE+zJRmwp+ZbIHinnVg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.20.2.tgz",
+      "integrity": "sha512-wcWISOobRWNm3cezm5HOZcYz1sKoHLd8VL1dl309DiixxVFoFe/o8HnwuIwn6sXre88Nwj+VwZUvJf4AFxkyrQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.20.2.tgz",
+      "integrity": "sha512-1MdwI6OOTsfQfek8sLwgyjOXAu+wKhLEoaOLTjbijk6E2WONYpH9ZU2mNtR+lZ2B4uwr+usqGuVfFT9tMtGvGw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.20.2.tgz",
+      "integrity": "sha512-K8/DhBxcVQkzYc43yJXDSyjlFeHQJBiowJ0uVL6Tor3jGQfSGHNNJcWxNbOI8v5k82prYqzPuwkzHt3J1T1iZQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.20.2.tgz",
+      "integrity": "sha512-eMpKlV0SThJmmJgiVyN9jTPJ2VBPquf6Kt/nAoo6DgHAoN57K15ZghiHaMvqjCye/uU4X5u3YSMgVBI1h3vKrQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.20.2.tgz",
+      "integrity": "sha512-2UyFtRC6cXLyejf/YEld4Hajo7UHILetzE1vsRcGL3earZEW77JxrFjH4Ez2qaTiEfMgAXxfAZCm1fvM/G/o8w==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.20.2.tgz",
+      "integrity": "sha512-GRibxoawM9ZCnDxnP3usoUDO9vUkpAxIIZ6GQI+IlVmr5kP3zUq+l17xELTHMWTWzjxa2guPNyrpq1GWmPvcGQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.20.2.tgz",
+      "integrity": "sha512-HfLOfn9YWmkSKRQqovpnITazdtquEW8/SoHW7pWpuEeguaZI4QnCRW6b+oZTztdBnZOS2hqJ6im/D5cPzBTTlQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.20.2.tgz",
+      "integrity": "sha512-N49X4lJX27+l9jbLKSqZ6bKNjzQvHaT8IIFUy+YIqmXQdjYCToGWwOItDrfby14c78aDd5NHQl29xingXfCdLQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
    "node_modules/@intlify/core-base": {
      "version": "9.1.9",
      "resolved": "https://registry.npmjs.org/@intlify/core-base/-/core-base-9.1.9.tgz",
@@ -3424,6 +3778,32 @@
        }
      }
    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.39.0.tgz",
+      "integrity": "sha512-lGVys55Qb00Wvh8DMAocp5kIcaNzEFTmGhfFd88LfaogYTRKrdxgtlO5H6S49v2Nd8R2C6wLOal0qv6/kCkOwA==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.39.0.tgz",
+      "integrity": "sha512-It9+M1zE31KWfqh/0cJLrrsCPiF72PoJjIChLX+rEcujVRCb4NLQ5QzFkzIZW8Kn8FTbvGQBY5TkKBau3S8cCQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
    "node_modules/@rollup/rollup-darwin-arm64": {
      "version": "4.39.0",
      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.39.0.tgz",
@@ -3437,6 +3817,227 @@
        "darwin"
      ]
    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.39.0.tgz",
+      "integrity": "sha512-mKXpNZLvtEbgu6WCkNij7CGycdw9cJi2k9v0noMb++Vab12GZjFgUXD69ilAbBh034Zwn95c2PNSz9xM7KYEAQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.39.0.tgz",
+      "integrity": "sha512-jivRRlh2Lod/KvDZx2zUR+I4iBfHcu2V/BA2vasUtdtTN2Uk3jfcZczLa81ESHZHPHy4ih3T/W5rPFZ/hX7RtQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.39.0.tgz",
+      "integrity": "sha512-8RXIWvYIRK9nO+bhVz8DwLBepcptw633gv/QT4015CpJ0Ht8punmoHU/DuEd3iw9Hr8UwUV+t+VNNuZIWYeY7Q==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.39.0.tgz",
+      "integrity": "sha512-mz5POx5Zu58f2xAG5RaRRhp3IZDK7zXGk5sdEDj4o96HeaXhlUwmLFzNlc4hCQi5sGdR12VDgEUqVSHer0lI9g==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.39.0.tgz",
+      "integrity": "sha512-+YDwhM6gUAyakl0CD+bMFpdmwIoRDzZYaTWV3SDRBGkMU/VpIBYXXEvkEcTagw/7VVkL2vA29zU4UVy1mP0/Yw==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.39.0.tgz",
+      "integrity": "sha512-EKf7iF7aK36eEChvlgxGnk7pdJfzfQbNvGV/+l98iiMwU23MwvmV0Ty3pJ0p5WQfm3JRHOytSIqD9LB7Bq7xdQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.39.0.tgz",
+      "integrity": "sha512-vYanR6MtqC7Z2SNr8gzVnzUul09Wi1kZqJaek3KcIlI/wq5Xtq4ZPIZ0Mr/st/sv/NnaPwy/D4yXg5x0B3aUUA==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loongarch64-gnu": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.39.0.tgz",
+      "integrity": "sha512-NMRUT40+h0FBa5fb+cpxtZoGAggRem16ocVKIv5gDB5uLDgBIwrIsXlGqYbLwW8YyO3WVTk1FkFDjMETYlDqiw==",
+      "cpu": [
+        "loong64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-powerpc64le-gnu": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.39.0.tgz",
+      "integrity": "sha512-0pCNnmxgduJ3YRt+D+kJ6Ai/r+TaePu9ZLENl+ZDV/CdVczXl95CbIiwwswu4L+K7uOIGf6tMo2vm8uadRaICQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.39.0.tgz",
+      "integrity": "sha512-t7j5Zhr7S4bBtksT73bO6c3Qa2AV/HqiGlj9+KB3gNF5upcVkx+HLgxTm8DK4OkzsOYqbdqbLKwvGMhylJCPhQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.39.0.tgz",
+      "integrity": "sha512-m6cwI86IvQ7M93MQ2RF5SP8tUjD39Y7rjb1qjHgYh28uAPVU8+k/xYWvxRO3/tBN2pZkSMa5RjnPuUIbrwVxeA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.39.0.tgz",
+      "integrity": "sha512-iRDJd2ebMunnk2rsSBYlsptCyuINvxUfGwOUldjv5M4tpa93K8tFMeYGpNk2+Nxl+OBJnBzy2/JCscGeO507kA==",
+      "cpu": [
+        "s390x"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.39.0.tgz",
+      "integrity": "sha512-t9jqYw27R6Lx0XKfEFe5vUeEJ5pF3SGIM6gTfONSMb7DuG6z6wfj2yjcoZxHg129veTqU7+wOhY6GX8wmf90dA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.39.0.tgz",
+      "integrity": "sha512-ThFdkrFDP55AIsIZDKSBWEt/JcWlCzydbZHinZ0F/r1h83qbGeenCt/G/wG2O0reuENDD2tawfAj2s8VK7Bugg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.39.0.tgz",
+      "integrity": "sha512-jDrLm6yUtbOg2TYB3sBF3acUnAwsIksEYjLeHL+TJv9jg+TmTwdyjnDex27jqEMakNKf3RwwPahDIt7QXCSqRQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.39.0.tgz",
+      "integrity": "sha512-6w9uMuza+LbLCVoNKL5FSLE7yvYkq9laSd09bwS0tMjkwXrmib/4KmoJcrKhLWHvw19mwU+33ndC69T7weNNjQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.39.0.tgz",
+      "integrity": "sha512-yAkUOkIKZlK5dl7u6dg897doBgLXmUHhIINM2c+sND3DZwnrdQkkSiDh7N75Ll4mM4dxSkYfXqU9fW3lLkMFug==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
    "node_modules/@sinonjs/commons": {
      "version": "1.8.6",
      "resolved": "https://registry.npmjs.org/@sinonjs/commons/-/commons-1.8.6.tgz",
@@ -7535,6 +8136,12 @@
      "dev": true,
      "license": "MIT"
    },
+    "node_modules/long": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz",
+      "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==",
+      "license": "Apache-2.0"
+    },
    "node_modules/lru-cache": {
      "version": "5.1.1",
      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
@@ -8222,6 +8829,15 @@
        }
      }
    },
+    "node_modules/pinia-plugin-persistedstate": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/pinia-plugin-persistedstate/-/pinia-plugin-persistedstate-3.2.1.tgz",
+      "integrity": "sha512-MK++8LRUsGF7r45PjBFES82ISnPzyO6IZx3CH5vyPseFLZCk1g2kgx6l/nW8pEBKxxd4do0P6bJw+mUSZIEZUQ==",
+      "license": "MIT",
+      "peerDependencies": {
+        "pinia": "^2.0.0"
+      }
+    },
    "node_modules/pirates": {
      "version": "4.0.7",
      "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz",
@@ -8530,6 +9146,18 @@
        "node": ">= 6"
      }
    },
+    "node_modules/protobufjs": {
+      "version": "8.7.0",
+      "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-8.7.0.tgz",
+      "integrity": "sha512-uu52JNxLh3vsL7tXU/h0gDaywufvuUCTbGSi0NKQKBZ2ZopkmrWQJSQO/EFqzu/5YhiwgVM8rq/a/iVpx4eZ0g==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "long": "^5.3.2"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
    "node_modules/proxy-addr": {
      "version": "2.0.7",
      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
@@ -26,6 +26,7 @@
    "@dcloudio/uni-ui": "^1.5.11",
    "pinia": "2.0.36",
    "pinia-plugin-persistedstate": "3.2.1",
+    "protobufjs": "^8.7.0",
    "vue": "^3.4.21",
    "vue-i18n": "^9.1.9"
  },
@@ -3,7 +3,240 @@
  "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"
+      }
+    ],
    "include": []
  },
  "setting": {
@@ -7,9 +7,13 @@
 		onHide
 	} from "@dcloudio/uni-app";
 	import websocket from "@/websocket";
+	import matchWebsocket from "@/matchWebsocket";
 	import {
 		getDeviceBatteryAPI
 	} from "@/apis";
+	import {
+		MESSAGETYPES
+	} from "@/constants";
 	import useStore from "@/store";
 	import {
 		storeToRefs
@@ -36,6 +40,9 @@
 				websocket.createWebSocket(token, onShootWsMsg);
 			}
 			if (!newVal) {
+				matchWebsocket.closeMatchWebSocket({
+					reason: "logout"
+				});
 				websocket.closeWebSocket();
 			}
 		}, {
@@ -73,18 +80,50 @@
 		// audioManager.play("射箭声音")
 	}

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

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

 try {
@@ -6,7 +8,7 @@ try {

    switch (envVersion) {
        case "develop": // 开发版
-            // BASE_URL = "http://192.168.1.30:8000/api/shoot";
+            // BASE_URL = "http://192.168.1.2:8000/api/shoot";
            BASE_URL = "https://apitest.shelingxingqiu.com/api/shoot";
            break;
        case "trial": // 体验版
@@ -24,6 +26,7 @@ try {
 }

 const ADDONS_BASE_URL = BASE_URL.replace(/\/api\/shoot$/, "/api/shoot");
+const PRACTICE_BASE_URL = BASE_URL.replace(/\/api\/shoot$/, "/api");

 // 统一处理业务接口请求，包含登录态、业务错误和 WiFi 连接空响应兼容。
 function request(method, url, data = {}, baseUrl = BASE_URL) {
@@ -261,12 +264,21 @@ export const createPractiseAPI = (arrows, time, target) => {
    });
 };

-export const startPractiseAPI = () => {
-    return request("POST", "/user/practice/begin");
+export const createPractiseV2API = (arrows, time, target, deviceId) => {
+    return request("POST", "/practice/create-v2", {
+        shootNumber: arrows,
+        shootTime: time,
+        targetType: Number(target || 1) * 20,
+        deviceId,
+    }, PRACTICE_BASE_URL);
 };

-export const endPractiseAPI = () => {
-    return request("POST", "/user/practice/stop");
+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) => {
@@ -451,6 +463,15 @@ export const getPractiseDataAPI = async () => {
    return request("GET", "/user/practice/statistics");
 };

+export const getPersonalTrainingAPI = async () => {
+    return request("GET", "/personal/training");
+};
+
+export const getTrainingDifficultyListAPI = async (type) => {
+    const query = type ? `?type=${encodeURIComponent(type)}` : "";
+    return request("GET", `/training/difficulty/list${query}`);
+};
+
 export const getBattleDataAPI = async () => {
    return request("GET", "/user/fight/statistics");
 };
@@ -553,9 +574,10 @@ export const getReadyAPI = (roomId) => {
 };

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

 export const kickPlayerAPI = (number, userId) => {
@@ -95,6 +95,28 @@ export const audioFils = {
 	"https://static.shelingxingqiu.com/shootaudio/%E5%91%BD%E4%B8%AD.mp3"
 };

+const AUDIO_LOAD_TIMEOUT_MS = 5000;
+const AUDIO_WARM_CONCURRENCY = 3;
+const AUDIO_WARM_RETRIES = 1;
+const AUDIO_WARM_PRIORITY_KEYS = [
+  "点击按钮",
+  "比赛开始",
+  "练习开始",
+  "请开始射击",
+  "轮到你了",
+  "比赛结束",
+  "射击无效",
+  "中场休息",
+  "下半场开始",
+  "决金箭轮",
+  "请蓝方射箭",
+  "请红方射箭",
+  "距离合格",
+  "距离不足",
+  "未上靶",
+  "X环",
+];
+
 // 版本控制日志函数
 function debugLog(...args) {
  // 获取当前环境信息
@@ -111,18 +133,15 @@ class AudioManager {
  constructor() {
    this.audioMap = new Map();
    this.currentPlayingKey = null;
-    this.maxRetries = 3;
-    // 多轮统一重试：最多重试的轮次与每轮间隔
-    this.maxRetryRounds = 10;
-    this.retryRoundIntervalMs = 1500;
    // 显式授权播放标记，防止 iOS 在设置 src 后误播
    this.allowPlayMap = new Map();

-    // 串行加载相关属性
-    this.audioKeys = [];
-    this.currentLoadingIndex = 0;
+    // 后台预热与单条加载状态
    this.isLoading = false;
-    this.loadingPromise = null;
+    this.loadingKeyPromises = new Map();
+    this.pendingPlayKeys = new Set();
+    this.cacheWritePromises = new Map();
+    this.warmAllPromise = null;

    // 连续播放队列相关属性
    this.sequenceQueue = [];
@@ -141,19 +160,14 @@ class AudioManager {
    // 静音开关
    this.isMuted = false;
    this.pendingPlayKey = null;
-    // 新增：就绪状态映射
    this.readyMap = new Map();
-    // 新增：首轮失败的音频集合与重试阶段标识
-    this.failedLoadKeys = new Set();
-    // 加载代数，用于 reloadAll 时作废旧的加载循环
+    // 加载代数，用于 reloadAll 时作废旧的异步加载
    this.loadGeneration = 0;
    // 本地路径缓存 Map: { url: localPath }
    this.localFileCache = uni.getStorageSync("audio_local_files") || {};
    // 启动时自动清理过期的缓存文件（URL 已不在 audioFils 中的文件）
    this.cleanObsoleteCache();
    this.bindAudioInterruptionEvents();
-
-    this.initAudios();
  }

  bindAudioInterruptionEvents() {
@@ -217,128 +231,122 @@ class AudioManager {
    }
  }

-  // 初始化音频（两阶段：首轮串行加载全部，次轮仅串行加载失败项一次）
-  initAudios() {
-    if (this.isLoading) {
-      debugLog("音频正在加载中，跳过重复初始化");
-      return this.loadingPromise;
-    }
-    debugLog("开始串行加载音频...");
-    this.isLoading = true;
-    this.audioKeys = Object.keys(audioFils);
-    this.currentLoadingIndex = 0;
-    this.failedLoadKeys.clear();
-
-    // 增加代数，使得旧的加载循环失效
-    this.loadGeneration = (this.loadGeneration || 0) + 1;
-    const currentGen = this.loadGeneration;
-
-    this.loadingPromise = new Promise((resolve) => {
-      const finalize = () => {
-        if (currentGen !== this.loadGeneration) return;
-        const runRounds = (round) => {
-          if (currentGen !== this.loadGeneration) return;
-          // 达到最大轮次或没有失败项，收尾
-          if (this.failedLoadKeys.size === 0 || round > this.maxRetryRounds) {
-            this.isLoading = false;
-            resolve();
-            return;
-          }
-
-          const retryKeys = Array.from(this.failedLoadKeys);
-          this.failedLoadKeys.clear();
-          debugLog(`开始第 ${round} 轮串行加载，共 ${retryKeys.length} 个`);
-
-          this.loadKeysSequentially(
-            retryKeys,
-            () => {
-              if (currentGen !== this.loadGeneration) return;
-              // 如仍有失败项，继续下一轮；否则结束
-              if (this.failedLoadKeys.size > 0 && round < this.maxRetryRounds) {
-                setTimeout(
-                  () => runRounds(round + 1),
-                  this.retryRoundIntervalMs
-                );
-              } else {
-                this.isLoading = false;
-                resolve();
-              }
-            },
-            currentGen
-          );
-        };
-
-        // 启动第 1 轮重试（如有失败项）
-        runRounds(1);
-      };
-      this.loadNextAudio(finalize, currentGen);
-    });
-    return this.loadingPromise;
+  getWarmupKeys() {
+    return Array.from(
+      new Set([...AUDIO_WARM_PRIORITY_KEYS, ...Object.keys(audioFils)])
+    );
  }

-  // 按自定义列表串行加载音频（避免并发过多）
-  loadKeysSequentially(keys, onComplete, gen) {
-    if (gen !== undefined && gen !== this.loadGeneration) return;
-    let idx = 0;
-    const list = Array.from(keys);
-    const next = () => {
-      if (gen !== undefined && gen !== this.loadGeneration) return;
-      if (idx >= list.length) {
-        if (onComplete) onComplete();
-        return;
-      }
-      const k = list[idx++];
+  ensureAudio(key) {
+    if (!audioFils[key]) return Promise.resolve(false);
+    if (this.readyMap.get(key) && this.audioMap.has(key)) {
+      return Promise.resolve(true);
+    }

-      // 已就绪的音频不再重载，避免把 ready 状态重置为 false
-      if (this.readyMap.get(k)) {
-        setTimeout(next, 50);
-        return;
-      }
+    const loadingPromise = this.loadingKeyPromises.get(key);
+    if (loadingPromise) return loadingPromise;

-      // 未就绪：已存在则重载；不存在则创建
-      if (this.audioMap.has(k)) {
-        this.retryLoadAudio(k);
-        setTimeout(next, 100);
-      } else {
-        this.createAudio(k, () => {
-          setTimeout(next, 100);
+    let promise;
+    promise = new Promise((resolve) => {
+      try {
+        this.createAudio(key, () => {
+          resolve(this.readyMap.get(key) === true && this.audioMap.has(key));
        });
-        return; // createAudio 内部会触发 next
+      } catch (error) {
+        debugLog(`音频 ${key} 创建失败`, error);
+        resolve(false);
+      }
+    }).finally(() => {
+      if (this.loadingKeyPromises.get(key) === promise) {
+        this.loadingKeyPromises.delete(key);
+      }
+    });
+    this.loadingKeyPromises.set(key, promise);
+    return promise;
+  }
+
+  async warmKeys(
+    keys,
+    { concurrency = AUDIO_WARM_CONCURRENCY, retries = AUDIO_WARM_RETRIES } = {}
+  ) {
+    const queue = Array.from(new Set(keys)).filter((key) => !!audioFils[key]);
+    if (!queue.length) return;
+
+    let index = 0;
+    const worker = async () => {
+      while (index < queue.length) {
+        const key = queue[index++];
+        let ready = await this.ensureAudio(key);
+        for (let attempt = 0; !ready && attempt < retries; attempt += 1) {
+          ready = await this.retryLoadAudio(key);
+        }
      }
    };
-    next();
+
+    const workerCount = Math.min(Math.max(1, concurrency), queue.length);
+    await Promise.all(Array.from({ length: workerCount }, () => worker()));
  }

-  // 串行加载下一个音频（首轮）
-  loadNextAudio(onComplete, gen) {
-    if (gen !== undefined && gen !== this.loadGeneration) return;
-    if (this.currentLoadingIndex >= this.audioKeys.length) {
-      debugLog("首轮加载遍历完成", this.currentLoadingIndex);
-      if (onComplete) onComplete();
+  warmButton() {
+    return this.warmKeys(["点击按钮"], { concurrency: 1, retries: 1 });
+  }
+
+  warmAll() {
+    if (this.warmAllPromise) return this.warmAllPromise;
+
+    debugLog("开始后台分级预热全部语音");
+    this.isLoading = true;
+    this.warmAllPromise = this.warmKeys(this.getWarmupKeys())
+      .catch((error) => {
+        debugLog("后台语音预热异常", error);
+      })
+      .finally(() => {
+        this.isLoading = false;
+        debugLog("后台语音预热结束", this.getLoadProgress());
+      });
+    return this.warmAllPromise;
+  }
+
+  // 保留旧入口兼容测试页或其他历史调用，实际行为改为非阻塞后台预热。
+  initAudios() {
+    return this.warmAll();
+  }
+
+  // 创建单个音频实例：缓存命中优先使用，未命中直接使用 CDN。
+  createAudio(key, callback) {
+    const src = audioFils[key];
+    const generation = this.loadGeneration;
+    let completed = false;
+
+    const complete = () => {
+      if (completed) return;
+      completed = true;
+      if (callback) callback();
+    };
+
+    if (!src) {
+      complete();
      return;
    }
-    const key = this.audioKeys[this.currentLoadingIndex];
-    debugLog(
-      `开始加载音频 ${this.currentLoadingIndex + 1}/${
-        this.audioKeys.length
-      }: ${key}`
-    );
-    this.createAudio(key, () => {
-      setTimeout(() => {
-        this.loadNextAudio(onComplete, gen);
-      }, 100);
-    });
-  }

-  // 创建单个音频实例（支持本地缓存）
-  createAudio(key, callback) {
-    this.currentLoadingIndex++;
-    const src = audioFils[key];
+    const existingAudio = this.audioMap.get(key);
+    if (existingAudio && !this.readyMap.get(key)) {
+      try {
+        existingAudio.destroy();
+      } catch (_) {}
+      this.audioMap.delete(key);
+    }
+
+    const isCurrentGeneration = () => generation === this.loadGeneration;
+
+    const setupAudio = (realSrc, resumeAfterReady = false) => {
+      if (!isCurrentGeneration()) {
+        complete();
+        return;
+      }

-    const setupAudio = (realSrc) => {
      const audio = uni.createInnerAudioContext();
      audio.autoplay = false;
-      audio.src = realSrc;
      try {
        if (typeof audio.volume === "number") {
          audio.volume = this.isMuted ? 0 : 1;
@@ -355,63 +363,99 @@ class AudioManager {
        }
      });

-      const loadTimeout = setTimeout(() => {
-        debugLog(`音频 ${key} 加载超时`);
-        this.recordLoadFailure(key);
+      let loadTimeout = null;
+      let readyHandled = false;
+      const clearLoadTimeout = () => {
+        if (!loadTimeout) return;
+        clearTimeout(loadTimeout);
+        loadTimeout = null;
+      };
+
+      const handleLoadFailure = (message) => {
+        if (this.audioMap.get(key) !== audio) return;
+        clearLoadTimeout();
+        debugLog(`音频 ${key} ${message}`);
+
+        const isLocalCache =
+          realSrc !== src && this.localFileCache[src] === realSrc;
+        const shouldResume =
+          this.allowPlayMap.get(key) === true || this.currentPlayingKey === key;
+        const shouldResumeDirectly = shouldResume && completed;
+
+        this.clearPlayWatchdog(key);
+        this.allowPlayMap.set(key, false);
+        if (this.currentPlayingKey === key) {
+          this.currentPlayingKey = null;
+        }
+        if (this.lastPlayKey === key) {
+          this.lastPlayKey = null;
+          this.lastPlayAt = 0;
+        }
+        this.readyMap.set(key, false);
        this.audioMap.delete(key);
        try {
          audio.destroy();
        } catch (_) {}
+
+        if (isLocalCache && isCurrentGeneration()) {
+          debugLog(`本地缓存失效，立即切换 CDN: ${key}`);
+          delete this.localFileCache[src];
+          uni.setStorageSync("audio_local_files", this.localFileCache);
+          uni.removeSavedFile({ filePath: realSrc });
+          setupAudio(src, shouldResumeDirectly);
+          void this.cacheRemoteFile(src, key);
+          return;
+        }
+
        this.finishPlayback(key, {
          advanceSequence: true,
          emitEnded: true,
        });
-        if (callback) callback();
-      }, 10000);
+        complete();
+      };
+
+      loadTimeout = setTimeout(() => {
+        handleLoadFailure("加载超时");
+      }, AUDIO_LOAD_TIMEOUT_MS);

      audio.onCanplay(() => {
+        if (this.audioMap.get(key) !== audio) return;
+        if (readyHandled) return;
+        readyHandled = true;
+        if (!isCurrentGeneration()) {
+          clearLoadTimeout();
+          this.audioMap.delete(key);
+          try {
+            audio.destroy();
+          } catch (_) {}
+          complete();
+          return;
+        }
        if (!this.allowPlayMap.get(key)) {
          try {
            audio.pause();
          } catch (_) {}
        }
-        clearTimeout(loadTimeout);
+        clearLoadTimeout();
        this.readyMap.set(key, true);
-        this.failedLoadKeys.delete(key);
-        // debugLog(`音频 ${key} 已加载完成`, this.getLoadProgress());
        uni.$emit("audioLoaded", key);
        const loadedAudioKeys = uni.getStorageSync("loadedAudioKeys") || {};
        loadedAudioKeys[key] = true;
        uni.setStorageSync("loadedAudioKeys", loadedAudioKeys);
-        if (callback) callback();
+        complete();
+
+        if (resumeAfterReady) {
+          setTimeout(() => {
+            const isSequenceCurrent =
+              this.isSequenceRunning &&
+              this.sequenceQueue[this.sequenceIndex] === key;
+            if (isSequenceCurrent) this._playSingle(key, false);
+          }, 0);
+        }
      });

      audio.onError((res) => {
-        clearTimeout(loadTimeout);
-        debugLog(`音频 ${key} 加载失败：`, res.errMsg);
-        // 如果是本地文件加载失败，可能是文件损坏，清除缓存以便下次重新下载
-        if (realSrc !== src && this.localFileCache[src] === realSrc) {
-          debugLog(`本地缓存失效，移除记录: ${key}`);
-          delete this.localFileCache[src];
-          uni.setStorageSync("audio_local_files", this.localFileCache);
-          // 移除文件
-          uni.removeSavedFile({ filePath: realSrc });
-        }
-        this.recordLoadFailure(key);
-        this.audioMap.delete(key);
-        try {
-          audio.destroy();
-        } catch (_) {}
-        this.finishPlayback(key, {
-          advanceSequence: true,
-          emitEnded: true,
-        });
-        if (this.readyMap.get(key)) {
-          // 这里不要去除，不然检查进度的时候由于没有重新加载而进度卡住，等播放失败的时候会重新加载
-          // this.readyMap.set(key, false);
-        } else {
-          if (callback) callback();
-        }
+        handleLoadFailure(`加载失败：${res.errMsg || "unknown"}`);
      });

      audio.onEnded(() => {
@@ -426,58 +470,78 @@ class AudioManager {
      });

      this.audioMap.set(key, audio);
+      audio.src = realSrc;
    };

    // 检查是否有可用的本地缓存
    this.checkLocalFile(src).then((localPath) => {
+      if (!isCurrentGeneration()) {
+        complete();
+        return;
+      }
      if (localPath) {
        debugLog(`命中本地缓存: ${key}`);
        setupAudio(localPath);
      } else {
-        // 下载并尝试保存
-        uni.downloadFile({
-          url: src,
-          timeout: 20000,
-          success: (res) => {
-            if (res.tempFilePath) {
-              // 尝试保存文件到本地存储（持久化）
-              uni.getFileSystemManager().saveFile({
-                tempFilePath: res.tempFilePath,
-                success: (saveRes) => {
-                  const savedPath = saveRes.savedFilePath;
-                  this.localFileCache[src] = savedPath;
-                  uni.setStorageSync("audio_local_files", this.localFileCache);
-                  debugLog(`音频已缓存到本地: ${key}`);
-                  setupAudio(savedPath);
-                },
-                fail: (err) => {
-                  debugLog(
-                    `保存音频失败(可能空间不足)，使用临时文件: ${key}`,
-                    err
-                  );
-                  setupAudio(res.tempFilePath);
-                },
-              });
-            } else {
-              this.recordLoadFailure(key);
-              this.finishPlayback(key, {
-                advanceSequence: true,
-                emitEnded: true,
-              });
-              if (callback) callback();
-            }
-          },
-          fail: () => {
-            this.recordLoadFailure(key);
-            this.finishPlayback(key, {
-              advanceSequence: true,
-              emitEnded: true,
-            });
-            if (callback) callback();
-          },
-        });
+        setupAudio(src);
+        void this.cacheRemoteFile(src, key);
+      }
+    }).catch(() => {
+      setupAudio(src);
+      void this.cacheRemoteFile(src, key);
+    });
+  }
+
+  cacheRemoteFile(url, key) {
+    if (this.localFileCache[url]) return Promise.resolve(true);
+    const currentPromise = this.cacheWritePromises.get(url);
+    if (currentPromise) return currentPromise;
+
+    let promise;
+    promise = new Promise((resolve) => {
+      if (typeof uni.downloadFile !== "function") {
+        resolve(false);
+        return;
+      }
+
+      uni.downloadFile({
+        url,
+        timeout: 20000,
+        success: (res) => {
+          if (!res.tempFilePath) {
+            resolve(false);
+            return;
+          }
+
+          let fileSystemManager;
+          try {
+            fileSystemManager = uni.getFileSystemManager();
+          } catch (_) {
+            resolve(false);
+            return;
+          }
+
+          fileSystemManager.saveFile({
+            tempFilePath: res.tempFilePath,
+            success: (saveRes) => {
+              this.localFileCache[url] = saveRes.savedFilePath;
+              uni.setStorageSync("audio_local_files", this.localFileCache);
+              debugLog(`音频已后台缓存到本地: ${key}`);
+              resolve(true);
+            },
+            fail: () => resolve(false),
+          });
+        },
+        fail: () => resolve(false),
+      });
+    }).finally(() => {
+      if (this.cacheWritePromises.get(url) === promise) {
+        this.cacheWritePromises.delete(url);
      }
    });
+
+    this.cacheWritePromises.set(url, promise);
+    return promise;
  }

  // 检查本地文件是否有效
@@ -504,11 +568,6 @@ class AudioManager {
    });
  }

-  // 新增：记录失败（首轮与次轮都会用到）
-  recordLoadFailure(key) {
-    this.failedLoadKeys.add(key);
-  }
-
  clearPlayWatchdog(key) {
    const timer = this.playWatchdogTimers.get(key);
    if (timer) {
@@ -612,19 +671,14 @@ class AudioManager {
  }

  reloadAudioKey(key) {
-    const audio = this.audioMap.get(key);
-    if (audio) {
-      try {
-        audio.destroy();
-      } catch (_) {}
-      this.audioMap.delete(key);
-    }
-    this.readyMap.set(key, false);
-    this.retryLoadAudio(key);
+    return this.retryLoadAudio(key);
  }

  // 重新加载音频
  retryLoadAudio(key) {
+    const loadingPromise = this.loadingKeyPromises.get(key);
+    if (loadingPromise) return loadingPromise;
+
    this.clearPlayWatchdog(key);
    const oldAudio = this.audioMap.get(key);
    if (oldAudio) {
@@ -632,7 +686,9 @@ class AudioManager {
        oldAudio.destroy();
      } catch (_) {}
    }
-    this.createAudio(key);
+    this.audioMap.delete(key);
+    this.readyMap.set(key, false);
+    return this.ensureAudio(key);
  }

  // 播放指定音频或音频数组（数组则按顺序连续播放）
@@ -695,6 +751,32 @@ class AudioManager {
    }
  }

+  waitForAudioAndPlay(key) {
+    if (this.pendingPlayKeys.has(key)) return;
+    this.pendingPlayKeys.add(key);
+
+    this.ensureAudio(key)
+      .then((ready) => {
+        const isSequenceCurrent =
+          this.isSequenceRunning && this.sequenceQueue[this.sequenceIndex] === key;
+        if (!isSequenceCurrent) return;
+
+        if (ready) {
+          this._playSingle(key, false);
+          return;
+        }
+
+        this.finishPlayback(key, {
+          advanceSequence: true,
+          emitEnded: true,
+          force: true,
+        });
+      })
+      .finally(() => {
+        this.pendingPlayKeys.delete(key);
+      });
+  }
+
  // 内部方法：播放单个 key
  _playSingle(key, forceStopAll = false) {
    if (this.isInterrupted) {
@@ -726,7 +808,7 @@ class AudioManager {
    }

    const audio = this.audioMap.get(key);
-    if (audio) {
+    if (audio && this.readyMap.get(key)) {
      // 播放前确保遵循当前静音状态
      try {
        if (typeof audio.volume === "number") {
@@ -768,32 +850,8 @@ class AudioManager {
      this.lastPlayAt = Date.now();
      this.startPlayWatchdog(key);
    } else {
-      debugLog(`音频 ${key} 不存在，尝试重新加载...`);
-      this.retryLoadAudio(key);
-      let loadWaitTimer = null;
-      const cleanup = () => {
-        try {
-          uni.$off("audioLoaded", handler);
-        } catch (_) {}
-        if (loadWaitTimer) {
-          clearTimeout(loadWaitTimer);
-          loadWaitTimer = null;
-        }
-      };
-      const handler = (loadedKey) => {
-        if (loadedKey === key) {
-          cleanup();
-          // 再次校验是否存在且就绪
-          const a = this.audioMap.get(key);
-          if (a && this.readyMap.get(key)) {
-            this._playSingle(key, false);
-          }
-        }
-      };
-      try {
-        uni.$on("audioLoaded", handler);
-      } catch (_) {}
-      loadWaitTimer = setTimeout(cleanup, 12000);
+      debugLog(`音频 ${key} 尚未就绪，按需加载后播放...`);
+      this.waitForAudioAndPlay(key);
    }
  }

@@ -886,9 +944,11 @@ class AudioManager {
    debugLog("本地音频缓存清理完成");
  }

-  // 手动重置并重新加载所有音频（用于卡住时恢复）
+  // 手动重置音频实例，并按之前的预热范围在后台恢复。
  reloadAll() {
-    debugLog("执行 reloadAll: 重置所有状态并重新加载");
+    debugLog("执行 reloadAll: 重置音频实例并后台恢复");
+    const shouldWarmAll = this.warmAllPromise !== null;
+    this.loadGeneration += 1;

    // 1. 停止所有播放
    this.stopAll();
@@ -903,8 +963,9 @@ class AudioManager {

    // 3. 重置状态
    this.readyMap.clear();
-    this.failedLoadKeys.clear();
    this.allowPlayMap.clear();
+    this.loadingKeyPromises.clear();
+    this.pendingPlayKeys.clear();
    this.clearAllPlayWatchdogs();
    this.currentPlayingKey = null;
    this.sequenceQueue = [];
@@ -915,13 +976,12 @@ class AudioManager {
    // 这里选择不自动全清，而是依赖 onError 里的单点清除。如果需要彻底重置，可取消注释：
    // this.clearCache();

-    // 4. 强制重置加载锁
+    // 4. 重置后台预热状态
    this.isLoading = false;
-    this.loadingPromise = null;
-    this.currentLoadingIndex = 0;
+    this.warmAllPromise = null;

-    // 5. 重新初始化 (initAudios 会自增 loadGeneration，从而终止之前的任何异步循环)
-    return this.initAudios();
+    // 5. 之前已启动过全量预热则继续全量恢复，否则只恢复按钮音效。
+    return shouldWarmAll ? this.warmAll() : this.warmButton();
  }
 }

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

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

 <template>
  <view class="footer">
-    <image class="footer-bg" src="../static/tab-bg.png" mode="widthFix" />
+    <image class="footer-bg" src="https://static.shelingxingqiu.com/shootmini/static/tab-bg.png" mode="widthFix" />
    <view
      v-for="(tab, index) in tabs"
      :key="index"
@@ -1,5 +1,5 @@
 <script setup>
-import { ref, onMounted, watch } from "vue";
+import { computed, ref, watch } from "vue";
 import useStore from "@/store";
 import { storeToRefs } from "pinia";
 const store = useStore();
@@ -26,12 +26,33 @@ const props = defineProps({
    type: Number,
    default: 45,
  },
+  sizeUnit: {
+    type: String,
+    default: "px",
+  },
+  imageMode: {
+    type: String,
+    default: "widthFix",
+  },
  borderColor: {
    type: String,
    default: "",
  },
 });
 const avatarFrame = ref("");
+const sizeValue = computed(() => `${Number(props.size)}${props.sizeUnit}`);
+const frameSizeValue = computed(() => `${Number(props.size) + 10}${props.sizeUnit}`);
+const avatarImageStyle = computed(() => ({
+  width: sizeValue.value,
+  height: sizeValue.value,
+  minHeight: sizeValue.value,
+  borderColor: props.borderColor || "#fff",
+}));
+const avatarFrameStyle = computed(() => ({
+  width: frameSizeValue.value,
+  height: frameSizeValue.value,
+}));
+
 watch(
  () => [config.value, props.rankLvl],
  () => {
@@ -51,10 +72,7 @@ watch(
      v-if="avatarFrame"
      :src="avatarFrame"
      mode="widthFix"
-      :style="{
-        width: Number(size) + 10 + 'px',
-        height: Number(size) + 10 + 'px',
-      }"
+      :style="avatarFrameStyle"
      class="avatar-frame"
    />
    <image
@@ -78,13 +96,8 @@ watch(
    <view v-if="rank > 3" class="rank-view">{{ rank }}</view>
    <image
      :src="src || '../static/user-icon.png'"
-      mode="widthFix"
-      :style="{
-        width: size + 'px',
-        height: size + 'px',
-        minHeight: size + 'px',
-        borderColor: borderColor || '#fff',
-      }"
+      :mode="imageMode"
+      :style="avatarImageStyle"
      class="avatar-image"
    />
  </view>
@@ -4,6 +4,7 @@ import { onShow } from "@dcloudio/uni-app";

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

 import useStore from "@/store";
 import { storeToRefs } from "pinia";
@@ -66,12 +67,7 @@ const onClick = debounce(async () => {
    loading.value = true;
    const result = await getBattleAPI();
    if (result && result.matchId) {
-      await uni.$checkAudio();
-      if (result.mode <= 3) {
-        await navigateOnce(`/pages/team-battle/index?battleId=${result.matchId}`);
-      } else {
-        await navigateOnce(`/pages/melee-battle?battleId=${result.matchId}`);
-      }
+      await returnToBattle(result, navigateOnce);
      return;
    }
    if (game.value.roomID) {
@@ -100,9 +96,9 @@ onBeforeUnmount(() => {
    class="back-to-game"
    @click="onClick"
  >
-    <image src="../static/back-to-game-bg.png" mode="widthFix" />
+    <image src="https://static.shelingxingqiu.com/shootmini/static/back-to-game-bg.png" mode="widthFix" />
    <block v-if="game.inBattle">
-      <image src="../static/pk-icon.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/pk-icon.png" mode="widthFix" />
      <text>返回进行中的对局</text>
    </block>
    <block v-else-if="game.roomID">
@@ -31,7 +31,7 @@ const normalRounds = computed(() => {
 <template>
  <view class="container">
    <view class="guide-row">
-      <image src="../static/shooter.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/shooter.png" mode="widthFix" />
      <view
        :style="{
          marginBottom: '10px',
@@ -42,7 +42,7 @@ const normalRounds = computed(() => {
      </view>
    </view>
    <view>
-      <image src="../static/battle-header-melee.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/battle-header-melee.png" mode="widthFix" />
      <text>蓝队({{ bluePoints }})</text>
      <text>红队({{ redPoints }})</text>
    </view>
@@ -41,7 +41,7 @@ const isMember = (player = {}) => player.vip === true || player.sVip === true;
  <view class="container" :style="{ paddingTop: showHeader ? '5px' : '0' }">
    <image
      v-if="showHeader"
-      :src="`../static/battle-header${players.length ? '-melee' : ''}.png`"
+      :src="`https://static.shelingxingqiu.com/shootmini/static/battle-header${players.length ? '-melee' : ''}.png`"
      mode="widthFix"
    />
    <view
@@ -113,6 +113,7 @@ const isMember = (player = {}) => player.vip === true || player.sVip === true;
      v-if="players.length"
      class="players-melee"
      scroll-x
+      :show-scrollbar="false"
      @touchmove="(e) => players.length > 5 && e.stopPropagation()"
      :style="{ paddingTop: showHeader ? '15px' : '0' }"
    >
@@ -151,6 +152,7 @@ const isMember = (player = {}) => player.vip === true || player.sVip === true;
 .container {
  width: 100%;
  position: relative;
+  z-index: 999;
  margin-bottom: 10px;
 }
 .container > image:first-child {
@@ -158,6 +160,7 @@ const isMember = (player = {}) => player.vip === true || player.sVip === true;
  width: 100%;
  top: -5px;
  z-index: 1;
+  pointer-events: none;
 }
 .players {
  display: flex;
@@ -188,15 +191,12 @@ const isMember = (player = {}) => player.vip === true || player.sVip === true;
 .players-melee {
  height: 80px;
  width: 100%;
-}
-.players-melee::-webkit-scrollbar {
-  width: 0;
-  height: 0;
-  color: transparent;
+  white-space: nowrap;
 }
 /* 小程序 scroll-view 不支持直接 flex，通过内层 wrapper 承载横向排列 */
 .players-melee-inner {
-  display: flex;
+  display: inline-flex;
+  min-width: 100%;
  height: 100%;
  flex-wrap: nowrap;
 }
@@ -246,7 +246,7 @@ onBeforeUnmount(() => {
    >
      <image
        class="shot-arrow"
-        src="../static/vip/svip-jian.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/vip/svip-jian.png"
        mode="heightFix"
      />
    </view>
@@ -263,7 +263,7 @@ onBeforeUnmount(() => {
      <image
        :key="`crack-${animationKey}`"
        class="shot-crack"
-        src="../static/vip/svip-lie.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/vip/svip-lie.png"
        mode="aspectFit"
        @animationend="handleCrackAnimationEnd"
      />
@@ -43,6 +43,10 @@ const props = defineProps({
    type: String,
    default: "solo", // solo 单排，team 双排
  },
+  missAsZero: {
+    type: Boolean,
+    default: false,
+  },
  stop: {
    type: Boolean,
    default: false,
@@ -78,6 +82,12 @@ const instance = getCurrentInstance();
 const ROUND_TIP_OFFSET_Y = -32;
 const EXPERIENCE_TIP_OFFSET_Y = -68;

+function getRoundText(shot) {
+  if (shot?.ringX) return "X环";
+  if (shot?.ring) return `${shot.ring}环`;
+  return props.missAsZero ? "0环" : "未上靶";
+}
+
 function buildShotEffectKey(team, shot, index) {
  return [
    team,
@@ -433,8 +443,7 @@ onBeforeUnmount(() => {
        v-if="latestOne"
        class="round-tip fade-in-out"
        :style="getRoundTipStyle(latestOne)"
-        >{{ latestOne.ringX ? "X" : latestOne.ring || "未上靶"
-        }}<text v-if="latestOne.ring">环</text>
+        >{{ getRoundText(latestOne) }}
      </view>
      <view
        v-if="
@@ -451,8 +460,7 @@ onBeforeUnmount(() => {
        v-if="bluelatestOne"
        class="round-tip fade-in-out"
        :style="getRoundTipStyle(bluelatestOne)"
-        >{{ bluelatestOne.ringX ? "X" : bluelatestOne.ring || "未上靶"
-        }}<text v-if="bluelatestOne.ring">环</text></view
+        >{{ getRoundText(bluelatestOne) }}</view
      >
      <block v-for="(bow, index) in scores" :key="index">
        <image
@@ -505,7 +513,7 @@ onBeforeUnmount(() => {
        @impact="shakeTarget"
        @complete="completeShotEffect"
      />
-      <image src="../static/bow-target.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/bow-target.png" mode="widthFix" />
    </view>
    <view class="footer">
      <PointSwitcher
@@ -1,5 +1,5 @@
 <script setup>
-import { ref, computed, onMounted, onBeforeUnmount } from "vue";
+import { ref } from "vue";
 import { onShow } from "@dcloudio/uni-app";
 import AppBackground from "@/components/AppBackground.vue";
 import Header from "@/components/Header.vue";
@@ -7,7 +7,7 @@ import ScreenHint from "@/components/ScreenHint.vue";
 import BackToGame from "@/components/BackToGame.vue";
 import {laserAimAPI, getBattleAPI, matchGameAPI} from "@/apis";
 import { capsuleHeight, debounce } from "@/util";
-import AudioManager from "@/audioManager";
+import { returnToBattle } from "@/utils/matchReturn";
 const props = defineProps({
  title: {
    type: String,
@@ -41,6 +41,10 @@ const props = defineProps({
    type: Boolean,
    default: true,
  },
+  headerClass: {
+    type: String,
+    default: "",
+  },
  titleStyle: {
    type: [String, Object, Array],
    default: () => ({}),
@@ -54,9 +58,6 @@ const isIOS = uni.getDeviceInfo().osName === "ios";
 const showHint = ref(false);
 const hintType = ref(0);
 const isLoading = ref(false);
-const audioInitProgress = ref(1);
-const audioProgress = ref(0);
-const audioTimer = ref(null);

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

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

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

@@ -117,16 +90,7 @@ const backToGame = debounce(async () => {
    isLoading.value = true;
    const result = await getBattleAPI();
    if (result && result.matchId) {
-      await checkAudioProgress();
-      if (result.mode <= 3) {
-        uni.navigateTo({
-          url: `/pages/team-battle/index?battleId=${result.matchId}`,
-        });
-      } else {
-        uni.navigateTo({
-          url: `/pages/melee-battle?battleId=${result.matchId}`,
-        });
-      }
+      await returnToBattle(result, navigateTo);
    }
  } catch (error) {
    console.error("获取当前游戏失败:", error);
@@ -156,6 +120,7 @@ const goCalibration = async () => {
    <AppBackground :type="bgType" :bgColor="bgColor" />
    <Header
      v-if="!isHome"
+      :class="headerClass"
      :title="title"
      :onBack="onBack"
      :whiteBackArrow="whiteBackArrow"
@@ -224,24 +189,6 @@ const goCalibration = async () => {
        </view>
      </view>
    </ScreenHint>
-    <view v-if="audioInitProgress < 1" class="audio-progress">
-      <image
-        src="https://static.shelingxingqiu.com/attachment/2025-11-26/deihtj15xjwcz3c1tx.png"
-        mode="widthFix"
-      />
-      <view>
-        <view :style="{ width: `${audioFinalProgress * 100}%` }">
-          <!-- <image
-            src="https://static.shelingxingqiu.com/attachment/2025-11-24/degu91a7si77sg9jqv.png"
-            mode="widthFix"
-          /> -->
-        </view>
-      </view>
-      <view>
-        <text>若加载时间过长，请</text>
-        <button hover-class="none" @click="restart">点击这里重启</button>
-      </view>
-    </view>
  </view>
 </template>

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

@@ -12,13 +12,13 @@ defineProps({
 const bubbleTypes = [
  "../static/long-bubble.png",
  "../static/long-bubble-middle.png",
-  "../static/long-bubble-tall.png",
+  "https://static.shelingxingqiu.com/shootmini/static/long-bubble-tall.png",
 ];
 </script>

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

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

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

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

 <template>
  <view class="container">
-    <image src="../static/donate.png" mode="widthFix" />
+    <image src="https://static.shelingxingqiu.com/shootmini/static/donate.png" mode="widthFix" />
    <text>感谢您对我们公益项目的支持！</text>
    <view class="amounts">
      <button
@@ -26,8 +26,8 @@ const items = ref(new Array(props.total).fill(9));
 const width = ref(92);
 const itemWidth = ref(0);
 const bgImages = [
-  "../static/complete-light1.png",
-  "../static/complete-light2.png",
+  "https://static.shelingxingqiu.com/shootmini/static/complete-light1.png",
+  "https://static.shelingxingqiu.com/shootmini/static/complete-light2.png",
 ];
 const bgIndex = ref(0);
 watch(
@@ -81,7 +81,7 @@ const openCoachComment = () => {
  <view class="container">
    <view :class="['container-header', showPanel ? 'scale-in' : 'scale-out']">
      <image :src="tipSrc" mode="widthFix" />
-      <image src="../static/finish-frame.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/finish-frame.png" mode="widthFix" />
      <text
        >完成<text class="gold-text">{{ validArrows }}</text
        >箭，获得<text class="gold-text">{{ validArrows }}</text
@@ -27,22 +27,22 @@ const getContentHeight = () => {
    <view class="scale-in" :style="{ height: getContentHeight() }">
      <image
        v-if="mode === 'normal'"
-        src="../static/screen-hint-bg.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/screen-hint-bg.png"
        mode="widthFix"
      />
      <image
        v-if="mode === 'tall'"
-        src="../static/coach-comment.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/coach-comment.png"
        mode="widthFix"
      />
      <image
        v-if="mode === 'square'"
-        src="../static/prompt-bg-square.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/prompt-bg-square.png"
        mode="widthFix"
      />
      <image
        v-if="mode === 'small'"
-        src="../static/finish-frame.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/finish-frame.png"
        mode="widthFix"
      />
      <slot />
@@ -20,7 +20,7 @@ const props = defineProps({
 <template>
  <view class="container" :style="{ display: show ? 'flex' : 'none' }">
    <view class="scale-in">
-      <image src="../static/point-book-tip-bg.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/point-book-tip-bg.png" mode="widthFix" />
      <slot />
    </view>
    <IconButton
@@ -150,13 +150,17 @@ async function onReceiveMessage(msg) {
    if (msg.details && Array.isArray(msg.details)) {
      arrow = msg.details[msg.details.length - 1];
    } else {
-      if (msg.shootData.playerId !== user.value.id) return;
+      if (!msg.shootData || String(msg.shootData.playerId) !== String(user.value.id)) return;
      if (msg.shootData) arrow = msg.shootData;
    }
    let key = [];
    key.push(arrow.ring ? `${arrow.ringX ? "X" : arrow.ring}环` : "未上靶");
-    if (arrow.angle !== null)
+    if (arrow.angle)
      key.push(`向${getDirectionText(arrow.angle)}调整`);
+    const shouldPlayTententen =
+      arrow.threeConsecutive10Rings === true ||
+      msg.shootData?.threeConsecutive10Rings === true;
+    if (!props.melee && shouldPlayTententen) key.push("tententen");
    audioManager.play(key, false);
  } else if (msg.type === MESSAGETYPESV2.HalfRest) {
    halfTime.value = true;
@@ -191,7 +195,7 @@ onBeforeUnmount(() => {
 <template>
  <view class="container" :style="{ display: show ? 'block' : 'none' }">
    <view>
-      <image src="../static/shooter.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/shooter.png" mode="widthFix" />
      <text>{{ tipContent }}</text>
      <button hover-class="none" @click="updateSound">
        <image
@@ -0,0 +1,535 @@
+<script setup>
+import { computed, getCurrentInstance, nextTick, onMounted, ref, watch } from "vue";
+
+const defaultCanvasSize = 300;
+const defaultRingCount = 10;
+
+const props = defineProps({
+  // canvas 唯一标识；不传时组件内部自动生成，避免多个靶面 canvas-id 冲突。
+  canvasId: {
+    type: String,
+    default: "",
+  },
+  // 业务坐标半径，例如 20 表示命中点坐标范围为 -20 到 20。
+  // 当前组件主要用它参与重绘判断，外层命中点定位也应使用同一半径。
+  coordinateRadius: {
+    type: Number,
+    default: 20,
+  },
+  // 是否显示靶心十字辅助线。
+  showCrosshair: {
+    type: Boolean,
+    default: false,
+  },
+  // 是否显示象限文字。
+  showQuadrantLabels: {
+    type: Boolean,
+    default: false,
+  },
+  // 是否显示环数文字。
+  showRingLabels: {
+    type: Boolean,
+    default: true,
+  },
+  // 象限文字配置，key 为 1/2/3/4。
+  quadrantLabels: {
+    type: Object,
+    default: () => ({
+      1: "1",
+      2: "2",
+      3: "3",
+      4: "4",
+    }),
+  },
+  // 高亮区域数组。
+  // quadrant: 1/2/3/4，表示第几个象限。
+  // rings: "all" 或环数数组，例如 [7, 8, 9, 10]。
+  // scope: "box" 表示整象限矩形，"sector" 表示环形扇区。
+  // style: 可覆盖高亮填充色、描边色、线宽比例。
+  highlightAreas: {
+    type: Array,
+    default: () => [],
+  },
+  // 只绘制透明高亮层，不绘制完整靶纸；用于叠加在靶纸图片上。
+  highlightOnly: {
+    type: Boolean,
+    default: false,
+  },
+  // 外部指定 canvas 绘制尺寸；用于让高亮层跟随靶图真实显示区域。
+  canvasWidth: {
+    type: Number,
+    default: 0,
+  },
+  canvasHeight: {
+    type: Number,
+    default: 0,
+  },
+  // 靶纸样式覆盖配置，例如环数、环色、环线颜色、环数字体等。
+  targetStyleConfig: {
+    type: Object,
+    default: () => ({}),
+  },
+  // 十字辅助线样式覆盖配置。
+  crosshairStyle: {
+    type: Object,
+    default: () => ({}),
+  },
+  // 象限文字样式覆盖配置。
+  quadrantLabelStyle: {
+    type: Object,
+    default: () => ({}),
+  },
+});
+
+const instance = getCurrentInstance();
+const localCanvasId = `target-canvas-${Math.random().toString(36).slice(2, 10)}`;
+const currentCanvasId = computed(() => props.canvasId || localCanvasId);
+const lastDrawKey = ref("");
+const canvasSize = ref({
+  width: defaultCanvasSize,
+  height: defaultCanvasSize,
+});
+
+// 完整靶纸默认样式，调用方可以通过 targetStyleConfig 局部覆盖。
+const defaultTargetStyleConfig = {
+  ringCount: defaultRingCount,
+  ringColors: {
+    1: "#f8f8f3",
+    2: "#f8f8f3",
+    3: "#595959",
+    4: "#595959",
+    5: "#24aee0",
+    6: "#24aee0",
+    7: "#ff1f35",
+    8: "#ff1f35",
+    9: "#f7d34a",
+    10: "#f7d34a",
+  },
+  ringLineColor: "rgba(150, 150, 150, 0.55)",
+  ringLineWidthRatio: 0.0022,
+  centerDotColor: "#ffffff",
+  centerDotRadiusRatio: 0.0048,
+  ringLabelFontRatio: 0.032,
+  ringLabelDarkColor: "#111111",
+  ringLabelLightColor: "#ffffff",
+};
+
+// 十字辅助线默认样式。
+const defaultCrosshairStyle = {
+  color: "rgba(20, 20, 20, 0.38)",
+  lineWidthRatio: 0.0025,
+};
+
+// 象限文字默认样式。
+const defaultQuadrantLabelStyle = {
+  color: "#ffffff",
+  fontSizeRatio: 0.045,
+  offsetRatio: 0.78,
+};
+
+// 高亮区域默认样式。
+const defaultHighlightStyle = {
+  color: "rgba(254, 216, 71, 0.34)",
+  strokeColor: "rgba(254, 216, 71, 0.82)",
+  lineWidthRatio: 0.003,
+};
+
+// 合并默认靶纸样式和外部传入样式，ringColors 单独深合并。
+const mergeTargetStyleConfig = () => ({
+  ...defaultTargetStyleConfig,
+  ...props.targetStyleConfig,
+  ringColors: {
+    ...defaultTargetStyleConfig.ringColors,
+    ...(props.targetStyleConfig?.ringColors || {}),
+  },
+});
+
+// 统一把外部传入值转成有效数字，非法值使用 fallback。
+const getNumber = (value, fallback = 0) => {
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) ? numberValue : fallback;
+};
+
+// 获取指定环数的填充色，兼容数字 key 和字符串 key。
+const getRingColor = (ring, config) => {
+  return config.ringColors?.[ring] || config.ringColors?.[String(ring)] || "#ffffff";
+};
+
+// 规范化高亮环数配置；"all" 表示全部环，数组或单值会过滤非法环数。
+const normalizeRings = (rings, ringCount) => {
+  if (rings === "all") {
+    return "all";
+  }
+
+  const rawRings = Array.isArray(rings) ? rings : [rings];
+  return rawRings
+    .map((ring) => Number(ring))
+    .filter((ring) => Number.isInteger(ring) && ring >= 1 && ring <= ringCount);
+};
+
+// 获取象限对应的扇形弧度范围。
+const getQuadrantAngles = (quadrant) => {
+  const angleMap = {
+    1: [Math.PI, Math.PI * 1.5],
+    2: [Math.PI * 1.5, Math.PI * 2],
+    3: [Math.PI * 0.5, Math.PI],
+    4: [0, Math.PI * 0.5],
+  };
+
+  return angleMap[Number(quadrant)] || null;
+};
+
+// 获取象限对应的矩形区域，用于整象限高亮。
+const getQuadrantBox = (quadrant, centerX, centerY, radius) => {
+  const boxMap = {
+    1: [centerX - radius, centerY - radius, radius, radius],
+    2: [centerX, centerY - radius, radius, radius],
+    3: [centerX - radius, centerY, radius, radius],
+    4: [centerX, centerY, radius, radius],
+  };
+
+  return boxMap[Number(quadrant)] || null;
+};
+
+// 绘制实心圆，靶纸环区和中心点都会用到。
+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));
+  }
+};
+
+// 绘制所有高亮区域，支持整象限矩形高亮和指定环数扇区高亮。
+const drawHighlights = (ctx, centerX, centerY, targetRadius, config) => {
+  props.highlightAreas.forEach((area = {}) => {
+    const angles = getQuadrantAngles(area.quadrant);
+
+    if (!angles) {
+      return;
+    }
+
+    const highlightStyle = {
+      ...defaultHighlightStyle,
+      ...(area.style || {}),
+    };
+    const highlightLineWidth = Math.max(1, targetRadius * highlightStyle.lineWidthRatio);
+    const rings = normalizeRings(area.rings || "all", config.ringCount);
+    const scope = area.scope || (rings === "all" ? "box" : "sector");
+
+    // 整象限默认画成矩形高亮，便于对应 1/2/3/4 号框训练提示。
+    if (rings === "all" && scope === "box") {
+      const box = getQuadrantBox(area.quadrant, centerX, centerY, targetRadius);
+      if (!box) return;
+      ctx.beginPath();
+      ctx.rect(...box);
+      ctx.setFillStyle(highlightStyle.color);
+      ctx.fill();
+      ctx.setStrokeStyle(highlightStyle.strokeColor);
+      ctx.setLineWidth(highlightLineWidth);
+      ctx.stroke();
+      return;
+    }
+
+    const targetRings = rings === "all"
+      ? Array.from({ length: config.ringCount }, (_, index) => index + 1)
+      : rings;
+
+    targetRings.forEach((ring) => {
+      const innerRadius = targetRadius * ((config.ringCount - ring) / config.ringCount);
+      const outerRadius = targetRadius * ((config.ringCount + 1 - ring) / config.ringCount);
+      drawAnnularSector(
+        ctx,
+        centerX,
+        centerY,
+        innerRadius,
+        outerRadius,
+        angles[0],
+        angles[1],
+        highlightStyle.color,
+        highlightStyle.strokeColor,
+        highlightLineWidth
+      );
+    });
+  });
+};
+
+// 绘制各环之间的分割线。
+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 drawQuadrantLabels = (ctx, centerX, centerY, targetRadius) => {
+  if (!props.showQuadrantLabels) {
+    return;
+  }
+
+  const style = {
+    ...defaultQuadrantLabelStyle,
+    ...props.quadrantLabelStyle,
+  };
+  const offset = targetRadius * style.offsetRatio;
+  const positions = {
+    1: [centerX - offset, centerY - offset],
+    2: [centerX + offset, centerY - offset],
+    3: [centerX - offset, centerY + offset],
+    4: [centerX + offset, centerY + offset],
+  };
+
+  ctx.setFontSize(Math.max(12, targetRadius * style.fontSizeRatio));
+  ctx.setTextAlign("center");
+  ctx.setTextBaseline("middle");
+  ctx.setFillStyle(style.color);
+
+  Object.entries(positions).forEach(([key, position]) => {
+    const label = props.quadrantLabels?.[key] || props.quadrantLabels?.[Number(key)];
+    if (label === undefined || label === null || label === "") return;
+    ctx.fillText(String(label), position[0], position[1]);
+  });
+};
+
+// 生成高亮区域的绘制 key，只保留真正影响画面的字段。
+const getHighlightDrawKeyAreas = () => {
+  return props.highlightAreas.map((area = {}) => ({
+    quadrant: area.quadrant,
+    rings: area.rings,
+    scope: area.scope,
+    style: area.style,
+  }));
+};
+
+// 生成本次绘制状态的唯一 key，用于避免相同内容重复 draw。
+const getDrawKey = (width, height) => {
+  return JSON.stringify({
+    width,
+    height,
+    coordinateRadius: props.coordinateRadius,
+    showCrosshair: props.showCrosshair,
+    showQuadrantLabels: props.showQuadrantLabels,
+    showRingLabels: props.showRingLabels,
+    highlightAreas: getHighlightDrawKeyAreas(),
+    targetStyleConfig: props.targetStyleConfig,
+    crosshairStyle: props.crosshairStyle,
+    quadrantLabelStyle: props.quadrantLabelStyle,
+    highlightOnly: props.highlightOnly,
+  });
+};
+
+// 主绘制入口：根据 highlightOnly 决定画完整靶纸，还是只画透明高亮层。
+const drawTarget = () => {
+  const width = Math.max(getNumber(canvasSize.value.width, defaultCanvasSize), 1);
+  const height = Math.max(getNumber(canvasSize.value.height, defaultCanvasSize), 1);
+  const drawKey = getDrawKey(width, height);
+
+  if (drawKey === lastDrawKey.value) {
+    return;
+  }
+
+  const size = Math.min(width, height);
+  const centerX = width / 2;
+  const centerY = height / 2;
+  const targetRadius = size / 2;
+  const config = mergeTargetStyleConfig();
+  const ctx = uni.createCanvasContext(currentCanvasId.value, instance?.proxy);
+
+  ctx.clearRect(0, 0, width, height);
+
+  if (!props.highlightOnly) {
+    drawTargetRings(ctx, centerX, centerY, targetRadius, config);
+  }
+
+  drawHighlights(ctx, centerX, centerY, targetRadius, config);
+
+  if (!props.highlightOnly) {
+    drawRingLines(ctx, centerX, centerY, targetRadius, config);
+    drawCircle(
+      ctx,
+      centerX,
+      centerY,
+      Math.max(1, targetRadius * config.centerDotRadiusRatio),
+      config.centerDotColor
+    );
+    drawCrosshair(ctx, centerX, centerY, targetRadius);
+    drawRingLabels(ctx, centerX, centerY, targetRadius, config);
+    drawQuadrantLabels(ctx, centerX, centerY, targetRadius);
+  }
+
+  ctx.draw();
+  lastDrawKey.value = drawKey;
+};
+
+const setCanvasSizeAndDraw = async (width, height) => {
+  canvasSize.value = {
+    width: width > 0 ? width : defaultCanvasSize,
+    height: height > 0 ? height : width || defaultCanvasSize,
+  };
+
+  await nextTick();
+  drawTarget();
+};
+
+// 读取 canvas 实际渲染尺寸后再绘制，保证小程序真机尺寸和坐标一致。
+const measureAndDraw = () => {
+  const propWidth = Math.round(getNumber(props.canvasWidth, 0));
+  const propHeight = Math.round(getNumber(props.canvasHeight, 0));
+
+  if (propWidth > 0 && propHeight > 0) {
+    setCanvasSizeAndDraw(propWidth, propHeight);
+    return;
+  }
+
+  const query = uni.createSelectorQuery().in(instance?.proxy);
+
+  query
+    .select(`#${currentCanvasId.value}`)
+    .boundingClientRect(async (rect) => {
+      const width = Math.round(getNumber(rect?.width, defaultCanvasSize));
+      const height = Math.round(getNumber(rect?.height, width || defaultCanvasSize));
+
+      await setCanvasSizeAndDraw(width, height);
+    })
+    .exec();
+};
+
+// 等待 Vue 完成 DOM 更新后重新测量和绘制。
+const scheduleDraw = async () => {
+  await nextTick();
+  measureAndDraw();
+};
+
+watch(
+  () => [
+    props.coordinateRadius,
+    props.showCrosshair,
+    props.showQuadrantLabels,
+    props.showRingLabels,
+    props.highlightAreas,
+    props.highlightOnly,
+    props.canvasWidth,
+    props.canvasHeight,
+    props.quadrantLabels,
+    props.targetStyleConfig,
+    props.crosshairStyle,
+    props.quadrantLabelStyle,
+  ],
+  scheduleDraw,
+  {
+    deep: true,
+  }
+);
+
+onMounted(() => {
+  setTimeout(measureAndDraw, 30);
+});
+</script>
+
+<template>
+  <canvas
+    :id="currentCanvasId"
+    class="target-canvas"
+    :canvas-id="currentCanvasId"
+    :width="canvasSize.width"
+    :height="canvasSize.height"
+  />
+</template>
+
+<style scoped>
+.target-canvas {
+  display: block;
+  width: 100%;
+  height: 100%;
+}
+</style>
@@ -111,7 +111,7 @@ onBeforeUnmount(() => {
      </view>
    </view>
    <view v-if="isBattle" class="ready-timer">
-      <image src="../static/test-tip.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/test-tip.png" mode="widthFix" />
      <view v-if="count >= 0">
        <text>具体正式比赛还有</text>
        <text>{{ count }}</text>
@@ -54,23 +54,23 @@ onBeforeUnmount(() => {
    <view v-if="showRank" class="up-rank">
      <image :src="user.avatar || '../static/user-icon.png'" mode="widthFix" />
      <image :src="nextRankImage" mode="widthFix" />
-      <image class="bg-effect" src="../static/shining-bg.png" mode="widthFix" />
+      <image class="bg-effect" src="https://static.shelingxingqiu.com/shootmini/static/shining-bg.png" mode="widthFix" />
      <image
        class="bg-effect"
-        src="../static/gold-shining.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/gold-shining.png"
        mode="widthFix"
      />
    </view>
    <view v-if="showGrade" class="up-grade">
      <image
        class="scale-in"
-        src="../static/user-upgrade.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/user-upgrade.png"
        mode="widthFix"
      />
-      <image class="bg-effect" src="../static/shining-bg.png" mode="widthFix" />
+      <image class="bg-effect" src="https://static.shelingxingqiu.com/shootmini/static/shining-bg.png" mode="widthFix" />
      <image
        class="bg-effect"
-        src="../static/gold-shining.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/gold-shining.png"
        mode="widthFix"
      />
    </view>
@@ -1,6 +1,7 @@
 export const MESSAGETYPES = {
  ShootSyncMeArrowID: parseInt("0x789b6b0d"), // 2023451405
  ShootSyncMePracticeID: parseInt("0xD88AE05E"), // 3632980062
+  ShootSyncBattleCreateMatchLinkID: parseInt("0xF86FF466"), // 2538869862
  WaitForAllReady: parseInt("0x615C13BE"), // 1633424318
  AllReady: parseInt("0x1CCB49FD"), // 483084797
  MeleeAllReady: parseInt("0x37132BD5"), // 924003285
@@ -53,6 +53,242 @@
    "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"
+                }
+            ]
+        },
        "setting" : {
            "urlCheck" : false,
            "minified" : true,
@@ -0,0 +1,992 @@
+import {
+  ClientMessageType,
+  ServerMessageType,
+  createAckMessage,
+  createHeartbeatAckMessage,
+  createLeaveMessage,
+  decodeServerMessage,
+  getServerMessageTypeName,
+} from "@/utils/matchProtocol";
+import { MESSAGETYPESV2 } from "@/constants";
+import { getDirectionText } from "@/util";
+import {
+  normalizeId,
+  normalizeMatchInfo,
+  normalizePlainObject,
+  pickField,
+} from "@/utils/matchAdapter";
+
+// 比赛服 websocket 独立管理器：
+// 负责连接、解码、ACK/LEAVE，并把比赛服消息适配成项目现有 socket-inbox 业务事件。
+let socket = null;
+let currentContext = null;
+let isConnecting = false;
+let manualClose = false;
+let audioAckListenerReady = false;
+let lastReadyRouteKey = "";
+let reconnectTimer = null;
+let connectTimeoutTimer = null;
+let livenessTimer = null;
+let reconnectAttempt = 0;
+let networkConnected = true;
+let lastNetworkType = "";
+
+// 后端要求非心跳消息必须等前端语音播报完成后再 ACK。
+const pendingAcks = [];
+const ACK_AUDIO_TIMEOUT_MS = 9000;
+const READY_ROUTE_FALLBACK_DELAY_MS = 300;
+const CONNECT_TIMEOUT_MS = 8000;
+const LIVENESS_TIMEOUT_MS = 30000;
+const RECONNECT_DELAYS_MS = [1000, 2000, 4000, 8000, 15000];
+const ROUND_AUDIO_NAMES = ["一", "二", "三", "四", "五"];
+const MATCH_STATUS_HALF_REST = 3;
+
+// 比赛服消息类型先映射成项目里已有的 V2 业务消息，页面仍然复用原来的 socket-inbox 流程。
+const BUSINESS_TYPE_BY_SERVER_TYPE = {
+  [ServerMessageType.SERVER_MSG_MATCH_READY]: MESSAGETYPESV2.AboutToStart,
+  [ServerMessageType.SERVER_MSG_MATCH_START]: MESSAGETYPESV2.BattleStart,
+  [ServerMessageType.SERVER_MSG_NOW_YOU]: MESSAGETYPESV2.ToSomeoneShoot,
+  [ServerMessageType.SERVER_MSG_SHOT]: MESSAGETYPESV2.ShootResult,
+  [ServerMessageType.SERVER_MSG_NEW_ROUND]: MESSAGETYPESV2.NewRound,
+  [ServerMessageType.SERVER_MSG_MATCH_END]: MESSAGETYPESV2.BattleEnd,
+  [ServerMessageType.SERVER_MSG_CHECK]: MESSAGETYPESV2.TestDistance,
+  [ServerMessageType.SERVER_MSG_NOT_ENOUGH_DISTANCE]: MESSAGETYPESV2.InvalidShot,
+  [ServerMessageType.SERVER_MSG_PRACTICE_END]: MESSAGETYPESV2.BattleEnd,
+};
+
+const MATCH_READY_SNAPSHOT_PREFIX = "match-ready-snapshot:";
+export const MATCH_WS_AUDIO_ACK_EVENT = "match-ws-audio-ack";
+export const MATCH_WS_STATE_EVENT = "match-ws-state";
+
+function normalizeShootData(shootData) {
+  if (!shootData || typeof shootData !== "object") return shootData;
+  const normalized = { ...shootData };
+  if (normalized.distance === undefined && normalized.dst !== undefined) {
+    normalized.distance = normalized.dst;
+  }
+  return normalized;
+}
+
+// 兼容普通接口通知的 camelCase 和 protobuf 解码后的 snake_case。
+function normalizePracticeInfo(practiceInfo = {}) {
+  if (!practiceInfo || typeof practiceInfo !== "object") return {};
+
+  const normalized = normalizePlainObject(practiceInfo);
+  if (practiceInfo.shoot_data || normalized.shootData) {
+    normalized.shootData = normalizeShootData(
+      normalizePlainObject(practiceInfo.shoot_data || normalized.shootData)
+    );
+  }
+  if (Array.isArray(practiceInfo.details || normalized.details)) {
+    normalized.details = (practiceInfo.details || normalized.details)
+      .map(normalizePlainObject)
+      .map(normalizeShootData);
+  }
+
+  return normalized;
+}
+
+function getCurrentMode(message = {}, normalizedInfo = {}) {
+  const mode = Number(
+    pickField(message, "mode") ??
+      normalizedInfo.mode ??
+      currentContext?.mode
+  );
+  return Number.isFinite(mode) ? mode : undefined;
+}
+
+function isMeleeMessage(message = {}, normalizedInfo = {}) {
+  const mode = getCurrentMode(message, normalizedInfo);
+  if (mode !== undefined) return mode > 3;
+  if (currentContext?.isMelee !== undefined) return currentContext.isMelee;
+  return normalizeRoute(getCurrentPageInfo()?.route) === "pages/melee-battle";
+}
+
+function isHalfRestTimeout(message = {}, matchInfo = {}) {
+  if (message.type !== ServerMessageType.SERVER_MSG_TIMEOUT) return false;
+  if (!isMeleeMessage(message, matchInfo)) return false;
+
+  const status = Number(pickField(message, "status") ?? matchInfo.status);
+  return status === MATCH_STATUS_HALF_REST || !Number.isFinite(status);
+}
+
+function getBusinessType(message, matchInfo) {
+  if (isHalfRestTimeout(message, matchInfo)) return MESSAGETYPESV2.HalfRest;
+  if (message.type === ServerMessageType.SERVER_MSG_TIMEOUT) {
+    return MESSAGETYPESV2.BattleEnd;
+  }
+  return BUSINESS_TYPE_BY_SERVER_TYPE[message.type];
+}
+
+function buildBusinessMessage(message) {
+  const matchInfo = normalizeMatchInfo(message.match_info);
+  if (
+    message.type === ServerMessageType.SERVER_MSG_MATCH_READY &&
+    (matchInfo.status === undefined ||
+      matchInfo.status === null ||
+      matchInfo.status === "")
+  ) {
+    matchInfo.status = 0;
+  }
+  const practiceInfo = normalizePracticeInfo(message.practice_info);
+  const businessType = getBusinessType(message, matchInfo);
+  if (!businessType) return null;
+
+  const mode = getCurrentMode(message, matchInfo);
+  const isMelee = isMeleeMessage(message, matchInfo);
+  const isSecondHalfStart =
+    message.type === ServerMessageType.SERVER_MSG_MATCH_START &&
+    isMelee &&
+    currentContext?.meleeHalfRest === true;
+
+  if (currentContext) {
+    if (mode !== undefined) {
+      currentContext.mode = mode;
+      currentContext.isMelee = isMelee;
+    } else if (isMelee) {
+      currentContext.isMelee = true;
+    }
+    if (businessType === MESSAGETYPESV2.HalfRest) {
+      currentContext.meleeHalfRest = true;
+    } else if (message.type === ServerMessageType.SERVER_MSG_MATCH_START) {
+      currentContext.meleeHalfRest = false;
+    }
+  }
+
+  const matchId = normalizeId(
+    pickField(message, "matchId", "match_id") ||
+      matchInfo.matchId ||
+      practiceInfo.id ||
+      currentContext?.matchId
+  );
+  const shootData = normalizeShootData(
+    matchInfo.shootData ||
+      practiceInfo.shootData ||
+      (message.shoot_data ? normalizePlainObject(message.shoot_data) : undefined)
+  );
+  const details = Array.isArray(practiceInfo.details)
+    ? practiceInfo.details
+    : matchInfo.details;
+
+  return {
+    ...matchInfo,
+    ...practiceInfo,
+    type: businessType,
+    id: matchId,
+    matchId,
+    shootData,
+    details,
+    sequence: message.sequence,
+    timestamp: message.timestamp,
+    matchWsType: message.type,
+    matchWsTypeName: getServerMessageTypeName(message.type),
+    isSecondHalfStart,
+  };
+}
+
+function getReadySnapshotKey(matchId) {
+  return `${MATCH_READY_SNAPSHOT_PREFIX}${normalizeId(matchId)}`;
+}
+
+function persistReadyTeams(message) {
+  const teams = message?.teams || {};
+  if (Number(message?.mode) > 3) return;
+
+  const bluePlayers = teams[1]?.players || teams["1"]?.players;
+  const redPlayers = teams[2]?.players || teams["2"]?.players;
+  if (Array.isArray(bluePlayers)) uni.setStorageSync("blue-team", bluePlayers);
+  if (Array.isArray(redPlayers)) uni.setStorageSync("red-team", redPlayers);
+}
+
+function persistReadySnapshot(message) {
+  const matchId = normalizeId(message?.matchId || message?.id);
+  if (!matchId) return;
+  uni.setStorageSync(getReadySnapshotKey(matchId), {
+    ...message,
+    savedAt: Date.now(),
+  });
+}
+
+function getBattlePageUrl(message) {
+  const matchId = normalizeId(message?.matchId || message?.id);
+  const mode = Number(message?.mode);
+  if (!matchId) return "";
+  if (!Number.isFinite(mode)) return "";
+  return mode <= 3
+    ? `/pages/team-battle/index?battleId=${matchId}`
+    : `/pages/melee-battle?battleId=${matchId}`;
+}
+
+function getCurrentPageInfo() {
+  if (typeof getCurrentPages !== "function") return null;
+  const pages = getCurrentPages();
+  return pages[pages.length - 1] || null;
+}
+
+function normalizeRoute(route) {
+  return String(route || "").replace(/^\//, "");
+}
+
+function getRouteFromUrl(url) {
+  return normalizeRoute(String(url || "").split("?")[0]);
+}
+
+function isCurrentBattlePage(url, matchId) {
+  const page = getCurrentPageInfo();
+  const route = normalizeRoute(page?.route);
+  const targetRoute = getRouteFromUrl(url);
+  if (!targetRoute || route !== targetRoute) return false;
+
+  const options = page?.options || page?.$page?.options || {};
+  const expectedMatchId = normalizeId(matchId);
+  if (!expectedMatchId) return true;
+
+  const routeMatchId = normalizeId(options.battleId);
+  if (routeMatchId) return routeMatchId === expectedMatchId;
+
+  return Boolean(
+    options.fromReturn &&
+      normalizeId(currentContext?.matchId) === expectedMatchId
+  );
+}
+
+function scheduleReadyRouteFallback(message) {
+  const url = getBattlePageUrl(message);
+  const matchId = normalizeId(message?.matchId || message?.id);
+  const routeKey = `${matchId}:${url}`;
+  if (!url || lastReadyRouteKey === routeKey) return;
+
+  lastReadyRouteKey = routeKey;
+  setTimeout(() => {
+    if (isCurrentBattlePage(url, matchId)) return;
+
+    const currentRoute = normalizeRoute(getCurrentPageInfo()?.route);
+    // battle-room 和 match-page 本身会消费 AboutToStart；这里不绕过页面内状态，避免好友房误触退房逻辑。
+    if (currentRoute === "pages/battle-room" || currentRoute === "pages/match-page") return;
+
+    uni.redirectTo({
+      url,
+      fail: (err) => {
+        console.log("[match-ws] ready route fallback failed", err, { url });
+      },
+    });
+  }, READY_ROUTE_FALLBACK_DELAY_MS);
+}
+
+function emitBusinessMessage(message) {
+  if (!message) return;
+  if (message.type === MESSAGETYPESV2.AboutToStart) {
+    persistReadyTeams(message);
+    persistReadySnapshot(message);
+    scheduleReadyRouteFallback(message);
+  }
+
+  uni.$emit("socket-inbox", message);
+}
+
+function resolvePlayerTeam(message, playerId) {
+  const teams = message?.teams || {};
+  const redPlayers = teams[2]?.players || teams["2"]?.players || [];
+  return redPlayers.some((item) => String(item.id) === String(playerId))
+    ? "red"
+    : "blue";
+}
+
+function getNowYouAudioKeys(message) {
+  const current = message?.current || {};
+  const keys = [];
+
+  if (current.goldRound) {
+    keys.push("决金箭轮");
+  } else if (current.round) {
+    const roundIndex = Math.max(0, Number(current.round) - 1);
+    const roundName = ROUND_AUDIO_NAMES[roundIndex] || current.round;
+    keys.push(`第${roundName}轮`);
+  }
+
+  if (String(current.playerId) === String(currentContext?.userId)) {
+    keys.push("轮到你了");
+    return keys;
+  }
+
+  const team = resolvePlayerTeam(message, current.playerId);
+  keys.push(team === "red" ? "请红方射箭" : "请蓝方射箭");
+  return keys;
+}
+
+function getShootResultAudioKeys(shootData) {
+  if (!shootData) return [];
+  const keys = [
+    shootData.ring ? `${shootData.ringX ? "X" : shootData.ring}环` : "未上靶",
+  ];
+  if (shootData.angle !== null && shootData.angle !== undefined) {
+    keys.push(`向${getDirectionText(shootData.angle)}调整`);
+  }
+  if (shootData.threeConsecutive10Rings === true) {
+    keys.push("tententen");
+  }
+  return keys;
+}
+
+function getTestDistanceAudioKeys(shootData) {
+  const distance = Number(shootData?.distance ?? shootData?.dst);
+  if (Number.isNaN(distance)) return [];
+  return [distance / 100 >= 5 ? "\u8ddd\u79bb\u5408\u683c" : "\u8ddd\u79bb\u4e0d\u8db3"];
+}
+
+function getAckAudioKeys(message, businessMessage) {
+  switch (message.type) {
+    case ServerMessageType.SERVER_MSG_MATCH_START:
+      return [businessMessage?.isSecondHalfStart ? "下半场开始" : "比赛开始"];
+    case ServerMessageType.SERVER_MSG_NOW_YOU:
+      if (isMeleeMessage(message, businessMessage)) return [];
+      return getNowYouAudioKeys(businessMessage);
+    case ServerMessageType.SERVER_MSG_SHOT:
+      if (
+        isMeleeMessage(message, businessMessage) &&
+        String(businessMessage?.shootData?.playerId) !== String(currentContext?.userId)
+      ) {
+        return [];
+      }
+      return getShootResultAudioKeys(businessMessage?.shootData);
+    case ServerMessageType.SERVER_MSG_MATCH_END:
+      return ["比赛结束"];
+    case ServerMessageType.SERVER_MSG_TIMEOUT:
+      if (businessMessage?.type === MESSAGETYPESV2.HalfRest) return ["中场休息"];
+      return ["比赛结束"];
+    case ServerMessageType.SERVER_MSG_PRACTICE_END:
+      return ["比赛结束"];
+    case ServerMessageType.SERVER_MSG_CHECK:
+      return getTestDistanceAudioKeys(businessMessage?.shootData);
+    case ServerMessageType.SERVER_MSG_NOT_ENOUGH_DISTANCE:
+      return ["射击无效"];
+    default:
+      return [];
+  }
+}
+
+function shouldCloseAfterAck(message, businessMessage) {
+  if (
+    message.type === ServerMessageType.SERVER_MSG_TIMEOUT &&
+    businessMessage?.type === MESSAGETYPESV2.HalfRest
+  ) {
+    return false;
+  }
+
+  return (
+    message.type === ServerMessageType.SERVER_MSG_MATCH_END ||
+    message.type === ServerMessageType.SERVER_MSG_TIMEOUT ||
+    message.type === ServerMessageType.SERVER_MSG_PRACTICE_END
+  );
+}
+
+// 追加 token 查询参数；如果后端地址已经带 token，则保持原样。
+function appendQuery(url, key, value) {
+  if (!value || new RegExp(`[?&]${key}=`).test(url)) return url;
+  return `${url}${url.includes("?") ? "&" : "?"}${key}=${encodeURIComponent(
+    value
+  )}`;
+}
+
+// 后端可能下发完整 ws 地址，也可能只给 host:port，这里统一转成可连接地址。
+function normalizeServerUrl(serverAddr, token) {
+  if (!serverAddr || typeof serverAddr !== "string") return "";
+
+  let url = serverAddr.trim();
+  if (!url) return "";
+
+  if (!/^wss?:\/\//i.test(url)) {
+    const [address, query = ""] = url.split("?");
+    const hasPath = address.includes("/");
+    const host = hasPath
+      ? address
+      : `${address}${address.includes(":") ? "" : ":8011"}/ws`;
+    url = `ws://${host}${query ? `?${query}` : ""}`;
+  }
+
+  return appendQuery(url, "token", token);
+}
+
+function getServerEndpoint(url) {
+  return String(url || "").split("?")[0];
+}
+
+function getUrlToken(url) {
+  const match = String(url || "").match(/[?&]token=([^&#]+)/i);
+  if (!match?.[1]) return "";
+  try {
+    return decodeURIComponent(match[1]);
+  } catch (_) {
+    return match[1];
+  }
+}
+
+function emitMatchSocketState(state, extra = {}) {
+  uni.$emit(MATCH_WS_STATE_EVENT, {
+    state,
+    matchId: currentContext?.matchId || "",
+    ...extra,
+  });
+}
+
+function clearReconnectTimer() {
+  if (!reconnectTimer) return;
+  clearTimeout(reconnectTimer);
+  reconnectTimer = null;
+}
+
+function clearConnectTimeout() {
+  if (!connectTimeoutTimer) return;
+  clearTimeout(connectTimeoutTimer);
+  connectTimeoutTimer = null;
+}
+
+function clearLivenessTimer() {
+  if (!livenessTimer) return;
+  clearTimeout(livenessTimer);
+  livenessTimer = null;
+}
+
+function clearSocketHealthTimers() {
+  clearConnectTimeout();
+  clearLivenessTimer();
+}
+
+function closeSocketTask(socketTask, reason) {
+  if (!socketTask) return;
+  try {
+    socketTask.close({ reason });
+  } catch (err) {
+    console.log("[match-ws] close socket task failed", reason, err);
+  }
+}
+
+function detachCurrentSocket(reason) {
+  const currentSocket = socket;
+  socket = null;
+  isConnecting = false;
+  clearSocketHealthTimers();
+  closeSocketTask(currentSocket, reason);
+}
+
+function scheduleReconnect(reason, { immediate = false } = {}) {
+  if (
+    manualClose ||
+    !currentContext ||
+    !networkConnected ||
+    reconnectTimer ||
+    socket ||
+    isConnecting
+  ) {
+    return;
+  }
+
+  const delay = immediate
+    ? 0
+    : RECONNECT_DELAYS_MS[
+        Math.min(reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)
+      ];
+  const attempt = reconnectAttempt + 1;
+  reconnectAttempt = attempt;
+  emitMatchSocketState("reconnecting", { reason, delay, attempt });
+
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = null;
+    if (manualClose || !currentContext || !networkConnected) return;
+    connectMatchWebSocket({
+      ...currentContext,
+      force: true,
+      reconnecting: true,
+      reconnectReason: reason,
+    });
+  }, delay);
+}
+
+function handleUnexpectedDisconnect(
+  socketTask,
+  reason,
+  detail,
+  { closeTask = true } = {}
+) {
+  if (socket !== socketTask) return;
+
+  socket = null;
+  isConnecting = false;
+  clearSocketHealthTimers();
+  if (closeTask) closeSocketTask(socketTask, reason);
+
+  console.log("[match-ws] unexpected disconnect", {
+    reason,
+    detail,
+    context: currentContext,
+  });
+  emitMatchSocketState(networkConnected ? "disconnected" : "offline", {
+    reason,
+  });
+  scheduleReconnect(reason);
+}
+
+function startConnectTimeout(socketTask) {
+  clearConnectTimeout();
+  connectTimeoutTimer = setTimeout(() => {
+    handleUnexpectedDisconnect(socketTask, "connect-timeout");
+  }, CONNECT_TIMEOUT_MS);
+}
+
+function resetLivenessTimer(socketTask) {
+  clearLivenessTimer();
+  livenessTimer = setTimeout(() => {
+    handleUnexpectedDisconnect(socketTask, "heartbeat-timeout");
+  }, LIVENESS_TIMEOUT_MS);
+}
+
+export function forceReconnectMatchWebSocket(reason = "force-reconnect") {
+  if (manualClose || !currentContext) return false;
+
+  clearReconnectTimer();
+  detachCurrentSocket(reason);
+  if (!networkConnected) {
+    emitMatchSocketState("offline", { reason });
+    return false;
+  }
+
+  reconnectAttempt = 0;
+  scheduleReconnect(reason, { immediate: true });
+  return true;
+}
+
+export function handleMatchNetworkStatusChange(status = {}) {
+  const previousConnected = networkConnected;
+  const networkType = String(status.networkType || "");
+  const nextConnected =
+    status.isConnected !== false && networkType.toLowerCase() !== "none";
+  const networkTypeChanged =
+    !!lastNetworkType && !!networkType && lastNetworkType !== networkType;
+
+  networkConnected = nextConnected;
+  if (networkType) lastNetworkType = networkType;
+  if (manualClose || !currentContext) return;
+
+  if (!nextConnected) {
+    clearReconnectTimer();
+    detachCurrentSocket("network-offline");
+    emitMatchSocketState("offline", { reason: "network-offline" });
+    return;
+  }
+
+  if (!previousConnected || networkTypeChanged) {
+    forceReconnectMatchWebSocket(
+      networkTypeChanged ? "network-type-changed" : "network-recovered"
+    );
+  }
+}
+
+// 统一发送二进制 protobuf 消息，并在日志里保留发送类型。
+function sendBuffer(buffer, label, clientMessage) {
+  if (!socket || !buffer) return;
+
+  const currentSocket = socket;
+  currentSocket.send({
+    data: buffer,
+    success: () => {
+      console.log("发送比赛服 WebSocket 消息", label, clientMessage);
+    },
+    fail: (err) => {
+      if (socket !== currentSocket) return;
+      console.log("比赛服 WebSocket 消息发送失败", label, clientMessage, err);
+      handleUnexpectedDisconnect(currentSocket, "send-failed", err);
+    },
+  });
+}
+
+function sendHeartbeatAck() {
+  // 心跳 ACK 不进入 pendingAcks，收到后立即回复。
+  const clientMessage = {
+    type: ClientMessageType.CLIENT_MSG_HEARTBEAT_ACK,
+  };
+  sendBuffer(
+    createHeartbeatAckMessage(),
+    "CLIENT_MSG_HEARTBEAT_ACK",
+    clientMessage
+  );
+}
+
+function sendAck({ matchId, sequence }) {
+  // sequence 由后端处理，前端只原样带回，不做重排和断线补发。
+  if (sequence === undefined || sequence === null || sequence === "") return;
+  const clientMessage = {
+    type: ClientMessageType.CLIENT_MSG_ACK,
+    match_id: matchId,
+    sequence,
+  };
+  sendBuffer(
+    createAckMessage({ matchId, sequence }),
+    "CLIENT_MSG_ACK",
+    clientMessage
+  );
+}
+
+function completeAckTask(task) {
+  if (task?.timer) clearTimeout(task.timer);
+  sendAck(task);
+  if (task.leaveAfterAck) {
+    setTimeout(() => {
+      closeMatchWebSocket({ reason: "match-end" });
+    }, 0);
+  }
+}
+
+function isSameAckTask(task, payload = {}) {
+  if (String(task?.sequence) !== String(payload.sequence)) return false;
+  if (!payload.matchId) return true;
+  return String(task?.matchId) === String(payload.matchId);
+}
+
+function completePendingAckByMessage(payload = {}) {
+  if (payload.sequence === undefined || payload.sequence === null || payload.sequence === "") {
+    return;
+  }
+
+  const index = pendingAcks.findIndex((task) => isSameAckTask(task, payload));
+  if (index === -1) return;
+
+  const [task] = pendingAcks.splice(index, 1);
+  console.log("[match-ws] ack after page audio", task.sequence, payload);
+  completeAckTask(task);
+}
+
+function flushPendingAcks() {
+  // 每次语音播报完成，只确认队首那条等待相同语音 key 的服务端消息。
+  if (!pendingAcks.length) return;
+  const endedKey = arguments[0];
+  const task = pendingAcks[0];
+  if (task.expectedAudioKey && endedKey && task.expectedAudioKey !== endedKey) {
+    return;
+  }
+  completeAckTask(pendingAcks.shift());
+}
+
+function ensureAudioAckListener() {
+  // 复用现有全局 audioEnded 事件，确保 ACK 时机落在播报结束之后。
+  if (audioAckListenerReady) return;
+  uni.$on("audioEnded", flushPendingAcks);
+  uni.$on(MATCH_WS_AUDIO_ACK_EVENT, completePendingAckByMessage);
+  audioAckListenerReady = true;
+}
+
+function removeAudioAckListener() {
+  if (!audioAckListenerReady) return;
+  uni.$off("audioEnded", flushPendingAcks);
+  uni.$off(MATCH_WS_AUDIO_ACK_EVENT, completePendingAckByMessage);
+  audioAckListenerReady = false;
+}
+
+function queueAckAfterAudio(message, businessMessage) {
+  // 除心跳外，只要服务端带了 sequence，都需要走 ACK；没有语音的消息立即 ACK。
+  if (
+    message.sequence === undefined ||
+    message.sequence === null ||
+    message.sequence === ""
+  ) {
+    return;
+  }
+  const task = {
+    matchId: normalizeId(
+      pickField(message, "matchId", "match_id") || currentContext?.matchId
+    ),
+    sequence: message.sequence,
+    leaveAfterAck: shouldCloseAfterAck(message, businessMessage),
+  };
+
+  const audioKeys = getAckAudioKeys(message, businessMessage).filter(Boolean);
+  if (!audioKeys.length) {
+    console.log(
+      "[match-ws] ack immediately without audio",
+      getServerMessageTypeName(message.type),
+      message.sequence
+    );
+    completeAckTask(task);
+    return;
+  }
+
+  task.expectedAudioKey = audioKeys[audioKeys.length - 1];
+  task.timer = setTimeout(() => {
+    const index = pendingAcks.indexOf(task);
+    if (index === -1) return;
+    pendingAcks.splice(index, 1);
+    console.log(
+      "[match-ws] ack audio wait timeout",
+      getServerMessageTypeName(message.type),
+      message.sequence,
+      task.expectedAudioKey
+    );
+    completeAckTask(task);
+  }, ACK_AUDIO_TIMEOUT_MS);
+  pendingAcks.push(task);
+  console.log(
+    "[match-ws] ack queued until audioEnded",
+    getServerMessageTypeName(message.type),
+    message.sequence,
+    task.expectedAudioKey
+  );
+}
+
+function handleMessage(data) {
+  // 比赛服下发 raw protobuf frame，先解码，再根据消息类型决定是否 ACK。
+  let message;
+  try {
+    message = decodeServerMessage(data);
+  } catch (err) {
+    console.log("[match-ws] decode failed", err, data);
+    return;
+  }
+
+  const decodedMatchId = normalizeId(pickField(message, "matchId", "match_id"));
+  if (decodedMatchId && currentContext) {
+    currentContext.matchId = decodedMatchId;
+  }
+
+  if (message.type === ServerMessageType.SERVER_MSG_HEARTBEAT) {
+    sendHeartbeatAck();
+    return;
+  }
+
+  const typeName = getServerMessageTypeName(message.type);
+  console.log("收到比赛服 WebSocket 消息", typeName, message);
+
+  const businessMessage = buildBusinessMessage(message);
+  if (businessMessage?.matchId && currentContext) {
+    currentContext.matchId = businessMessage.matchId;
+  }
+  queueAckAfterAudio(message, businessMessage);
+  emitBusinessMessage(businessMessage);
+}
+
+function sendLeave() {
+  // 主动关闭、比赛结束、页面离开时发 CLIENT_MSG_LEAVE。
+  if (!socket || !currentContext?.matchId) return;
+  const clientMessage = {
+    type: ClientMessageType.CLIENT_MSG_LEAVE,
+    match_id: currentContext.matchId,
+    user_id: currentContext.userId,
+  };
+  sendBuffer(
+    createLeaveMessage({
+      matchId: clientMessage.match_id,
+      userId: clientMessage.user_id,
+    }),
+    "CLIENT_MSG_LEAVE",
+    clientMessage
+  );
+}
+
+export function connectMatchWebSocket(options = {}) {
+  // 入口参数来自原 websocket 的比赛服地址通知，不影响原有 websocket 连接。
+  const {
+    serverAddr,
+    matchId,
+    userId,
+    token,
+    mode,
+    force = false,
+    reconnecting = false,
+    reconnectReason = "",
+  } = options;
+  const normalizedMatchId = normalizeId(matchId);
+  const normalizedUserId = normalizeId(userId);
+  const normalizedMode = Number(mode);
+  const incomingUrl = normalizeServerUrl(serverAddr, token);
+  const currentUrlToken = getUrlToken(currentContext?.url);
+  const shouldKeepAuthenticatedUrl = !!(
+    currentContext &&
+    currentContext.matchId === normalizedMatchId &&
+    getServerEndpoint(currentContext.url) === getServerEndpoint(incomingUrl) &&
+    currentUrlToken &&
+    !getUrlToken(incomingUrl)
+  );
+  const url = shouldKeepAuthenticatedUrl ? currentContext.url : incomingUrl;
+  const resolvedServerAddr = shouldKeepAuthenticatedUrl
+    ? currentContext.serverAddr
+    : serverAddr;
+  const resolvedToken = shouldKeepAuthenticatedUrl
+    ? currentContext.token || currentUrlToken
+    : token;
+
+  if (shouldKeepAuthenticatedUrl) {
+    console.log("[match-ws] keep authenticated url for same match", {
+      matchId: normalizedMatchId,
+      endpoint: getServerEndpoint(url),
+    });
+  }
+
+  if (!url || !normalizedMatchId) {
+    console.log("[match-ws] missing serverAddr or matchId", options);
+    return;
+  }
+
+  const isSameContext =
+    currentContext?.url === url &&
+    currentContext?.matchId === normalizedMatchId;
+  if (!force && socket && isSameContext) {
+    // 同一场比赛同一地址重复通知时不重复建连。
+    console.log("[match-ws] already connected or connecting", {
+      matchId: normalizedMatchId,
+      url,
+    });
+    return;
+  }
+
+  if (force && isSameContext) {
+    // 网络切换或假死重连时只销毁旧链路，保留比赛上下文且不发送 LEAVE。
+    detachCurrentSocket(reconnectReason || "force-reconnect");
+  } else if (!isSameContext) {
+    // 切换比赛服地址时先关闭旧连接，不发送 LEAVE，避免误通知旧比赛离场。
+    closeMatchWebSocket({ sendLeave: false, reason: "switch" });
+  }
+
+  clearReconnectTimer();
+  manualClose = false;
+  isConnecting = true;
+  if (!isSameContext) reconnectAttempt = 0;
+  const connectedOnce = isSameContext && currentContext?.connectedOnce === true;
+  currentContext = {
+    serverAddr: resolvedServerAddr,
+    matchId: normalizedMatchId,
+    userId: normalizedUserId,
+    token: resolvedToken,
+    url,
+    mode: Number.isFinite(normalizedMode) ? normalizedMode : undefined,
+    isMelee:
+      Number.isFinite(normalizedMode) ? normalizedMode > 3 : undefined,
+    meleeHalfRest: isSameContext
+      ? currentContext?.meleeHalfRest === true
+      : false,
+    connectedOnce,
+  };
+  ensureAudioAckListener();
+  emitMatchSocketState(reconnecting ? "reconnecting" : "connecting", {
+    reason: reconnectReason,
+    attempt: reconnectAttempt,
+  });
+
+  const socketTask = uni.connectSocket({
+    url,
+    success: () => {
+      console.log("[match-ws] connect requested", {
+        matchId: normalizedMatchId,
+        url,
+      });
+    },
+    fail: (err) => {
+      if (socket !== socketTask) return;
+      socket = null;
+      isConnecting = false;
+      console.log("[match-ws] connect failed", err);
+      clearSocketHealthTimers();
+      emitMatchSocketState(networkConnected ? "disconnected" : "offline", {
+        reason: "connect-failed",
+      });
+      scheduleReconnect("connect-failed");
+    },
+  });
+
+  socket = socketTask;
+  startConnectTimeout(socketTask);
+
+  socketTask.onOpen(() => {
+    if (socket !== socketTask) return;
+    clearConnectTimeout();
+    isConnecting = false;
+    const wasReconnected =
+      currentContext?.connectedOnce === true || reconnecting || reconnectAttempt > 0;
+    if (currentContext) currentContext.connectedOnce = true;
+    reconnectAttempt = 0;
+    resetLivenessTimer(socketTask);
+    console.log("[match-ws] connected", {
+      matchId: normalizedMatchId,
+      url,
+      reconnected: wasReconnected,
+    });
+    emitMatchSocketState("open", {
+      reason: reconnectReason,
+      reconnected: wasReconnected,
+    });
+  });
+
+  socketTask.onMessage((res) => {
+    if (socket !== socketTask) return;
+    resetLivenessTimer(socketTask);
+    handleMessage(res.data);
+  });
+
+  socketTask.onError((err) => {
+    if (socket !== socketTask) return;
+    console.log("[match-ws] socket error", err);
+    handleUnexpectedDisconnect(socketTask, "socket-error", err);
+  });
+
+  socketTask.onClose((result) => {
+    if (socket !== socketTask) return;
+    console.log("[match-ws] closed", {
+      manualClose,
+      result,
+      context: currentContext,
+    });
+    if (manualClose) return;
+    handleUnexpectedDisconnect(socketTask, "socket-close", result, {
+      closeTask: false,
+    });
+  });
+}
+
+export function connectMatchWebSocketFromNotice(notice, fallbackUserId) {
+  // 原 websocket 下发的比赛服通知统一从这里转成连接参数。
+  if (!notice) return;
+  connectMatchWebSocket({
+    serverAddr: pickField(notice, "serverAddr", "server_addr"),
+    matchId: pickField(notice, "matchId", "match_id"),
+    userId: pickField(notice, "userId", "user_id") || fallbackUserId,
+    mode: pickField(notice, "mode"),
+    token: notice.token || notice.wsToken || notice.ws_token,
+  });
+}
+
+export function closeMatchWebSocket(options = {}) {
+  // 默认关闭时会发送 LEAVE；内部切换连接可通过 sendLeave:false 跳过。
+  const { sendLeave: shouldSendLeave = true, reason = "manual" } = options;
+
+  manualClose = true;
+  clearReconnectTimer();
+  clearSocketHealthTimers();
+  reconnectAttempt = 0;
+  pendingAcks.forEach((task) => {
+    if (task?.timer) clearTimeout(task.timer);
+  });
+  pendingAcks.length = 0;
+
+  if (socket) {
+    const currentSocket = socket;
+    if (shouldSendLeave) sendLeave();
+    socket = null;
+    try {
+      currentSocket.close({ reason });
+    } catch (err) {
+      console.log("[match-ws] close failed", err);
+    }
+  }
+
+  isConnecting = false;
+  removeAudioAckListener();
+  console.log("[match-ws] close requested", { reason, currentContext });
+  currentContext = null;
+}
+
+export default {
+  ClientMessageType,
+  ServerMessageType,
+  connectMatchWebSocket,
+  connectMatchWebSocketFromNotice,
+  closeMatchWebSocket,
+  forceReconnectMatchWebSocket,
+  handleMatchNetworkStatusChange,
+};
@@ -0,0 +1,104 @@
+// 首页一周打卡展示数据，直接对应顶部 7 个日期卡片。
+export const trainingHomeWeekSchedule = [
+  {
+    key: "mon",
+    label: "周一",
+    status: "done",
+    icon: "../../static/training-home/done.png",
+  },
+  {
+    key: "tue",
+    label: "周二",
+    status: "done",
+    icon: "../../static/training-home/done.png",
+  },
+  {
+    key: "wed",
+    label: "周三",
+    status: "missed",
+    icon: "../../static/training-home/missed.png",
+  },
+  {
+    key: "thu",
+    label: "周四",
+    status: "missed",
+    icon: "../../static/training-home/missed.png",
+  },
+  {
+    key: "fri",
+    label: "周五",
+    status: "done",
+    icon: "../../static/training-home/done.png",
+  },
+  {
+    key: "sat",
+    label: "周六",
+    status: "done",
+    icon: "../../static/training-home/done.png",
+  },
+  {
+    key: "sun",
+    label: "周日",
+    status: "missed",
+    icon: "../../static/training-home/missed.png",
+  },
+];
+
+// 首页统计卡数据，按设计稿从左到右展示。
+export const trainingHomeStats = [
+  { key: "days", value: "12", unit: "天", label: "共训练" },
+  { key: "shots", value: "112", unit: "支", label: "累计射箭" },
+  { key: "hitRate", value: "30", unit: "%", label: "命中率" },
+  { key: "endurance", value: "6", unit: "支/分钟", label: "耐力射击" },
+  { key: "calories", value: "31W", unit: "卡路里", label: "共消耗" },
+];
+
+// 雷达图区文案与数值配置。
+export const trainingHomeRadar = {
+  labels: ["基础", "精准", "力量", "节奏", "耐力"],
+  values: [5.5, 6.3, 10, 4.5, 6],
+  maxValue: 10,
+  surpassValue: '80%'
+};
+
+// 首页主推荐训练卡数据。
+export const trainingHomeFeatured = {
+  title: "基础训练",
+  progressText: "当前进度 LV7 >",
+};
+
+// 首页四个训练入口卡片数据。
+export const trainingHomeModes = [
+  {
+    key: "endurance",
+    title: "耐力训练",
+    progressText: "当前进度 LV5 >",
+    icon: "../../static/training-home/img_3.png",
+    recommended: true,
+    disabled: false,
+  },
+  {
+    key: "precision",
+    title: "精准训练",
+    progressText: "当前进度 LV3 >",
+    icon: "../../static/training-home/img_4.png",
+    recommended: false,
+    disabled: false,
+  },
+  {
+    key: "rhythm",
+    title: "节奏训练",
+    progressText: "当前进度 LV6 >",
+    icon: "../../static/training-home/img_5.png",
+    recommended: false,
+    disabled: false,
+  },
+  {
+    key: "power",
+    title: "力量训练",
+    progressText: "Coming!  LV10",
+    icon: "../../static/training-home/img_6.png",
+    recommended: false,
+    disabled: true,
+  },
+];
@@ -0,0 +1,113 @@
+// 难度页当前用于保存“开始训练前上下文”的本地存储 key。
+export const trainingDifficultyStorageKey = "training-selection";
+
+// 当前是页面联调用的模拟数据：
+// 1. 总难度 20 级
+// 2. 已解锁到 Lv3
+// 3. 前三关展示不同完成进度
+const totalDifficultyLevel = 20;
+const mockedUnlockedDifficultyId = "lv3";
+const mockedDifficultyProgressMap = {
+  lv1: 100,
+  lv2: 90,
+  lv3: 70,
+};
+
+const modeList = [
+  {
+    key: "endurance",
+    title: "耐力训练",
+  },
+  {
+    key: "precision",
+    title: "精准训练",
+  },
+  {
+    key: "rhythm",
+    title: "节奏训练",
+  },
+  {
+    key: "basic",
+    title: "基础训练",
+  },
+  {
+    key: "power",
+    title: "力量训练",
+  },
+  {
+    key: "focus",
+    title: "专注训练",
+  },
+];
+
+const createDifficultyId = (level) => `lv${level}`;
+
+const createDifficultyLabel = (level) => `Lv${level}`;
+
+// 根据等级生成模拟文案，方便一次性扩展到更多关卡。
+const createDifficultySummary = (level) => {
+  return [
+    `箭靶划分为${Math.min(1 + Math.floor((level - 1) / 5), 4)}个区域`,
+    `需${4 + level}次命中目标`,
+    `${100 + Math.floor((level - 1) / 2) * 10}秒内完成所有射击`,
+    "需使用20CM全环靶",
+  ];
+};
+
+// 难度页的节点位置已经在页面内统一计算，
+// 这里保留最核心的 id / label 即可，不再维护无效的 left / top / style 字段。
+const createDifficultyNode = (level) => {
+  return {
+    id: createDifficultyId(level),
+    label: createDifficultyLabel(level),
+  };
+};
+
+const createDifficultyDetail = (level) => {
+  const id = createDifficultyId(level);
+  const label = createDifficultyLabel(level);
+
+  return {
+    id,
+    label,
+    title: `${label}难度`,
+    summary: createDifficultySummary(level),
+    startText: "开始",
+    targetPaperType: "20CM全环靶",
+  };
+};
+
+// 所有训练模式当前共用同一套难度定义。
+const sharedDifficultyNodes = Array.from(
+  { length: totalDifficultyLevel },
+  (_, index) => createDifficultyNode(index + 1)
+);
+
+const sharedDifficultyDetails = Object.fromEntries(
+  Array.from({ length: totalDifficultyLevel }, (_, index) => {
+    const detail = createDifficultyDetail(index + 1);
+    return [detail.id, detail];
+  })
+);
+
+const createModeConfig = ({ key, title, reward = null }) => {
+  return {
+    key,
+    title,
+    nodes: sharedDifficultyNodes,
+    details: sharedDifficultyDetails,
+    activeDifficultyId: mockedUnlockedDifficultyId,
+    progressMap: mockedDifficultyProgressMap,
+    reward,
+  };
+};
+
+// 难度页数据源入口：
+// 页面通过 getTrainingDifficultyModeConfig(modeKey) 获取当前模式完整配置。
+export const trainingDifficultyModeMap = Object.fromEntries(
+  modeList.map((mode) => [mode.key, createModeConfig(mode)])
+);
+
+export const getTrainingDifficultyModeConfig = (modeKey) => {
+  return trainingDifficultyModeMap[modeKey] || trainingDifficultyModeMap.precision;
+};
@@ -30,9 +30,6 @@
        "navigationBarTitleText": ""
      }
    },
-    {
-      "path": "pages/team-battle/index"
-    },
    {
      "path": "pages/melee-battle"
    },
@@ -69,24 +66,9 @@
    {
      "path": "pages/user"
    },
-    {
-      "path": "pages/member/orders"
-    },
-    {
-      "path": "pages/member/order-detail"
-    },
-    {
-      "path": "pages/member/be-vip"
-    },
-    {
-      "path": "pages/member/vip-intro"
-    },
-    {
-      "path": "pages/member/agreement"
-    },
-    {
-      "path": "pages/grade-intro"
-    },
+    {
+      "path": "pages/grade-intro"
+    },
    {
      "path": "pages/rank-intro"
    },
@@ -117,15 +99,21 @@
    {
      "path": "pages/match-detail"
    },
-    {
-      "path": "pages/team-battle/team-bow-data"
-    },
    {
      "path": "pages/melee-bow-data"
    },
    {
      "path": "pages/mine-bow-data"
    },
+    {
+      "path": "pages/training/difficulty"
+    },
+    {
+      "path": "pages/training/index"
+    },
+    {
+      "path": "pages/training/practise-one"
+    },
    {
      "path": "pages/ota-wifi",
      "style": {
@@ -150,5 +138,37 @@
      "^uni-(.*)": "@dcloudio/uni-ui/lib/uni-$1/uni-$1.vue"
    }
  },
-  "subPackages": []
+  "subPackages": [
+    {
+      "root": "pages/member",
+      "pages": [
+        {
+          "path": "orders"
+        },
+        {
+          "path": "order-detail"
+        },
+        {
+          "path": "be-vip"
+        },
+        {
+          "path": "vip-intro"
+        },
+        {
+          "path": "agreement"
+        }
+      ]
+    },
+    {
+      "root": "pages/team-battle",
+      "pages": [
+        {
+          "path": "index"
+        },
+        {
+          "path": "team-bow-data"
+        }
+      ]
+    }
+  ]
 }
@@ -82,7 +82,7 @@ const checkBowData = () => {
  <view class="container">
    <block v-if="data.mode <= 3">
      <view class="header-team" :style="{ marginTop: '25%' }">
-        <image src="../static/battle-result.png" mode="widthFix" />
+        <image src="https://static.shelingxingqiu.com/shootmini/static/battle-result.png" mode="widthFix" />
        <view class="header-solo" v-if="data.mode === 1">
          <text
            :style="{
@@ -107,7 +107,7 @@ const checkBowData = () => {
      </view>
      <view class="header-mvp" v-if="data.mode === 2 || data.mode === 3">
        <image
-          :src="`../static/${data.winTeam === 1 ? 'blue' : 'red'}-team-win.png`"
+          :src="`https://static.shelingxingqiu.com/shootmini/static/${data.winTeam === 1 ? 'blue' : 'red'}-team-win.png`"
          mode="widthFix"
        />
        <view
@@ -117,8 +117,8 @@ const checkBowData = () => {
            }deg)`,
          }"
        >
-          <view v-if="data.mvp && data.mvp.totalRings">
-            <image src="../static/title-mvp.png" mode="widthFix" />
+          <view v-if="data.mvp && data.mvp.player_match_result.total_ring">
+            <image src="https://static.shelingxingqiu.com/shootmini/static/title-mvp.png" mode="widthFix" />
            <text
              >斩获<text
                :style="{
@@ -127,7 +127,7 @@ const checkBowData = () => {
                  margin: '0 3px',
                  fontWeight: '600',
                }"
-                >{{ data.mvp.totalRings }}</text
+                >{{ data.mvp.player_match_result.total_ring }}</text
              >环</text
            >
          </view>
@@ -153,7 +153,7 @@ const checkBowData = () => {
        </view>
      </view>
      <view class="battle-winner">
-        <image src="../static/shining-bg.png" mode="widthFix" />
+        <image src="https://static.shelingxingqiu.com/shootmini/static/shining-bg.png" mode="widthFix" />
        <image
          :src="ifWin ? '../static/you-win.png' : '../static/you-lost.png'"
          mode="widthFix"
@@ -173,7 +173,7 @@ const checkBowData = () => {
    <block v-else>
      <view class="header-melee">
        <view />
-        <image src="../static/battle-result.png" mode="widthFix" />
+        <image src="https://static.shelingxingqiu.com/shootmini/static/battle-result.png" mode="widthFix" />
        <view />
      </view>
      <view
@@ -248,7 +248,7 @@ const checkBowData = () => {
      class="battle-e"
      :style="{ marginTop: data.mode > 3 ? '20px' : '20vw' }"
    >
-      <image src="../static/row-yellow-bg.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/row-yellow-bg.png" mode="widthFix" />
      <view class="team-avatar">
        <Avatar
          :src="user.avatar"
@@ -1,6 +1,6 @@
 <script setup>
 import { ref, onMounted, computed, onBeforeUnmount } from "vue";
-import { onShow, onLoad, onShareAppMessage } from "@dcloudio/uni-app";
+import { onShow, onHide, onLoad, onShareAppMessage } from "@dcloudio/uni-app";
 import Container from "@/components/Container.vue";
 import PlayerSeats from "@/components/PlayerSeats.vue";
 import GuideTwo from "@/components/GuideTwo.vue";
@@ -14,12 +14,14 @@ import {
  chooseTeamAPI,
  getReadyAPI,
  kickPlayerAPI,
+  getBattleAPI,
 } from "@/apis";
-import { isLimitError } from "@/util";
+import { debounce, isLimitError } from "@/util";
 import { MESSAGETYPES, MESSAGETYPESV2 } from "@/constants";
 import useStore from "@/store";
 import { storeToRefs } from "pinia";
 import audioManager from "@/audioManager";
+import { returnToBattle } from "@/utils/matchReturn";
 const store = useStore();
 const { user } = storeToRefs(store);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-.choose-side-left-item>view>text,
-.choose-side-right-item>view>text {
+.team-player-avatar>text {
  font-size: 16rpx;
  border-radius: 20rpx;
  line-height: 26rpx;
@@ -15,19 +15,19 @@ import BubbleTip from "@/components/BubbleTip.vue";
 import audioManager from "@/audioManager";
 import {
  createPractiseAPI,
-  startPractiseAPI,
-  endPractiseAPI,
  getPractiseAPI,
+  startPractiseAPI,
  laserAimAPI,
  laserCloseAPI,
 } from "@/apis";
+import { connectMatchWebSocket, closeMatchWebSocket } from "@/matchWebsocket";
 import { sharePractiseData } from "@/canvas";
 import { wxShare, debounce } from "@/util";
 import { MESSAGETYPESV2 } from "@/constants";
 import useStore from "@/store";
 import { storeToRefs } from "pinia";
 const store = useStore();
-const { user } = storeToRefs(store);
+const { user, device } = storeToRefs(store);
 const scores = ref([]);
 const isSvip = ref(false);
 const step = ref(0);
@@ -50,6 +50,7 @@ const showGuide = ref(false);
 const laserActive = ref(false);
 const guideSwiperIndex = ref(0);
 const sharing = ref(false);
+const RESULT_TIP_CDN = "https://static.shelingxingqiu.com/shootmini/static";

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

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

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

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

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

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

 <template>
@@ -361,13 +407,7 @@ const onClose = async () => {
        :total="total"
        :onClose="onClose"
        :result="practiseResult"
-        :tipSrc="`../static/${
-          practiseResult.details.filter(
-            (arrow) => arrow.x !== -30 && arrow.y !== -30
-          ).length < total
-            ? 'un'
-            : ''
-        }finish-tip.png`"
+        :tipSrc="getResultTipSrc(practiseResult)"
      />
      <canvas class="share-canvas" id="shareCanvas" type="2d"></canvas>
    </view>
@@ -27,6 +27,8 @@ const data = ref({});
 const showOverlay = ref(false);
 /** 自动关闭覆盖层的计时器 */
 const overlayTimer = ref(null);
+const overlayDelayTimer = ref(null);
+let loadGeneration = 0;
 /** 控制经验条是否执行进场动画（弹窗关闭后才置 true，避免动画被遮挡） */
 const showExpAnim = ref(false);

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

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

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

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

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

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

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

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

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

 const closeLimitModal = () => {
  showLimitModal.value = false;
@@ -116,6 +128,7 @@ const goMyRecord = () => {
  });
 };
 onShow(async () => {
+  loading.value = false;
  if (user.value.id) {
    const [result] = await Promise.all([
      getBattleDataAPI(),
@@ -196,10 +209,10 @@ onLoad(async (options) => {
      </view>
      <view class="create-room">
        <image src="https://static.shelingxingqiu.com/attachment/2025-07-15/dbcejys872iyun92h6.png" mode="widthFix" />
-        <image src="../static/room-notfound-title.png" mode="widthFix" />
+        <image src="https://static.shelingxingqiu.com/shootmini/static/room-notfound-title.png" mode="widthFix" />
        <view>
          <image :src="user.avatar" mode="widthFix" />
-          <image src="../static/versus.png" mode="widthFix" />
+          <image src="https://static.shelingxingqiu.com/shootmini/static/versus.png" mode="widthFix" />
          <view>
            <image src="../static/question-mark.png" mode="widthFix" />
          </view>
@@ -208,7 +221,12 @@ onLoad(async (options) => {
          <view v-if="challengeLimitText" class="pp-text">
            {{ challengeLimitText }}
          </view>
-          <SButton width="80%" :rounded="30" :onClick="() => $clickSound(onCreateRoom)">
+          <SButton
+            width="80%"
+            :rounded="30"
+            :disabled="createRoomLoading"
+            :onClick="() => { $clickSound(); return onCreateRoom(); }"
+          >
            创建约战房
          </SButton>
        </view>
@@ -256,11 +256,6 @@ const toPage = async (path) => {
    showModal.value = true;
    return;
  }
-  // if (path === "/pages/first-try") {
-  // if (canEenter(user.value, device.value, online.value, path)) {
-  //   await uni.$checkAudio();
-  // }
-  // }
  uni.navigateTo({url: path});
 };

@@ -423,7 +418,7 @@ onShareTimeline(() => {
              <text v-else-if="online">设备在线</text>
            </block>
            <image
-                src="../static/first-try.png"
+                src="https://static.shelingxingqiu.com/shootmini/static/first-try.png"
                mode="widthFix"
                @click="() => toPage('/pages/first-try')"
            />
@@ -433,11 +428,12 @@ onShareTimeline(() => {
            </BubbleTip>
          </view>
          <view class="play-card">
-            <view @click="$clickSound(() => toPage('/pages/practise'))">
-              <image src="../static/my-practise.png" mode="widthFix"/>
+            <!-- toPage('/pages/practise') -->
+            <view @click="$clickSound(() => toPage('/pages/training/index'))">
+              <image src="https://static.shelingxingqiu.com/shootmini/static/my-practise.png" mode="widthFix"/>
            </view>
            <view @click="$clickSound(() => toPage('/pages/friend-battle'))">
-              <image src="../static/friend-battle.png" mode="widthFix"/>
+              <image src="https://static.shelingxingqiu.com/shootmini/static/friend-battle.png" mode="widthFix"/>
            </view>
          </view>
        </view>
@@ -452,7 +448,7 @@ onShareTimeline(() => {
              hover-class="none"
          ></button>
          <view class="ranking-players" @click="toRankListPage">
-            <img src="../static/juezhanbang.png" mode="widthFix"/>
+            <img src="https://static.shelingxingqiu.com/shootmini/static/juezhanbang.png" mode="widthFix"/>
            <view class="divide-line"></view>
            <view class="player-avatars">
              <view
@@ -486,7 +482,7 @@ onShareTimeline(() => {
          </view>
          <view class="my-data">
            <view @click="() => toPage('/pages/my-growth')">
-              <image src="../static/my-growth.png" mode="widthFix"/>
+              <image src="https://static.shelingxingqiu.com/shootmini/static/my-growth.png" mode="widthFix"/>
            </view>
            <view @click="() => toPage('/pages/ranking')">
              <view>
@@ -4,20 +4,27 @@ import { onLoad, onShow, onHide } from "@dcloudio/uni-app";
 import Container from "@/components/Container.vue";
 import Matching from "@/components/Matching.vue";
 import ModalDialog from "@/components/ModalDialog.vue";
+import audioManager from "@/audioManager";
 import { matchGameAPI, getBattleAPI } from "@/apis";
 import { MESSAGETYPESV2 } from "@/constants";
 import { isLimitError } from "@/util";
+import { returnToBattle } from "@/utils/matchReturn";

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

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

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

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

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

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

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

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

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

@@ -13,7 +13,14 @@ import TestDistance from "@/components/TestDistance.vue";
 import SModal from "@/components/SModal.vue";
 import audioManager from "@/audioManager";
 import { getBattleAPI, laserCloseAPI } from "@/apis";
+import {
+  closeMatchWebSocket,
+  connectMatchWebSocket,
+  MATCH_WS_AUDIO_ACK_EVENT,
+  MATCH_WS_STATE_EVENT,
+} from "@/matchWebsocket";
 import { MESSAGETYPESV2 } from "@/constants";
+import { takeMatchReturnSnapshot } from "@/utils/matchReturn";
 import useStore from "@/store";
 import { storeToRefs } from "pinia";
 const store = useStore();
@@ -30,13 +37,24 @@ const playersSorted = ref([]);
 const playersScores = ref([]);
 const halfTimeTip = ref(false);
 const halfRest = ref(false);
+const DEFAULT_READY_TIME = 15;
 const HALF_REST_SECONDS = 20;
+const MATCH_READY_SNAPSHOT_PREFIX = "match-ready-snapshot:";
+const MATCH_STATUS_BY_TEXT = {
+  MATCH_STATUS_READY: 0,
+  MATCH_STATUS_STARTED: 1,
+  MATCH_STATUS_END: 2,
+  MATCH_STATUS_TIMEOUT: 3,
+  MATCH_STATUS_UNEXPECTEDLY: 4,
+};
 const halfRestRemain = ref(HALF_REST_SECONDS);
+const readyTime = ref(DEFAULT_READY_TIME);
 let halfRestTimer = null;
 /** 控制设备离线提示弹窗的显示状态 */
 const showOfflineModal = ref(false);
-/** 记录每位玩家当前半场连续 10 环及以上次数，key 为 playerId，用于触发 tententen 音效 */
-const xRingStreaks = ref({});
+let battleEnded = false;
+let skipNextRestoreOnShow = false;
+let restoreGeneration = 0;

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

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

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

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

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

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

  if (halfRestRemain.value <= 0) return;

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

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

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

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

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

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

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

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

@@ -288,7 +462,12 @@ onShow(async () => {
  <Container :title="title" :bgType="1">
    <view class="container">
      <BattleHeader v-if="!start" :players="players" />
-      <TestDistance v-if="start === false" :guide="false" :isBattle="true" />
+      <TestDistance
+        v-if="start === false"
+        :guide="false"
+        :isBattle="true"
+        :count="readyTime"
+      />
      <ShootProgress
        :show="start"
        :start="start && !halfRest"
@@ -310,6 +489,7 @@ onShow(async () => {
        :totalRound="12"
        :scores="playersScores.map((r) => r[user.id]).flat()"
        :isSvip="isCurrentUserSvip"
+        :missAsZero="true"
        :stop="halfRest"
      />
      <view :style="{ paddingBottom: '20px' }">
@@ -65,7 +65,7 @@ onLoad(async (options) => {
  <Container title="靶纸">
    <view class="container">
      <image
-        src="../static/battle-header-melee.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/battle-header-melee.png"
        mode="widthFix"
        :style="{ top: '-50rpx' }"
      />
@@ -161,7 +161,7 @@ onShow(async () => {
  <Container title="弓箭绑定">
    <view v-if="!device.deviceId" class="scan-code">
      <button hover-class="none" @click="$clickSound(handleScan)">
-        <image src="../static/scan.png" mode="widthFix" />
+        <image src="https://static.shelingxingqiu.com/shootmini/static/scan.png" mode="widthFix" />
      </button>
      <button hover-class="none" @click="showTip = true">
        <text>扫</text>
@@ -172,7 +172,7 @@ onShow(async () => {
      <text>射灵智能弓箭，三模传感系统与独创靶环算法，</text>
      <text>毫秒级在线实时对战，让你拥有全球约战的乐趣！</text>
      <button hover-class="none" @click="toDeviceIntroPage">
-        <image src="../static/have-no-device.png" mode="widthFix" />
+        <image src="https://static.shelingxingqiu.com/shootmini/static/have-no-device.png" mode="widthFix" />
      </button>
      <ScreenHint
        mode="square"
@@ -219,7 +219,7 @@ onShow(async () => {
        :style="{ marginBottom: calibration ? '250rpx' : '100rpx' }"
      >
        <view>
-          <image src="../static/device-icon.png" mode="widthFix" />
+          <image src="https://static.shelingxingqiu.com/shootmini/static/device-icon.png" mode="widthFix" />
          <text>{{ device.deviceName }}</text>
          <view class="calibration" v-if="calibration">
            <button hover-class="none" @click="goCalibration">
@@ -286,7 +286,7 @@ onShow(async () => {
    <view v-if="device.deviceId && !justBind" class="has-device">
      <view class="device-binded">
        <view>
-          <image src="../static/device-icon.png" mode="widthFix" />
+          <image src="https://static.shelingxingqiu.com/shootmini/static/device-icon.png" mode="widthFix" />
          <text>{{ device.deviceName }}</text>
          <view class="calibration">
            <button hover-class="none" @click="goCalibration">
@@ -44,7 +44,7 @@ onMounted(async () => {
  <Container :bgType="5" bgColor="#F5F5F5" :whiteBackArrow="false">
    <view class="top-part">
      <view>
-        <image src="../static/point-champion.png" mode="widthFix" />
+        <image src="https://static.shelingxingqiu.com/shootmini/static/point-champion.png" mode="widthFix" />
        <image
          :src="list[0] && list[0].avatar ? list[0].avatar : ''"
          mode="widthFix"
@@ -348,7 +348,7 @@ onShareTimeline(() => {
      />
      <view class="heat-map">
        <image
-          :src="bowTargetSrc || '../static/bow-target.png'"
+          :src="bowTargetSrc || 'https://static.shelingxingqiu.com/shootmini/static/bow-target.png'"
          mode="widthFix"
        />
        <image
@@ -374,7 +374,7 @@ onShareTimeline(() => {
      </view>
      <view class="reward" v-if="data.totalArrow">
        <button hover-class="none" @click="showTip = true">
-          <image src="../static/reward-us.png" mode="widthFix" />
+          <image src="https://static.shelingxingqiu.com/shootmini/static/reward-us.png" mode="widthFix" />
        </button>
      </view>
      <RingBarChart :data="data.ringRate" v-if="user.id" />
@@ -1,5 +1,5 @@
 <script setup>
-import { ref, onMounted, onBeforeUnmount, nextTick } from "vue";
+import { ref, onMounted, onBeforeUnmount } from "vue";
 import { onLoad } from "@dcloudio/uni-app";
 import Container from "@/components/Container.vue";
 import ShootProgress from "@/components/ShootProgress.vue";
@@ -15,10 +15,11 @@ import audioManager from "@/audioManager";

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

 const start = ref(false);
 const scores = ref([]);
 const isSvip = ref(false);
 const total = 12;
-/** 当前练习中连续 10 环及以上计数，用于触发 tententen 音效 */
-const xRingStreak = ref(0);
 const practiseResult = ref({});
 const practiseId = ref("");
 const showGuide = ref(false);
 const tips = ref("");
 const targetType = ref(1);
 const sharing = ref(false);
+const exiting = ref(false);
+const RESULT_TIP_CDN = "https://static.shelingxingqiu.com/shootmini/static";

 onLoad((options) => {
  if (options.target) {
@@ -47,54 +48,64 @@ onLoad((options) => {
  }
 });

+const createPractise = async () => {
+  closeMatchWebSocket({ reason: "practice-recreate" });
+  const result = await createPractiseAPI(
+    total,
+    120,
+    targetType.value,
+    device.value.deviceId
+  );
+  if (result?.id) practiseId.value = result.id;
+  if (!result?.serverAddr) {
+    uni.showToast({
+      title: "练习连接信息异常，请重试",
+      icon: "none",
+    });
+    return null;
+  }
+  connectMatchWebSocket({
+    serverAddr: result.serverAddr,
+    matchId: result.id,
+    userId: user.value.id,
+  });
+  return result;
+};
+
+const beginPractise = async () => {
+  if (!practiseId.value) {
+    uni.showToast({
+      title: "练习未创建，请重试",
+      icon: "none",
+    });
+    return false;
+  }
+  await startPractiseAPI(practiseId.value);
+  return true;
+};
+
 const onReady = async () => {
-  await startPractiseAPI();
+  const result = await beginPractise();
+  if (!result) return;
  scores.value = [];
  isSvip.value = false;
-  xRingStreak.value = 0; // 新一局开始，重置 X 环连续计数
  start.value = true;
  audioManager.play("练习开始");
 };

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

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

@@ -110,12 +121,32 @@ async function onComplete() {
    start.value = false;
    scores.value = [];
    isSvip.value = false;
-    xRingStreak.value = 0; // 重新开始练习，重置 X 环连续计数
-    const result = await createPractiseAPI(total, 120);
-    if (result) practiseId.value = result.id;
+    await createPractise();
  }
 }

+async function exitPractise() {
+  if (exiting.value) return;
+  exiting.value = true;
+
+  try {
+    if (practiseId.value && !practiseResult.value?.details) {
+      await endPractiseAPI(practiseId.value);
+    }
+  } catch (error) {
+    console.error("Failed to stop practice", error);
+  } finally {
+    uni.navigateBack();
+  }
+}
+
+const getResultTipSrc = (result = {}) => {
+  const validCount = (result.details || []).filter(
+    (arrow) => arrow.x !== -30 && arrow.y !== -30
+  ).length;
+  return `${RESULT_TIP_CDN}/${validCount < total ? "un" : ""}finish-tip.png`;
+};
+
 const onClickShare = debounce(async () => {
  if (sharing.value) return;
  sharing.value = true;
@@ -132,22 +163,15 @@ const onClickShare = debounce(async () => {
  }
 });

-function onAudioEnded(s) {
-  if (s.indexOf("比赛结束") >= 0) {
-    onOver()
-  }
-}
-
 onMounted(async () => {
+  void audioManager.warmAll();
  // audioManager.play("第一轮");
  uni.setKeepScreenOn({
    keepScreenOn: true,
  });
  uni.$on("socket-inbox", onReceiveMessage);
  uni.$on("share-image", onClickShare);
-  uni.$on("audioEnded", onAudioEnded);
-  const result = await createPractiseAPI(total, 120, targetType.value);
-  if (result) practiseId.value = result.id;
+  await createPractise();
 });

 onBeforeUnmount(() => {
@@ -156,9 +180,8 @@ onBeforeUnmount(() => {
  });
  uni.$off("socket-inbox", onReceiveMessage);
  uni.$off("share-image", onClickShare);
-  uni.$off("audioEnded", onAudioEnded);
  audioManager.stopAll();
-  endPractiseAPI();
+  closeMatchWebSocket({ reason: "practice-leave" });
 });
 </script>

@@ -167,6 +190,7 @@ onBeforeUnmount(() => {
    :bgType="1"
    title="个人单组练习"
    :showBottom="!start && !scores.length"
+    :onBack="exitPractise"
  >
    <view>
      <TestDistance v-if="!start && !practiseResult.id" />
@@ -203,13 +227,7 @@ onBeforeUnmount(() => {
          :total="total"
          :onClose="onComplete"
          :result="practiseResult"
-          :tipSrc="`../static/${
-            practiseResult.details.filter(
-              (arrow) => arrow.x !== -30 && arrow.y !== -30
-            ).length < total
-              ? 'un'
-              : ''
-          }finish-tip.png`"
+          :tipSrc="getResultTipSrc(practiseResult)"
        />
        <canvas class="share-canvas" id="shareCanvas" type="2d"></canvas>
      </block>
@@ -1,5 +1,5 @@
 <script setup>
-import { ref, onMounted, onBeforeUnmount, nextTick } from "vue";
+import { ref, onMounted, onBeforeUnmount } from "vue";
 import Container from "@/components/Container.vue";
 import ShootProgress from "@/components/ShootProgress.vue";
 import BowTarget from "@/components/BowTarget.vue";
@@ -14,10 +14,11 @@ import audioManager from "@/audioManager";

 import {
  createPractiseAPI,
-  startPractiseAPI,
  endPractiseAPI,
  getPractiseAPI,
+  startPractiseAPI,
 } from "@/apis";
+import { connectMatchWebSocket, closeMatchWebSocket } from "@/matchWebsocket";
 import { sharePractiseData } from "@/canvas";
 import { wxShare, debounce } from "@/util";
 import { MESSAGETYPESV2 } from "@/constants";
@@ -26,19 +27,19 @@ import useStore from "@/store";
 import { storeToRefs } from "pinia";
 import {onLoad} from "@dcloudio/uni-app";
 const store = useStore();
-const { user } = storeToRefs(store);
+const { user, device } = storeToRefs(store);

 const start = ref(false);
 const scores = ref([]);
 const isSvip = ref(false);
 const total = 36;
-/** 当前练习中连续 10 环及以上计数，用于触发 tententen 音效 */
-const xRingStreak = ref(0);
 const practiseResult = ref({});
 const practiseId = ref("");
 const showGuide = ref(false);
 const targetType = ref(1);
 const sharing = ref(false);
+const exiting = ref(false);
+const RESULT_TIP_CDN = "https://static.shelingxingqiu.com/shootmini/static";

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

+const createPractise = async () => {
+  closeMatchWebSocket({ reason: "practice-recreate" });
+  const result = await createPractiseAPI(
+    total,
+    3600,
+    targetType.value,
+    device.value.deviceId
+  );
+  if (result?.id) practiseId.value = result.id;
+  if (!result?.serverAddr) {
+    uni.showToast({
+      title: "练习连接信息异常，请重试",
+      icon: "none",
+    });
+    return null;
+  }
+  connectMatchWebSocket({
+    serverAddr: result.serverAddr,
+    matchId: result.id,
+    userId: user.value.id,
+  });
+  return result;
+};
+
+const beginPractise = async () => {
+  if (!practiseId.value) {
+    uni.showToast({
+      title: "练习未创建，请重试",
+      icon: "none",
+    });
+    return false;
+  }
+  await startPractiseAPI(practiseId.value);
+  return true;
+};
+
 const onReady = async () => {
-  await startPractiseAPI();
+  const result = await beginPractise();
+  if (!result) return;
  scores.value = [];
  isSvip.value = false;
-  xRingStreak.value = 0; // 新一局开始，重置 X 环连续计数
  start.value = true;
  audioManager.play("练习开始");
 };

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

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

+async function exitPractise() {
+  if (exiting.value) return;
+  exiting.value = true;
+
+  try {
+    if (practiseId.value && !practiseResult.value?.details) {
+      await endPractiseAPI(practiseId.value);
+    }
+  } catch (error) {
+    console.error("Failed to stop practice", error);
+  } finally {
+    uni.navigateBack();
+  }
+}
+
+const getResultTipSrc = (result = {}) => {
+  const validCount = (result.details || []).filter(
+    (arrow) => arrow.x !== -30 && arrow.y !== -30
+  ).length;
+  return `${RESULT_TIP_CDN}/${validCount < total ? "2un" : ""}finish-tip.png`;
+};
+
 const onClickShare = debounce(async () => {
  if (sharing.value) return;
  sharing.value = true;
@@ -148,13 +179,13 @@ const onClickShare = debounce(async () => {
 });

 onMounted(async () => {
+  void audioManager.warmAll();
  uni.setKeepScreenOn({
    keepScreenOn: true,
  });
  uni.$on("socket-inbox", onReceiveMessage);
  uni.$on("share-image", onClickShare);
-  const result = await createPractiseAPI(total, 3600, targetType.value);
-  if (result) practiseId.value = result.id;
+  await createPractise();
 });

 onBeforeUnmount(() => {
@@ -164,7 +195,7 @@ onBeforeUnmount(() => {
  uni.$off("socket-inbox", onReceiveMessage);
  uni.$off("share-image", onClickShare);
  audioManager.stopAll();
-  endPractiseAPI();
+  closeMatchWebSocket({ reason: "practice-leave" });
 });
 </script>

@@ -173,6 +204,7 @@ onBeforeUnmount(() => {
    :bgType="1"
    title="日常耐力挑战"
    :showBottom="!start && !scores.length"
+    :onBack="exitPractise"
  >
    <view>
      <TestDistance v-if="!start && !practiseResult.id" />
@@ -211,13 +243,7 @@ onBeforeUnmount(() => {
          :rowCount="9"
          :onClose="onComplete"
          :result="practiseResult"
-          :tipSrc="`../static/${
-            practiseResult.details.filter(
-              (arrow) => arrow.x !== -30 && arrow.y !== -30
-            ).length < total
-              ? '2un'
-              : ''
-          }finish-tip.png`"
+          :tipSrc="getResultTipSrc(practiseResult)"
        />
        <canvas class="share-canvas" id="shareCanvas" type="2d"></canvas>
      </block>
@@ -63,39 +63,39 @@ import Container from "@/components/Container.vue";
            <view class="table-row">
              <text>倔强青铜</text>
              <view>
-                <text>青铜1*</text>
-                <text>青铜2*</text>
-                <text>青铜3*</text>
+                <text>青铜1</text>
+                <text>青铜2</text>
+                <text>青铜3</text>
              </view>
              <text>每个小段位需要满 3星才能晋升到下一个段位，共9颗星。</text>
            </view>
            <view class="table-row">
              <text>秩序白银</text>
              <view>
-                <text>白铜1*</text>
-                <text>白铜2*</text>
-                <text>白铜3*</text>
+                <text>白铜1</text>
+                <text>白铜2</text>
+                <text>白铜3</text>
              </view>
              <text>每个小段位需要满 3颗星才能晋升到下一个段位，共9颗星。</text>
            </view>
            <view class="table-row">
              <text>荣耀黄金</text>
              <view>
-                <text>黄金1*</text>
-                <text>黄金2*</text>
-                <text>黄金3*</text>
-                <text>黄金4*</text>
+                <text>黄金1</text>
+                <text>黄金2</text>
+                <text>黄金3</text>
+                <text>黄金4</text>
              </view>
              <text>每个小段位需要满4颗星才能晋升到下一个段位，共16颗星。</text>
            </view>
            <view class="table-row">
              <text>永恒钻石</text>
              <view>
-                <text>钻石1*</text>
-                <text>钻石2*</text>
-                <text>钻石3*</text>
-                <text>钻石4*</text>
-                <text>钻石5*</text>
+                <text>钻石1</text>
+                <text>钻石2</text>
+                <text>钻石3</text>
+                <text>钻石4</text>
+                <text>钻石5</text>
              </view>
              <text>每个小段位需要满5颗星才能晋升到下一个段位，共25颗星。</text>
            </view>
@@ -126,7 +126,6 @@ const toMatchPage = async (gameType, teamSize) => {
    showLimitModal.value = true;
    return;
  }
-  await uni.$checkAudio();
  uni.navigateTo({
    url: `/pages/match-page?gameType=${gameType}&teamSize=${teamSize}`,
  });
@@ -328,8 +327,8 @@ onShow(async () => {
    <view class="battle-types-box">
      <view class="battle-types">
        <view class="first">
-          <image src="../static/rank/battle-choose.png" mode="widthFix" />
-          <image class="star" src="../static/rank/star.png" mode="widthFix" />
+          <image src="https://static.shelingxingqiu.com/shootmini/static/rank/battle-choose.png" mode="widthFix" />
+          <image class="star" src="https://static.shelingxingqiu.com/shootmini/static/rank/star.png" mode="widthFix" />
        </view>
        <image
          src="../static/rank/battle1v1.svg"
@@ -49,8 +49,6 @@ const battleWay = ref(0);
 const lastToSomeoneShootKey = ref("");
 /** 控制设备离线提示弹窗的显示状态 */
 const showOfflineModal = ref(false);
-/** 记录每位玩家当前轮连续 10 环及以上次数，key 为 playerId，用于触发 tententen 音效 */
-const xRingStreaks = ref({});

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

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

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

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

 import useStore from "@/store";
 import { storeToRefs } from "pinia";
@@ -66,12 +67,7 @@ const onClick = debounce(async () => {
    loading.value = true;
    const result = await getBattleAPI();
    if (result && result.matchId) {
-      await uni.$checkAudio();
-      if (result.mode <= 3) {
-        await navigateOnce(`/pages/team-battle/index?battleId=${result.matchId}`);
-      } else {
-        await navigateOnce(`/pages/melee-battle?battleId=${result.matchId}`);
-      }
+      await returnToBattle(result, navigateOnce);
      return;
    }
    if (game.value.roomID) {
@@ -100,9 +96,9 @@ onBeforeUnmount(() => {
    class="back-to-game"
    @click="onClick"
  >
-    <image src="../../../static/back-to-game-bg.png" mode="widthFix" />
+    <image src="https://static.shelingxingqiu.com/shootmini/static/back-to-game-bg.png" mode="widthFix" />
    <block v-if="game.inBattle">
-      <image src="../../../static/pk-icon.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/pk-icon.png" mode="widthFix" />
      <text>返回进行中的对局</text>
    </block>
    <block v-else-if="game.roomID">
@@ -31,7 +31,7 @@ const normalRounds = computed(() => {
 <template>
  <view class="container">
    <view class="guide-row">
-      <image src="../../../static/shooter.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/shooter.png" mode="widthFix" />
      <view
        :style="{
          marginBottom: '10px',
@@ -42,7 +42,7 @@ const normalRounds = computed(() => {
      </view>
    </view>
    <view>
-      <image src="../../../static/battle-header-melee.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/battle-header-melee.png" mode="widthFix" />
      <text>蓝队({{ bluePoints }})</text>
      <text>红队({{ redPoints }})</text>
    </view>
@@ -41,7 +41,7 @@ const isMember = (player = {}) => player.vip === true || player.sVip === true;
  <view class="container" :style="{ paddingTop: showHeader ? '5px' : '0' }">
    <image
      v-if="showHeader"
-      :src="`../../../static/battle-header${players.length ? '-melee' : ''}.png`"
+      :src="`https://static.shelingxingqiu.com/shootmini/static/battle-header${players.length ? '-melee' : ''}.png`"
      mode="widthFix"
    />
    <view
@@ -151,6 +151,7 @@ const isMember = (player = {}) => player.vip === true || player.sVip === true;
 .container {
  width: 100%;
  position: relative;
+  z-index: 999;
  margin-bottom: 10px;
 }
 .container > image:first-child {
@@ -531,7 +531,7 @@ onBeforeUnmount(() => {
        @impact="shakeTarget"
        @complete="completeShotEffect"
      />
-      <image src="../../../static/bow-target.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/bow-target.png" mode="widthFix" />
    </view>
    <view class="footer">
      <PointSwitcher
@@ -1,5 +1,5 @@
 <script setup>
-import { ref, computed, onMounted, onBeforeUnmount } from "vue";
+import { ref } from "vue";
 import { onShow } from "@dcloudio/uni-app";
 import AppBackground from "./AppBackground.vue";
 import Header from "./Header.vue";
@@ -7,7 +7,7 @@ import ScreenHint from "./ScreenHint.vue";
 import BackToGame from "./BackToGame.vue";
 import {laserAimAPI, getBattleAPI, matchGameAPI} from "@/apis";
 import { capsuleHeight, debounce } from "@/util";
-import AudioManager from "@/audioManager";
+import { returnToBattle } from "@/utils/matchReturn";
 const props = defineProps({
  title: {
    type: String,
@@ -58,9 +58,6 @@ const isIOS = uni.getDeviceInfo().osName === "ios";
 const showHint = ref(false);
 const hintType = ref(0);
 const isLoading = ref(false);
-const audioInitProgress = ref(1);
-const audioProgress = ref(0);
-const audioTimer = ref(null);

 const showGlobalHint = (type) => {
  hintType.value = type;
@@ -71,55 +68,21 @@ const hideGlobalHint = () => {
  showHint.value = false;
 };

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

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

@@ -127,16 +90,7 @@ const backToGame = debounce(async () => {
    isLoading.value = true;
    const result = await getBattleAPI();
    if (result && result.matchId) {
-      await checkAudioProgress();
-      if (result.mode <= 3) {
-        uni.navigateTo({
-          url: `/pages/team-battle/index?battleId=${result.matchId}`,
-        });
-      } else {
-        uni.navigateTo({
-          url: `/pages/melee-battle?battleId=${result.matchId}`,
-        });
-      }
+      await returnToBattle(result, navigateTo);
    }
  } catch (error) {
    console.error("获取当前游戏失败:", error);
@@ -233,13 +187,13 @@ const goCalibration = async () => {
        </view>
      </view>
    </ScreenHint>
-    <view v-if="loading || audioInitProgress < 1" class="audio-progress">
+    <view v-if="loading" class="audio-progress">
      <image
        src="https://static.shelingxingqiu.com/attachment/2025-11-26/deihtj15xjwcz3c1tx.png"
        mode="widthFix"
      />
      <view>
-        <view :style="{ width: `${loadingProgress * 100}%` }">
+        <view :style="{ width: '100%' }">
          <!-- <image
            src="https://static.shelingxingqiu.com/attachment/2025-11-24/degu91a7si77sg9jqv.png"
            mode="widthFix"
@@ -247,8 +201,7 @@ const goCalibration = async () => {
        </view>
      </view>
      <view>
-        <text>{{ loading ? loadingText || "加载中..." : "若加载时间过长，请" }}</text>
-        <button v-if="!loading" hover-class="none" @click="restart">点击这里重启</button>
+        <text>{{ loadingText || "加载中..." }}</text>
      </view>
    </view>
  </view>
@@ -12,13 +12,13 @@ defineProps({
 const bubbleTypes = [
  "../../../static/long-bubble.png",
  "../../../static/long-bubble-middle.png",
-  "../../../static/long-bubble-tall.png",
+  "https://static.shelingxingqiu.com/shootmini/static/long-bubble-tall.png",
 ];
 </script>

 <template>
  <view class="container">
-    <image src="../../../static/shooter.png" mode="widthFix" />
+    <image src="https://static.shelingxingqiu.com/shootmini/static/shooter.png" mode="widthFix" />
    <view>
      <image
        v-if="!noBg"
@@ -27,22 +27,22 @@ const getContentHeight = () => {
    <view class="scale-in" :style="{ height: getContentHeight() }">
      <image
        v-if="mode === 'normal'"
-        src="../../../static/screen-hint-bg.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/screen-hint-bg.png"
        mode="widthFix"
      />
      <image
        v-if="mode === 'tall'"
-        src="../../../static/coach-comment.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/coach-comment.png"
        mode="widthFix"
      />
      <image
        v-if="mode === 'square'"
-        src="../../../static/prompt-bg-square.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/prompt-bg-square.png"
        mode="widthFix"
      />
      <image
        v-if="mode === 'small'"
-        src="../../../static/finish-frame.png"
+        src="https://static.shelingxingqiu.com/shootmini/static/finish-frame.png"
        mode="widthFix"
      />
      <slot />
@@ -111,7 +111,7 @@ onBeforeUnmount(() => {
      </view>
    </view>
    <view v-if="isBattle" class="ready-timer">
-      <image src="../../../static/test-tip.png" mode="widthFix" />
+      <image src="https://static.shelingxingqiu.com/shootmini/static/test-tip.png" mode="widthFix" />
      <view v-if="count >= 0">
        <text>具体正式比赛还有</text>
        <text>{{ count }}</text>
@@ -13,8 +13,15 @@ import TeamAvatars from "./components/TeamAvatars.vue";
 import ShootProgress2 from "./components/ShootProgress2.vue";
 import SModal from "./components/SModal.vue";
 import { laserCloseAPI, getBattleAPI } from "@/apis";
+import {
+  closeMatchWebSocket,
+  connectMatchWebSocket,
+  MATCH_WS_AUDIO_ACK_EVENT,
+  MATCH_WS_STATE_EVENT,
+} from "@/matchWebsocket";
 import { MESSAGETYPESV2 } from "@/constants";
 import { getDirectionText } from "@/util";
+import { takeMatchReturnSnapshot } from "@/utils/matchReturn";
 import audioManager, {
  AUDIO_INTERRUPTION_BEGIN_EVENT,
  AUDIO_INTERRUPTION_END_EVENT,
@@ -26,7 +33,7 @@ const store = useStore();
 const { user, online } = storeToRefs(store);

 const DEFAULT_SHOOT_TIME = 15;
-const READY_SECONDS = 15;
+const DEFAULT_READY_TIME = 15;
 const READY_TIMER_EMIT_DELAY = 200;
 const RESTORE_DELAY = 300;
 const RESTORE_EMPTY_ID_RETRY_DELAY = 50;
@@ -41,7 +48,14 @@ const AUDIO_TIMEOUT_PER_KEY = 2600;
 const AUDIO_TIMEOUT_MAX = 12000;
 const BATTLE_CANCEL_RETURN_DELAY = 2000;
 const ROUND_AUDIO_NAMES = ["一", "二", "三", "四", "五"];
-const X_RING_STREAKS_KEY = "team-battle-x-ring-streaks";
+const MATCH_READY_SNAPSHOT_PREFIX = "match-ready-snapshot:";
+const MATCH_STATUS_BY_TEXT = {
+  MATCH_STATUS_READY: 0,
+  MATCH_STATUS_STARTED: 1,
+  MATCH_STATUS_END: 2,
+  MATCH_STATUS_TIMEOUT: 3,
+  MATCH_STATUS_UNEXPECTEDLY: 4,
+};
 const PROGRESS_ZERO_EVENT = "team-battle-progress-zero";
 const COUNTDOWN_READY_EVENT = "team-battle-countdown-ready";

@@ -67,9 +81,9 @@ const showRoundTip = ref(false);
 const isFinalShoot = ref(false);
 const matchStatus = ref(undefined);
 const shootTimeTotal = ref(DEFAULT_SHOOT_TIME);
+const readyTime = ref(DEFAULT_READY_TIME);
 const showOfflineModal = ref(false);
 const restoreLoading = ref(false);
-const xRingStreaks = ref({});

 // 消息队列：只保存“待执行”的战况消息，页面展示统一由队列串行驱动。
 const battleQueue = ref([]);
@@ -89,6 +103,10 @@ let restoreLoadingTimer = null;
 let pendingRoundAudio = false;
 // 一旦收到 BattleEnd，后续普通消息就不再进入队列。
 let battleEnded = false;
+let battleEndTaskRunning = false;
+let resultNavigationPending = false;
+let skipNextRestoreOnShow = false;
+let pendingReturnSnapshot = null;
 const handledMessageKeys = new Set();
 const handledMessageKeyOrder = [];
 const queuedMessageKeys = new Set();
@@ -108,27 +126,88 @@ watch(online, (newVal, oldVal) => {
 });

 // 统一把秒级或毫秒级时间戳转成毫秒，方便和本机时间比较。
-function loadXRingStreaks() {
-  const cached = uni.getStorageSync(X_RING_STREAKS_KEY);
-  xRingStreaks.value =
-    cached && typeof cached === "object" && !Array.isArray(cached) ? cached : {};
-}
-
-function saveXRingStreaks() {
-  uni.setStorageSync(X_RING_STREAKS_KEY, xRingStreaks.value);
-}
-
-function clearXRingStreaks() {
-  xRingStreaks.value = {};
-  uni.removeStorageSync(X_RING_STREAKS_KEY);
-}
-
 function normalizeTimestamp(value) {
  const numberValue = Number(value || 0);
  if (!numberValue) return 0;
  return numberValue < 1000000000000 ? numberValue * 1000 : numberValue;
 }

+function getReadyTime(battleInfo) {
+  const value = Number(battleInfo?.readyTime);
+  return Number.isFinite(value) && value > 0 ? value : DEFAULT_READY_TIME;
+}
+
+function getReadyRemainingSeconds(battleInfo) {
+  const total = getReadyTime(battleInfo);
+  const countdownStartTime = normalizeTimestamp(battleInfo?.countdownStartTime);
+  if (!countdownStartTime) return total;
+
+  const elapsed = Math.max(0, (Date.now() - countdownStartTime) / 1000);
+  return Math.max(0, total - elapsed);
+}
+
+function getReadySnapshotKey(matchId) {
+  return `${MATCH_READY_SNAPSHOT_PREFIX}${String(matchId || "")}`;
+}
+
+function normalizeBattleInfo(battleInfo) {
+  if (!battleInfo || typeof battleInfo !== "object") return battleInfo;
+
+  const statusText = battleInfo.statusText || battleInfo.status_text;
+  if (
+    (battleInfo.status === undefined ||
+      battleInfo.status === null ||
+      battleInfo.status === "") &&
+    MATCH_STATUS_BY_TEXT[statusText] !== undefined
+  ) {
+    return {
+      ...battleInfo,
+      status: MATCH_STATUS_BY_TEXT[statusText],
+    };
+  }
+
+  return battleInfo;
+}
+
+function hasKnownStatus(battleInfo) {
+  return !(
+    battleInfo?.status === undefined ||
+    battleInfo?.status === null ||
+    battleInfo?.status === ""
+  );
+}
+
+function hasStartedSnapshot(battleInfo) {
+  if (hasKnownStatus(battleInfo)) return Number(battleInfo.status) !== 0;
+
+  const current = battleInfo?.current || {};
+  return !!(
+    current.playerId ||
+    current.startTime ||
+    current.round ||
+    (Array.isArray(battleInfo?.rounds) && battleInfo.rounds.length)
+  );
+}
+
+function takeReadySnapshot(matchId) {
+  const key = getReadySnapshotKey(matchId);
+  const snapshot = uni.getStorageSync(key);
+  if (snapshot) uni.removeStorageSync(key);
+  return normalizeBattleInfo(snapshot);
+}
+
+function reconnectMatchServer(battleInfo) {
+  const status = Number(battleInfo?.status);
+  if ([2, 3, 4].includes(status)) return;
+  if (!battleInfo?.serverAddr) return;
+
+  connectMatchWebSocket({
+    serverAddr: battleInfo.serverAddr,
+    matchId: battleInfo.matchId || battleId.value,
+    userId: user.value.id,
+  });
+}
+
 // 从不同消息结构中提取服务端时间，作为恢复和去重的时间基准。
 function getServerTime(message) {
  return normalizeTimestamp(
@@ -289,6 +368,10 @@ function hideRestoreLoading() {
 }

 function showRestoreLoading() {
+  if (start.value === false) {
+    hideRestoreLoading();
+    return;
+  }
  clearRestoreLoadingTimer();
  restoreLoading.value = true;
  restoreLoadingTimer = setTimeout(() => {
@@ -297,6 +380,16 @@ function showRestoreLoading() {
  }, RESTORE_LOADING_TIMEOUT);
 }

+// 终局开始后作废恢复请求，避免恢复遮罩与结算跳转抢占画面。
+function cancelPendingBattleRestore() {
+  restoreGeneration += 1;
+  if (pendingRestoreTimer) {
+    clearTimeout(pendingRestoreTimer);
+    pendingRestoreTimer = null;
+  }
+  hideRestoreLoading();
+}
+
 // 页面重置、离开或恢复快照时调用，统一清理队列、等待器、音频和进度条。
 function invalidateBattleQueue({ stopAudio = false, stopProgress = false } = {}) {
  // 提升队列代际并清空待执行消息，确保恢复快照时不会继续跑旧战况。
@@ -316,7 +409,10 @@ function invalidateBattleQueue({ stopAudio = false, stopProgress = false } = {})
 function enqueueBattleMessage(message) {
  if (Array.isArray(message) || !message?.type) return;
  if (battleEnded && message.type !== MESSAGETYPESV2.BattleEnd) return;
-  if (message.type === MESSAGETYPESV2.BattleEnd) battleEnded = true;
+  if (message.type === MESSAGETYPESV2.BattleEnd) {
+    battleEnded = true;
+    cancelPendingBattleRestore();
+  }

  if (message.type === MESSAGETYPESV2.InvalidShot) {
    const receivedAt = Date.now();
@@ -391,7 +487,9 @@ async function executeBattleTask(task, runId) {
  if (!task || !isQueueAlive(runId)) return;
  const type = task.type;

-  if (type === MESSAGETYPESV2.BattleStart) {
+  if (type === MESSAGETYPESV2.AboutToStart) {
+    applyBattleSnapshot(task.message, { restore: true });
+  } else if (type === MESSAGETYPESV2.BattleStart) {
    await runBattleStartTask(task, runId);
  } else if (type === MESSAGETYPESV2.ToSomeoneShoot) {
    await runToSomeoneShootTask(task, runId);
@@ -402,7 +500,7 @@ async function executeBattleTask(task, runId) {
  } else if (type === MESSAGETYPESV2.BattleEnd) {
    await runBattleEndTask(task, runId);
  } else if (type === MESSAGETYPESV2.InvalidShot) {
-    await runInvalidShotTask(runId);
+    await runInvalidShotTask(task, runId);
  }
 }

@@ -448,6 +546,24 @@ function onAudioEnded(key) {
  });
 }

+function notifyMatchAudioAck(task) {
+  const message = task?.message;
+  if (
+    message?.sequence === undefined ||
+    message?.sequence === null ||
+    message?.sequence === ""
+  ) {
+    return;
+  }
+
+  uni.$emit(MATCH_WS_AUDIO_ACK_EVENT, {
+    matchId: message.matchId || battleId.value,
+    sequence: message.sequence,
+    matchWsType: message.matchWsType,
+    matchWsTypeName: message.matchWsTypeName,
+  });
+}
+
 function handleBattleCovered() {
  if (pendingRestoreTimer) {
    clearTimeout(pendingRestoreTimer);
@@ -462,6 +578,11 @@ function handleBattleRecovered() {
  scheduleRestoreLatestBattle();
 }

+function closeBattleServer(reason) {
+  if (battleEnded) return;
+  closeMatchWebSocket({ reason });
+}
+
 // 队伍信息优先用接口返回值；接口缺失时使用本地缓存，避免重进页面时头像为空。
 function loadTeamPlayers(teamInfo, storageKey) {
  if (Array.isArray(teamInfo?.players)) return [...teamInfo.players];
@@ -526,6 +647,7 @@ function applyRestoreNewRoundSnapshot(battleInfo) {

 // 回填比赛基础信息：队伍、比分、轮次、金箭状态等公共字段都在这里统一处理。
 function applyBattleBase(battleInfo) {
+  battleInfo = normalizeBattleInfo(battleInfo);
  if (!battleInfo) return;
  if (battleInfo.matchId) battleId.value = battleInfo.matchId;
  if (battleInfo.status !== undefined) {
@@ -656,7 +778,7 @@ function getBackendRemainingSeconds(battleInfo, total) {
  return null;
 }

-// 计算当前倒计时剩余秒数：后端字段优先，其次按开始时间和当前时间补算。
+// 计算当前倒计时剩余秒数：后端字段优先，其次按 ACK 时间和当前时间补算。
 function getRemainingSeconds(battleInfo, task, options = {}) {
  const total = getShootTimeSeconds(battleInfo);
  const backendRemain = getBackendRemainingSeconds(battleInfo, total);
@@ -664,8 +786,9 @@ function getRemainingSeconds(battleInfo, task, options = {}) {
  // 新轮首箭由后端 shootTime 定完整时长；没有明确剩余时间时，不扣前端轮次弹窗/语音耗时。
  if (options.fullDurationIfNoBackendRemain) return total;

-  const startTime = normalizeTimestamp(battleInfo?.current?.startTime);
-  if (!startTime) return total;
+  const ackTime = normalizeTimestamp(battleInfo?.current?.ackTime);
+  console.log(11111111111111111111111111,ackTime)
+  if (!ackTime) return total;

  // 后端时间是准的，前端只根据语音耗时和接收延迟做近似补偿。
  // 但回前台的 API 快照不一定带“当前后端时间”，恢复场景优先用本机当前时间计算最新剩余秒数。
@@ -674,7 +797,8 @@ function getRemainingSeconds(battleInfo, task, options = {}) {
    : task?.serverTime || getServerTime(battleInfo) || Date.now();
  const waitAfterReceive = task?.serverTime ? Date.now() - task.receivedAt : 0;
  const effectiveNow = anchorTime + waitAfterReceive;
-  const elapsed = Math.max(0, (effectiveNow - startTime) / 1000);
+  const elapsed = Math.max(0, (effectiveNow - ackTime) / 1000);
+  console.log('剩余：', elapsed, waitAfterReceive,  Math.max(0, Math.min(total, total - elapsed)))
  return Math.max(0, Math.min(total, total - elapsed));
 }

@@ -723,6 +847,7 @@ function stopProgressAfterMount() {
 // 待开局状态：清理比赛态展示，并恢复准备倒计时。
 function applyReadyState(battleInfo) {
  hideRestoreLoading();
+  readyTime.value = getReadyTime(battleInfo);
  start.value = false;
  showRoundTip.value = false;
  currentShooterId.value = 0;
@@ -734,17 +859,15 @@ function applyReadyState(battleInfo) {
  clearProgressZeroWaiters();
  cancelRoundTipDisplay();

-  const createTime = normalizeTimestamp(battleInfo?.createTime || Date.now());
-  const readyElapsed = (Date.now() - createTime) / 1000;
-  if (readyElapsed > 0 && readyElapsed < READY_SECONDS) {
-    setTimeout(() => {
-      uni.$emit("update-timer", READY_SECONDS - readyElapsed - 0.2);
-    }, READY_TIMER_EMIT_DELAY);
-  }
+  setTimeout(() => {
+    uni.$emit("update-timer", getReadyRemainingSeconds(battleInfo));
+  }, READY_TIMER_EMIT_DELAY);
 }

 // 快照恢复入口：只把页面拉到服务端最新状态，不重放已经发生过的语音。
 function applyBattleSnapshot(battleInfo, { restore = false, restoreEventType = 0 } = {}) {
+  battleInfo = normalizeBattleInfo(battleInfo);
+  if (!battleInfo) return;
  // 快照恢复只负责“把页面拉回最新状态”，不重放历史语音。
  applyBattleBase(battleInfo);
  if (battleInfo.status === 0) {
@@ -752,6 +875,12 @@ function applyBattleSnapshot(battleInfo, { restore = false, restoreEventType = 0
    return;
  }

+  if (!hasStartedSnapshot(battleInfo)) {
+    hideRestoreLoading();
+    if (start.value === false) applyReadyState(battleInfo);
+    return;
+  }
+
  start.value = true;
  showRoundTip.value = false;

@@ -787,12 +916,12 @@ function applyBattleSnapshot(battleInfo, { restore = false, restoreEventType = 0
 // 开局任务：切换到正式比赛态，并播报“比赛开始”。
 async function runBattleStartTask(task, runId) {
  // 开赛任务只负责切换正式态并播“比赛开始”，后续进入队列顺序。
-  clearXRingStreaks();
  applyBattleBase(task.message);
  start.value = true;
  pendingRoundAudio = true;
  updateShotInfo(task.message);
  await playAudioKeys("比赛开始", { interrupt: false });
+  notifyMatchAudioAck(task);
  if (!isQueueAlive(runId)) return;
 }

@@ -846,11 +975,12 @@ async function runToSomeoneShootTask(task, runId) {
  });

  await audioPromise;
+  notifyMatchAudioAck(task);
  if (!isQueueAlive(runId)) return;

-  const remainingSeconds = getRemainingSeconds(battleInfo, task, {
-    fullDurationIfNoBackendRemain: isRoundFirstShoot,
-  });
+  // 实时换人消息的倒计时由本条语音 ACK 驱动：后端收到 ACK 后才开始计时，
+  // 因此前端也应从完整 shootTime 启动，不能扣除消息排队及 tententen/提示语音耗时。
+  const remainingSeconds = getShootTimeSeconds(battleInfo);
  const countdown = getCountdownPayload(remainingSeconds, shootTimeTotal.value);
  markProgressDeadline(countdown);
  uni.$emit("update-remain", {
@@ -861,29 +991,6 @@ async function runToSomeoneShootTask(task, runId) {
  });
 }

-function isTenPlusRing(shot) {
-  return !!(shot?.ringX || Number(shot?.ring) >= 10);
-}
-
-function updateXRingStreak(shooterId, isTenPlusRingShot) {
-  if (!shooterId) return false;
-  const id = String(shooterId);
-  if (!isTenPlusRingShot) {
-    xRingStreaks.value[id] = 0;
-    saveXRingStreaks();
-    return false;
-  }
-
-  xRingStreaks.value[id] = (xRingStreaks.value[id] || 0) + 1;
-  if (xRingStreaks.value[id] < 3) {
-    saveXRingStreaks();
-    return false;
-  }
-  xRingStreaks.value[id] = 0;
-  saveXRingStreaks();
-  return true;
-}
-
 function buildShootResultAudioKeys(shootData) {
  if (!shootData) return [];
  const audioKeys = [
@@ -892,6 +999,9 @@ function buildShootResultAudioKeys(shootData) {
  if (shootData.angle !== null && shootData.angle !== undefined) {
    audioKeys.push(`向${getDirectionText(shootData.angle)}调整`);
  }
+  if (shootData.threeConsecutive10Rings === true) {
+    audioKeys.push("tententen");
+  }
  return audioKeys;
 }

@@ -911,13 +1021,9 @@ async function runShootResultTask(task) {
    };
  }

-  const isTententen = updateXRingStreak(
-    currentShooterId.value,
-    isTenPlusRing(battleInfo.shootData)
-  );
  const audioKeys = buildShootResultAudioKeys(battleInfo.shootData);
-  if (isTententen) audioKeys.push("tententen");
  await playAudioKeys(audioKeys, { interrupt: false });
+  notifyMatchAudioAck(task);
 }

 // 新回合任务：展示上一回合结算弹窗，弹窗关闭后再允许下一轮继续。
@@ -962,47 +1068,88 @@ async function runNewRoundTask(task, runId) {
  pendingRoundAudio = true;
 }

+function navigateToBattleResultOnce(matchId) {
+  const targetMatchId = matchId || battleId.value;
+  if (!targetMatchId || resultNavigationPending) return false;
+
+  resultNavigationPending = true;
+  battleEnded = true;
+  cancelPendingBattleRestore();
+
+  uni.redirectTo({
+    url: `/pages/friend-battle-result?battleId=${targetMatchId}`,
+    fail: (err) => {
+      resultNavigationPending = false;
+      console.log("navigate to battle result failed:", err);
+    },
+  });
+  return true;
+}
+
 // 终局任务：播放结束语音后，根据状态跳结果页或返回上一页。
 async function runBattleEndTask(task, runId) {
-  const battleInfo = task.message;
-  applyBattleBase(battleInfo);
-  battleEnded = true;
-  clearXRingStreaks();
-  matchStatus.value = battleInfo.status;
-  if (battleInfo.status === 4) {
-    showRoundTip.value = true;
-    currentBluePoint.value = 0;
-    currentRedPoint.value = 0;
+  if (resultNavigationPending) {
+    notifyMatchAudioAck(task);
+    return;
  }

-  // 终局语音必须完整播完，再决定跳转或返回。
-  await playAudioKeys("比赛结束", { interrupt: false, timeout: AUDIO_TIMEOUT_MAX });
-  if (!isQueueAlive(runId)) return;
+  battleEndTaskRunning = true;
+  try {
+    const battleInfo = task.message;
+    applyBattleBase(battleInfo);
+    battleEnded = true;
+    matchStatus.value = battleInfo.status;
+    if (battleInfo.status === 4) {
+      showRoundTip.value = true;
+      currentBluePoint.value = 0;
+      currentRedPoint.value = 0;
+    }

-  if (matchStatus.value === 2) {
-    uni.redirectTo({
-      url: `/pages/friend-battle-result?battleId=${battleId.value}`,
-    });
-  } else if (matchStatus.value === 4) {
-    setTimeout(() => {
-      uni.navigateBack();
-    }, BATTLE_CANCEL_RETURN_DELAY);
+    // 终局语音必须完整播完，再决定跳转或返回。
+    await playAudioKeys("比赛结束", { interrupt: false, timeout: AUDIO_TIMEOUT_MAX });
+    notifyMatchAudioAck(task);
+    if (!isQueueAlive(runId)) return;
+
+    if (matchStatus.value === 2) {
+      navigateToBattleResultOnce(battleId.value);
+    } else if (matchStatus.value === 4) {
+      const roomNumber = battleInfo.roomId || store.game.roomNumber || store.game.roomID;
+      setTimeout(() => {
+        if (roomNumber) {
+          uni.redirectTo({
+            url: `/pages/battle-room?roomNumber=${encodeURIComponent(roomNumber)}&fromResult=1`,
+          });
+        } else {
+          uni.navigateBack();
+        }
+      }, BATTLE_CANCEL_RETURN_DELAY);
+    }
+  } finally {
+    battleEndTaskRunning = false;
  }
 }

 // 无效射击任务：弹 toast 并播报无效射击，不修改比赛主状态。
-async function runInvalidShotTask(runId) {
+async function runInvalidShotTask(task, runId) {
  if (!isQueueAlive(runId)) return;
  uni.showToast({
    title: "距离不足，无效",
    icon: "none",
  });
  await playAudioKeys("射击无效", { interrupt: false });
+  notifyMatchAudioAck(task);
 }

 // 回前台恢复入口：拉取服务端快照，处理结束态，然后继续消费增量队列。
 async function restoreLatestBattle() {
-  if (!battleId.value) return;
+  if (
+    !battleId.value ||
+    battleEnded ||
+    battleEndTaskRunning ||
+    resultNavigationPending
+  ) {
+    return;
+  }
  const currentRestoreId = ++restoreGeneration;
  showRestoreLoading();

@@ -1016,6 +1163,7 @@ async function restoreLatestBattle() {
    console.log("restore latest battle failed:", err);
  }
  if (currentRestoreId !== restoreGeneration) return;
+  result = normalizeBattleInfo(result);
  if (!result) {
    hideRestoreLoading();
    runBattleQueue();
@@ -1031,16 +1179,12 @@ async function restoreLatestBattle() {
  const restoreEventType = Number(result?.eventType || 0);

  if (result.status === 2) {
-    clearXRingStreaks();
    hideRestoreLoading();
-    uni.redirectTo({
-      url: `/pages/friend-battle-result?battleId=${result.matchId}`,
-    });
+    battleEnded = true;
+    if (!battleEndTaskRunning) navigateToBattleResultOnce(result.matchId);
    return;
  }
-  if (result.status === 4) {
-    clearXRingStreaks();
-  }
+  reconnectMatchServer(result);

  if (restoreEventType === MESSAGETYPESV2.NewRound) {
    const prevRound = getRestorePrevRound(result);
@@ -1070,6 +1214,8 @@ async function restoreLatestBattle() {
 }

 function scheduleRestoreLatestBattle() {
+  if (battleEnded || battleEndTaskRunning || resultNavigationPending) return;
+
  if (pendingRestoreTimer) {
    clearTimeout(pendingRestoreTimer);
    pendingRestoreTimer = null;
@@ -1086,6 +1232,18 @@ function scheduleRestoreLatestBattle() {
  }, RESTORE_EMPTY_ID_RETRY_DELAY);
 }

+function onMatchSocketState(event) {
+  if (event?.state !== "open" || event?.reconnected !== true) return;
+  if (
+    event.matchId &&
+    battleId.value &&
+    String(event.matchId) !== String(battleId.value)
+  ) {
+    return;
+  }
+  scheduleRestoreLatestBattle();
+}
+
 // 页面统一的 socket 回调，只负责把消息送进战况队列。
 function onReceiveMessage(message) {
  enqueueBattleMessage(message);
@@ -1094,10 +1252,13 @@ function onReceiveMessage(message) {
 // 新对局入口：彻底清空上一局残留的状态、队列和缓存。
 onLoad((options) => {
  console.log('重新进入了')
+  const returnSnapshot = options.fromReturn ? takeMatchReturnSnapshot() : null;
+  pendingReturnSnapshot = returnSnapshot;
+  skipNextRestoreOnShow = false;
  // 新对局入口：把所有会串场的状态、队列、时间戳和缓存一次性清空。
  start.value = null;
  tips.value = "";
-  battleId.value = options.battleId || "";
+  battleId.value = returnSnapshot?.matchId || options.battleId || "";
  currentRound.value = 0;
  roundTipRound.value = 0;
  goldenRound.value = 0;
@@ -1117,7 +1278,6 @@ onLoad((options) => {
  shootTimeTotal.value = DEFAULT_SHOOT_TIME;
  showOfflineModal.value = false;
  hideRestoreLoading();
-  loadXRingStreaks();
  queueGeneration += 1;
  battleQueue.value = [];
  queueRunning.value = false;
@@ -1126,6 +1286,8 @@ onLoad((options) => {
  restoreGeneration += 1;
  pendingRoundAudio = false;
  battleEnded = false;
+  battleEndTaskRunning = false;
+  resultNavigationPending = false;
  handledMessageKeys.clear();
  handledMessageKeyOrder.length = 0;
  queuedMessageKeys.clear();
@@ -1135,6 +1297,15 @@ onLoad((options) => {
  store.updateShotInfo(0, 0);
  store.updateTips("");
  latestShotFlash.value = null;
+  if (returnSnapshot) {
+    skipNextRestoreOnShow = true;
+    showRestoreLoading();
+    return;
+  }
+  const readySnapshot = takeReadySnapshot(battleId.value);
+  if (readySnapshot?.status === 0) {
+    applyBattleSnapshot(readySnapshot, { restore: true });
+  }
  scheduleRestoreLatestBattle();
 });

@@ -1149,11 +1320,20 @@ onMounted(async () => {
  uni.$on(AUDIO_INTERRUPTION_END_EVENT, handleBattleRecovered);
  uni.$on(PROGRESS_ZERO_EVENT, onProgressZero);
  uni.$on(COUNTDOWN_READY_EVENT, hideRestoreLoading);
+  uni.$on(MATCH_WS_STATE_EVENT, onMatchSocketState);
+  if (pendingReturnSnapshot) {
+    const returnSnapshot = pendingReturnSnapshot;
+    pendingReturnSnapshot = null;
+    reconnectMatchServer(returnSnapshot);
+    scheduleRestoreLatestBattle();
+  }
  await laserCloseAPI();
 });

 // 离开页面时清理监听、停止音频，并让当前队列整体失效。
 onBeforeUnmount(() => {
+  restoreGeneration += 1;
+  battleEndTaskRunning = false;
  uni.setKeepScreenOn({
    keepScreenOn: false,
  });
@@ -1161,12 +1341,15 @@ onBeforeUnmount(() => {
  uni.$off("audioEnded", onAudioEnded);
  uni.$off(PROGRESS_ZERO_EVENT, onProgressZero);
  uni.$off(COUNTDOWN_READY_EVENT, hideRestoreLoading);
+  uni.$off(MATCH_WS_STATE_EVENT, onMatchSocketState);
  if (pendingRestoreTimer) {
    clearTimeout(pendingRestoreTimer);
    pendingRestoreTimer = null;
  }
+  pendingReturnSnapshot = null;
  hideRestoreLoading();
  invalidateBattleQueue({ stopAudio: true, stopProgress: true });
+  closeBattleServer("team-battle-unmount");
  console.log('onBeforeUnmount', '页面卸载前')
  audioManager.stopAll();
  uni.$off(AUDIO_INTERRUPTION_BEGIN_EVENT, handleBattleCovered);
@@ -1176,11 +1359,16 @@ onBeforeUnmount(() => {
 onHide(()=>{
  console.log('onHide', '页面大退')
  handleBattleCovered();
+  closeBattleServer("team-battle-hide");
 })

 // 每次回到前台都重新拉最新比赛快照，确保画面与后端一致。
 onShow(() => {
  console.log('onshow')
+  if (skipNextRestoreOnShow) {
+    skipNextRestoreOnShow = false;
+    return;
+  }
  scheduleRestoreLatestBattle();
 });
 </script>
@@ -1199,7 +1387,12 @@ onShow(() => {
          :blueTeam="blueTeam"
          :winner="0"
      />
-      <TestDistance v-if="start === false" :guide="false" :isBattle="true"/>
+      <TestDistance
+          v-if="start === false"
+          :guide="false"
+          :isBattle="true"
+          :count="readyTime"
+      />
      <!-- 比赛进行中显示：左右队伍、进度条、靶面和底部比分。 -->
      <view v-if="start" class="players-row">
        <TeamAvatars
@@ -0,0 +1,116 @@
+<script setup>
+import AppBackground from "@/components/AppBackground.vue";
+import Avatar from "@/components/Avatar.vue";
+import BowTarget from "./BowTarget.vue";
+import ScorePanel from "./ScorePanel.vue";
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+const store = useStore();
+const { user } = storeToRefs(store);
+
+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="10" />
+    <view class="header">
+      <view>
+        <Avatar :src="user.avatar" :rankLvl="user.rankLvl" :size="45" />
+        <view>
+          <text>{{ user.nickName }}</text>
+          <text>{{ user.lvlName }}</text>
+        </view>
+      </view>
+      <view @click="onClose">
+        <image src="/static/close-white.png" mode="widthFix" />
+      </view>
+    </view>
+    <view :style="{ width: '100%', marginBottom: '20px' }">
+      <BowTarget :scores="arrows" />
+    </view>
+    <view class="desc">
+      <text>{{ arrows.length }}</text>
+      <text>支箭，共</text>
+      <text>{{ arrows.reduce((a, b) => a + (b.ring || 0), 0) }}</text>
+      <text>环</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;
+}
+.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>
@@ -0,0 +1,665 @@
+<script setup>
+import {
+  computed,
+  onBeforeUnmount,
+  onMounted,
+  ref,
+  watch,
+} from "vue";
+import PointSwitcher from "@/components/PointSwitcher.vue";
+import TargetCanvas from "@/components/TargetCanvas.vue";
+
+import { MESSAGETYPES, MESSAGETYPESV2 } from "@/constants";
+import { simulShootAPI } 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: () => [],
+  },
+  mode: {
+    type: String,
+    default: "solo", // solo 单排，team 双排
+  },
+  stop: {
+    type: Boolean,
+    default: false,
+  },
+  coordinateRadius: {
+    type: Number,
+    default: 20,
+  },
+  hitRadiusPx: {
+    type: Number,
+    default: 2,
+  },
+  zoomHitRadiusPx: {
+    type: Number,
+    default: 5,
+  },
+  showCrosshair: {
+    type: Boolean,
+    default: false,
+  },
+  showQuadrantLabels: {
+    type: Boolean,
+    default: false,
+  },
+  quadrantLabels: {
+    type: Object,
+    default: () => ({
+      1: "1",
+      2: "2",
+      3: "3",
+      4: "4",
+    }),
+  },
+  highlightAreas: {
+    type: Array,
+    default: () => [],
+  },
+});
+
+const pMode = ref(true);
+const latestOne = ref(null);
+const bluelatestOne = ref(null);
+const prevScores = ref([]);
+const prevBlueScores = ref([]);
+const timer = ref(null);
+const dirTimer = ref(null);
+const angle = ref(null);
+const circleColor = ref("");
+const ROUND_TIP_OFFSET_Y = -32;
+const EXPERIENCE_TIP_OFFSET_Y = -68;
+
+const getNumber = (value, fallback = 0) => {
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) ? numberValue : fallback;
+};
+
+const safeTargetRadius = computed(() => {
+  return Math.max(getNumber(props.coordinateRadius, 20), 1);
+});
+
+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 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 }
+  );
+}
+
+watch(
+  () => props.scores,
+  (newVal) => {
+    if (newVal.length - prevScores.value.length === 1) {
+      latestOne.value = newVal[newVal.length - 1];
+      if (timer.value) clearTimeout(timer.value);
+      timer.value = setTimeout(() => {
+        latestOne.value = null;
+      }, 1000);
+    }
+    prevScores.value = [...newVal];
+  },
+  {
+    deep: true,
+  }
+);
+
+watch(
+  () => props.blueScores,
+  (newVal) => {
+    if (newVal.length - prevBlueScores.value.length === 1) {
+      bluelatestOne.value = newVal[newVal.length - 1];
+      if (timer.value) clearTimeout(timer.value);
+      timer.value = setTimeout(() => {
+        bluelatestOne.value = null;
+      }, 1000);
+    }
+    prevBlueScores.value = [...newVal];
+  },
+  {
+    deep: true,
+  }
+);
+
+const simulShoot = async () => {
+  if (device.value.deviceId) await simulShootAPI(device.value.deviceId);
+};
+const simulShoot2 = async () => {
+  if (device.value.deviceId) {
+    const r1 = Math.random() > 0.5 ? 0.01 : 0.02;
+    await simulShootAPI(device.value.deviceId, r1, r1);
+  }
+};
+
+const 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%)`,
+  };
+});
+
+const currentArrowIndex = computed(() => {
+  return props.scores.length + props.blueScores.length + 1;
+});
+
+const getHighlightArrowIndex = (area = {}) => {
+  const arrowIndex = Number(area.arrowIndex ?? area.arrowNo ?? area.arrow);
+  return Number.isInteger(arrowIndex) && arrowIndex > 0 ? arrowIndex : null;
+};
+
+const currentHighlightAreas = computed(() => {
+  if (!Array.isArray(props.highlightAreas) || props.highlightAreas.length === 0) {
+    return [];
+  }
+
+  const hasExplicitArrowIndex = props.highlightAreas.some((area = {}) => {
+    return getHighlightArrowIndex(area) !== null;
+  });
+
+  const matchedAreas = props.highlightAreas.filter((area = {}) => {
+    return getHighlightArrowIndex(area) === currentArrowIndex.value;
+  });
+
+  if (hasExplicitArrowIndex) {
+    return matchedAreas;
+  }
+
+  if (props.highlightAreas.length === 1) {
+    return props.highlightAreas.slice(0, 1);
+  }
+
+  const currentArea = props.highlightAreas[currentArrowIndex.value - 1];
+  return currentArea ? [currentArea] : [];
+});
+
+const showHighlightCanvas = computed(() => {
+  return props.totalRound > 0 && currentHighlightAreas.value.length > 0;
+});
+
+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);
+});
+
+onBeforeUnmount(() => {
+  if (timer.value) {
+    clearTimeout(timer.value);
+    timer.value = null;
+  }
+  if (dirTimer.value) {
+    clearTimeout(dirTimer.value);
+    dirTimer.value = null;
+  }
+  uni.$off("socket-inbox", onReceiveMessage);
+});
+</script>
+
+<template>
+  <view class="container">
+    <!-- <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">
+      <image
+        class="target-image"
+        src="../../../static/bow-target.png"
+        mode="aspectFit"
+      />
+      <TargetCanvas
+        v-if="showHighlightCanvas"
+        class="target-highlight-layer"
+        :coordinateRadius="coordinateRadius"
+        :showCrosshair="false"
+        :showQuadrantLabels="false"
+        :showRingLabels="false"
+        :highlightOnly="true"
+        :highlightAreas="currentHighlightAreas"
+      />
+      <view v-if="angle !== null" class="arrow-dir" :style="arrowStyle">
+        <view :style="{ background: circleColor }">
+          <image src="../../../static/dot-circle.png" mode="widthFix" />
+        </view>
+      </view>
+      <view v-if="stop" class="stop-sign">中场休息</view>
+      <view
+        v-if="latestOne && latestOne.ring && user.id === latestOne.playerId"
+        class="e-value fade-in-out"
+        :style="getExperienceTipStyle(latestOne)"
+      >
+        经验 +1
+      </view>
+      <view
+        v-if="latestOne"
+        class="round-tip fade-in-out"
+        :style="getRoundTipStyle(latestOne)"
+        >{{ latestOne.ringX ? "X" : latestOne.ring || "未上靶"
+        }}<text v-if="latestOne.ring">环</text>
+      </view>
+      <view
+        v-if="
+          bluelatestOne &&
+          bluelatestOne.ring &&
+          user.id === bluelatestOne.playerId
+        "
+        class="e-value fade-in-out"
+        :style="getExperienceTipStyle(bluelatestOne)"
+      >
+        经验 +1
+      </view>
+      <view
+        v-if="bluelatestOne"
+        class="round-tip fade-in-out"
+        :style="getRoundTipStyle(bluelatestOne)"
+        >{{ bluelatestOne.ringX ? "X" : bluelatestOne.ring || "未上靶"
+        }}<text v-if="bluelatestOne.ring">环</text></view
+      >
+      <block v-for="(bow, index) in scores" :key="index">
+        <view
+          v-if="bow.ring > 0"
+          :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">
+        <view
+          v-if="bow.ring > 0"
+          :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>
+    </view>
+    <view class="footer">
+      <PointSwitcher
+        :onChange="(val) => (pMode = val)"
+        :style="{ zIndex: 999 }"
+      />
+    </view>
+    <view class="simul" v-if="env !== 'release'">
+      <button @click="simulShoot">模拟</button>
+      <button @click="simulShoot2">射箭</button>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.container {
+  width: calc(100vw - 30px);
+  height: calc(100vw - 30px);
+  padding: 0px 15px;
+  position: relative;
+}
+.target {
+  position: relative;
+  margin: 10px;
+  width: calc(100% - 20px);
+  height: calc(100% - 20px);
+  z-index: 0;
+}
+.target-image {
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 100%;
+  height: 100%;
+  z-index: 0;
+  pointer-events: none;
+}
+.target-highlight-layer {
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 100%;
+  height: 100%;
+  z-index: 1;
+  pointer-events: none;
+}
+.e-value {
+  position: absolute;
+  background-color: #0006;
+  color: #fff;
+  font-size: 12px;
+  padding: 4px 7px;
+  border-radius: 5px;
+  z-index: 4;
+  width: 50px;
+  text-align: center;
+}
+.round-tip {
+  position: absolute;
+  color: #fff;
+  font-size: 30px;
+  font-weight: bold;
+  z-index: 4;
+  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;
+}
+.hit {
+  position: absolute;
+  border-radius: 50%;
+  z-index: 3;
+  color: #fff;
+  transition: all 0.3s ease;
+  box-sizing: border-box;
+}
+.s-point {
+}
+.b-point {
+  border: 1px solid #fff;
+  z-index: 3;
+  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 target-pump-in {
+  from {
+    transform: translate(-50%, -50%) scale(2);
+  }
+
+  to {
+    transform: translate(-50%, -50%) scale(1);
+  }
+}
+.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: 5;
+  font-weight: bold;
+}
+.arrow-dir {
+  position: absolute;
+  width: 100%;
+  height: 52%;
+  left: 50%;
+  bottom: 50%;
+  z-index: 4;
+  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>
@@ -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("../static/bubble-tip.png");
+  width: 157rpx;
+  height: 105rpx;
+  padding-top: 10px;
+  padding-left: 30rpx;
+}
+.normal2 {
+  background-image: url("../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("../static/bubble-tip2.png");
+  width: 370rpx;
+  height: 70rpx;
+  top: -50%;
+  left: 49%;
+}
+.short {
+  background-image: url("../static/bubble-tip3.png");
+  width: 300rpx;
+  height: 70rpx;
+  top: -50%;
+  right: -1%;
+}
+</style>
@@ -0,0 +1,157 @@
+<script setup>
+import { ref, watch, onMounted, onBeforeUnmount } 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 bgImages = [
+  "../static/complete-light1.png",
+  "../static/complete-light2.png",
+];
+const bgIndex = ref(0);
+
+const getDisplayText = (arrow) => {
+  if (!arrow) return "-";
+  if (arrow.ringX) return "X";
+  return arrow.ring ?? "-";
+};
+
+const isLowScore = (arrow) => {
+  if (!arrow || arrow.ringX) return false;
+  const ring = Number(arrow.ring);
+  return Number.isFinite(ring) && ring < 6;
+};
+
+watch(
+  () => props.total,
+  (newValue) => {
+    items.value = new Array(newValue).fill(9);
+  }
+);
+const timer = ref(null);
+onMounted(() => {
+  timer.value = setInterval(() => {
+    bgIndex.value = bgIndex.value === 0 ? 1 : 0;
+  }, 200);
+});
+onBeforeUnmount(() => {
+  if (timer.value) {
+    clearInterval(timer.value);
+  }
+});
+</script>
+<template>
+  <view class="container">
+    <image
+      v-if="total > 0 && arrows.length === total && completeEffect"
+      :src="bgImages[bgIndex]"
+      class="complete-light"
+      :style="{
+        width: `calc(${(100 / (rowCount + 2)) * rowCount}vw + ${
+          (100 / (total * 2)) * (rowCount * 2 + (total === 12 ? 8 : 24))
+        }px)`,
+        height: `calc(${(100 / (rowCount + 2)) * (total / rowCount)}vw + ${
+          (100 / (total * 2)) *
+          ((total / rowCount) * 2 + (total === 12 ? 7 : 24))
+        }px)`,
+        top: `${total === 12 ? -2 : -3}vw`,
+      }"
+    />
+    <view
+      v-for="(_, index) in items"
+      :key="index"
+      class="score-item"
+    >
+      <image
+        class="score-item-bg"
+        :src="
+          isLowScore(arrows[index])
+            ? '/static/training-difficulty-design/block-gray.png'
+            : '/static/training-difficulty-design/block-gold.png'
+        "
+      />
+      <text
+        class="score-value"
+        :class="{ 'score-value--low': isLowScore(arrows[index]) }"
+      >
+        {{ getDisplayText(arrows[index]) }}
+      </text>
+    </view>
+  </view>
+</template>
+
+<style scoped lang="scss">
+.container {
+  width: 100%;
+  display: flex;
+  flex-wrap: wrap;
+  box-sizing: border-box;
+  position: relative;
+  padding: 30rpx 40rpx 0 40rpx;
+}
+.score-item {
+  position: relative;
+  width: 100rpx;
+  height: 56rpx;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  overflow: hidden;
+  margin-right: 14rpx;
+  margin-bottom: 14rpx;
+}
+
+.score-item:nth-child(6n) {
+  margin-right: 0;
+}
+
+.score-item-bg {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100rpx;
+  height: 56rpx;
+}
+
+.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);
+}
+
+.complete-light {
+  position: absolute;
+}
+</style>
@@ -0,0 +1,109 @@
+<script setup>
+import { computed } from "vue";
+
+const props = defineProps({
+  arrows: {
+    type: Array,
+    default: () => [],
+  },
+  total: {
+    type: Number,
+    default: 0,
+  },
+});
+
+const getDisplayText = (arrow = {}) => {
+  if (!arrow) return "";
+  if (!arrow.ring) return "-";
+  return arrow.ringX ? "X" : String(arrow.ring);
+};
+
+const isLowScore = (arrow = {}) => {
+  if (!arrow || arrow.ringX) return false;
+  return Number(arrow.ring) < 6;
+};
+
+const displayArrows = computed(() => {
+  const list = [...props.arrows];
+  if (props.total > 0 && list.length < props.total) {
+    list.push(null);
+  }
+  return list;
+});
+</script>
+
+<template>
+  <view v-if="displayArrows.length" class="score-panel">
+    <view class="score-grid">
+      <view
+        v-for="(arrow, index) in displayArrows"
+        :key="index"
+        class="score-card"
+      >
+        <image class="score-card-bg" :src="isLowScore(arrow)?'/static/training-difficulty-design/block-gray.png':'/static/training-difficulty-design/block-gold.png'"></image>
+        <text
+          class="score-value"
+          :class="{ 'score-value--low': isLowScore(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-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-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>
@@ -0,0 +1,628 @@
+<script setup>
+import { ref, onMounted, computed } from "vue";
+import ScreenHint from "./ScreenHint.vue";
+import BowData from "./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: () => { },
+  },
+  onRetry: {
+    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 closePanel = () => {
+  showPanel.value = false;
+  setTimeout(() => {
+    props.onClose();
+  }, 300);
+};
+
+const retryPractice = () => {
+  showPanel.value = false;
+  setTimeout(() => {
+    props.onRetry();
+  }, 300);
+};
+
+function onClickShare() {
+  uni.$emit("share-image");
+}
+
+onMounted(() => {
+  if (props.result.lvl > user.value.lvl) {
+    showUpgrade.value = true;
+  }
+});
+
+const details = computed(() => props.result.details || []);
+
+const arrows = computed(() => {
+  const data = new Array(props.total).fill(null);
+  details.value.forEach((arrow, index) => {
+    data[index] = arrow;
+  });
+  return data;
+});
+
+const validArrows = computed(() => arrows.value.filter((a) => !!a?.ring).length);
+const totalRing = computed(() =>
+  details.value.reduce((last, next) => last + (Number(next.ring) || 0), 0)
+);
+
+const gainedExp = computed(
+  () => props.result.exp || props.result.experience || validArrows.value
+);
+
+const currentLevel = computed(
+  () => props.result.lvl || user.value.lvl || user.value.rankLvl || 1
+);
+
+const currentExp = computed(
+  () => props.result.currentExp || props.result.score || user.value.scores || 0
+);
+
+const nextExp = computed(
+  () => props.result.nextExp || props.result.upgradeScore || 100
+);
+
+const expPercent = computed(() => {
+  if (!nextExp.value) return 0;
+  return Math.min(100, Math.max(0, (currentExp.value / nextExp.value) * 100));
+});
+
+const findValue = (...keys) => {
+  const item = keys.find((key) => props.result[key] !== undefined);
+  return item ? props.result[item] : undefined;
+};
+
+const formatDuration = (value) => {
+  const seconds = Number(value || 0);
+  if (!seconds) return "--";
+  const minutes = Math.floor(seconds / 60);
+  const rest = seconds % 60;
+  return minutes ? `${minutes}分${rest}秒` : `${rest}秒`;
+};
+
+const usedTime = computed(() =>
+  findValue("duration", "usedTime", "shootTime", "time")
+);
+
+const hitCompare = computed(
+  () => Number(findValue("hitCompare", "hitDiff", "hitDelta") || 0)
+);
+
+const timeCompare = computed(
+  () => Number(findValue("timeCompare", "timeDiff", "durationDiff") || 0)
+);
+
+const calories = computed(
+  () => Number(findValue("calories", "calorie", "kcal") || 0)
+);
+</script>
+
+<template>
+  <view :class="['result-mask', showPanel ? 'result-mask--show' : 'result-mask--hide']">
+    <image class="hero-glow" src="/static/training-difficulty-design/result-bg.png" mode="widthFix" />
+    <view class="result-title">
+      <image class="result-title-bg" src="/static/training-difficulty-design/result-t-bg.png" mode="widthFix" />
+      <view class="result-title-text">Lv{{ currentLevel }}</view>
+    </view>
+
+    <view class="result-panel">
+      <view class="line-top"></view>
+      <view class="line-bottom"></view>
+      <view class="stats">
+        <view class="stat-row">
+          <image class="stat-bg" src="/static/training-difficulty-design/result-c-bg.png" mode="scaleToFill" />
+          <view class="stat-cell">
+            <text class="stat-label">共命中目标</text>
+            <view class="stat-value">
+              <text>{{ validArrows }}</text>
+              <text class="stat-unit">次</text>
+            </view>
+          </view>
+          <view class="stat-divider"></view>
+          <view class="stat-cell stat-cell--compare">
+            <text class="stat-label">对比上次</text>
+            <view class="stat-value">
+              <text>{{ Math.abs(hitCompare) }}</text>
+              <text class="stat-unit">次</text>
+              <image class="trend-icon" :class="{ 'trend-icon--down': hitCompare < 0 }"
+                src="/static/training-difficulty-design/result-up.png" mode="widthFix" />
+            </view>
+          </view>
+        </view>
+
+        <view class="stat-row">
+          <image class="stat-bg" src="/static/training-difficulty-design/result-c-bg.png" mode="scaleToFill" />
+          <view class="stat-cell">
+            <text class="stat-label">用时</text>
+            <view class="stat-value">
+              <text>{{ formatDuration(usedTime) }}</text>
+            </view>
+          </view>
+          <view class="stat-divider"></view>
+          <view class="stat-cell stat-cell--compare">
+            <text class="stat-label">对比上次</text>
+            <view class="stat-value">
+              <text>{{ formatDuration(Math.abs(timeCompare)) }}</text>
+              <image class="trend-icon" :class="{ 'trend-icon--down': timeCompare <= 0 }"
+                src="/static/training-difficulty-design/result-up.png" mode="widthFix" />
+            </view>
+          </view>
+        </view>
+         <view class="stat-row">
+          <image class="stat-bg" src="/static/training-difficulty-design/result-c-bg.png" mode="scaleToFill" />
+          <view class="stat-cell">
+            <text class="stat-label">消耗卡路里</text>
+            <view class="stat-value">
+              <text>{{ calories }}卡</text>
+            </view>
+          </view>
+          <text class="stat-equal">≈</text>
+          <!-- <view class="stat-divider"></view> -->
+          <view class="stat-cell stat-cell--compare">
+            <view class="stat-value">
+              <image v-for="index in 3" :key="index" class="rice-icon"
+                  src="/static/training-difficulty-design/result-rice.png" mode="widthFix" />
+            </view>
+          </view>
+        </view>
+
+     
+        <view class="actions">
+          <view class="action-item" @click="() => (showBowData = true)">
+            <image class="action-icon" src="/static/training-difficulty-design/result-icon-1.png" mode="widthFix" />
+            <text>查看靶纸</text>
+          </view>
+          <view v-if="validArrows === total" class="action-item" @click="() => (showComment = true)">
+            <image class="action-icon" src="/static/training-difficulty-design/result-icon-2.png" mode="widthFix" />
+            <text>教练点评</text>
+          </view>
+          <view v-if="validArrows === total" class="action-item" @click="onClickShare">
+            <image class="action-icon" src="/static/training-difficulty-design/result-icon-3.png" mode="widthFix" />
+            <text>分享成绩</text>
+          </view>
+        </view>
+      </view>
+    </view>
+    <view class="oper-box">
+      <view class="exp-area">
+        <text class="exp-gain">+{{ gainedExp }}经验</text>
+        <view class="level-progress">
+          <text class="level-text">LV.{{ currentLevel }}</text>
+          <view class="progress-track">
+            <view class="progress-fill" :style="{ width: `${expPercent}%` }"></view>
+          </view>
+          <text class="progress-text">{{ currentExp }} / {{ nextExp }}</text>
+        </view>
+      </view>
+
+      <view class="footer-actions">
+        <view class="result-btn result-btn--muted" @click="closePanel">
+          <text>{{ validArrows === total ? "完成" : "返回" }}</text>
+        </view>
+        <view class="result-btn result-btn--primary" @click="retryPractice">
+          <text>再来一次</text>
+        </view>
+      </view>
+    </view>
+
+    <ScreenHint :show="showComment" :onClose="() => (showComment = false)" mode="tall">
+      <view class="coach-comment">
+        <text>
+          您本次练习取得了<text class="gold-text">{{ totalRing }}</text>环的成绩，所有箭支上靶后的平均点间距离为<text class="gold-text">{{
+            Number((result.average_distance || 0).toFixed(2))
+            }}</text>，{{
+              result.spreadEvaluation === "Dispersed"
+                ? "还需要持续改进哦~"
+                : "成绩优秀。"
+            }}
+        </text>
+        <view>
+          <image src="https://static.shelingxingqiu.com/attachment/2025-11-26/deihtj15xjwcz3c1tx.png" mode="widthFix" />
+          <text class="coach-suggestion">
+            针对您本次的练习，{{
+              result.spreadEvaluation === "Dispersed"
+                ? "我们建议您充分练习推弓、靠位以及撒放动作一致性。"
+                : totalRing >= 100
+                  ? "我们建议您继续保持即可。"
+                  : `我们建议您将设备的瞄准器${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 lang="scss">
+.result-mask {
+  width: 100vw;
+  height: 100vh;
+  position: fixed;
+  top: 0;
+  left: 0;
+  overflow: hidden;
+  background:
+    linear-gradient(180deg,
+      rgba(24, 22, 17, 0.38) 0%,
+      rgba(24, 22, 17, 0.56) 28%,
+      rgba(17, 17, 25, 0.92) 58%),
+    rgba(0, 0, 0, 0.72);
+  z-index: 999;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-direction: column;
+}
+
+.result-mask--show {
+  opacity: 1;
+}
+
+.result-mask--hide {
+  opacity: 0;
+  transition: opacity 0.3s ease;
+}
+
+.hero-glow {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+}
+
+.result-title {
+  position: relative;
+  width: 100%;
+  height: 264rpx;
+  z-index: 2;
+}
+
+.result-title-bg {
+  width: 100%;
+  height: 264rpx;
+  display: block;
+}
+
+.result-title-text {
+  width: 100%;
+  font-size: 28rpx;
+  color: #FBFCE6;
+  font-weight: 600;
+  line-height: 40rpx;
+  text-align: center;
+  position: absolute;
+  top: 116rpx;
+  left: 0;
+}
+
+.result-panel {
+  width: 100vw;
+  height: 634rpx;
+  padding: 144rpx 80rpx 0 80rpx;
+  box-sizing: border-box;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  background: rgba(0, 0, 0, 0.8);
+  z-index: 1;
+  margin-top: -100rpx;
+  position: relative;
+}
+
+.stats {
+  width: 100%;
+  margin-top: 34rpx;
+}
+
+.line-top {
+  background: linear-gradient(45deg, rgba(205, 183, 122, 0) 0%, #CDB77A 49.92%, rgba(205, 183, 122, 0) 100%);
+  width: 100%;
+  height: 4rpx;
+  opacity: 0.9;
+  position: absolute;
+  top: 2rpx;
+  left: 0;
+}
+
+.line-bottom {
+  background: linear-gradient(45deg, rgba(205, 183, 122, 0) 0%, #CDB77A 49.92%, rgba(205, 183, 122, 0) 100%);
+  width: 100%;
+  height: 4rpx;
+  opacity: 0.9;
+  position: absolute;
+  bottom: 2rpx;
+  left: 0;
+}
+
+.stat-row {
+  width: 100%;
+  height: 62rpx;
+  position: relative;
+  display: flex;
+  align-items: center;
+  margin-bottom: 52rpx;
+  // border: 2rpx solid rgba(209, 184, 125, 0.72);
+  // border-radius: 14rpx;
+  transform: skewX(-12deg);
+  box-sizing: border-box;
+}
+
+.stat-cell {
+  flex: 1;
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  transform: skewX(12deg);
+}
+
+.stat-bg {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 582rpx;
+  height: 62rpx;
+}
+
+.stat-cell--compare {
+  padding-left: 8rpx;
+  box-sizing: border-box;
+}
+
+.stat-label {
+  position: absolute;
+  top: -30rpx;
+  color: rgba(255, 255, 255, 0.7);
+  font-size: 20rpx;
+  line-height: 1;
+}
+
+.stat-value {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 120rpx;
+  color: #F3E0B9;
+  font-size: 32rpx;
+  line-height: 1;
+  font-weight: 700;
+  font-style: italic;
+}
+
+.stat-unit {
+  margin-left: 4rpx;
+  font-size: 24rpx;
+}
+
+.stat-divider {
+  width: 2rpx;
+  height: 34rpx;
+  background: rgba(197, 160, 92, 0.64);
+  transform: skewX(12deg);
+}
+
+.stat-equal{
+  width: 30rpx;
+  height: 40rpx;
+  color: #F3E0B9;
+  font-size: 30rpx;
+  margin-left: 10rpx;
+}
+
+.trend-icon {
+  width: 28rpx;
+  height: 42rpx;
+  margin-left: 16rpx;
+}
+
+.trend-icon--down {
+  transform: rotate(180deg);
+}
+
+.stat-bg {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 582rpx;
+  height: 62rpx;
+}
+
+.rice-list {
+  width: 160rpx;
+  display: flex;
+  align-items: center;
+}
+
+.rice-icon {
+  width: 36rpx;
+  height: 34rpx;
+  margin-right: 14rpx;
+}
+
+.oper-box {
+  position: relative;
+  z-index: 1;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  width: 598rpx;
+}
+
+.actions {
+  width: 350rpx;
+  display: flex;
+  justify-content: space-between;
+  margin: 0 auto;
+  margin-top: 38rpx;
+}
+
+.action-item {
+  width: 80rpx;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+
+.action-icon {
+  width: 70rpx;
+  height: 68rpx;
+}
+
+.action-item>text {
+  margin-top: 4rpx;
+  color: #FAE6BC;
+  font-size: 20rpx;
+  line-height: 1;
+  white-space: nowrap;
+}
+
+.exp-area {
+  width: 100%;
+  margin-top: auto;
+  padding-top: 122rpx;
+}
+
+.exp-gain {
+  display: block;
+  margin-bottom: 14rpx;
+  color: #f6e3b2;
+  font-size: 22rpx;
+  line-height: 1;
+  text-align: center;
+}
+
+.level-progress {
+  display: flex;
+  align-items: center;
+  width: 100%;
+}
+
+.level-text,
+.progress-text {
+  color: rgba(255, 255, 255, 0.86);
+  font-size: 24rpx;
+  line-height: 1;
+}
+
+.level-text {
+  min-width: 60rpx;
+}
+
+.progress-text {
+  min-width: 72rpx;
+  text-align: right;
+}
+
+.progress-track {
+  flex: 1;
+  height: 10rpx;
+  margin: 0 14rpx;
+  border-radius: 999rpx;
+  overflow: hidden;
+  background: rgba(255, 255, 255, 0.26);
+}
+
+.progress-fill {
+  height: 100%;
+  border-radius: 999rpx;
+  background: linear-gradient(90deg, #ff940f 0%, #ffbb33 58%, #fff0a7 100%);
+}
+
+.footer-actions {
+  width: 100%;
+  display: flex;
+  justify-content: center;
+  margin-top: 70rpx;
+}
+
+.result-btn {
+  width: 234rpx;
+  height: 72rpx;
+  border-radius: 999rpx;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin: 0 18rpx;
+}
+
+.result-btn>text {
+  font-size: 28rpx;
+  line-height: 1;
+  font-weight: 700;
+}
+
+.result-btn--muted {
+  color: #ffffff;
+  background: rgba(255, 255, 255, 0.2);
+}
+
+.result-btn--primary {
+  background: #FED847;
+  color: #151515;
+}
+
+.gold-text {
+  color: #fed847;
+}
+
+.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;
+}
+
+.coach-suggestion {
+  margin-top: 12px;
+}
+</style>
@@ -0,0 +1,89 @@
+<script setup>
+import IconButton from "@/components/IconButton.vue";
+
+const props = defineProps({
+  show: {
+    type: Boolean,
+    default: false,
+  },
+  onClose: {
+    type: Function,
+    default: null,
+  },
+  mode: {
+    type: String,
+    default: "normal",
+  },
+});
+const getContentHeight = () => {
+  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="/static/screen-hint-bg.png"
+        mode="widthFix"
+      />
+      <image
+        v-if="mode === 'tall'"
+        src="/static/coach-comment.png"
+        mode="widthFix"
+      />
+      <image
+        v-if="mode === 'square'"
+        src="/static/prompt-bg-square.png"
+        mode="widthFix"
+      />
+      <image
+        v-if="mode === 'small'"
+        src="/static/finish-frame.png"
+        mode="widthFix"
+      />
+      <slot />
+    </view>
+    <IconButton
+      v-if="!!onClose"
+      src="/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: -18vw;
+  z-index: -1;
+  transform: translateY(-75px);
+}
+</style>
@@ -0,0 +1,387 @@
+<script setup>
+import { ref, watch, onMounted, onBeforeUnmount, computed } from "vue";
+import audioManager from "@/audioManager";
+import { MESSAGETYPESV2 } from "@/constants";
+import { getDirectionText } from "@/util";
+import Avatar from "@/components/Avatar.vue";
+
+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,
+  },
+  onStop: {
+    type: Function,
+    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 halfTime = ref(false);
+const wait = ref(0);
+const transitionStyle = ref("all 1s linear");
+
+const progressPercent = computed(() => {
+  if (!props.total) return 0;
+  return Math.max(0, Math.min(100, (remain.value / props.total) * 100));
+});
+
+const displayName = computed(() => {
+  return (
+    user.value?.nickName ||
+    user.value?.nickname ||
+    user.value?.name ||
+    "Archer"
+  );
+});
+
+const avatarSrc = computed(() => {
+  return user.value?.avatar || "/static/shooter2.png";
+});
+
+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 ? "中场休息" : `中场休息(${wait.value}秒)`;
+  }
+  return props.start && remain.value === 0 ? "时间到！" : 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) {
+    halfTime.value = false;
+    audioManager.play("比赛开始");
+  } else if (msg.type === MESSAGETYPESV2.BattleEnd) {
+    audioManager.play("比赛结束", false);
+  } else if (msg.type === MESSAGETYPESV2.ShootResult) {
+    let arrow = {};
+    if (msg.details && Array.isArray(msg.details)) {
+      arrow = msg.details[msg.details.length - 1];
+    } else {
+      if (msg.shootData.playerId !== user.value.id) return;
+      if (msg.shootData) arrow = msg.shootData;
+    }
+    let key = [];
+    key.push(arrow.ring ? `${arrow.ringX ? "X" : arrow.ring}环` : "未上靶");
+    if (arrow.angle !== null) {
+      key.push(`向${getDirectionText(arrow.angle)}调整`);
+    }
+    audioManager.play(key, false);
+  } else if (msg.type === MESSAGETYPESV2.HalfRest) {
+    halfTime.value = true;
+    audioManager.play("中场休息");
+  } else if (msg.type === MESSAGETYPESV2.InvalidShot) {
+    uni.showToast({
+      title: "距离不足，无效",
+      icon: "none",
+    });
+    audioManager.play("射击无效");
+  }
+}
+
+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 v-if="show" class="progress-card">
+    <view class="progress-card__header">
+      <view class="progress-card__profile">
+        <view class="progress-card__avatar-shell">
+          <Avatar
+            :src="avatarSrc"
+            :size="80"
+            size-unit="rpx"
+            image-mode="aspectFill"
+          />
+        </view>
+        <text class="progress-card__name">{{ displayName }}</text>
+      </view>
+
+      <!-- <button class="progress-card__sound" hover-class="none" @click="updateSound">
+        <image
+          class="progress-card__sound-icon"
+          :src="`/static/sound${sound ? '' : '-off'}-yellow.png`"
+          mode="aspectFit"
+        />
+      </button> -->
+    </view>
+
+    <view class="progress-card__track-wrap">
+      <image
+          class="progress-card__titile"
+          src="../../../static/training-difficulty-design/text-icon-cgxl.png"
+          mode="aspectFit"
+        />
+      <view class="progress-card__track">
+        <view
+          class="progress-card__fill"
+          :style="{
+            width: `${progressPercent}%`,
+            backgroundColor: barColor,
+            right: tips.includes('红队') ? 0 : 'unset',
+            transition: transitionStyle,
+          }"
+        />
+        <view class="progress-card__badge">
+          <text class="progress-card__badge-text">剩余{{ remain }}秒</text>
+        </view>
+      </view>
+      <!-- <text v-if="tipContent" class="progress-card__tip">{{ tipContent }}123</text> -->
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.progress-card {
+  box-sizing: border-box;
+  /* padding: 50rpx 30rpx 0 30rpx; */
+  margin: 70rpx 30rpx 0 30rpx;
+}
+
+.progress-card__header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+}
+
+.progress-card__profile {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+}
+
+.progress-card__avatar-shell {
+  width: 86rpx;
+  height: 86rpx;
+  padding: 3rpx;
+  box-sizing: border-box;
+  border-radius: 50%;
+  background: linear-gradient(180deg, rgba(255, 209, 153, 1), rgba(162, 119, 55, 1));
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.progress-card__avatar {
+  width: 100%;
+  height: 100%;
+  display: block;
+  border-radius: 50%; 
+}
+
+.progress-card__name {
+  width: 86rpx;
+  color: #E7BA80;
+  font-size: 18rpx;
+  line-height: 1;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  text-align: center;
+  margin-top: 10rpx;
+}
+
+.progress-card__sound {
+  width: 68rpx;
+  height: 68rpx;
+  margin: 0;
+  padding: 0;
+  border: none;
+  border-radius: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: rgba(28, 24, 21, 0.72);
+  box-shadow: 0 8rpx 18rpx rgba(0, 0, 0, 0.18);
+}
+
+.progress-card__sound::after {
+  border: none;
+}
+
+.progress-card__sound-icon {
+  width: 34rpx;
+  height: 34rpx;
+}
+
+.progress-card__track-wrap {
+  margin-top: -156rpx;
+  padding-left: 102rpx;
+}
+
+.progress-card__titile{
+  width: 260rpx;
+  height: 72rpx;
+  margin-left: 110rpx;
+}
+
+.progress-card__track {
+  position: relative;
+  width: 100%;
+  height: 24rpx;
+  border-radius: 18rpx;
+  overflow: hidden;
+  background: #444444;
+}
+
+.progress-card__fill {
+  position: absolute;
+  top: 0;
+  left: 0;
+  bottom: 0;
+  border-radius: 18rpx;
+  background: linear-gradient( 133deg, #FFD19A 0%, #A17636 100%);
+}
+
+.progress-card__badge {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  min-width: 156rpx;
+  height: 40rpx;
+  padding: 0 24rpx;
+  box-sizing: border-box;
+  border-radius: 999rpx;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  /* background: rgba(164, 117, 47, 0.94); */
+  /* box-shadow: 0 4rpx 10rpx rgba(76, 45, 7, 0.22); */
+}
+
+.progress-card__badge-text {
+  color: #fff7de;
+  font-size: 18rpx;
+  line-height: 1;
+  white-space: nowrap;
+}
+
+.progress-card__tip {
+  display: block;
+  margin-top: 16rpx;
+  color: rgba(255, 243, 216, 0.88);
+  font-size: 24rpx;
+  line-height: 1.4;
+  text-align: center;
+}
+</style>
@@ -0,0 +1,196 @@
+<script setup>
+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 useStore from "@/store";
+import { storeToRefs } from "pinia";
+const store = useStore();
+const { user, device } = storeToRefs(store);
+const props = defineProps({
+  guide: {
+    type: Boolean,
+    default: true,
+  },
+  isBattle: {
+    type: Boolean,
+    default: false,
+  },
+  count: {
+    type: Number,
+    default: 15,
+  },
+});
+const arrow = ref({});
+const distance = ref(0);
+const showsimul = ref(false);
+const count = ref(props.count);
+const timer = ref(null);
+
+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);
+});
+onBeforeUnmount(() => {
+  if (timer.value) clearInterval(timer.value);
+  uni.$off("update-timer", updateTimer);
+});
+
+async function onReceiveMessage(msg) {
+  if (Array.isArray(msg)) return;
+  if (msg.type === MESSAGETYPESV2.TestDistance) {
+    distance.value = Number((msg.shootData.distance / 100).toFixed(2));
+    if (distance.value >= 5) audioManager.play("距离合格");
+    else audioManager.play("距离不足");
+  }
+}
+
+const simulShoot = async () => {
+  if (device.value.deviceId) await simulShootAPI(device.value.deviceId);
+};
+
+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">
+    <view class="test-area">
+      <image
+        class="text-bg"
+        src="../../../static/training-difficulty-design/par-bg.png"
+        mode="widthFix"
+      />
+      <button
+        class="simul"
+        @click="simulShoot"
+        hover-class="none"
+        v-if="showsimul"
+      >
+        模拟射箭
+      </button>
+      <view class="warnning-text">
+        <view class="target-tip">当前靶子为<text class="text-yellow">20cm</text>全环靶,请更换靶子</view>
+        <block v-if="distance > 0">
+          <text>当前距离<text class="text-yellow">{{ distance }}</text>米</text>
+          <text v-if="distance >= 5">已达到距离要求</text>
+          <text v-else>请调整站位</text>
+        </block>
+        <block v-else>
+          <text>请射箭，测试站距</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="../../../static/test-tip.png" mode="widthFix" />
+      <view v-if="count >= 0">
+        <text>具体正式比赛还有</text>
+        <text>{{ count }}</text>
+        <text>秒</text>
+      </view>
+      <view v-else> 进入中... </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 {
+  width: 100%;
+  height: auto;
+  position: relative;
+}
+
+.text-bg {
+  width: 100%;
+  position: relative;
+}
+.warnning-text {
+  color: #fff;
+  display: flex;
+  flex-direction: column;
+  height: 200rpx;
+  position: absolute;
+  top: 142rpx;
+  left: 0;
+  width: 100%;
+  font-size: 36rpx;
+  text-align: center;
+}
+.target-tip{
+  margin-bottom: 28rpx;
+}
+.text-yellow{
+  color: #FED847;
+}
+.simul {
+  position: absolute;
+  color: #fff;
+  right: 10px;
+  top: 30rpx;
+}
+.user-row{
+  position: absolute;
+  bottom: 34rpx;
+  left: 0rpx;
+  width: 100%;
+  padding: 0 34rpx;
+  box-sizing: border-box;
+}
+
+
+</style>
@@ -0,0 +1,327 @@
+<script setup>
+import { computed } from "vue";
+
+const lockedBadgeBackground =
+  "/static/training-difficulty-design/unlock.svg";
+const unlockedBadgeBackground =
+  "/static/training-difficulty-design/lock.svg";
+
+const props = defineProps({
+  node: {
+    type: Object,
+    required: true,
+  },
+  active: {
+    type: Boolean,
+    default: false,
+  },
+  completedProgress: {
+    type: Number,
+    default: 0,
+  },
+  locked: {
+    type: Boolean,
+    default: false,
+  },
+});
+
+const emit = defineEmits(["click"]);
+
+const badgeStyle = computed(() => {
+  const { left, top } = props.node.style || {};
+
+  return {
+    left,
+    top,
+  };
+});
+
+const progressValue = computed(() => {
+  const value = Number(props.completedProgress);
+
+  if (!Number.isFinite(value)) return 0;
+
+  return Math.max(0, Math.min(100, value));
+});
+
+const badgeStateStyle = computed(() => {
+  const label = String(props.node?.label || "");
+  const estimatedLabelWidthRpx = Math.max(36, label.length * 14);
+  const labelCircleSizeRpx = Math.max(58, estimatedLabelWidthRpx + 18);
+  const badgeSizeRpx = Math.max(
+    124,
+    Math.round(labelCircleSizeRpx / 0.4727)
+  );
+
+  return {
+    "--badge-progress": progressValue.value,
+    "--badge-size": `${badgeSizeRpx}rpx`,
+    "--badge-label-size": `${labelCircleSizeRpx}rpx`,
+    "--badge-orbit-offset": "12rpx",
+    "--badge-locked-ring-offset": "12rpx",
+  };
+});
+
+const showProgress = computed(() => {
+  return !props.locked;
+});
+
+const badgeFillSrc = computed(() => {
+  return props.locked ? lockedBadgeBackground : unlockedBadgeBackground;
+});
+
+const handleClick = () => {
+  emit("click", props.node);
+};
+</script>
+
+<template>
+  <view
+    class="difficulty-badge"
+    :class="{
+      'difficulty-badge--active': active,
+      'difficulty-badge--progress': showProgress,
+      'difficulty-badge--locked': locked,
+    }"
+    :style="[badgeStyle, badgeStateStyle]"
+    @click="handleClick"
+  >
+    <view class="difficulty-badge__fill">
+      <image class="difficulty-badge__bg" :src="badgeFillSrc" mode="aspectFit" />
+      <view v-if="active" class="difficulty-badge__active-orbit">
+        <view
+          class="difficulty-badge__active-triangle difficulty-badge__active-triangle--top"
+        ></view>
+        <view
+          class="difficulty-badge__active-triangle difficulty-badge__active-triangle--right"
+        ></view>
+        <view
+          class="difficulty-badge__active-triangle difficulty-badge__active-triangle--bottom"
+        ></view>
+        <view
+          class="difficulty-badge__active-triangle difficulty-badge__active-triangle--left"
+        ></view>
+      </view>
+      <view class="difficulty-badge__label-wrap">
+        <view class="difficulty-badge__label">{{ node.label }}</view>
+      </view>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.difficulty-badge,
+.difficulty-badge__fill,
+.difficulty-badge__label-wrap {
+  box-sizing: border-box;
+}
+
+.difficulty-badge {
+  position: absolute;
+  transform: translate(-50%, -50%);
+  z-index: 2;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  transition: transform 0.2s ease, opacity 0.2s ease;
+}
+
+.difficulty-badge--active {
+  transform: translate(-50%, -50%) scale(1.04);
+}
+
+.difficulty-badge--active::before {
+  content: "";
+  position: absolute;
+  inset: calc(var(--badge-orbit-offset) * -1);
+  border: 4rpx solid transparent;
+  border-radius: 50%;
+  pointer-events: none;
+  box-sizing: border-box;
+}
+
+.difficulty-badge--active::after {
+  content: "";
+  position: absolute;
+  inset: -24rpx;
+  border: 4rpx solid rgba(254, 208, 152, 0.96);
+  border-radius: 50%;
+  box-shadow: inset 0 0 10rpx rgba(254, 208, 152, 0.88),
+    inset 0 0 22rpx rgba(254, 208, 152, 0.32),
+    0 0 14rpx rgba(254, 208, 152, 0.92),
+    0 0 32rpx rgba(254, 208, 152, 0.52),
+    0 0 52rpx rgba(254, 208, 152, 0.22);
+  pointer-events: none;
+  box-sizing: border-box;
+}
+
+.difficulty-badge__active-orbit {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  width: calc(100% + var(--badge-orbit-offset) * 2);
+  height: calc(100% + var(--badge-orbit-offset) * 2);
+  border-radius: 50%;
+  z-index: 3;
+  pointer-events: none;
+  transform: translate(-50%, -50%);
+  animation: badge-orbit-spin 5.4s linear infinite;
+  transform-origin: center;
+}
+
+.difficulty-badge__active-triangle {
+  position: absolute;
+  width: 0;
+  height: 0;
+  border-style: solid;
+  z-index: 2;
+  pointer-events: none;
+  opacity: 0.92;
+  filter: drop-shadow(0 0 8rpx rgba(255, 255, 255, 0.45));
+}
+
+.difficulty-badge__active-triangle--top {
+  top: -3rpx;
+  left: 50%;
+  transform: translateX(-50%);
+  border-width: 11rpx 8rpx 0 8rpx;
+  border-color: #ffffff transparent transparent transparent;
+}
+
+.difficulty-badge__active-triangle--right {
+  right: -3rpx;
+  top: 50%;
+  transform: translateY(-50%);
+  border-width: 8rpx 11rpx 8rpx 0;
+  border-color: transparent #ffffff transparent transparent;
+}
+
+.difficulty-badge__active-triangle--bottom {
+  bottom: -3rpx;
+  left: 50%;
+  transform: translateX(-50%);
+  border-width: 0 8rpx 11rpx 8rpx;
+  border-color: transparent transparent #ffffff transparent;
+}
+
+.difficulty-badge__active-triangle--left {
+  left: -3rpx;
+  top: 50%;
+  transform: translateY(-50%);
+  border-width: 8rpx 0 8rpx 11rpx;
+  border-color: transparent transparent transparent #ffffff;
+}
+
+.difficulty-badge__fill {
+  width: var(--badge-size);
+  height: var(--badge-size);
+  position: relative;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: 50%;
+}
+
+.difficulty-badge__bg {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  display: block;
+  z-index: 1;
+}
+
+.difficulty-badge--active .difficulty-badge__fill::before,
+.difficulty-badge--active .difficulty-badge__fill::after {
+  content: none;
+}
+
+.difficulty-badge--progress .difficulty-badge__fill::before,
+.difficulty-badge--progress .difficulty-badge__fill::after {
+  content: "";
+  position: absolute;
+  inset: -12rpx;
+  padding: 6rpx;
+  border-radius: inherit;
+  -webkit-mask: linear-gradient(#fff 0 0) content-box,
+    linear-gradient(#fff 0 0);
+  -webkit-mask-composite: xor;
+  mask: linear-gradient(#fff 0 0) content-box, linear-gradient(#fff 0 0);
+  mask-composite: exclude;
+  pointer-events: none;
+}
+
+.difficulty-badge--progress .difficulty-badge__fill::before {
+  background: rgba(255, 255, 255, 0.35);
+}
+
+.difficulty-badge--progress .difficulty-badge__fill::after {
+  background: conic-gradient(
+    from -90deg,
+    rgba(254, 208, 152, 1) 0,
+    rgba(255, 229, 198, 1) calc(var(--badge-progress) * 1%),
+    transparent calc(var(--badge-progress) * 1%) 100%
+  );
+}
+
+.difficulty-badge--active .difficulty-badge__label,
+.difficulty-badge--progress .difficulty-badge__label {
+  color: #333333;
+}
+
+.difficulty-badge--locked {
+  opacity: 1;
+}
+
+.difficulty-badge--locked::before {
+  content: "";
+  position: absolute;
+  inset: calc(var(--badge-locked-ring-offset) * -1);
+  border: 2rpx solid rgba(160, 160, 160, 0.5);
+  border-radius: 50%;
+  pointer-events: none;
+  box-sizing: border-box;
+}
+
+.difficulty-badge--locked .difficulty-badge__label {
+  color: rgba(51, 51, 51, 0.54);
+}
+
+.difficulty-badge__label-wrap {
+  width: var(--badge-label-size);
+  height: var(--badge-label-size);
+  border-radius: 50%;
+  position: relative;
+  z-index: 2;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin-top: -5rpx;
+}
+
+.difficulty-badge__label {
+  color: rgba(51, 51, 51, 0.7);
+  font-size: 24rpx;
+  max-width: 100%;
+  height: 34rpx;
+  line-height: 34rpx;
+  font-family: "PingFang SC", sans-serif;
+  font-weight: 600;
+  text-align: center;
+  white-space: nowrap;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  overflow: hidden;
+}
+
+@keyframes badge-orbit-spin {
+  from {
+    transform: translate(-50%, -50%) rotate(0deg);
+  }
+
+  to {
+    transform: translate(-50%, -50%) rotate(360deg);
+  }
+}
+</style>
@@ -0,0 +1,86 @@
+<script setup>
+import { computed } from "vue";
+
+const props = defineProps({
+  title: {
+    type: String,
+    default: "",
+  },
+  lines: {
+    type: Array,
+    default: () => [],
+  },
+});
+
+const previewLines = computed(() => {
+  return props.lines.map((line) => String(line || "").trim()).filter(Boolean);
+});
+</script>
+
+<template>
+  <view class="difficulty-preview">
+    <image
+      class="difficulty-preview__bg"
+      src="/static/training-difficulty-design/text.png"
+      mode="widthFix"
+    />
+    <view class="difficulty-preview__content">
+      <text class="difficulty-preview__title">{{ title }}</text>
+      <view class="difficulty-preview__copy">
+        <text
+          v-for="(line, index) in previewLines"
+          :key="`${line}-${index}`"
+          class="difficulty-preview__line"
+        >
+          {{ line }}
+        </text>
+      </view>
+    </view>
+  </view>
+</template>
+
+<style scoped>
+.difficulty-preview {
+  position: relative;
+  width: 100%;
+}
+
+.difficulty-preview__bg {
+  display: block;
+  width: 100%;
+}
+
+.difficulty-preview__content {
+  position: absolute;
+  top: 28rpx;
+  left: 30rpx;
+  box-sizing: border-box;
+  width: 486rpx;
+}
+
+.difficulty-preview__title {
+  display: block;
+  color: #ffd543;
+  font-size: 24rpx;
+  line-height: 34rpx;
+  font-family: "PingFang SC", sans-serif;
+  text-align: center;
+}
+
+.difficulty-preview__copy {
+  width: 80%;
+  margin: 0 auto;
+  display: block;
+  color: #ffffff;
+  font-size: 24rpx;
+  line-height: 34rpx;
+  font-family: "PingFang SC", sans-serif;
+  text-align: center;
+}
+
+.difficulty-preview__line {
+  display: block;
+}
+
+
+</style>
@@ -0,0 +1,81 @@
+<script setup>
+const props = defineProps({
+  text: {
+    type: String,
+    default: "开始",
+  },
+});
+
+const emit = defineEmits(["click"]);
+
+const handleClick = () => {
+  emit("click");
+};
+</script>
+
+<template>
+  <button
+    class="difficulty-start"
+    hover-class="difficulty-start--hover"
+    @click="handleClick"
+  >
+    <image
+      class="difficulty-start__button"
+      src="/static/training-difficulty-design/btn.png"
+      mode="widthFix"
+    />
+  </button>
+</template>
+
+<style scoped>
+.difficulty-start {
+  position: relative;
+  width: 302rpx;
+  height: 170rpx;
+  padding: 0;
+  border: 0;
+  background: transparent;
+  margin: 0 auto;
+}
+
+.difficulty-start::after {
+  border: 0;
+}
+
+.difficulty-start--hover {
+  transform: translateY(2rpx) scale(0.99);
+}
+
+.difficulty-start__mascot {
+  position: absolute;
+  left: 50%;
+  top: 0;
+  z-index: 1;
+  width: 112rpx;
+  transform: translateX(-50%);
+}
+
+.difficulty-start__button {
+  position: absolute;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  z-index: 2;
+  width: 100%;
+}
+
+.difficulty-start__text {
+  position: absolute;
+  left: 0;
+  right: 0;
+  bottom: 58rpx;
+  z-index: 3;
+  color: #9f4d00;
+  font-size: 64rpx;
+  line-height: 76rpx;
+  text-align: center;
+  font-family: "AlimamaShuHeiTi-Bold", "PingFang SC", sans-serif;
+  font-weight: 800;
+  text-shadow: 0 3rpx 0 rgba(255, 245, 205, 0.78);
+}
+</style>
@@ -0,0 +1,801 @@
+<script setup>
+import { computed, nextTick, ref } from "vue";
+import { onLoad, onShow, onUnload } from "@dcloudio/uni-app";
+import Container from "@/components/Container.vue";
+import TrainingDifficultyBadge from "./components/TrainingDifficultyBadge.vue";
+import TrainingDifficultyPreviewCard from "./components/TrainingDifficultyPreviewCard.vue";
+import TrainingDifficultyStartButton from "./components/TrainingDifficultyStartButton.vue";
+import { getTrainingDifficultyListAPI } from "@/apis";
+
+// 难度页接口数据源：
+// 1. 接口：GET /training/difficulty/list?type=base/endurance/precision/rhythm
+// 2. 当前进度：接口 user_levels / list.completed，路由参数可覆盖选中难度
+const trainingDifficultyStorageKey = "training-selection";
+const trainingDifficultyRefreshEvent = "training-difficulty-refresh";
+const defaultTrainingType = "precision";
+const defaultUnlockedDifficultyId = "lv1";
+const trainingTypeMetaMap = {
+  base: {
+    key: "base",
+    title: "基础训练",
+  },
+  endurance: {
+    key: "endurance",
+    title: "耐力训练",
+  },
+  precision: {
+    key: "precision",
+    title: "精准训练",
+  },
+  rhythm: {
+    key: "rhythm",
+    title: "节奏训练",
+  },
+};
+const routeModeTypeMap = {
+  basic: "base",
+  base: "base",
+  endurance: "endurance",
+  precision: "precision",
+  rhythm: "rhythm",
+};
+const defaultTargetType = 1;
+
+const resolveTrainingType = (mode) => {
+  const normalizedMode = String(mode || "").toLowerCase();
+  return routeModeTypeMap[normalizedMode] || defaultTrainingType;
+};
+
+const createDifficultyId = (level) => `lv${level}`;
+
+const toNumber = (value, fallback = 0) => {
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) ? numberValue : fallback;
+};
+
+const clampProgress = (value) => {
+  return Math.min(Math.max(value, 0), 100);
+};
+
+const getDifficultyProgress = (item = {}) => {
+  const completedCnt = toNumber(item.completed_cnt);
+  const promoteCnt = toNumber(item.promote_cnt);
+
+  if (item.completed) {
+    return 100;
+  }
+
+  if (promoteCnt <= 0) {
+    return 0;
+  }
+
+  return clampProgress(Math.round((completedCnt / promoteCnt) * 100));
+};
+
+const checkDifficultyCompleted = (item = {}) => {
+  const completedCnt = toNumber(item.completed_cnt);
+  const promoteCnt = toNumber(item.promote_cnt);
+
+  return Boolean(item.completed) || (promoteCnt > 0 && completedCnt >= promoteCnt);
+};
+
+const getDifficultyModeText = (mode) => {
+  return Number(mode) === 1 ? "随机区域+指定环数" : "随机区域命中";
+};
+
+const createEmptyModeConfig = (type = defaultTrainingType) => {
+  const meta = trainingTypeMetaMap[type] || trainingTypeMetaMap[defaultTrainingType];
+
+  return {
+    key: meta.key,
+    title: meta.title,
+    nodes: [],
+    details: {},
+    activeDifficultyId: defaultUnlockedDifficultyId,
+    progressMap: {},
+  };
+};
+
+const createDifficultySummary = (item = {}) => {
+  const desc = String(item.desc || "").trim();
+  const type = item.type;
+  const arrows = toNumber(item.arrows);
+  const timeLimit = toNumber(item.time_limit);
+  const hitReq = toNumber(item.hit_req);
+  const totalReq = toNumber(item.total_req);
+  const blocks = toNumber(item.blocks);
+  const promoteCnt = toNumber(item.promote_cnt);
+  const timeText = timeLimit > 0 ? `${timeLimit}秒内完成` : "不限时完成";
+  const promoteText = promoteCnt > 0 ? `完成${promoteCnt}次晋级` : "";
+
+  const summaryMap = {
+    base: [
+      desc || (hitReq > 0 ? `每箭命中${hitReq}环以上` : "上靶即可"),
+      [`${arrows}箭`, promoteText].filter(Boolean).join(" · "),
+    ],
+    endurance: [
+      desc || `${timeText}${arrows}箭`,
+      [`累计${totalReq}环`, promoteText].filter(Boolean).join(" · "),
+    ],
+    precision: [
+      desc || `命中${blocks}个指定区域`,
+      [
+        `${arrows}箭`,
+        timeText,
+        getDifficultyModeText(item.mode),
+        promoteText,
+      ]
+        .filter(Boolean)
+        .join(" · "),
+    ],
+    rhythm: [
+      desc || `间隔${timeLimit}秒射击`,
+      [
+        `${arrows}箭`,
+        hitReq > 0 ? `每箭${hitReq}环以上` : "上靶即可",
+        getDifficultyModeText(item.mode),
+        promoteText,
+      ]
+        .filter(Boolean)
+        .join(" · "),
+    ],
+  };
+
+  return (summaryMap[type] || [desc]).filter(Boolean);
+};
+
+const normalizeTrainingDifficultyConfig = (result, type) => {
+  const meta = trainingTypeMetaMap[type] || trainingTypeMetaMap[defaultTrainingType];
+  const list = Array.isArray(result?.list) ? result.list : [];
+  const rawItems = list.filter((item) => !item?.type || item.type === meta.key);
+  const difficultyItems = rawItems
+    .map((item) => {
+      const level = toNumber(item?.difficulty);
+
+      if (level <= 0) {
+        return null;
+      }
+
+      const id = createDifficultyId(level);
+      const label = `Lv${level}`;
+
+      return {
+        ...item,
+        recordId: item.id,
+        completedCnt: toNumber(item.completed_cnt),
+        promoteCnt: toNumber(item.promote_cnt),
+        id,
+        level,
+        label,
+        title: `${label}难度`,
+        summary: createDifficultySummary(item),
+        startText: "开始",
+        targetPaperType: "20CM全环靶",
+      };
+    })
+    .filter(Boolean)
+    .sort((first, second) => first.level - second.level);
+  const maxLevel = difficultyItems.reduce(
+    (currentMax, item) => Math.max(currentMax, item.level),
+    0
+  );
+  const completedLevelFromList = difficultyItems.reduce((currentMax, item) => {
+    return checkDifficultyCompleted(item)
+      ? Math.max(currentMax, item.level)
+      : currentMax;
+  }, 0);
+  const userCompletedLevel = toNumber(result?.user_levels?.[meta.key]);
+  const highestCompletedLevel = userCompletedLevel || completedLevelFromList;
+  const unlockedLevel = maxLevel
+    ? Math.min(Math.max(highestCompletedLevel + 1, 1), maxLevel)
+    : 1;
+
+  return {
+    key: meta.key,
+    title: meta.title,
+    nodes: difficultyItems.map((item) => ({
+      id: item.id,
+      label: item.label,
+    })),
+    details: Object.fromEntries(
+      difficultyItems.map((item) => [item.id, item])
+    ),
+    activeDifficultyId: createDifficultyId(unlockedLevel),
+    progressMap: Object.fromEntries(
+      difficultyItems.map((item) => [item.id, getDifficultyProgress(item)])
+    ),
+  };
+};
+
+// 难度轴布局参数，节点按“等级越低越靠下”的方式排列。
+const nodesLayout = {
+  viewportHeightRpx: 1020,
+  topPaddingRpx: 136,
+  bottomPaddingRpx: 144,
+  verticalGapRpx: 188,
+  anchorOffsetRpx: 796,
+  horizontalPatternRpx: [388, 232, 516, 258, 458, 304],
+  nearHorizontalDistanceRpx: 170,
+  extraGapScale: 0.5,
+};
+
+const emptyDifficulty = {
+  id: "",
+  label: "",
+  title: "",
+  summary: [],
+  startText: "开始",
+  targetPaperType: "",
+};
+
+// 页面基础状态
+const pageConfig = ref(createEmptyModeConfig(defaultTrainingType));
+const unlockedDifficultyId = ref(defaultUnlockedDifficultyId);
+const selectedDifficultyId = ref(defaultUnlockedDifficultyId);
+const nodesScrollTop = ref(0);
+const nodesScrollWithAnimation = ref(false);
+const routeOptions = ref({});
+const needRefreshProgress = ref(false);
+
+const difficultyProgressMap = computed(() => {
+  return pageConfig.value?.progressMap || {};
+});
+
+const clamp = (value, min, max) => {
+  return Math.min(Math.max(value, min), max);
+};
+
+// 从 lv1 / lv20 这类 id 中提取等级数值，统一用于排序、解锁判断和进度比较。
+const getDifficultyLevel = (difficultyId = "") => {
+  const matched = String(difficultyId).match(/\d+/);
+  return matched ? Number(matched[0]) : 0;
+};
+
+// 合并节点基础信息和难度详情，并统一按等级升序整理。
+const createDifficultyNodes = (config) => {
+  const details = config?.details || {};
+  const rawNodes = Array.isArray(config?.nodes) ? config.nodes : [];
+  const nodeMap = new Map(rawNodes.map((node) => [node.id, node]));
+  const difficultyIds = new Set([
+    ...rawNodes.map((node) => node.id),
+    ...Object.keys(details),
+  ]);
+
+  return Array.from(difficultyIds)
+    .map((difficultyId) => {
+      const level = getDifficultyLevel(difficultyId);
+      const node = nodeMap.get(difficultyId) || {};
+      const detail = details[difficultyId] || {};
+      const label = node.label || detail.label || `Lv${level || ""}`;
+
+      return {
+        ...node,
+        ...detail,
+        id: difficultyId,
+        level,
+        label,
+        title: detail.title || `${label}难度`,
+        summary: Array.isArray(detail.summary) ? detail.summary : [],
+        startText: detail.startText || "开始",
+        targetPaperType: detail.targetPaperType || "",
+      };
+    })
+    .filter((node) => node.id && node.level > 0)
+    .sort((first, second) => first.level - second.level);
+};
+
+const findValidDifficultyId = (difficultyId, nodes) => {
+  return nodes.some((node) => node.id === difficultyId) ? difficultyId : "";
+};
+
+const getNextDifficultyId = (difficultyId, nodes) => {
+  const currentLevel = getDifficultyLevel(difficultyId);
+  return (
+    nodes.find((node) => node.level === currentLevel + 1)?.id || difficultyId
+  );
+};
+
+// 统一解析当前最新已解锁难度：
+// completedDifficultyId 优先级最高，可在完成当前难度后自动推进到下一关。
+const resolveUnlockedDifficultyId = (options, config, nodes) => {
+  const completedDifficultyId = findValidDifficultyId(
+    options.completedDifficultyId,
+    nodes
+  );
+
+  if (completedDifficultyId) {
+    return getNextDifficultyId(completedDifficultyId, nodes);
+  }
+
+  return (
+    [
+      options.currentDifficultyId,
+      options.latestDifficultyId,
+      options.activeDifficultyId,
+      config.activeDifficultyId,
+      defaultUnlockedDifficultyId,
+    ].find((difficultyId) => findValidDifficultyId(difficultyId, nodes)) ||
+    nodes[0]?.id ||
+    defaultUnlockedDifficultyId
+  );
+};
+
+// 如果传入的默认选中项尚未解锁，则自动回退到当前最新已解锁难度。
+const resolveSelectedDifficultyId = (difficultyId, nodes, currentUnlockedId) => {
+  const safeDifficultyId = findValidDifficultyId(difficultyId, nodes);
+
+  if (!safeDifficultyId) {
+    return currentUnlockedId;
+  }
+
+  return getDifficultyLevel(safeDifficultyId) <=
+    getDifficultyLevel(currentUnlockedId)
+    ? safeDifficultyId
+    : currentUnlockedId;
+};
+
+// 页面渲染使用的难度节点列表，包含纵向轨道坐标。
+const difficultyNodes = computed(() => {
+  const nodes = createDifficultyNodes(pageConfig.value);
+  const leftPositions = nodes.map((_, index) => {
+    return nodesLayout.horizontalPatternRpx[
+      index % nodesLayout.horizontalPatternRpx.length
+    ];
+  });
+  const offsetsFromBottom = [];
+  let accumulatedOffsetRpx = 0;
+
+  nodes.forEach((node, index) => {
+    if (index > 0) {
+      const previousLeftRpx = leftPositions[index - 1];
+      const currentLeftRpx = leftPositions[index];
+      const horizontalDistanceRpx = Math.abs(currentLeftRpx - previousLeftRpx);
+      const extraGapRpx =
+        Math.max(
+          0,
+          nodesLayout.nearHorizontalDistanceRpx - horizontalDistanceRpx
+        ) * nodesLayout.extraGapScale;
+
+      accumulatedOffsetRpx +=
+        nodesLayout.verticalGapRpx + Math.round(extraGapRpx);
+    }
+
+    offsetsFromBottom.push(accumulatedOffsetRpx);
+  });
+
+  const contentHeightRpx = Math.max(
+    nodesLayout.viewportHeightRpx,
+    nodesLayout.topPaddingRpx +
+      nodesLayout.bottomPaddingRpx +
+      (offsetsFromBottom[offsetsFromBottom.length - 1] || 0)
+  );
+
+  return nodes.map((node, index) => {
+    const leftRpx = leftPositions[index];
+    const topRpx =
+      contentHeightRpx -
+      nodesLayout.bottomPaddingRpx -
+      offsetsFromBottom[index];
+
+    return {
+      ...node,
+      leftRpx,
+      topRpx,
+      style: {
+        left: `${leftRpx}rpx`,
+        top: `${topRpx}rpx`,
+      },
+    };
+  });
+});
+
+const difficultyConnectors = computed(() => {
+  const nodes = difficultyNodes.value;
+
+  return nodes.slice(1).map((currentNode, index) => {
+    const previousNode = nodes[index];
+    const startX = Number(previousNode?.leftRpx || 0);
+    const startY = Number(previousNode?.topRpx || 0);
+    const endX = Number(currentNode?.leftRpx || 0);
+    const endY = Number(currentNode?.topRpx || 0);
+    const midX = (startX + endX) / 2;
+    const midY = (startY + endY) / 2;
+    const angle =
+      (Math.atan2(endY - startY, endX - startX) * 180) / Math.PI + 90;
+
+    return {
+      id: `${previousNode.id}-${currentNode.id}`,
+      left: `${midX}rpx`,
+      top: `${midY}rpx`,
+      transform: `translate(-50%, -50%) rotate(${angle}deg)`,
+    };
+  });
+});
+
+const nodesTrackHeightRpx = computed(() => {
+  const bottomNode = difficultyNodes.value[0];
+
+  if (!bottomNode) {
+    return nodesLayout.viewportHeightRpx;
+  }
+
+  return Math.max(
+    nodesLayout.viewportHeightRpx,
+    bottomNode.topRpx + nodesLayout.bottomPaddingRpx
+  );
+});
+
+const nodesTrackStyle = computed(() => {
+  return {
+    height: `${nodesTrackHeightRpx.value}rpx`,
+  };
+});
+
+const selectedDifficulty = computed(() => {
+  return (
+    difficultyNodes.value.find((node) => node.id === selectedDifficultyId.value) ||
+    difficultyNodes.value[0] ||
+    emptyDifficulty
+  );
+});
+
+// 优先显示配置中的难度进度；没有配置时，再按已解锁等级推导完成态。
+const getCompletedDifficultyProgress = (node) => {
+  const configuredProgress = Number(difficultyProgressMap.value[node?.id]);
+
+  if (Number.isFinite(configuredProgress) && configuredProgress > 0) {
+    return configuredProgress;
+  }
+
+  return getDifficultyLevel(node?.id) < getDifficultyLevel(unlockedDifficultyId.value)
+    ? 100
+    : 0;
+};
+
+const checkDifficultyLocked = (node) => {
+  return getDifficultyLevel(node?.id) > getDifficultyLevel(unlockedDifficultyId.value);
+};
+
+// 根据目标难度计算 scroll-view 应滚动到的位置，顶部/底部会自动吸附边界。
+const scrollToDifficulty = (difficultyId, animated = false) => {
+  const node = difficultyNodes.value.find((item) => item.id === difficultyId);
+
+  if (!node) {
+    return;
+  }
+
+  const maxScrollRpx = Math.max(
+    nodesTrackHeightRpx.value - nodesLayout.viewportHeightRpx,
+    0
+  );
+  const targetScrollRpx = clamp(
+    node.topRpx - nodesLayout.anchorOffsetRpx,
+    0,
+    maxScrollRpx
+  );
+
+  nodesScrollWithAnimation.value = animated;
+  nodesScrollTop.value = uni.upx2px(targetScrollRpx);
+};
+
+// 首次进入页面需要静默定位到默认难度；
+// 定位完成后再开启滚动动画，避免第一次手动切换时丢失过渡效果。
+const initScrollPosition = () => {
+  scrollToDifficulty(selectedDifficultyId.value, false);
+
+  nextTick(() => {
+    nodesScrollWithAnimation.value = true;
+  });
+};
+
+const normalizeRouteOptions = (options = {}) => {
+  const difficultyLevel = toNumber(options.difficulty);
+  const completedDifficultyLevel = toNumber(options.completedDifficulty);
+
+  return {
+    ...options,
+    difficultyId:
+      options.difficultyId ||
+      (difficultyLevel > 0 ? createDifficultyId(difficultyLevel) : ""),
+    completedDifficultyId:
+      options.completedDifficultyId ||
+      (completedDifficultyLevel > 0
+        ? createDifficultyId(completedDifficultyLevel)
+        : ""),
+  };
+};
+
+const applyPageState = (options = {}, config) => {
+  const safeOptions = normalizeRouteOptions(options);
+  const nodes = createDifficultyNodes(config);
+  const currentUnlockedId = resolveUnlockedDifficultyId(
+    safeOptions,
+    config,
+    nodes
+  );
+
+  pageConfig.value = config;
+  unlockedDifficultyId.value = currentUnlockedId;
+  selectedDifficultyId.value = resolveSelectedDifficultyId(
+    safeOptions.difficultyId,
+    nodes,
+    currentUnlockedId
+  );
+
+  nextTick(() => {
+    initScrollPosition();
+  });
+};
+
+const initPageState = async (options = {}, refreshOptions = {}) => {
+  const { keepCurrent = false } = refreshOptions;
+  const trainingType = resolveTrainingType(options.mode);
+  const fallbackConfig = createEmptyModeConfig(trainingType);
+
+  if (!keepCurrent) {
+    pageConfig.value = fallbackConfig;
+  }
+
+  try {
+    const result = await getTrainingDifficultyListAPI(trainingType);
+    applyPageState(
+      options,
+      normalizeTrainingDifficultyConfig(result, trainingType)
+    );
+  } catch (error) {
+    console.log("training difficulty load failed", error);
+    if (!keepCurrent) {
+      applyPageState(options, fallbackConfig);
+    }
+    uni.showToast({
+      title: "训练难度加载失败",
+      icon: "none",
+    });
+  }
+};
+
+const cleanQueryValue = (value) => {
+  if (value === undefined || value === null || value === "") {
+    return "";
+  }
+
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return "";
+  }
+
+  return value;
+};
+
+const createPracticeQuery = (difficulty) => {
+  const trainingType = pageConfig.value.key || defaultTrainingType;
+  const commonQuery = {
+    type: trainingType,
+    difficultyId: difficulty.id,
+    difficulty: difficulty.level,
+    recordId: difficulty.recordId,
+    arrows: toNumber(difficulty.arrows, 12),
+    time: toNumber(difficulty.time_limit, 120) || 120,
+    target: defaultTargetType,
+  };
+  const typedQueryMap = {
+    base: {
+      hitReq: toNumber(difficulty.hit_req),
+    },
+    endurance: {
+      totalReq: toNumber(difficulty.total_req),
+    },
+    precision: {
+      blocks: toNumber(difficulty.blocks),
+      mode: toNumber(difficulty.mode),
+    },
+    rhythm: {
+      hitReq: toNumber(difficulty.hit_req),
+      mode: toNumber(difficulty.mode),
+    },
+  };
+
+  return {
+    ...commonQuery,
+    ...(typedQueryMap[trainingType] || {}),
+  };
+};
+
+const createPracticeUrl = (difficulty) => {
+  const query = Object.entries(createPracticeQuery(difficulty))
+    .map(([key, value]) => [key, cleanQueryValue(value)])
+    .filter(([, value]) => value !== "")
+    .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+    .join("&");
+
+  return `/pages/training/practise-one${query ? `?${query}` : ""}`;
+};
+
+const saveTrainingContext = () => {
+  const difficulty = selectedDifficulty.value;
+
+  if (!difficulty.id) {
+    return;
+  }
+
+  uni.setStorageSync(trainingDifficultyStorageKey, {
+    trainingType: pageConfig.value.key,
+    trainingTitle: pageConfig.value.title,
+    difficultyId: difficulty.id,
+    difficultyLabel: difficulty.label,
+    targetType: defaultTargetType,
+    targetPaperType: difficulty.targetPaperType,
+  });
+};
+
+const handleSelectDifficulty = (node) => {
+  if (!node?.id) {
+    return;
+  }
+
+  if (checkDifficultyLocked(node)) {
+    uni.showToast({
+      title: "难度尚未解锁",
+      icon: "none",
+    });
+    return;
+  }
+
+  if (node.id === selectedDifficultyId.value) {
+    return;
+  }
+
+  selectedDifficultyId.value = node.id;
+  nextTick(() => {
+    scrollToDifficulty(node.id, true);
+  });
+};
+
+const handleStart = () => {
+  if (!selectedDifficulty.value.id) {
+    return;
+  }
+
+  saveTrainingContext();
+  uni.navigateTo({
+    url: createPracticeUrl(selectedDifficulty.value),
+  });
+};
+
+const markProgressRefresh = () => {
+  needRefreshProgress.value = true;
+};
+
+onLoad((options = {}) => {
+  routeOptions.value = { ...options };
+  uni.$on(trainingDifficultyRefreshEvent, markProgressRefresh);
+  initPageState(options);
+});
+
+onShow(() => {
+  if (!needRefreshProgress.value) {
+    return;
+  }
+
+  needRefreshProgress.value = false;
+  initPageState(routeOptions.value, {
+    keepCurrent: true,
+  });
+});
+
+onUnload(() => {
+  uni.$off(trainingDifficultyRefreshEvent, markProgressRefresh);
+});
+</script>
+
+<template>
+  <Container
+    :title="pageConfig.title"
+    :bgType="8"
+    bgColor="#1c1c23"
+    :scroll="false"
+  >
+    <view class="difficulty-page">
+      <view class="difficulty-page__nodes">
+        <scroll-view
+          class="difficulty-page__nodes-scroll"
+          scroll-y
+          enhanced
+          :scroll-top="nodesScrollTop"
+          :scroll-with-animation="nodesScrollWithAnimation"
+          :show-scrollbar="false"
+        >
+          <view class="difficulty-page__nodes-track" :style="nodesTrackStyle">
+            <image
+              v-for="connector in difficultyConnectors"
+              :key="connector.id"
+              class="difficulty-page__connector"
+              src="../../static/training-difficulty-design/jiantou.png"
+              mode="aspectFit"
+              :style="connector"
+            />
+            <TrainingDifficultyBadge
+              v-for="node in difficultyNodes"
+              :key="node.id"
+              :node="node"
+              :active="node.id === selectedDifficultyId"
+              :locked="checkDifficultyLocked(node)"
+              :completedProgress="getCompletedDifficultyProgress(node)"
+              @click="handleSelectDifficulty"
+            />
+          </view>
+        </scroll-view>
+      </view>
+
+      <view class="difficulty-page__preview">
+        <TrainingDifficultyPreviewCard
+          :title="selectedDifficulty.title"
+          :lines="selectedDifficulty.summary"
+        />
+      </view>
+
+      <view class="difficulty-page__start">
+        <TrainingDifficultyStartButton
+          :text="selectedDifficulty.startText"
+          @click="handleStart"
+        />
+      </view>
+    </view>
+  </Container>
+</template>
+
+<style scoped>
+.difficulty-page {
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+  padding: 18rpx 0 40rpx;
+  overflow: hidden;
+}
+
+.difficulty-page__nodes {
+  position: relative;
+  flex: 1;
+  min-height: 0;
+  z-index: 2;
+  margin-bottom: 8rpx;
+}
+
+.difficulty-page__nodes-scroll {
+  width: 100%;
+  height: 100%;
+}
+
+.difficulty-page__nodes-track {
+  position: relative;
+  width: 100%;
+  min-height: 100%;
+}
+
+.difficulty-page__connector {
+  position: absolute;
+  width: 18rpx;
+  height: 28rpx;
+  z-index: 1;
+  pointer-events: none;
+}
+
+.difficulty-page__preview {
+  position: relative;
+  flex: none;
+  z-index: 3;
+  width: 540rpx;
+  height: 172rpx;
+  margin: 0 auto;
+}
+
+.difficulty-page__start {
+  position: relative;
+  flex: none;
+  z-index: 4;
+  width: 302rpx;
+  height: 190rpx;
+  margin: 0 auto;
+  top: -16rpx;
+}
+</style>
@@ -0,0 +1,885 @@
+<script setup>
+import { nextTick, onMounted, ref } from "vue";
+import { onShow } from "@dcloudio/uni-app";
+import Container from "@/components/Container.vue";
+import TargetPicker from "@/components/TargetPicker.vue";
+import { getPersonalTrainingAPI } from "@/apis";
+
+const checkedIcon = "../../static/training-home/done.png";
+const missedIcon = "../../static/training-home/missed.png";
+// 后端训练项目 id 与难度页 mode 参数的映射关系。
+const trainingModeRouteMap = {
+  base: "basic",
+  endurance: "endurance",
+  precision: "precision",
+  rhythm: "rhythm",
+  strength: "power",
+};
+// 训练项目卡片右侧主图标。
+const trainingModeIconMap = {
+  base_bow: "../../static/training-home/img_22.png",
+  bow: "../../static/training-home/img_3.png",
+  target: "../../static/training-home/img_4.png",
+  wave: "../../static/training-home/img_5.png",
+  muscle: "../../static/training-home/img_6.png",
+};
+// 训练项目卡片标题图，按接口 id 映射本地资源。
+const trainingModeTitleImageMap = {
+  endurance: "../../static/training-home/nailixunlian.png",
+  precision: "../../static/training-home/jingzhunxunlian.png",
+  rhythm: "../../static/training-home/jiezouxunlian.png",
+  strength: "../../static/training-home/liliangxulian.png",
+};
+const defaultWeekDays = ["周一", "周二", "周三", "周四", "周五", "周六", "周日"];
+const defaultRadarDimensions = [
+  { name: "基础", score: 0 },
+  { name: "精准", score: 0 },
+  { name: "力量", score: 0 },
+  { name: "节奏", score: 0 },
+  { name: "耐力", score: 0 },
+];
+
+// 页面始终直接消费接口字段，这里只保留一份兜底结构，避免模板访问空值。
+const createDefaultTrainingData = () => ({
+  week_days: defaultWeekDays.map((day) => ({ day, status: "cross" })),
+  stats: {
+    total_training_days: 0,
+    total_arrows: 0,
+    hit_rate: 0,
+    endurance_shoot_speed: 0,
+    total_calories: 0,
+    overtake_rate: 0,
+  },
+  radar: {
+    dimensions: defaultRadarDimensions,
+  },
+  training_items: [],
+});
+
+const trainingData = ref(createDefaultTrainingData());
+const pageMounted = ref(false);
+const showRoutineTargetPicker = ref(false);
+const trainingRadarCanvasId = "training-home-radar";
+const radarImageWidth = 225;
+const radarImageHeight = 224;
+const radarFigureWidthRpx = 448;
+const radarFigureHeightRpx = Math.round(
+  (radarFigureWidthRpx * radarImageHeight) / radarImageWidth
+);
+const radarCanvasWidth = Math.round(uni.upx2px(radarFigureWidthRpx));
+const radarCanvasHeight = Math.round(uni.upx2px(radarFigureHeightRpx));
+const radarScaleX = radarCanvasWidth / radarImageWidth;
+const radarScaleY = radarCanvasHeight / radarImageHeight;
+const radarScale = Math.min(radarScaleX, radarScaleY);
+const radarCenterX = 112.0624 * radarScaleX;
+const radarCenterY = 111.4645 * radarScaleY;
+const radarStrokeWidth = Math.max(1, 2 * radarScale);
+const radarPointRadius = Math.max(2.5, 3.5 * radarScale);
+const radarOuterRadiusX = 110.7089 * radarScaleX;
+const radarOuterRadiusY = 110.7089 * radarScaleY;
+const radarMaxValue = 100;
+const radarFigureStyle = {
+  width: `${radarFigureWidthRpx}rpx`,
+  height: `${radarFigureHeightRpx}rpx`,
+};
+
+const formatValue = (value, digits = 1) => {
+  const numberValue = Number(value);
+  if (!Number.isFinite(numberValue)) return "--";
+  return String(Number(numberValue.toFixed(digits)));
+};
+
+const getLevelText = (item) => {
+  if (!item) return "";
+  const level = Number(item.current_level) || 0;
+  return item.is_locked ? `Coming! LV${level}` : `当前进度 LV${level} >`;
+};
+
+// 卡路里字段按需求做 K / W 缩写展示。
+const getCaloriesValue = (value) => {
+  const numberValue = Number(value);
+  if (!Number.isFinite(numberValue)) return "--";
+  if (numberValue >= 10000) return `${formatValue(numberValue / 10000)}W`;
+  if (numberValue >= 1000) return `${formatValue(numberValue / 1000)}K`;
+  return formatValue(numberValue, 0);
+};
+
+const getTrainingIcon = (item = {}) =>
+  trainingModeIconMap[item.icon] || trainingModeIconMap.bow;
+
+const getTrainingTitleImage = (item = {}) =>
+  trainingModeTitleImageMap[item.id] || "";
+
+const getTrainingMode = (item = {}) =>
+  trainingModeRouteMap[item.id] || item.id || "";
+
+const getRadarPoint = (centerX, centerY, radiusX, radiusY, angle) => ({
+  x: centerX + radiusX * Math.cos(angle),
+  y: centerY + radiusY * Math.sin(angle),
+});
+
+// 雷达图直接使用接口的 5 维 score，按 0-100 等比映射到顶点位置。
+const drawRadar = () => {
+  const dimensions = Array.isArray(trainingData.value.radar?.dimensions)
+    ? trainingData.value.radar.dimensions.slice(0, 5)
+    : [];
+
+  if (dimensions.length !== 5) return;
+
+  const ctx = uni.createCanvasContext(trainingRadarCanvasId);
+  const angles = dimensions.map(
+    (_, index) => (-90 + index * 72) * (Math.PI / 180)
+  );
+
+  ctx.clearRect(0, 0, radarCanvasWidth, radarCanvasHeight);
+
+  const points = dimensions.map((item, index) => {
+    const normalized = Math.max(
+      0,
+      Math.min(Number(item.score) || 0, radarMaxValue)
+    );
+    const progress = normalized / radarMaxValue;
+
+    return getRadarPoint(
+      radarCenterX,
+      radarCenterY,
+      radarOuterRadiusX * progress,
+      radarOuterRadiusY * progress,
+      angles[index]
+    );
+  });
+
+  ctx.beginPath();
+  points.forEach((point, index) => {
+    if (index === 0) ctx.moveTo(point.x, point.y);
+    else ctx.lineTo(point.x, point.y);
+  });
+  ctx.closePath();
+  ctx.setFillStyle("rgba(255, 209, 154, 0.26)");
+  ctx.fill();
+  ctx.setStrokeStyle("rgba(220, 162, 92, 0.92)");
+  ctx.setLineWidth(radarStrokeWidth);
+  ctx.stroke();
+
+  points.forEach((point) => {
+    ctx.beginPath();
+    ctx.arc(point.x, point.y, radarPointRadius, 0, 2 * Math.PI);
+    ctx.setFillStyle("rgba(221, 162, 90, 1)");
+    ctx.fill();
+  });
+
+  ctx.beginPath();
+  ctx.arc(radarCenterX, radarCenterY, radarPointRadius, 0, 2 * Math.PI);
+  ctx.setFillStyle("rgba(125, 107, 83, 0.65)");
+  ctx.fill();
+  ctx.draw();
+};
+
+// 小程序 canvas 首次渲染时机不稳定，延后一帧再绘制更稳。
+const refreshRadar = async () => {
+  await nextTick();
+  setTimeout(() => {
+    drawRadar();
+  }, 30);
+};
+
+const loadPersonalTrainingData = async () => {
+  try {
+    const result = await getPersonalTrainingAPI();
+    trainingData.value = {
+      week_days:
+        Array.isArray(result?.week_days) && result.week_days.length
+          ? result.week_days
+          : createDefaultTrainingData().week_days,
+      stats: {
+        total_training_days: result?.stats?.total_training_days ?? 0,
+        total_arrows: result?.stats?.total_arrows ?? 0,
+        hit_rate: result?.stats?.hit_rate ?? 0,
+        endurance_shoot_speed: result?.stats?.endurance_shoot_speed ?? 0,
+        total_calories: result?.stats?.total_calories ?? 0,
+        overtake_rate: result?.stats?.overtake_rate ?? 0,
+      },
+      radar: {
+        dimensions:
+          Array.isArray(result?.radar?.dimensions) &&
+          result.radar.dimensions.length === 5
+            ? result.radar.dimensions
+            : createDefaultTrainingData().radar.dimensions,
+      },
+      training_items: Array.isArray(result?.training_items)
+        ? result.training_items
+        : [],
+    };
+  } catch (error) {
+    console.log("personal training load failed", error);
+    trainingData.value = createDefaultTrainingData();
+  } finally {
+    await refreshRadar();
+  }
+};
+
+const openTrainingRecord = () => {
+  uni.navigateTo({
+    url: "/pages/my-growth?tab=2",
+  });
+};
+
+const openTrainingItem = (item = {}) => {
+  const mode = getTrainingMode(item);
+  if (!mode) return;
+
+  if (item.is_locked) {
+    uni.showToast({
+      title: `${item.name || "训练"} 暂未开放`,
+      icon: "none",
+    });
+    return;
+  }
+
+  uni.navigateTo({
+    url: `/pages/training/difficulty?mode=${mode}`,
+  });
+};
+
+const openRoutineTraining = () => {
+  showRoutineTargetPicker.value = true;
+};
+
+const handleRoutineTargetConfirm = (target) => {
+  showRoutineTargetPicker.value = false;
+  uni.navigateTo({
+    url: `/pages/practise-one?target=${target}`,
+  });
+};
+
+// 首次进入页面时拉取数据并完成雷达图初始化。
+onMounted(async () => {
+  await loadPersonalTrainingData();
+  pageMounted.value = true;
+});
+
+// 从其他页面返回时刷新训练数据，保持进度与推荐状态最新。
+onShow(async () => {
+  if (!pageMounted.value) return;
+  await loadPersonalTrainingData();
+});
+</script>
+
+<template>
+  <Container :showBackToGame="true" :bgType="7" bgColor="#050b19">
+    <view class="training-home">
+      <view class="week-grid">
+        <view
+          v-for="item in trainingData.week_days"
+          :key="item.day"
+          class="week-item"
+        >
+          <view class="week-item-bg"></view>
+          <image
+            class="week-item-icon"
+            :src="item.status === 'checked' ? checkedIcon : missedIcon"
+            mode="widthFix"
+          />
+          <text
+            class="week-item-label"
+            :class="{ 'week-item-label-active': item.status === 'checked' }"
+          >
+            {{ item.day }}
+          </text>
+        </view>
+      </view>
+
+      <view class="stats-card">
+        <view class="stats-card-bg"></view>
+        <image
+          class="stats-quote stats-quote-left"
+          src="../../static/training-home/img_17.png"
+          mode="widthFix"
+        />
+        <image
+          class="stats-quote stats-quote-right"
+          src="../../static/training-home/img_16.png"
+          mode="widthFix"
+        />
+        <view class="stats-grid">
+          <view class="stats-item">
+            <view class="stats-value-row">
+              <view class="stats-value-group">
+                <text class="stats-value">
+                  {{ formatValue(trainingData.stats.total_training_days, 0) }}
+                </text>
+                <text class="stats-unit">天</text>
+                <view class="stats-value-decoration"></view>
+              </view>
+            </view>
+            <text class="stats-label">共训练</text>
+          </view>
+
+          <view class="stats-item">
+            <view class="stats-value-row">
+              <view class="stats-value-group">
+                <text class="stats-value">
+                  {{ formatValue(trainingData.stats.total_arrows, 0) }}
+                </text>
+                <text class="stats-unit">支</text>
+                <view class="stats-value-decoration"></view>
+              </view>
+            </view>
+            <text class="stats-label">累计射箭</text>
+          </view>
+
+          <view class="stats-item">
+            <view class="stats-value-row">
+              <view class="stats-value-group">
+                <text class="stats-value">
+                  {{ formatValue(trainingData.stats.hit_rate) }}
+                </text>
+                <text class="stats-unit">%</text>
+                <view class="stats-value-decoration"></view>
+              </view>
+            </view>
+            <text class="stats-label">命中率</text>
+          </view>
+
+          <view class="stats-item">
+            <view class="stats-value-row">
+              <view class="stats-value-group">
+                <text class="stats-value">
+                  {{ formatValue(trainingData.stats.endurance_shoot_speed, 0) }}
+                </text>
+                <text class="stats-unit">支/分钟</text>
+                <view class="stats-value-decoration"></view>
+              </view>
+            </view>
+            <text class="stats-label">耐力射击</text>
+          </view>
+
+          <view class="stats-item">
+            <view class="stats-value-row">
+              <view class="stats-value-group">
+                <text class="stats-value">
+                  {{ getCaloriesValue(trainingData.stats.total_calories) }}
+                </text>
+                <text class="stats-unit">卡路里</text>
+                <view class="stats-value-decoration"></view>
+              </view>
+            </view>
+            <text class="stats-label">共消耗</text>
+          </view>
+        </view>
+      </view>
+
+      <view class="radar-section">
+        <view class="record-bubble" @click="openTrainingRecord">
+          <image
+            class="record-bubble-bg"
+            src="../../static/training-home/img_28.png"
+            mode="widthFix"
+          />
+          <view class="record-bubble-copy">
+            <view class="record-main">
+              已超越<text class="record-main-highlight">{{ formatValue(trainingData.stats.overtake_rate) }}%</text>对手
+            </view>
+            <view class="record-sub-row">
+              <text class="record-sub-text">我的训练记录</text>
+              <image
+                class="record-arrow"
+                src="../../static/training-home/img_7.png"
+                mode="widthFix"
+              />
+            </view>
+          </view>
+        </view>
+
+        <view class="radar-board">
+          <text class="radar-label radar-label-top">
+            {{ trainingData.radar.dimensions[0].name }}
+          </text>
+          <text class="radar-label radar-label-right">
+            {{ trainingData.radar.dimensions[1].name }}
+          </text>
+          <text class="radar-label radar-label-bottom-right">
+            {{ trainingData.radar.dimensions[2].name }}
+          </text>
+          <text class="radar-label radar-label-bottom-left">
+            {{ trainingData.radar.dimensions[3].name }}
+          </text>
+          <text class="radar-label radar-label-left">
+            {{ trainingData.radar.dimensions[4].name }}
+          </text>
+
+          <view class="radar-figure" :style="radarFigureStyle">
+            <image
+              class="radar-grid-image"
+              :style="radarFigureStyle"
+              src="../../static/training-home/img_19.png"
+            />
+            <canvas
+              :canvas-id="trainingRadarCanvasId"
+              :id="trainingRadarCanvasId"
+              class="radar-canvas"
+              :style="radarFigureStyle"
+              :width="radarCanvasWidth"
+              :height="radarCanvasHeight"
+            />
+            <image
+              class="radar-mascot"
+              src="../../static/training-home/img_21.png"
+              mode="widthFix"
+            />
+          </view>
+        </view>
+      </view>
+
+      <view class="featured-card" @click="openRoutineTraining">
+        <image
+          class="featured-card-bg"
+          src="../../static/training-home/img_22.png"
+          mode="widthFix"
+        />
+        <view class="featured-card-mask"></view>
+        <view class="featured-card-copy">
+          <text class="featured-card-title">常规训练</text>
+          <text class="featured-card-subtitle">12箭练习</text>
+        </view>
+      </view>
+
+      <view class="mode-grid">
+        <view
+          v-for="item in trainingData.training_items.filter((item) => item.id !== 'strength')"
+          :key="item.id"
+          class="mode-card"
+          @click="openTrainingItem(item)"
+        >
+          <view v-if="item.is_recommended" class="mode-tag">推荐</view>
+          <view class="mode-card-copy">
+            <image
+              v-if="getTrainingTitleImage(item)"
+              class="mode-card-title-image"
+              :src="getTrainingTitleImage(item)"
+              mode="widthFix"
+            />
+            <text v-else class="mode-card-title">{{ item.name }}</text>
+            <text class="mode-card-progress">{{ getLevelText(item) }}</text>
+          </view>
+          <image
+            class="mode-card-icon"
+            :src="getTrainingIcon(item)"
+            mode="aspectFit"
+          />
+        </view>
+      </view>
+    </view>
+    <TargetPicker
+      :show="showRoutineTargetPicker"
+      :onClose="() => (showRoutineTargetPicker = false)"
+      :onConfirm="handleRoutineTargetConfirm"
+    />
+  </Container>
+</template>
+
+<style scoped>
+.training-home {
+  position: relative;
+  overflow: hidden;
+  padding: 18rpx 20rpx 60rpx 20rpx;
+}
+
+.week-grid {
+  display: flex;
+  justify-content: space-between;
+  margin-top: 18rpx;
+}
+
+.week-item {
+  position: relative;
+  width: 92rpx;
+  height: 96rpx;
+  border-radius: 16rpx;
+  overflow: hidden;
+}
+
+.week-item-bg {
+  width: 100%;
+  height: 100%;
+  background: linear-gradient(180deg, #2f2d2b 0%, #252831 100%);
+  opacity: 0.5;
+}
+
+.week-item-icon {
+  position: absolute;
+  left: 28rpx;
+  top: 14rpx;
+  width: 36rpx;
+}
+
+.week-item-label {
+  position: absolute;
+  left: 0;
+  right: 0;
+  bottom: 10rpx;
+  color: rgba(255, 255, 255, 0.6);
+  font-size: 20rpx;
+  text-align: center;
+  line-height: 28rpx;
+}
+
+.week-item-label-active {
+  color: #e7ba80;
+}
+
+.stats-card {
+  position: relative;
+  margin-top: 32rpx;
+  width: 100%;
+  height: 124rpx;
+  overflow: hidden;
+  border-radius: 24rpx;
+}
+
+.stats-card-bg {
+  position: absolute;
+  inset: 0;
+  background: linear-gradient(180deg, #2f2d2b 0%, #252831 100%);
+  opacity: 0.5;
+}
+
+.stats-quote {
+  position: absolute;
+  z-index: 1;
+  width: 53rpx;
+  height: 50rpx;
+}
+
+.stats-quote-left {
+  left: 4rpx;
+  top: 4rpx;
+}
+
+.stats-quote-right {
+  right: 4rpx;
+  bottom: 4rpx;
+}
+
+.stats-grid {
+  position: absolute;
+  z-index: 1;
+  left: 36rpx;
+  right: 36rpx;
+  top: 22rpx;
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+}
+
+.stats-item {
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  text-align: center;
+}
+
+.stats-value-row {
+  display: flex;
+  align-items: flex-end;
+  justify-content: center;
+  width: 100%;
+  height: 48rpx;
+  line-height: 48rpx;
+}
+
+.stats-value-group {
+  position: relative;
+  display: inline-flex;
+  align-items: flex-end;
+  justify-content: center;
+  min-width: 72rpx;
+  white-space: nowrap;
+}
+
+.stats-value-decoration {
+  position: absolute;
+  left: 0;
+  right: 0;
+  bottom: 6rpx;
+  min-width: 72rpx;
+  height: 12rpx;
+  border-radius: 6rpx;
+  background: linear-gradient(133deg, #ffd19a 0%, #a17636 100%);
+  opacity: 0.5;
+}
+
+.stats-value {
+  position: relative;
+  z-index: 1;
+  color: #fff;
+  font-size: 34rpx;
+  font-family: Helvetica, Arial, sans-serif;
+  font-weight: 500;
+  line-height: 46rpx;
+}
+
+.stats-unit {
+  position: relative;
+  z-index: 1;
+  margin-left: 4rpx;
+  padding-bottom: 8rpx;
+  color: #fff;
+  font-size: 20rpx;
+  line-height: 28rpx;
+  opacity: 0.6;
+}
+
+.stats-label {
+  display: inline-block;
+  margin-top: 6rpx;
+  color: #fcce96;
+  font-size: 20rpx;
+  line-height: 28rpx;
+  opacity: 0.6;
+}
+
+.radar-section {
+  position: relative;
+  padding-top: 34rpx;
+}
+
+.record-bubble {
+  position: absolute;
+  right: 0;
+  top: 10rpx;
+  width: 202rpx;
+  height: 122rpx;
+  z-index: 3;
+}
+
+.record-bubble-bg {
+  width: 202rpx;
+}
+
+.record-bubble-copy {
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: 24rpx;
+  text-align: center;
+}
+
+.record-main {
+  color: #fff;
+  font-size: 24rpx;
+  line-height: 30rpx;
+}
+
+.record-main-highlight {
+  color: #e7ba80;
+}
+
+.record-sub-row {
+  margin-top: 4rpx;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.record-sub-text {
+  color: #ffd947;
+  font-size: 24rpx;
+  height: 30rpx;
+  line-height: 30rpx;
+}
+
+.record-arrow {
+  width: 24rpx;
+}
+
+.radar-board {
+  position: relative;
+  width: 100%;
+  height: 514rpx;
+}
+
+.radar-label {
+  position: absolute;
+  color: rgba(255, 255, 255, 0.78);
+  font-size: 28rpx;
+  line-height: 40rpx;
+}
+
+.radar-label-top {
+  left: 350rpx;
+  top: 14rpx;
+  transform: translateX(-50%);
+  opacity: 0.5;
+}
+
+.radar-label-right {
+  right: 77rpx;
+  top: 190rpx;
+  opacity: 0.5;
+}
+
+.radar-label-bottom-right {
+  right: 170rpx;
+  bottom: 18rpx;
+  opacity: 0.5;
+}
+
+.radar-label-bottom-left {
+  left: 170rpx;
+  bottom: 18rpx;
+  opacity: 0.5;
+}
+
+.radar-label-left {
+  left: 75rpx;
+  top: 180rpx;
+  opacity: 0.5;
+}
+
+.radar-figure {
+  position: absolute;
+  left: 50%;
+  top: 54rpx;
+  transform: translateX(-50%);
+  overflow: visible;
+}
+
+.radar-grid-image,
+.radar-canvas {
+  position: absolute;
+  left: 0;
+  top: 0;
+}
+
+.radar-mascot {
+  position: absolute;
+  right: 38rpx;
+  top: 0;
+  width: 92rpx;
+}
+
+.featured-card {
+  position: relative;
+  width: 100%;
+  height: 150rpx;
+  margin-top: 70rpx;
+  border-radius: 16rpx;
+  overflow: hidden;
+}
+
+.featured-card-bg {
+  width: 100%;
+}
+
+.featured-card-mask {
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 278rpx;
+  height: 150rpx;
+  background: linear-gradient(90deg, #ffdaa0 0%, #f5c580 74%, rgba(245, 197, 128, 0) 100%);
+}
+
+.featured-card-copy {
+  position: absolute;
+  left: 30rpx;
+  top: 34rpx;
+  display: flex;
+  flex-direction: column;
+}
+
+.featured-card-title {
+  display: block;
+  color: #895409;
+  font-size: 34rpx;
+  font-family: "AlimamaShuHeiTi-Bold", "PingFang SC", sans-serif;
+  font-weight: 700;
+  line-height: 42rpx;
+}
+
+.featured-card-subtitle {
+  display: block;
+  margin-top: 10rpx;
+  color: #895409;
+  font-size: 22rpx;
+  line-height: 32rpx;
+  opacity: 0.72;
+}
+
+.mode-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 16rpx 18rpx;
+  margin-top: 16rpx;
+}
+
+.mode-card {
+  position: relative;
+  height: 150rpx;
+  box-shadow: inset 2rpx 2rpx 6rpx 0rpx rgba(255, 255, 255, 0.27);
+  border-radius: 16rpx;
+  border: 2rpx solid rgba(235, 184, 123, 0.5);
+  background: rgba(0, 0, 0, 0.5);
+  overflow: hidden;
+}
+
+.mode-tag {
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 72rpx;
+  height: 34rpx;
+  line-height: 34rpx;
+  text-align: center;
+  font-size: 20rpx;
+  color: #000;
+  border-bottom-right-radius: 16rpx;
+  background: linear-gradient(133deg, #ffd19a 0%, #a17636 100%);
+}
+
+.mode-card-copy {
+  position: absolute;
+  left: 30rpx;
+  top: 40rpx;
+}
+
+.mode-card-title {
+  display: block;
+  background-image: linear-gradient(
+    133deg,
+    rgba(235, 184, 123, 0.8) 0%,
+    rgba(181, 140, 78, 0.8) 100%
+  );
+  color: #e7ba80;
+  font-size: 32rpx;
+  font-family: "AlimamaShuHeiTi-Bold", "PingFang SC", sans-serif;
+  font-weight: 700;
+  line-height: 38rpx;
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+}
+
+.mode-card-title-image {
+  display: block;
+  width: 128rpx;
+}
+
+.mode-card-progress {
+  display: block;
+  margin-top: 14rpx;
+  color: #fcce96;
+  font-size: 22rpx;
+  line-height: 32rpx;
+  opacity: 0.5;
+}
+
+.mode-card-icon {
+  position: absolute;
+  right: 12rpx;
+  top: 14rpx;
+  width: 124rpx;
+  height: 124rpx;
+}
+</style>
@@ -0,0 +1,537 @@
+<script setup>
+import { computed, ref, onMounted, onBeforeUnmount } from "vue";
+import { onLoad } from "@dcloudio/uni-app";
+import Container from "@/components/Container.vue";
+import ShootProgress from "./components/ShootProgress.vue";
+import BowTarget from "./components/BowTarget.vue";
+import ScorePanel2 from "./components/ScorePanel2.vue";
+import ScoreResult from "./components/ScoreResult.vue";
+import Avatar from "@/components/Avatar.vue";
+import BowPower from "@/components/BowPower.vue";
+import TestDistance from "./components/TestDistance.vue";
+import BubbleTip from "./components/BubbleTip.vue";
+import audioManager from "@/audioManager";
+
+import {
+  createPractiseAPI,
+  startPractiseAPI,
+  endPractiseAPI,
+  getPractiseAPI,
+} from "@/apis";
+import { sharePractiseData } from "@/canvas";
+import { wxShare, debounce } from "@/util";
+import { MESSAGETYPESV2, roundsName } from "@/constants";
+
+import useStore from "@/store";
+import { storeToRefs } from "pinia";
+const store = useStore();
+const { user } = storeToRefs(store);
+
+const sound = ref(true);
+const start = ref(false);
+const pageStages = Object.freeze({
+  DISTANCE: "distance",
+  SHOOTING: "shooting",
+  RESULT: "result",
+  LOADING: "loading",
+});
+const pageStage = ref(pageStages.DISTANCE);
+const scores = ref([]);
+const defaultTotal = 12;
+const defaultShootTime = 120;
+const defaultTargetType = 1;
+const total = ref(defaultTotal);
+const shootTime = ref(defaultShootTime);
+const practiseResult = ref({});
+const practiseId = ref("");
+const showGuide = ref(false);
+const tips = ref("");
+const targetType = ref(defaultTargetType);
+const trainingParams = ref({});
+const trainingDifficultyRefreshEvent = "training-difficulty-refresh";
+const useHighlightTest = ref(false);
+const highlightTestTimer = ref(null);
+
+const env = computed(() => {
+  try {
+    return uni.getAccountInfoSync().miniProgram.envVersion;
+  } catch (error) {
+    return "release";
+  }
+});
+
+const isDistanceStage = computed(() => pageStage.value === pageStages.DISTANCE);
+const isShootingStage = computed(() => pageStage.value === pageStages.SHOOTING);
+const hasPractiseResult = computed(() => !!practiseResult.value?.details);
+const showResult = computed(
+  () => pageStage.value === pageStages.RESULT && hasPractiseResult.value
+);
+
+const defaultHighlightAreas = [{ quadrant: 1, rings: [7] }];
+
+// 临时高亮测试数据：第 N 项对应第 N 箭，每箭展示一个不同区域。
+const highlightTestAreas = [
+  { arrowIndex: 1, quadrant: 1, rings: [10] },
+  { arrowIndex: 2, quadrant: 2, rings: [9, 10] },
+  { arrowIndex: 3, quadrant: 3, rings: [8, 9] },
+  { arrowIndex: 4, quadrant: 4, rings: [7, 8] },
+  { arrowIndex: 5, quadrant: 1, rings: [6, 7] },
+  { arrowIndex: 6, quadrant: 2, rings: [5, 6] },
+  { arrowIndex: 7, quadrant: 3, rings: [4, 5] },
+  { arrowIndex: 8, quadrant: 4, rings: [3, 4] },
+  { arrowIndex: 9, quadrant: 1, rings: "all", scope: "sector" },
+  { arrowIndex: 10, quadrant: 2, rings: "all", scope: "sector" },
+  { arrowIndex: 11, quadrant: 3, rings: "all", scope: "sector" },
+  { arrowIndex: 12, quadrant: 4, rings: "all", scope: "sector" },
+];
+
+const targetHighlightAreas = computed(() => {
+  return useHighlightTest.value ? highlightTestAreas : defaultHighlightAreas;
+});
+
+const toRouteNumber = (value, fallback = 0) => {
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) ? numberValue : fallback;
+};
+
+const toPositiveRouteNumber = (value, fallback) => {
+  const numberValue = toRouteNumber(value, fallback);
+  return numberValue > 0 ? numberValue : fallback;
+};
+
+const createPractice = async () => {
+  const result = await createPractiseAPI(
+    total.value,
+    shootTime.value,
+    targetType.value
+  );
+
+  if (result) practiseId.value = result.id;
+};
+
+const clearHighlightTestTimer = () => {
+  if (highlightTestTimer.value) {
+    clearInterval(highlightTestTimer.value);
+    highlightTestTimer.value = null;
+  }
+};
+
+const buildHighlightTestScore = (index) => ({
+  playerId: user.value?.id,
+  ring: 9,
+  ringX: false,
+  x: ((index % 4) - 1.5) * 2,
+  y: (Math.floor(index / 4) - 1) * 2,
+  angle: null,
+});
+
+const setHighlightTestArrow = (arrowIndex) => {
+  const completedCount = Math.max(arrowIndex - 1, 0);
+  scores.value = Array.from({ length: completedCount }, (_, index) =>
+    buildHighlightTestScore(index)
+  );
+};
+
+// 临时测试入口：自动切换第 1 到第 12 箭，让 BowTarget 按当前箭展示不同高亮。
+const runHighlightTest = () => {
+  clearHighlightTestTimer();
+  useHighlightTest.value = true;
+  practiseResult.value = {};
+  pageStage.value = pageStages.SHOOTING;
+  start.value = true;
+
+  let arrowIndex = 1;
+  setHighlightTestArrow(arrowIndex);
+
+  highlightTestTimer.value = setInterval(() => {
+    if (arrowIndex >= highlightTestAreas.length) {
+      clearHighlightTestTimer();
+      return;
+    }
+
+    arrowIndex += 1;
+    setHighlightTestArrow(arrowIndex);
+  }, 1000);
+};
+
+const resetHighlightTest = () => {
+  clearHighlightTestTimer();
+  useHighlightTest.value = false;
+  scores.value = [];
+};
+
+onLoad((options = {}) => {
+  targetType.value = toPositiveRouteNumber(options.target, defaultTargetType);
+  total.value = toPositiveRouteNumber(options.arrows, defaultTotal);
+  shootTime.value = toPositiveRouteNumber(options.time, defaultShootTime);
+  trainingParams.value = {
+    type: options.type || "",
+    difficultyId: options.difficultyId || "",
+    difficulty: toRouteNumber(options.difficulty),
+    recordId: options.recordId || "",
+    hitReq: toRouteNumber(options.hitReq),
+    totalReq: toRouteNumber(options.totalReq),
+    blocks: toRouteNumber(options.blocks),
+    mode: toRouteNumber(options.mode),
+  };
+});
+
+const onReady = async () => {
+  pageStage.value = pageStages.LOADING;
+  clearHighlightTestTimer();
+  useHighlightTest.value = false;
+  try {
+    await startPractiseAPI();
+    practiseResult.value = {};
+    scores.value = [];
+    start.value = true;
+    pageStage.value = pageStages.SHOOTING;
+    audioManager.play("练习开始");
+  } catch (error) {
+    start.value = false;
+    pageStage.value = pageStages.DISTANCE;
+    throw error;
+  }
+};
+
+const onOver = async () => {
+  if (!isShootingStage.value) return;
+
+  clearHighlightTestTimer();
+  pageStage.value = pageStages.LOADING;
+  start.value = false;
+
+  try {
+    practiseResult.value = (await getPractiseAPI(practiseId.value)) || {};
+    pageStage.value = hasPractiseResult.value
+      ? pageStages.RESULT
+      : pageStages.DISTANCE;
+  } catch (error) {
+    start.value = true;
+    pageStage.value = pageStages.SHOOTING;
+    throw error;
+  }
+};
+
+async function onReceiveMessage(msg) {
+  if (msg.type === MESSAGETYPESV2.ShootResult && isShootingStage.value) {
+    scores.value = msg.details;
+  } else if (msg.type === MESSAGETYPESV2.BattleEnd) {
+    // setTimeout(onOver, 1500);
+  }
+}
+
+function onComplete() {
+  pageStage.value = pageStages.LOADING;
+  start.value = false;
+  uni.$emit(trainingDifficultyRefreshEvent);
+  uni.navigateBack();
+}
+
+async function onRetry() {
+  pageStage.value = pageStages.LOADING;
+  clearHighlightTestTimer();
+  useHighlightTest.value = false;
+  practiseId.value = "";
+  practiseResult.value = {};
+  start.value = false;
+  scores.value = [];
+  try {
+    await createPractice();
+  } finally {
+    pageStage.value = pageStages.DISTANCE;
+  }
+}
+
+const onClickShare = debounce(async () => {
+  await sharePractiseData("shareCanvas", 2, user.value, practiseResult.value);
+  await wxShare("shareCanvas");
+});
+
+function onAudioEnded(s) {
+  if (s.indexOf("比赛结束") >= 0) {
+    onOver()
+  }
+}
+
+const updateSound = () => {
+  sound.value = !sound.value;
+  audioManager.setMuted(!sound.value);
+};
+
+
+onMounted(async () => {
+  // audioManager.play("第一轮");
+  uni.setKeepScreenOn({
+    keepScreenOn: true,
+  });
+  uni.$on("socket-inbox", onReceiveMessage);
+  uni.$on("share-image", onClickShare);
+  uni.$on("audioEnded", onAudioEnded);
+  await createPractice();
+});
+
+onBeforeUnmount(() => {
+  uni.setKeepScreenOn({
+    keepScreenOn: false,
+  });
+  uni.$off("socket-inbox", onReceiveMessage);
+  uni.$off("share-image", onClickShare);
+  uni.$off("audioEnded", onAudioEnded);
+  audioManager.stopAll();
+  clearHighlightTestTimer();
+  endPractiseAPI();
+});
+</script>
+
+<template>
+  <Container
+    :bgType="isDistanceStage ? 9 : 11"
+    :showBottom="isDistanceStage"
+    :scroll="!isShootingStage"
+  >
+    <view class="practise-content">
+      <TestDistance v-if="isDistanceStage" />
+      <view v-else-if="isShootingStage" class="shooting-layout">
+        <view class="shooting-fixed">
+          <ShootProgress
+            :start="start"
+            :onStop="onOver"
+          />
+          <view class="user-row">
+            <!-- <Avatar :src="user.avatar" :size="35" /> -->
+            <BubbleTip v-if="showGuide" type="normal2">
+              <text>还有两场，坚持</text>
+              <text>就是胜利！💪</text>
+            </BubbleTip>
+            <!-- <BowPower /> -->
+          </view>
+          <BowTarget
+            :totalRound="start ? total / 4 : 0"
+            :currentRound="scores.length % 3"
+            :scores="scores"
+            :showCrosshair="false"
+            :highlightAreas="targetHighlightAreas"
+          />
+          <view v-if="env !== 'release'" class="highlight-test-actions">
+            <button
+              class="highlight-test-btn"
+              hover-class="none"
+              @click="runHighlightTest"
+            >
+              高亮测试
+            </button>
+            <button
+              class="highlight-test-btn"
+              hover-class="none"
+              @click="resetHighlightTest"
+            >
+              重置高亮
+            </button>
+          </view>
+          <view class="sound-text-box">
+            <button class="sound-btn" hover-class="none" @click="updateSound">
+              <image
+                class="sound-icon"
+                :src="`/static/sound${sound ? '' : '-off'}-yellow.png`"
+                mode="aspectFit"
+              />
+            </button>
+            <view class="bat-text-big-box">
+              <image
+                class="dao-icon"
+                src="../../static/training-difficulty-design/dao-icon.png"
+                mode="widthFix"
+              />
+              <view class="bat-text-box">
+                <view class="bat-text-small-box">
+                  <view class="text-round-box">
+                    <view class="text1">每箭命中9环之上</view>
+                    <view class="text2">剩余<text class="text2-yellow">3</text>箭</view>
+                  </view>
+                </view>
+              </view>
+            </view>
+          </view>
+        </view>
+        <scroll-view
+          class="score-scroll"
+          scroll-y
+          :enhanced="true"
+          :show-scrollbar="false"
+        >
+          <ScorePanel2 :arrows="scores" :total="total" />
+        </scroll-view>
+      </view>
+      <ScoreResult
+        v-else-if="showResult"
+        :rowCount="6"
+        :total="total"
+        :onClose="onComplete"
+        :onRetry="onRetry"
+        :result="practiseResult"
+      />
+      <canvas class="share-canvas" id="shareCanvas" type="2d"></canvas>
+    </view>
+    <template #bottom>
+      <view class="btn-box">
+        <image
+          class="btn-box-bg"
+          src="../../static/training-difficulty-design/par-star.png"
+          mode="widthFix"
+        />
+        <button class="btn" @click="onReady">准备好了，开始练习</button>
+      </view>
+    </template>
+  </Container>
+</template>
+
+<style scoped>
+.practise-content {
+  height: 100%;
+  min-height: 0;
+}
+
+.shooting-layout {
+  height: 100%;
+  min-height: 0;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+}
+
+.shooting-fixed {
+  flex-shrink: 0;
+}
+
+.score-scroll {
+  flex: 1;
+  height: 0;
+  min-height: 0;
+  overflow: hidden;
+}
+
+.btn-box{
+  width: 488rpx;
+  height: 234rpx;
+  position: fixed;
+  bottom: 130rpx;
+  left: 50%;
+  transform: translateX(-50%);
+}
+.btn-box-bg{
+  width: 100%;
+}
+.btn{
+  width: 330rpx;
+  height: 70rpx;
+  line-height: 70rpx;
+  background: #FED847;
+  border-radius: 44rpx;
+  text-align: center;
+  color: #000000;
+  font-size: 28rpx;
+  font-weight: 500;
+  position: absolute;
+  left: 50%;
+  transform: translateX(-50%);
+  bottom: -36rpx;
+}
+
+.highlight-test-actions {
+  display: flex;
+  justify-content: center;
+  margin-top: -24rpx;
+  position: relative;
+  z-index: 10;
+}
+
+.highlight-test-btn {
+  width: 150rpx;
+  height: 48rpx;
+  line-height: 48rpx;
+  padding: 0;
+  border-radius: 24rpx;
+  background: rgba(0, 0, 0, 0.48);
+  color: #fed847;
+  font-size: 22rpx;
+}
+
+.highlight-test-btn::after {
+  border: none;
+}
+
+.highlight-test-btn + .highlight-test-btn {
+  margin-left: 16rpx;
+}
+
+.sound-text-box{
+  height: 125rpx;
+  padding: 0 56rpx;
+  display: flex;
+  align-items: flex-end;
+}
+.sound-btn {
+  width: 76rpx;
+  height: 70rpx;
+  border: none;
+}
+
+.sound-btn::after {
+  border: none;
+}
+
+.sound-icon {
+  width: 76rpx;
+  height: 70rpx;
+}
+.bat-text-big-box{
+  flex: 1;
+  position: relative;
+}
+.dao-icon{
+  width: 160rpx;
+  height: 125rpx;
+  position: absolute;
+  left: 0;
+  bottom: 0;
+}
+.text-round-box{
+  width: 100%;
+}
+.bat-text-box{
+  display: flex;
+}
+.bat-text-small-box{
+  background: rgba(0, 0, 0, 0.5);
+  width: auto;
+  min-width: 100rpx;
+  border-radius: 16rpx 60rpx 60rpx 16rpx;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  padding-left: 176rpx;
+  height: 112rpx;
+  padding-right: 30rpx;
+  font-size: 30rpx;
+  color: #E7BA80;
+}
+.text1{
+  font-size: 30rpx;
+  font-weight: 400;
+  color: #E7BA80;
+  line-height: 42rpx;
+}
+.text2{
+  color: #FFFFFF;
+  font-size: 26rpx;
+  font-weight: 400;
+  line-height: 36rpx;
+}
+.text2-yellow{
+  font-size: 30rpx;
+  color: #FFD947;
+  font-weight: 500;
+  margin: 0 4rpx;
+}
+</style>
@@ -19,7 +19,6 @@ const toOrderPage = () => {

 const toFristTryPage = async () => {
  if (canEenter(user.value, device.value, online.value, "/pages/first-try")) {
-    await uni.$checkAudio();
    uni.navigateTo({
      url: "/pages/first-try",
    });
@@ -136,7 +135,7 @@ const buildVersion = typeof __BUILD_TIME__ !== 'undefined' ? __BUILD_TIME__ : ''
          <text>点</text>
        </UserItem>
        <view class="my-grow" @click="toMyGrowthPage">
-          <image src="../static/my-grow.png" mode="widthFix" />
+          <image src="https://static.shelingxingqiu.com/shootmini/static/my-grow.png" mode="widthFix" />
        </view>
        <UserItem title="关于我们" :onClick="toAboutUsPage" />
        <UserItem
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="55px" height="55px" viewBox="0 0 55 55" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <title>编组 11</title>
+    <g id="页面-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <g id="训练难度展示" transform="translate(-160.000000, -478.000000)">
+            <g id="编组-2备份" transform="translate(154.000000, 472.000000)">
+                <g id="编组-11" transform="translate(6.000000, 6.000000)">
+                    <circle id="椭圆形" fill="#CACACA" cx="27.5" cy="27.5" r="27.5"></circle>
+                    <circle id="椭圆形" fill="#FFFFFF" cx="27.5" cy="26" r="25"></circle>
+                    <circle id="椭圆形" fill="#5E5E5E" cx="27.5" cy="26" r="22"></circle>
+                    <circle id="椭圆形" fill="#17B6F2" cx="27.5" cy="26" r="19.5"></circle>
+                    <circle id="椭圆形" fill="#FFC2C2" cx="27.5" cy="26" r="17"></circle>
+                    <circle id="椭圆形" fill="#FF1F33" opacity="0.800000012" cx="27.5" cy="26" r="14.5"></circle>
+                    <circle id="椭圆形" fill="#FED847" cx="27.5" cy="26" r="13"></circle>
+                </g>
+            </g>
+        </g>
+    </g>
+</svg>
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
zhangyi	a78ab1daeb	Merge branch 'test' into feat-prac	2026-07-20 17:58:40 +08:00
zhangyi	886faa0007	update:新增匹配跳转幂等	2026-07-20 16:46:04 +08:00
zhangyi	b15c37cb4a	update:优化10人乱斗测距页	2026-07-17 18:26:14 +08:00
zhangyi	f64a6b5c95	update:新增房间重连逻辑，优化tententen语音，修复mvp斩获环	2026-07-16 16:40:32 +08:00
zhangyi	621397e25d	update:优化比赛流程	2026-07-16 11:38:17 +08:00
zhangyi	fa7ad8f538	update:优化比赛结束	2026-07-15 16:57:48 +08:00
zhangyi	af7f70ba80	update:修改mvp字段	2026-07-15 15:22:31 +08:00
zhangyi	1c7cf74eb9	update:优化段位介绍	2026-07-15 09:55:01 +08:00
zhangyi	e9023ecc9f	update:新增dist排除代码	2026-07-14 17:59:52 +08:00
zhangyi	080af14be8	update:语音加载优化，修复大乱斗未重连比赛服问题	2026-07-13 14:50:21 +08:00
zhangyi	1796d4aa40	update:房间新增vip特效	2026-07-10 18:13:41 +08:00
zhangyi	4b39107453	update：优化大乱斗断连	2026-07-10 17:49:42 +08:00
zhangyi	3e090e5b33	update:修复大乱斗	2026-07-10 16:45:03 +08:00
zhangyi	98ca638b63	update:新增比赛服断线重连机制	2026-07-10 15:11:45 +08:00
zhangyi	b5373bee31	update:新版本websocket	2026-07-10 13:57:09 +08:00
zhangyi	58a7bb2017	update:优化个人练习	2026-07-09 18:29:04 +08:00
zhangyi	82eedc3ab8	update:分包、对接个人练习	2026-07-09 17:53:29 +08:00
zhangyi	ac4d8dfb38	Merge branch 'test' into feat-websoc	2026-07-09 16:26:31 +08:00
zhangyi	725a3ddcb9	update:优化比赛	2026-07-09 16:15:27 +08:00
zhangyi	33187e0cc3	update；优化比赛服	2026-07-09 15:48:28 +08:00
zhangyi	bf6b87b59c	update:优化跳转	2026-07-09 14:43:25 +08:00
zhangyi	12729a1cef	update:修复日志和防抖	2026-07-09 14:35:48 +08:00
zhangyi	f8efe4c4a4	update：优化比赛	2026-07-09 11:43:06 +08:00
zhangyi	af07d09ab6	update:优化比赛队列	2026-07-08 18:18:27 +08:00
zhangyi	e0d976fcce	update:更新比赛服逻辑	2026-07-08 16:03:34 +08:00
zhangyi	01ac4f9c03	update:新增比赛服链接	2026-07-08 14:51:35 +08:00
zhangyi	0bf4773400	Merge branch 'test' into feat-prac	2026-06-15 09:32:27 +08:00
zhangyi	022683aff1	Merge branch 'test' into feat-prac	2026-06-02 15:54:15 +08:00
zhangyi	72518fa17e	update:优化样式	2026-06-01 15:39:40 +08:00
zhangyi	f5497c534d	update:代码备份	2026-06-01 10:59:26 +08:00
zhangyi	b3fc11f1b1	update:代码备份	2026-05-29 17:46:52 +08:00
zhangyi	8b25a10d4c	Merge branch 'test' into feat-prac	2026-05-29 14:01:03 +08:00
zhangyi	0e82416800	Merge branch 'test' into feat-prac	2026-05-28 11:16:54 +08:00
zhangyi	e6d00e7ea9	Merge branch 'test' into feat-prac	2026-05-28 09:46:54 +08:00
zhangyi	18afba01ec	update:新增基础训练入口	2026-05-26 11:38:49 +08:00
zhangyi	2780d1a6df	update:代码备份	2026-05-26 10:23:31 +08:00
zhangyi	2a53f6739e	update:对接个人训练难度页	2026-05-26 09:33:28 +08:00
zhangyi	bae31add22	update:对接个人训练首页	2026-05-20 16:36:07 +08:00
zhangyi	465b9c8dc7	update:代码备份	2026-05-18 16:39:36 +08:00
zhangyi	3ff11df1d7	update:代码备份	2026-05-18 11:05:13 +08:00
zhangyi	21d8d0fbdb	update:代码备份	2026-05-18 09:20:07 +08:00
zhangyi	fc7149121b	update：优化	2026-05-15 10:23:59 +08:00
zhangyi	8061ddbed5	update：训练难度展示ui完成	2026-05-15 09:46:33 +08:00
zhangyi	bb50c7ca10	update:删除个人训练首页的无用组件	2026-05-13 10:54:15 +08:00
zhangyi	1bca5977c1	个人训练改版首页存档	2026-05-13 10:49:31 +08:00