fix: 修复game2,game3,移除多余图片

frontend-h5/src/composables/useGameSocket.ts

@@ -137,7 +137,7 @@ export function useGameSocket(options: GameSocketOptions) {
                     // debugger
                     return;
                 }
-                $toast('您已进入当前游戏房间')
+                $toast('您已进入游戏房间')
                 userJoinStatus.value = true
                 break
             }

frontend-h5/src/pages/game3/Game3.vue

@@ -157,6 +157,18 @@ function startGameCountdown(seconds = 60) {
   gameCountdownTimer = window.setTimeout(tickCountdown, 1000);
 }
 
+function syncGameCountdown(seconds: number) {
+  const syncedSeconds = Math.max(0, Math.floor(seconds));
+  if (countdownInterval.value - syncedSeconds <= 1) return;
+
+  if (syncedSeconds === 0) {
+    countdownInterval.value = 0;
+    return;
+  }
+
+  startGameCountdown(syncedSeconds);
+}
+
 function resetToLoadingView() {
   stopGameCountdown();
   if (guFrameTimer) {
@@ -231,10 +243,20 @@ if (wechat) {
     onScoreSubmitted: (is_save, data) => {
       if (!is_save) {
         //非保存状态下
+        const nextScore = Number(typeof data === "object" ? data?.score : NaN);
         const nextRank = Number(typeof data === "object" ? data?.rank : data);
+        const remainingSeconds = Number(
+          typeof data === "object" ? data?.remainingSeconds : NaN,
+        );
+        if (Number.isFinite(nextScore) && nextScore >= 0) {
+          score.value = nextScore;
+        }
         if (Number.isFinite(nextRank) && nextRank > 0) {
           rank.value = nextRank;
         }
+        if (Number.isFinite(remainingSeconds) && remainingSeconds >= 0) {
+          syncGameCountdown(remainingSeconds);
+        }
       } else if (typeof data === "object" && data) {
         if (Array.isArray(data.list)) {
           rankList.value = data.list.map((item: any, index: number) => ({
@@ -250,6 +272,7 @@ if (wechat) {
           rank.value = nextRank;
         }
       }
+      return { code: "MSYF", score: score.value };
     },
     onRescoreSubmitted: (_recount) => {
       submitScore(true);

frontend-large/src/pages/game2/views/Rank1View.vue

@@ -20,12 +20,14 @@ const HORSE_SPRITE_COLUMNS = 10;
 const HORSE_FRAME_DURATION = 50;
 const RACE_TICK_DURATION = 50;
 const RACE_DURATION = 60_000;
-const RANK_RUNNING_GAP = 45;
-const RANK_SPEED_FACTORS = [1.04, 1.025, 1.01, 0.995, 0.98, 0.965];
-const FINISH_RANK_OFFSETS = [0, 72, 94, 181, 207, 302];
-const TIE_POSITION_OFFSETS = [48, -76, 96, -28, 67, -108];
+const RANK_RUNNING_GAP = 135;
+const RANK_FINISH_PROGRESS = [1, 0.86, 0.8, 0.74, 0.69, 0.65];
+const RANK_SPEED_FACTORS = [1.08, 1.04, 1.01, 0.98, 0.95, 0.92];
 const RACE_START_X = -225;
 const TRACK_MAX_X = 1595;
+const BASE_SPEED_PER_TICK = (TRACK_MAX_X - RACE_START_X) / (RACE_DURATION / RACE_TICK_DURATION);
+const MAX_SPEED_PER_TICK = BASE_SPEED_PER_TICK * 1.25;
+const MAX_ACCELERATION_PER_TICK = 0.035;
 const BACKGROUND_WIDTH = 2358;
 const STAGE_WIDTH = 1920;
 const designStage = ref<InstanceType<typeof DesignStage> | null>(null);
@@ -49,7 +51,6 @@ type Racer = {
     paceAmplitude: number;
     paceFrequency: number;
     pacePhase: number;
-    tieOffset: number;
 };
 const START_COUNTDOWN_SECONDS = 3;
 const racers = ref<Racer[]>([]);
@@ -107,10 +108,9 @@ const createPaceProfile = (key: string) => {
     const hash = Math.abs(hashKey(key));
 
     return {
-        paceAmplitude: 14 + hash % 18,
+        paceAmplitude: 25 + hash % 35,
         paceFrequency: 1.5 + (hash % 5) * 0.2,
         pacePhase: (hash % 360) * Math.PI / 180,
-        tieOffset: TIE_POSITION_OFFSETS[hash % TIE_POSITION_OFFSETS.length]!,
     };
 };
 
@@ -120,8 +120,6 @@ const isRealPlayer = (player: Player) => (
     && player.nickname !== '-'
 );
 
-const scoreOf = (player: Player) => Number(player.score || 0);
-
 const renderRaceBackground = () => {
     const progress = Math.min(raceElapsed.value / RACE_DURATION, 1);
     const backgroundX = -(BACKGROUND_WIDTH - STAGE_WIDTH) * progress;
@@ -136,22 +134,18 @@ const targetXForRacer = (racer: Racer, rankIndex: number) => {
     const safeRankIndex = Math.max(0, Math.min(rankIndex, HORSE_COUNT - 1));
     const progress = Math.min(raceElapsed.value / RACE_DURATION, 1);
     const runningGap = RANK_RUNNING_GAP * Math.sin(Math.PI * progress);
-    const finishOffset = FINISH_RANK_OFFSETS[safeRankIndex]! * progress;
+    const rankedDistance = (TRACK_MAX_X - RACE_START_X)
+        * RANK_FINISH_PROGRESS[safeRankIndex]!
+        * progress;
     const paceFade = Math.sin(Math.PI * progress);
     const paceOffset = Math.sin(
         racer.pacePhase + progress * Math.PI * 2 * racer.paceFrequency,
     ) * racer.paceAmplitude * paceFade;
-    const tiedCount = racers.value.filter(
-        ({ player }) => scoreOf(player) === scoreOf(racer.player),
-    ).length;
-    const tieOffset = tiedCount > 1 ? racer.tieOffset * progress : 0;
 
     return RACE_START_X
-        + (TRACK_MAX_X - RACE_START_X) * progress
+        + rankedDistance
         - safeRankIndex * runningGap
-        - finishOffset
-        + paceOffset
-        + tieOffset;
+        + paceOffset;
 };
 
 const createRandomLanesByRank = () => {
@@ -230,20 +224,28 @@ const updateRacePositions = (tickScale = 1) => {
 
     racers.value.forEach((racer) => {
         const rankIndex = rankedPlayerKeys.value.indexOf(racer.key);
-        const racerScore = scoreOf(racer.player);
-        const sameScoreRank = rankedPlayerKeys.value.findIndex((key) => {
-            const rankedRacer = racers.value.find((item) => item.key === key);
-            return rankedRacer && scoreOf(rankedRacer.player) === racerScore;
-        });
-        const effectiveRank = sameScoreRank >= 0
-            ? sameScoreRank
-            : rankIndex >= 0 ? rankIndex : HORSE_COUNT - 1;
+        const effectiveRank = rankIndex >= 0 ? rankIndex : HORSE_COUNT - 1;
         const targetX = targetXForRacer(racer, effectiveRank);
         const speedFactor = RANK_SPEED_FACTORS[effectiveRank] ?? RANK_SPEED_FACTORS.at(-1)!;
-        const desiredSpeed = Math.max((targetX - racer.x) * 0.18 * speedFactor, 0);
-        const speedBlend = 1 - Math.pow(1 - 0.24, tickScale);
-
-        racer.speed += (desiredSpeed - racer.speed) * speedBlend;
+        const finishProgress = RANK_FINISH_PROGRESS[effectiveRank] ?? RANK_FINISH_PROGRESS.at(-1)!;
+        const positionCorrection = Math.max(
+            -0.35,
+            Math.min((targetX - racer.x) * 0.008, 0.35),
+        );
+        const desiredSpeed = Math.max(
+            0,
+            Math.min(
+                BASE_SPEED_PER_TICK * finishProgress * speedFactor + positionCorrection,
+                MAX_SPEED_PER_TICK,
+            ),
+        );
+        const speedDifference = desiredSpeed - racer.speed;
+        const accelerationLimit = MAX_ACCELERATION_PER_TICK * tickScale;
+
+        racer.speed += Math.max(
+            -accelerationLimit,
+            Math.min(speedDifference, accelerationLimit),
+        );
         racer.x = Math.min(racer.x + Math.max(racer.speed, 0) * tickScale, TRACK_MAX_X);
     });
 };