update

2026-03-24 15:25:40 +08:00
parent 292a4181ce
commit 58fe43607a
7 changed files with 757 additions and 9 deletions
--- a/src/features/chengdu-game/useChengduGameRoom.ts
+++ b/src/features/chengdu-game/useChengduGameRoom.ts
@@ -29,6 +29,17 @@ interface ActionEventLike {
  data?: unknown
 }

+interface PendingClaimOption {
+  playerId: string
+  actions: string[]
+}
+
+export interface ActionButtonState {
+  type: 'draw' | 'discard' | 'peng' | 'gang' | 'hu' | 'pass'
+  label: string
+  disabled: boolean
+}
+
 export interface SeatView {
  key: SeatKey
  player: RoomPlayerState | null
@@ -38,6 +49,19 @@ export interface SeatView {
  subLabel: string
 }

+function humanizeSuit(value: string): string {
+  const suitMap: Record<string, string> = {
+    W: '万',
+    B: '筒',
+    T: '条',
+    wan: '万',
+    tong: '筒',
+    tiao: '条',
+  }
+
+  return suitMap[value] ?? value
+}
+
 export interface ChengduGameRoomModel {
  auth: Ref<StoredAuth | null>
  roomState: typeof activeRoomState
@@ -52,8 +76,12 @@ export interface ChengduGameRoomModel {
  leaveRoomPending: Ref<boolean>
  canStartGame: ComputedRef<boolean>
  seatViews: ComputedRef<SeatView[]>
+  selectedTile: Ref<string | null>
+  actionButtons: ComputedRef<ActionButtonState[]>
  connectWs: () => Promise<void>
  sendStartGame: () => void
+  selectTile: (tile: string) => void
+  sendGameAction: (type: ActionButtonState['type']) => void
  backHall: () => void
 }

@@ -69,10 +97,12 @@ export function useChengduGameRoom(
  const wsError = ref('')
  const wsMessages = ref<string[]>([])
  const startGamePending = ref(false)
+  const actionPending = ref(false)
  const lastStartRequestId = ref('')
  const leaveRoomPending = ref(false)
  const lastLeaveRoomRequestId = ref('')
  const leaveHallAfterAck = ref(false)
+  const selectedTile = ref<string | null>(null)

  const roomId = computed(() => {
    return typeof route.params.roomId === 'string' ? route.params.roomId : ''
@@ -121,6 +151,64 @@ export function useChengduGameRoom(
    )
  })

+  const myPlayer = computed(() => {
+    return roomState.value.players.find((player) => player.playerId === currentUserId.value) ?? null
+  })
+
+  const isMyTurn = computed(() => {
+    return myPlayer.value?.index === roomState.value.currentTurnIndex
+  })
+
+  const pendingClaimOptions = computed<PendingClaimOption[]>(() => {
+    return normalizePendingClaimOptions(roomState.value.game?.state?.pendingClaim)
+  })
+
+  const myClaimActions = computed(() => {
+    const claim = pendingClaimOptions.value.find((item) => item.playerId === currentUserId.value)
+    return new Set(claim?.actions ?? [])
+  })
+
+  const canDraw = computed(() => {
+    return roomState.value.status === 'playing' && isMyTurn.value && Boolean(roomState.value.game?.state?.needDraw)
+  })
+
+  const canDiscard = computed(() => {
+    return (
+      roomState.value.status === 'playing' &&
+      isMyTurn.value &&
+      !roomState.value.game?.state?.needDraw &&
+      roomState.value.myHand.length > 0 &&
+      Boolean(selectedTile.value)
+    )
+  })
+
+  const actionButtons = computed<ActionButtonState[]>(() => {
+    return [
+      { type: 'draw', label: '摸牌', disabled: !canDraw.value || actionPending.value },
+      { type: 'discard', label: '出牌', disabled: !canDiscard.value || actionPending.value },
+      {
+        type: 'peng',
+        label: '碰',
+        disabled: !myClaimActions.value.has('peng') || actionPending.value,
+      },
+      {
+        type: 'gang',
+        label: '杠',
+        disabled: !myClaimActions.value.has('gang') || actionPending.value,
+      },
+      {
+        type: 'hu',
+        label: '胡',
+        disabled: !myClaimActions.value.has('hu') || actionPending.value,
+      },
+      {
+        type: 'pass',
+        label: '过',
+        disabled: !myClaimActions.value.has('pass') || actionPending.value,
+      },
+    ]
+  })
+
  const seatViews = computed<SeatView[]>(() => {
    const seats: Record<SeatKey, RoomPlayerState | null> = {
      top: null,
@@ -165,7 +253,7 @@ export function useChengduGameRoom(
        player,
        isSelf,
        isTurn: turnSeat === seat,
-        label: player ? (isSelf ? '你' : player.playerId) : '空位',
+        label: player ? (isSelf ? '你' : player.displayName || `玩家${player.index + 1}`) : '空位',
        subLabel: player ? `座位 ${player.index}` : '',
      }
    })
@@ -230,6 +318,29 @@ export function useChengduGameRoom(
    return ''
  }

+  function normalizeActionName(value: unknown): string {
+    const raw = toStringOrEmpty(value).trim().toLowerCase()
+    if (!raw) {
+      return ''
+    }
+    const actionMap: Record<string, string> = {
+      candraw: 'draw',
+      draw: 'draw',
+      candiscard: 'discard',
+      discard: 'discard',
+      canpeng: 'peng',
+      peng: 'peng',
+      cangang: 'gang',
+      gang: 'gang',
+      canhu: 'hu',
+      hu: 'hu',
+      canpass: 'pass',
+      pass: 'pass',
+    }
+
+    return actionMap[raw.replace(/[_\-\s]/g, '')] ?? raw
+  }
+
  function toSession(source: NonNullable<typeof auth.value>): AuthSession {
    return {
      token: source.token,
@@ -361,19 +472,198 @@ export function useChengduGameRoom(
      return null
    }

-    const playerId = toStringOrEmpty(player.playerId ?? player.player_id ?? player.user_id ?? player.id)
+    const playerId = toStringOrEmpty(
+      player.playerId ??
+        player.player_id ??
+        player.PlayerID ??
+        player.UserID ??
+        player.user_id ??
+        player.id,
+    )
    if (!playerId) {
      return null
    }

-    const seatIndex = toFiniteNumber(player.index ?? player.seat ?? player.position ?? player.player_index)
+    const seatIndex = toFiniteNumber(
+      player.index ??
+        player.Index ??
+        player.seat ??
+        player.Seat ??
+        player.position ??
+        player.Position ??
+        player.player_index,
+    )
    return {
      index: seatIndex ?? fallbackIndex,
      playerId,
+      displayName:
+        toStringOrEmpty(
+          player.playerName ??
+            player.player_name ??
+            player.PlayerName ??
+            player.username ??
+            player.nickname,
+        ) || undefined,
      ready: Boolean(player.ready),
+      handCount:
+        toFiniteNumber(player.handCount ?? player.hand_count ?? player.HandCount) ?? undefined,
+      melds: normalizeTileList(player.melds ?? player.Melds),
+      outTiles: normalizeTileList(player.outTiles ?? player.out_tiles ?? player.OutTiles),
+      hasHu: toBoolean(player.hasHu ?? player.has_hu ?? player.HasHu),
+      missingSuit:
+        toStringOrEmpty(player.missingSuit ?? player.missing_suit ?? player.MissingSuit) || null,
    }
  }

+  function normalizeTileList(value: unknown): string[] {
+    if (!Array.isArray(value)) {
+      return []
+    }
+
+    return value
+      .flatMap((item) => {
+        if (Array.isArray(item)) {
+          return item.map((nested) => toStringOrEmpty(nested)).filter(Boolean)
+        }
+        const record = toRecord(item)
+        if (record) {
+          const explicit =
+            toStringOrEmpty(
+              record.tile ?? record.Tile ?? record.code ?? record.Code ?? record.name ?? record.Name,
+            ) || ''
+          if (explicit) {
+            return [explicit]
+          }
+
+          const suit = toStringOrEmpty(record.suit ?? record.Suit)
+          const tileValue = toStringOrEmpty(record.value ?? record.Value)
+          if (suit && tileValue) {
+            return [`${humanizeSuit(suit)}${tileValue}`]
+          }
+
+          return []
+        }
+        return [toStringOrEmpty(item)].filter(Boolean)
+      })
+      .filter(Boolean)
+  }
+
+  function normalizePublicGameState(source: Record<string, unknown>): GameState | null {
+    const publicPlayers = (Array.isArray(source.players) ? source.players : [])
+      .map((item, index) => normalizePlayer(item, index))
+      .filter((item): item is RoomPlayerState => Boolean(item))
+      .sort((a, b) => a.index - b.index)
+
+    const currentTurnPlayerId = toStringOrEmpty(
+      source.current_turn_player ?? source.currentTurnPlayer ?? source.current_turn_player_id,
+    )
+    const currentTurnIndex =
+      publicPlayers.find((player) => player.playerId === currentTurnPlayerId)?.index ?? null
+
+    return {
+      rule: null,
+      state: {
+        phase: toStringOrEmpty(source.phase),
+        dealerIndex: 0,
+        currentTurn: currentTurnIndex ?? 0,
+        needDraw: toBoolean(source.need_draw ?? source.needDraw),
+        players: publicPlayers.map((player) => ({
+          playerId: player.playerId,
+          index: player.index,
+          ready: player.ready,
+        })),
+        wall: Array.from({
+          length: toFiniteNumber(source.wall_count ?? source.wallCount) ?? 0,
+        }).map((_, index) => `wall-${index}`),
+        lastDiscardTile:
+          toStringOrEmpty(source.last_discard_tile ?? source.lastDiscardTile) || null,
+        lastDiscardBy: toStringOrEmpty(source.last_discard_by ?? source.lastDiscardBy),
+        pendingClaim: toRecord(source.pending_claim ?? source.pendingClaim),
+        winners: Array.isArray(source.winners)
+          ? source.winners.map((item) => toStringOrEmpty(item)).filter(Boolean)
+          : [],
+        scores: normalizeScores(source.scores),
+        lastDrawPlayerId: '',
+        lastDrawFromGang: false,
+        lastDrawIsLastTile: false,
+        huWay: '',
+      },
+    }
+  }
+
+  function normalizePendingClaimOptions(value: unknown): PendingClaimOption[] {
+    const pendingClaim = toRecord(value)
+    if (!pendingClaim) {
+      return []
+    }
+
+    const rawOptions =
+      (Array.isArray(pendingClaim.options) ? pendingClaim.options : null) ??
+      (Array.isArray(pendingClaim.Options) ? pendingClaim.Options : null) ??
+      []
+
+    const optionsFromArray = rawOptions
+      .map((option) => {
+        const record = toRecord(option)
+        if (!record) {
+          return null
+        }
+        const playerId = toStringOrEmpty(
+          record.playerId ?? record.player_id ?? record.PlayerID ?? record.user_id ?? record.UserID,
+        )
+        if (!playerId) {
+          return null
+        }
+        const actions = new Set<string>()
+        for (const value of Object.values(record)) {
+          if (typeof value === 'boolean' && value) {
+            continue
+          }
+        }
+        for (const [key, enabled] of Object.entries(record)) {
+          if (typeof enabled === 'boolean' && enabled) {
+            const normalized = normalizeActionName(key)
+            if (normalized && normalized !== 'playerid' && normalized !== 'userid') {
+              actions.add(normalized)
+            }
+          }
+        }
+        if (Array.isArray(record.actions)) {
+          for (const action of record.actions) {
+            const normalized = normalizeActionName(action)
+            if (normalized) {
+              actions.add(normalized)
+            }
+          }
+        }
+
+        return { playerId, actions: [...actions] }
+      })
+      .filter((item): item is PendingClaimOption => Boolean(item))
+
+    if (optionsFromArray.length > 0) {
+      return optionsFromArray
+    }
+
+    const claimPlayerId = toStringOrEmpty(
+      pendingClaim.playerId ??
+        pendingClaim.player_id ??
+        pendingClaim.PlayerID ??
+        pendingClaim.user_id ??
+        pendingClaim.UserID,
+    )
+    if (!claimPlayerId) {
+      return []
+    }
+
+    const actions = Object.entries(pendingClaim)
+      .filter(([, enabled]) => typeof enabled === 'boolean' && enabled)
+      .map(([key]) => normalizeActionName(key))
+      .filter(Boolean)
+
+    return actions.length > 0 ? [{ playerId: claimPlayerId, actions }] : []
+  }
+
  function extractCurrentTurnIndex(value: Record<string, unknown>): number | null {
    const game = toRecord(value.game)
    const gameState = toRecord(game?.state)
@@ -495,21 +785,44 @@ export function useChengduGameRoom(
      .filter((item) => Boolean(item.playerId))
    const resolvedPlayers = players.length > 0 ? players : playersFromIds
    const parsedPlayerCount = toFiniteNumber(room.player_count ?? room.playerCount)
-    const game = normalizeGame(room.game)
+    const game = normalizeGame(room.game) ?? normalizePublicGameState(room)
+    const playersFromGame = game?.state?.players
+      .map((player, index) =>
+        normalizePlayer(
+          {
+            player_id: player.playerId,
+            index: player.index ?? index,
+          },
+          index,
+        ),
+      )
+      .filter((item): item is RoomPlayerState => Boolean(item))
+    const finalPlayers =
+      resolvedPlayers.length > 0 ? resolvedPlayers : playersFromGame && playersFromGame.length > 0 ? playersFromGame : []
+    const derivedTurnIndex =
+      extractCurrentTurnIndex(room) ??
+      (game?.state
+        ? finalPlayers.find((player) => player.playerId === toStringOrEmpty(room.current_turn_player ?? room.currentTurnPlayer))
+            ?.index ?? null
+        : null)

    return {
      id,
      name: toStringOrEmpty(room.name) || roomState.value.name,
      gameType: toStringOrEmpty(room.gameType ?? room.game_type) || roomState.value.gameType || 'chengdu',
-      ownerId: toStringOrEmpty(room.ownerId ?? room.owner_id),
+      ownerId: toStringOrEmpty(room.ownerId ?? room.owner_id ?? room.OwnerID ?? room.ownerID),
      maxPlayers,
-      playerCount: parsedPlayerCount ?? resolvedPlayers.length,
+      playerCount:
+        parsedPlayerCount ??
+        toFiniteNumber(room.player_count ?? room.playerCount ?? room.playerCount) ??
+        finalPlayers.length,
      status: toStringOrEmpty(room.status) || roomState.value.status || 'waiting',
      createdAt: toStringOrEmpty(room.createdAt ?? room.created_at) || roomState.value.createdAt,
      updatedAt: toStringOrEmpty(room.updatedAt ?? room.updated_at) || roomState.value.updatedAt,
      game: game ?? roomState.value.game,
-      players: resolvedPlayers,
-      currentTurnIndex: extractCurrentTurnIndex(room),
+      players: finalPlayers,
+      currentTurnIndex: derivedTurnIndex,
+      myHand: [],
    }
  }

@@ -607,6 +920,34 @@ export function useChengduGameRoom(
    ) {
      startGamePending.value = false
    }
+
+    if (event.status === 'error') {
+      actionPending.value = false
+    }
+
+    if (eventType === 'my_hand') {
+      const handPayload = payload ?? data
+      const handRecord = toRecord(handPayload)
+      const hand = normalizeTileList(handRecord?.hand ?? handRecord?.tiles ?? handRecord?.myHand)
+      roomState.value = {
+        ...roomState.value,
+        myHand: hand,
+        playerCount: roomState.value.playerCount || roomState.value.players.length,
+      }
+      if (!selectedTile.value || !hand.includes(selectedTile.value)) {
+        selectedTile.value = hand[0] ?? null
+      }
+      actionPending.value = false
+      return
+    }
+
+    if (
+      ['room_state', 'room_player_update', 'room_joined', 'room_member_joined', 'room_member_left'].includes(
+        eventType,
+      )
+    ) {
+      actionPending.value = false
+    }
  }

  function createRequestId(prefix: string): string {
@@ -648,6 +989,41 @@ export function useChengduGameRoom(
    pushWsMessage(`[client] 请求开始游戏 requestId=${requestId}`)
  }

+  function selectTile(tile: string): void {
+    selectedTile.value = selectedTile.value === tile ? null : tile
+  }
+
+  function sendGameAction(type: ActionButtonState['type']): void {
+    if (!ws.value || ws.value.readyState !== WebSocket.OPEN || !currentUserId.value) {
+      return
+    }
+
+    const requestId = createRequestId(type)
+    const payload: Record<string, unknown> = {}
+
+    if (type === 'discard' && selectedTile.value) {
+      payload.tile = selectedTile.value
+      payload.discard_tile = selectedTile.value
+      payload.code = selectedTile.value
+    }
+
+    actionPending.value = true
+    const message = {
+      type,
+      sender: currentUserId.value,
+      target: 'room',
+      roomId: roomState.value.id || roomId.value,
+      seq: Date.now(),
+      requestId,
+      trace_id: createRequestId('trace'),
+      payload,
+    }
+
+    logWsSend(message)
+    ws.value.send(JSON.stringify(message))
+    pushWsMessage(`[client] 请求${type} requestId=${requestId}`)
+  }
+
  function sendLeaveRoom(): boolean {
    if (!ws.value || ws.value.readyState !== WebSocket.OPEN) {
      wsError.value = 'WebSocket 未连接，无法退出房间'
@@ -774,6 +1150,8 @@ export function useChengduGameRoom(
      leaveRoomPending.value = false
      lastLeaveRoomRequestId.value = ''
      leaveHallAfterAck.value = false
+      actionPending.value = false
+      selectedTile.value = null
    },
    { immediate: true },
  )
@@ -826,8 +1204,12 @@ export function useChengduGameRoom(
    leaveRoomPending,
    canStartGame,
    seatViews,
+    selectedTile,
+    actionButtons,
    connectWs,
    sendStartGame,
+    selectTile,
+    sendGameAction,
    backHall,
  }
 }