turtlesoup type store service重构

src/services/game.ts

@@ -1,7 +1,7 @@
 // services/game.ts
 import { Result, createSuccess, createError } from '@/types/result'
 import { cloudApi } from '@/api'
-import { type Game } from '@/types/game'
+import { type Game, GameType } from '@/types/game'
 import { USE_MOCK } from '@/services'
 
 // Mock游戏数据
@@ -9,6 +9,7 @@ const mockGames: Game[] = [
   {
     id: '1',
     title: '海龟汤',
+    type: GameType.TURTLE_SOUP,
     image: 'https://images.unsplash.com/photo-1582845512747-e42001c95638?ixlib=rb-1.2.1&auto=format&fit=crop&w=400&h=100&q=80',
     minPlayers: 1,
     maxPlayers: 10,
@@ -36,6 +37,7 @@ const mockGames: Game[] = [
   {
     id: '2',
     title: '剧本杀',
+    type: GameType.WORD_GAME,
     image: 'https://images.unsplash.com/photo-1529156069898-49953e39b3ac?ixlib=rb-1.2.1&auto=format&fit=crop&w=400&h=100&q=80',
     minPlayers: 4,
     maxPlayers: 8,
@@ -63,6 +65,7 @@ const mockGames: Game[] = [
   {
     id: '3',
     title: '狼人杀',
+    type: GameType.WORD_GAME,
     image: 'https://images.unsplash.com/photo-1529156069898-49953e39b3ac?ixlib=rb-1.2.1&auto=format&fit=crop&w=400&h=100&q=80',
     minPlayers: 6,
     maxPlayers: 12,

src/services/games/turtlesoup.ts

@@ -1,636 +1,228 @@
-// services/games/turtlesoup.ts
 import { Result, createSuccess, createError } from '@/types/result'
 import { cloudApi } from '@/api'
 import { USE_MOCK } from '@/services'
-import { 
+import {
   type TurtleSoupGameHostView,
   type TurtleSoupGamePlayerView,
-  type TurtleSoupQuestion,
-  type TurtleSoupHint,
   type TurtleSoupGameSettings,
-  type TurtleSoupGameResult,
   type TurtleSoupTheme,
   type TurtleSoupPuzzle,
   TurtleSoupGameStatus,
   TurtleSoupDifficulty,
-  TurtleSoupAnswerType,
   TurtleSoupThemeType
 } from '@/types/games/turtlesoup'
 
-// Mock 主题数据
+// Mock 主题数据（字段同步 themeId）
 const mockThemes: TurtleSoupTheme[] = [
   {
-    id: 'theme-1',
+    themeId: 'theme-1',
     name: '经典解谜',
     description: '基础主题 · 免费',
     type: TurtleSoupThemeType.BASIC,
     isLocked: false
   },
   {
-    id: 'theme-2',
+    themeId: 'theme-2',
     name: '环球影城',
     description: '特色主题 · 20元/小时',
     type: TurtleSoupThemeType.PREMIUM,
     price: 20,
     isNew: true,
     isLocked: true
-  },
-  {
-    id: 'theme-3',
-    name: '迪士尼奇幻',
-    description: '特色主题 · 15元/小时',
-    type: TurtleSoupThemeType.PREMIUM,
-    price: 15,
-    isLocked: true
-  },
-  {
-    id: 'theme-4',
-    name: '奇幻冒险',
-    description: '特色主题 · 12元/小时',
-    type: TurtleSoupThemeType.PREMIUM,
-    price: 12,
-    isLocked: true
   }
 ]
 
-// Mock 题目数据
+// Mock 题目数据（字段同步 puzzleId 等）
 const mockPuzzles: TurtleSoupPuzzle[] = [
   {
-    id: 'puzzle-1',
+    puzzleId: 'puzzle-1',
+    themeId: 'theme-1',
     title: '神秘的手表',
-    description: '简单 · 平均用时25分钟',
+    scenario: '一个男人收到了一块神秘的手表...',
+    truth: '这块手表可以预知未来...',
+    keyClues: ['这块手表有特殊功能。', '它能预测未来。'],
+    hints: [
+      { keyword: '特殊功能', sentence: '手表可以预知未来。' }
+    ],
     difficulty: TurtleSoupDifficulty.EASY,
     averageDuration: 25
-  },
-  {
-    id: 'puzzle-2',
-    title: '迷路的青蛙',
-    description: '中等 · 平均用时35分钟',
-    difficulty: TurtleSoupDifficulty.MEDIUM,
-    averageDuration: 35
-  },
-  {
-    id: 'puzzle-3',
-    title: '消失的邮轮',
-    description: '困难 · 平均用时50分钟',
-    difficulty: TurtleSoupDifficulty.HARD,
-    averageDuration: 50
   }
 ]
 
-// Mock 主持人视图数据
+// Mock 主持人视图
 const mockHostView: TurtleSoupGameHostView = {
   id: 'game-1',
   roomId: 'room-1',
   title: '欢乐海龟汤',
-  roomCode: 'ABC123',
-  description: '一个男人收到了一块神秘的手表，戴上后就再也无法取下来，一周后他自杀了，为什么？',
-  solution: '这个手表可以预知未来24小时内将发生的事情。男人看到了自己将在一周后死亡，尝试了各种方法改变命运但都失败了。最终，由于无法承受这种预知但无法改变的煎熬，他选择了自杀。这反而实现了手表的预言。',
-  hints: [
-    {
-      id: 'hint-1',
-      content: '这块手表有特殊功能，不是普通手表。',
-      revealed: true,
-      revealedAt: Date.now() - 600000 // 10分钟前
-    },
-    {
-      id: 'hint-2',
-      content: '手表可以显示未来将发生的事情。',
-      revealed: true,
-      revealedAt: Date.now() - 300000 // 5分钟前
-    },
-    {
-      id: 'hint-3',
-      content: '男人尝试了多种方法改命运，但都失败了。',
-      revealed: false
-    },
-    {
-      id: 'hint-4',
-      content: '手表预测的是他的死亡，但没有预测到真体方式。',
-      revealed: false
-    },
-    {
-      id: 'hint-5',
-      content: '手表的预言总是会实现，但方式可能有所不同。',
-      revealed: false
-    }
-  ],
-  questions: [
-    {
-      id: 'q-1',
-      content: '手表是有特殊功能的吗？',
-      askedBy: 'user-1',
-      askedByName: '小明',
-      timestamp: Date.now() - 900000, // 15分钟前
-      answered: true,
-      answer: TurtleSoupAnswerType.YES,
-      answeredAt: Date.now() - 890000 // 14分50秒前
-    },
-    {
-      id: 'q-2',
-      content: '这块手表能预测未来吗？',
-      askedBy: 'user-2',
-      askedByName: '小红',
-      timestamp: Date.now() - 600000, // 10分钟前
-      answered: true,
-      answer: TurtleSoupAnswerType.YES,
-      answeredAt: Date.now() - 590000 // 9分50秒前
-    },
-    {
-      id: 'q-3',
-      content: '是因为手表带来厄运吗？',
-      askedBy: 'user-1',
-      askedByName: '小明',
-      timestamp: Date.now() - 300000, // 5分钟前
-      answered: false
-    }
-  ],
+  theme: mockThemes[0],
+  puzzle: mockPuzzles[0],
   status: TurtleSoupGameStatus.ACTIVE,
-  createTime: Date.now() - 3600000, // 1小时前
-  startTime: Date.now() - 1800000, // 30分钟前
+  startTime: Date.now() - 1800000,
   currentTime: Date.now(),
-  duration: 30, // 30分钟
+  duration: 30,
   hostId: 'host-user',
   hostName: '小明 (我)',
   players: [
     {
       id: 'user-1',
       name: '小红',
-      avatar: 'https://example.com/avatar1.png',
-      joinedAt: Date.now() - 3000000, // 50分钟前
+      avatar: '',
+      joinedAt: Date.now() - 3000000,
       questionCount: 2
-    },
-    {
-      id: 'user-2',
-      name: '小李',
-      avatar: 'https://example.com/avatar2.png',
-      joinedAt: Date.now() - 2700000, // 45分钟前
-      questionCount: 1
-    },
-    {
-      id: 'user-3',
-      name: '丽丽',
-      avatar: 'https://example.com/avatar3.png',
-      joinedAt: Date.now() - 1800000, // 30分钟前
-      questionCount: 0
     }
   ],
+  progress: 40,
+  difficulty: TurtleSoupDifficulty.MEDIUM,
   settings: {
     themeId: 'theme-1',
     puzzleId: 'puzzle-1',
     difficulty: TurtleSoupDifficulty.MEDIUM,
-    maxPlayers: 10,
-    isPrivate: false
-  },
-  playerCount: 3,
-  progress: 40 // 40%
+    maxPlayers: 10
+  }
 }
 
-// Mock 玩家视图数据
+// Mock 玩家视图
 const mockPlayerView: TurtleSoupGamePlayerView = {
   id: 'game-1',
   roomId: 'room-1',
   title: '欢乐海龟汤',
-  description: '一个男人收到了一块神秘的手表，戴上后就再也无法取下来，一周后他自杀了，为什么？',
-  revealedHints: [
-    {
-      id: 'hint-1',
-      content: '这块手表有特殊功能，不是普通手表。',
-      revealedAt: Date.now() - 600000 // 10分钟前
-    },
-    {
-      id: 'hint-2',
-      content: '手表可以显示未来将发生的事情。',
-      revealedAt: Date.now() - 300000 // 5分钟前
-    }
-  ],
-  myQuestions: [
-    {
-      id: 'q-1',
-      content: '手表是有特殊功能的吗？',
-      askedBy: 'user-1',
-      askedByName: '小明 (我)',
-      timestamp: Date.now() - 900000, // 15分钟前
-      answered: true,
-      answer: TurtleSoupAnswerType.YES,
-      answeredAt: Date.now() - 890000 // 14分50秒前
-    },
-    {
-      id: 'q-3',
-      content: '是因为手表带来厄运吗？',
-      askedBy: 'user-1',
-      askedByName: '小明 (我)',
-      timestamp: Date.now() - 300000, // 5分钟前
-      answered: false
-    }
-  ],
-  allQuestions: [
-    {
-      id: 'q-1',
-      content: '手表是有特殊功能的吗？',
-      askedByName: '小明 (我)',
-      answer: TurtleSoupAnswerType.YES,
-      timestamp: Date.now() - 900000 // 15分钟前
-    },
-    {
-      id: 'q-2',
-      content: '这块手表能预测未来吗？',
-      askedByName: '小红',
-      answer: TurtleSoupAnswerType.YES,
-      timestamp: Date.now() - 600000 // 10分钟前
-    }
-  ],
+  theme: mockThemes[0],
+  puzzle: mockPuzzles[0],
   status: TurtleSoupGameStatus.ACTIVE,
-  startTime: Date.now() - 1800000, // 30分钟前
+  startTime: Date.now() - 1800000,
   currentTime: Date.now(),
-  duration: 30, // 30分钟
+  duration: 30,
   hostId: 'host-user',
-  hostName: '小明',
-  progress: 40, // 40%
+  hostName: '小明 (我)',
+  progress: 40,
   difficulty: TurtleSoupDifficulty.MEDIUM,
+  settings: {
+    themeId: 'theme-1',
+    puzzleId: 'puzzle-1',
+    difficulty: TurtleSoupDifficulty.MEDIUM,
+    maxPlayers: 10
+  },
+  myPlayerInfo: {
+    id: 'user-1',
+    name: '小红',
+    avatar: '',
+    joinedAt: Date.now() - 3000000,
+    questionCount: 2
+  },
   otherPlayers: [
     {
       id: 'user-2',
-      name: '小红',
-      avatar: 'https://example.com/avatar2.png'
-    },
-    {
-      id: 'user-3',
       name: '小李',
-      avatar: 'https://example.com/avatar3.png'
+      avatar: ''
     }
   ]
 }
 
-// 海龟汤游戏服务
 export const turtleSoupService = {
-  /**
-   * 获取主题列表
-   */
   async getThemes(): Promise<Result<TurtleSoupTheme[]>> {
-    // 如果在开发环境或非小程序环境，使用Mock数据
     if (USE_MOCK || process.env.TARO_ENV !== 'weapp') {
-      return new Promise(resolve => {
-        setTimeout(() => {
-          resolve(createSuccess(mockThemes));
-        }, 300);
-      });
+      return new Promise(resolve => setTimeout(() => resolve(createSuccess(mockThemes)), 300))
     }
-    
-    // 使用cloudApi调用云函数
     return cloudApi.call<{ themes: TurtleSoupTheme[] }>('getTurtleSoupThemes')
       .then(result => {
-        if (result.success && result.data?.themes) {
-          return createSuccess(result.data.themes);
-        }
-        return createError(result.message || '获取主题列表失败');
+        if (result.success && result.data?.themes) return createSuccess(result.data.themes)
+        return createError(result.message || '获取主题列表失败')
       })
-      .catch(error => {
-        console.error('获取主题列表失败:', error);
-        return createError(error.message || '获取主题列表失败');
-      });
+      .catch(error => createError(error.message || '获取主题列表失败'))
   },
-  
 
-  /**
-   * 解锁主题
-   * @param themeId 主题ID
-   */
   async unlockTheme(themeId: string): Promise<Result<TurtleSoupTheme>> {
-    // 如果在开发环境或非小程序环境，使用Mock数据 
     if (USE_MOCK || process.env.TARO_ENV !== 'weapp') {
-      return new Promise(resolve => {
-        setTimeout(() => {
-          const theme = mockThemes.find(t => t.id === themeId);
-          if (!theme) {
-            resolve(createError('主题未找到'));
-          } else {
-            resolve(createSuccess(theme));
-          }
-        }, 300);
-      });
+      return new Promise(resolve => setTimeout(() => {
+        const theme = mockThemes.find(t => t.themeId === themeId)
+        resolve(theme ? createSuccess(theme) : createError('主题未找到'))
+      }, 300))
     }
-    
-    // 使用cloudApi调用云函数
     return cloudApi.call<{ theme: TurtleSoupTheme }>('unlockTurtleSoupTheme', { themeId })
-      .then(result => {
-        if (result.success && result.data?.theme) {
-          return createSuccess(result.data.theme);
-        }
-        return createError(result.message || '解锁主题失败');
-      })
-      .catch(error => {
-        console.error('解锁主题失败:', error);
-        return createError(error.message || '解锁主题失败');  
-      });
+      .then(result => result.success && result.data?.theme
+        ? createSuccess(result.data.theme)
+        : createError(result.message || '解锁主题失败'))
+      .catch(error => createError(error.message || '解锁主题失败'))
   },
-  
-  /**
-   * 获取题目列表
-   * @param themeId 主题ID
-   * @param difficulty 可选的难度筛选
-   */
+
   async getPuzzles(themeId: string, difficulty?: TurtleSoupDifficulty): Promise<Result<TurtleSoupPuzzle[]>> {
-    // 如果在开发环境或非小程序环境，使用Mock数据
     if (USE_MOCK || process.env.TARO_ENV !== 'weapp') {
-      return new Promise(resolve => {
-        setTimeout(() => {
-          let puzzles = [...mockPuzzles];
-          
-          // 如果指定了难度，进行过滤
-          if (difficulty) {
-            puzzles = puzzles.filter(p => p.difficulty === difficulty);
-          }
-          
-          resolve(createSuccess(puzzles));
-        }, 300);
-      });
+      return new Promise(resolve => setTimeout(() => {
+        let puzzles = mockPuzzles.filter(p => p.themeId === themeId)
+        if (difficulty) puzzles = puzzles.filter(p => p.difficulty === difficulty)
+        resolve(createSuccess(puzzles))
+      }, 300))
     }
-    
-    // 使用cloudApi调用云函数
     return cloudApi.call<{ puzzles: TurtleSoupPuzzle[] }>('getTurtleSoupPuzzles', { themeId, difficulty })
       .then(result => {
-        if (result.success && result.data?.puzzles) {
-          return createSuccess(result.data.puzzles);
-        }
-        return createError(result.message || '获取题目列表失败');
+        if (result.success && result.data?.puzzles) return createSuccess(result.data.puzzles)
+        return createError(result.message || '获取题目列表失败')
       })
-      .catch(error => {
-        console.error('获取题目列表失败:', error);
-        return createError(error.message || '获取题目列表失败');
-      });
+      .catch(error => createError(error.message || '获取题目列表失败'))
   },
-  
-  /**
-   * 获取主持人游戏数据
-   * @param gameId 游戏ID
-   */
+
+  async createGame(settings: TurtleSoupGameSettings): Promise<Result<{ gameId: string, roomId: string, title: string }>> {
+    if (!settings.themeId) return createError('请选择游戏主题')
+    if (!settings.puzzleId) return createError('请选择游戏题目')
+    if (USE_MOCK || process.env.TARO_ENV !== 'weapp') {
+      return new Promise(resolve => setTimeout(() => {
+        const gameId = `game-${Date.now()}`
+        const roomId = `room-${Date.now()}`
+        resolve(createSuccess({
+          gameId,
+          roomId,
+          title: mockPuzzles.find(p => p.puzzleId === settings.puzzleId)?.title || '新游戏'
+        }))
+      }, 500))
+    }
+    return cloudApi.call<{ gameId: string, roomId: string, title: string }>('createTurtleSoupGame', settings)
+  },
+
   async getHostGameData(gameId: string): Promise<Result<TurtleSoupGameHostView>> {
-    // 如果在开发环境或非小程序环境，使用Mock数据
     if (USE_MOCK || process.env.TARO_ENV !== 'weapp') {
-      return new Promise(resolve => {
-        setTimeout(() => {
-          resolve(createSuccess(mockHostView));
-        }, 300);
-      });
+      return new Promise(resolve => setTimeout(() => resolve(createSuccess(mockHostView)), 300))
     }
-    
-    // 使用cloudApi调用云函数
     return cloudApi.call<{ game: TurtleSoupGameHostView }>('getTurtleSoupHostGame', { gameId })
-      .then(result => {
-        if (result.success && result.data?.game) {
-          return createSuccess(result.data.game);
-        }
-        return createError(result.message || '获取游戏数据失败');
-      })
-      .catch(error => {
-        console.error('获取主持人游戏数据失败:', error);
-        return createError(error.message || '获取游戏数据失败');
-      });
+      .then(result => result.success && result.data?.game
+        ? createSuccess(result.data.game)
+        : createError(result.message || '获取游戏数据失败'))
+      .catch(error => createError(error.message || '获取主持人游戏数据失败'))
   },
-  
-  /**
-   * 获取玩家游戏数据
-   * @param gameId 游戏ID
-   */
+
   async getPlayerGameData(gameId: string): Promise<Result<TurtleSoupGamePlayerView>> {
-    // 如果在开发环境或非小程序环境，使用Mock数据
     if (USE_MOCK || process.env.TARO_ENV !== 'weapp') {
-      return new Promise(resolve => {
-        setTimeout(() => {
-          resolve(createSuccess(mockPlayerView));
-        }, 300);
-      });
+      return new Promise(resolve => setTimeout(() => resolve(createSuccess(mockPlayerView)), 300))
     }
-    
-    // 使用cloudApi调用云函数
     return cloudApi.call<{ game: TurtleSoupGamePlayerView }>('getTurtleSoupPlayerGame', { gameId })
-      .then(result => {
-        if (result.success && result.data?.game) {
-          return createSuccess(result.data.game);
-        }
-        return createError(result.message || '获取游戏数据失败');
-      })
-      .catch(error => {
-        console.error('获取玩家游戏数据失败:', error);
-        return createError(error.message || '获取游戏数据失败');
-      });
+      .then(result => result.success && result.data?.game
+        ? createSuccess(result.data.game)
+        : createError(result.message || '获取游戏数据失败'))
+      .catch(error => createError(error.message || '获取玩家游戏数据失败'))
   },
-  
-  /**
-   * 创建新游戏
-   * @param settings 游戏设置
-   */
-  async createGame(settings: TurtleSoupGameSettings): Promise<Result<{ gameId: string, roomId: string, title: string }>> {
-    // 数据验证
-    if (!settings.themeId) return createError('请选择游戏主题');
-    if (!settings.puzzleId) return createError('请选择游戏题目');
-    
-    // 如果在开发环境或非小程序环境，使用Mock数据
-    if (USE_MOCK || process.env.TARO_ENV !== 'weapp') {
-      return new Promise(resolve => {
-        setTimeout(() => {
-          const gameId = `game-${Date.now()}`;
-          const roomId = `room-${Date.now()}`;
-          resolve(createSuccess({ 
-            gameId, 
-            roomId,
-            title: mockPuzzles.find(p => p.id === settings.puzzleId)?.title || '新游戏'
-          }));
-        }, 500);
-      });
-    }
-    
-    // 使用cloudApi调用云函数
-    return cloudApi.call<{ gameId: string, roomId: string, title: string }>('createTurtleSoupGame', settings);
-  },
-  
-  /**
-   * 为已有房间创建游戏
-   * @param roomId 房间ID
-   * @param settings 游戏设置
-   */
-  async createGameForRoom(roomId: string, settings: TurtleSoupGameSettings): Promise<Result<{ gameId: string }>> {
-    // 数据验证
-    if (!settings.themeId) return createError('请选择游戏主题');
-    if (!settings.puzzleId) return createError('请选择游戏题目');
-    
-    // 如果在开发环境或非小程序环境，使用Mock数据
-    if (USE_MOCK || process.env.TARO_ENV !== 'weapp') {
-      return new Promise(resolve => {
-        setTimeout(() => {
-          const gameId = `game-${Date.now()}`;
-          resolve(createSuccess({ gameId }));
-        }, 500);
-      });
-    }
-    
-    // 使用cloudApi调用云函数
-    return cloudApi.call<{ gameId: string }>('createTurtleSoupGameForRoom', { roomId, settings });
-  },
-  
-  /**
-   * 开始游戏
-   * @param gameId 游戏ID
-   */
+
   async startGame(gameId: string): Promise<Result<{ success: boolean }>> {
-    // 如果在开发环境或非小程序环境，使用Mock数据
     if (USE_MOCK || process.env.TARO_ENV !== 'weapp') {
-      return new Promise(resolve => {
-        setTimeout(() => {
-          resolve(createSuccess({ success: true }));
-        }, 300);
-      });
+      return new Promise(resolve => setTimeout(() => resolve(createSuccess({ success: true })), 300))
     }
-    
-    // 使用cloudApi调用云函数
-    return cloudApi.call<{ success: boolean }>('startTurtleSoupGame', { gameId });
+    return cloudApi.call<{ success: boolean }>('startTurtleSoupGame', { gameId })
   },
-  
-  /**
-   * 提交问题
-   * @param gameId 游戏ID
-   * @param content 问题内容
-   */
-  async submitQuestion(gameId: string, content: string): Promise<Result<{ questionId: string }>> {
-    if (!content.trim()) {
-      return createError('问题内容不能为空');
-    }
-    
-    // 如果在开发环境或非小程序环境，使用Mock数据
-    if (USE_MOCK || process.env.TARO_ENV !== 'weapp') {
-      return new Promise(resolve => {
-        setTimeout(() => {
-          const questionId = `q-${Date.now()}`;
-          resolve(createSuccess({ questionId }));
-        }, 300);
-      });
-    }
-    
-    // 使用cloudApi调用云函数
-    return cloudApi.call<{ questionId: string }>('submitTurtleSoupQuestion', { gameId, content });
-  },
-  
-  /**
-   * 回答问题
-   * @param questionId 问题ID
-   * @param answer 答案类型
-   */
-  async answerQuestion(questionId: string, answer: TurtleSoupAnswerType): Promise<Result<{ success: boolean }>> {
-    // 如果在开发环境或非小程序环境，使用Mock数据
-    if (USE_MOCK || process.env.TARO_ENV !== 'weapp') {
-      return new Promise(resolve => {
-        setTimeout(() => {
-          resolve(createSuccess({ success: true }));
-        }, 200);
-      });
-    }
-    
-    // 使用cloudApi调用云函数
-    return cloudApi.call<{ success: boolean }>('answerTurtleSoupQuestion', { questionId, answer });
-  },
-  
-  /**
-   * 公开提示
-   * @param gameId 游戏ID
-   * @param hintId 提示ID
-   */
-  async revealHint(gameId: string, hintId: string): Promise<Result<{ success: boolean }>> {
-    // 如果在开发环境或非小程序环境，使用Mock数据
-    if (USE_MOCK || process.env.TARO_ENV !== 'weapp') {
-      return new Promise(resolve => {
-        setTimeout(() => {
-          resolve(createSuccess({ success: true }));
-        }, 200);
-      });
-    }
-    
-    // 使用cloudApi调用云函数
-    return cloudApi.call<{ success: boolean }>('revealTurtleSoupHint', { gameId, hintId });
-  },
-  
-  /**
-   * 提交解答
-   * @param gameId 游戏ID
-   * @param solution 玩家提交的解答
-   */
+
   async submitSolution(gameId: string, solution: string): Promise<Result<{ correct: boolean }>> {
-    if (!solution.trim()) {
-      return createError('解答内容不能为空');
-    }
-    
-    // 如果在开发环境或非小程序环境，使用Mock数据
+    if (!solution.trim()) return createError('解答内容不能为空')
     if (USE_MOCK || process.env.TARO_ENV !== 'weapp') {
-      return new Promise(resolve => {
-        setTimeout(() => {
-          // 模拟50%的概率答对
-          const correct = Math.random() > 0.5;
-          resolve(createSuccess({ correct }));
-        }, 300);
-      });
+      return new Promise(resolve => setTimeout(() => {
+        const correct = Math.random() > 0.5
+        resolve(createSuccess({ correct }))
+      }, 300))
     }
-    
-    // 使用cloudApi调用云函数
-    return cloudApi.call<{ correct: boolean }>('submitTurtleSoupSolution', { gameId, solution });
+    return cloudApi.call<{ correct: boolean }>('submitTurtleSoupSolution', { gameId, solution })
   },
-  
-  /**
-   * 结束游戏
-   * @param gameId 游戏ID
-   * @param result 游戏结果数据
-   */
-  async endGame(gameId: string, result: { 
-    solved: boolean; 
-    solvedBy?: string; 
-    solvedByName?: string;
-    solution?: string;
-  }): Promise<Result<TurtleSoupGameResult>> {
-    // 如果在开发环境或非小程序环境，使用Mock数据
-    if (USE_MOCK || process.env.TARO_ENV !== 'weapp') {
-      return new Promise(resolve => {
-        setTimeout(() => {
-          const gameResult: TurtleSoupGameResult = {
-            gameId,
-            solved: result.solved,
-            solvedBy: result.solvedBy,
-            solvedByName: result.solvedByName,
-            solution: result.solution,
-            duration: 30, // 30分钟
-            questionCount: 15,
-            hintsRevealed: 2,
-            completionTime: Date.now(),
-            playerCount: 4
-          };
-          
-          resolve(createSuccess(gameResult));
-        }, 400);
-      });
-    }
-    
-    // 使用cloudApi调用云函数
-    return cloudApi.call<TurtleSoupGameResult>('endTurtleSoupGame', { gameId, result });
-  },
-  
-  /**
-   * 更新游戏进度
-   * @param gameId 游戏ID
-   * @param progress 进度百分比(0-100)
-   */
+
   async updateProgress(gameId: string, progress: number): Promise<Result<{ success: boolean }>> {
-    if (progress < 0 || progress > 100) {
-      return createError('进度值必须在0-100之间');
-    }
-    
-    // 如果在开发环境或非小程序环境，使用Mock数据
+    if (progress < 0 || progress > 100) return createError('进度值必须在0-100之间')
     if (USE_MOCK || process.env.TARO_ENV !== 'weapp') {
-      return new Promise(resolve => {
-        setTimeout(() => {
-          resolve(createSuccess({ success: true }));
-        }, 200);
-      });
+      return new Promise(resolve => setTimeout(() => resolve(createSuccess({ success: true })), 200))
     }
-    
-    // 使用cloudApi调用云函数
-    return cloudApi.call<{ success: boolean }>('updateTurtleSoupProgress', { gameId, progress });
+    return cloudApi.call<{ success: boolean }>('updateTurtleSoupProgress', { gameId, progress })
   }
-};
+}

src/stores/games/turtlesoup.ts

@@ -1,134 +1,59 @@
-// stores/games/turtlesoup.ts
 import { defineStore } from 'pinia'
 import { turtleSoupService } from '@/services/games/turtlesoup'
-import { 
+import {
   type TurtleSoupGameHostView,
   type TurtleSoupGamePlayerView,
-  type TurtleSoupQuestion,
-  type TurtleSoupHint,
   type TurtleSoupTheme,
   type TurtleSoupPuzzle,
   type TurtleSoupGameSettings,
-  TurtleSoupAnswerType,
   TurtleSoupGameStatus,
   TurtleSoupDifficulty
 } from '@/types/games/turtlesoup'
-import { useUserStore } from '@/stores/user'
 import { RoomStatus } from '@/types/room'
 import { ref, computed } from 'vue'
 
 export const useTurtleSoupStore = defineStore('turtlesoup', () => {
-  // 基本状态
+  // 状态
   const hostView = ref<TurtleSoupGameHostView | null>(null)
   const playerView = ref<TurtleSoupGamePlayerView | null>(null)
   const loading = ref(false)
   const submitting = ref(false)
   const error = ref<string | null>(null)
   const isHost = ref(false)
-  const localDraft = ref('') // 问题/解答草稿
-  
-  // 游戏设置 - 主持人创建或修改游戏时使用
+  const localDraft = ref('')
+
+  // 游戏设置
   const gameSettings = ref<TurtleSoupGameSettings>({
     themeId: '',
     puzzleId: '',
     difficulty: TurtleSoupDifficulty.MEDIUM,
-    maxPlayers: 10,
-    isPrivate: false
+    maxPlayers: 10
   })
-  
-  // 可用主题列表
+
+  // 主题和题目
   const availableThemes = ref<TurtleSoupTheme[]>([])
-  
-  // 可用题目列表
   const availablePuzzles = ref<TurtleSoupPuzzle[]>([])
-  
+
   // 计算属性
-  const currentView = computed(() => {
-    return isHost.value ? hostView.value : playerView.value
-  })
-  
-  // 获取游戏状态
-  const gameStatus = computed(() => {
-    return currentView.value?.status || TurtleSoupGameStatus.CREATED
-  })
-  
-  // 游戏是否激活
-  const isGameActive = computed(() => {
-    return gameStatus.value === TurtleSoupGameStatus.ACTIVE
-  })
-  
-  // 获取已公开的提示
-  const revealedHints = computed(() => {
-    if (isHost.value && hostView.value) {
-      return hostView.value.hints.filter(hint => hint.revealed)
-    } else if (playerView.value) {
-      return playerView.value.revealedHints
-    }
-    return []
-  })
-  
-  // 获取未公开的提示 (只有主持人可见)
-  const unrevealedHints = computed(() => {
-    if (isHost.value && hostView.value) {
-      return hostView.value.hints.filter(hint => !hint.revealed)
-    }
-    return []
-  })
-  
-  // 获取排序后的问题列表（最新的在前）
-  const sortedQuestions = computed(() => {
-    if (isHost.value && hostView.value) {
-      return [...hostView.value.questions].sort((a, b) => b.timestamp - a.timestamp)
-    } else if (playerView.value) {
-      return [...playerView.value.allQuestions].sort((a, b) => b.timestamp - a.timestamp)
-    }
-    return []
-  })
-  
-  // 获取待回答的问题（只有主持人可见）
-  const pendingQuestions = computed(() => {
-    if (isHost.value && hostView.value) {
-      return hostView.value.questions.filter(q => !q.answered)
-        .sort((a, b) => b.timestamp - a.timestamp)
-    }
-    return []
-  })
-  
-  // 获取我的问题（玩家视图）
-  const myQuestions = computed(() => {
-    if (!isHost.value && playerView.value) {
-      return playerView.value.myQuestions.sort((a, b) => b.timestamp - a.timestamp)
-    }
-    return []
-  })
-  
-  // 获取游戏时长（分钟）
+  const currentView = computed(() => isHost.value ? hostView.value : playerView.value)
+  const gameStatus = computed(() => currentView.value?.status || TurtleSoupGameStatus.CREATED)
+  const isGameActive = computed(() => gameStatus.value === TurtleSoupGameStatus.ACTIVE)
+  const isGameEnded = computed(() => gameStatus.value === TurtleSoupGameStatus.COMPLETED || gameStatus.value === TurtleSoupGameStatus.ABANDONED)
+
+  // 游戏时长
   const gameDuration = computed(() => {
     const view = currentView.value
     if (!view || !view.startTime) return 0
-    
     return Math.floor(((view.currentTime || Date.now()) - view.startTime) / 60000)
   })
-  
-  // 获取游戏进度
-  const gameProgress = computed(() => {
-    return currentView.value?.progress || 0
-  })
-  
-  // 获取房间代码
-  const roomCode = computed(() => {
-    return isHost.value && hostView.value ? hostView.value.roomCode : ''
-  })
-  
-  // 游戏是否已结束
-  const isGameEnded = computed(() => {
-    return gameStatus.value === TurtleSoupGameStatus.COMPLETED || 
-           gameStatus.value === TurtleSoupGameStatus.ABANDONED
-  })
-  
-  // Actions
-  
-  // 重置状态
+
+  // 游戏进度
+  const gameProgress = computed(() => currentView.value?.progress || 0)
+
+  // 房间代码
+  const roomCode = computed(() => (isHost.value && hostView.value ? hostView.value.roomId : ''))
+
+  // 重置
   function resetState() {
     hostView.value = null
     playerView.value = null
@@ -137,40 +62,29 @@ export const useTurtleSoupStore = defineStore('turtlesoup', () => {
     error.value = null
     isHost.value = false
     localDraft.value = ''
-    
-    // 重置游戏设置到默认值
     gameSettings.value = {
       themeId: '',
       puzzleId: '',
       difficulty: TurtleSoupDifficulty.MEDIUM,
-      maxPlayers: 10,
-      isPrivate: false
+      maxPlayers: 10
     }
   }
-  
-  // 设置游戏视图类型
+
   function setViewType(role: 'host' | 'player') {
     isHost.value = role === 'host'
   }
-  
-  // 更新游戏设置
+
   function updateGameSettings(settings: Partial<TurtleSoupGameSettings>) {
-    gameSettings.value = {
-      ...gameSettings.value,
-      ...settings
-    }
+    gameSettings.value = { ...gameSettings.value, ...settings }
   }
-  
-  // 加载可用的主题列表
+
+  // 主题
   async function loadThemes() {
     if (availableThemes.value.length > 0) return availableThemes.value
-    
     loading.value = true
     error.value = null
-    
     try {
       const result = await turtleSoupService.getThemes()
-      
       if (result.success && result.data) {
         availableThemes.value = result.data
         return result.data
@@ -179,7 +93,6 @@ export const useTurtleSoupStore = defineStore('turtlesoup', () => {
         return []
       }
     } catch (e) {
-      console.error('加载主题失败:', e)
       error.value = e instanceof Error ? e.message : '未知错误'
       return []
     } finally {
@@ -189,20 +102,16 @@ export const useTurtleSoupStore = defineStore('turtlesoup', () => {
 
   async function unlockTheme(themeId: string) {
     const result = await turtleSoupService.unlockTheme(themeId)
-    if (result.success) {
-      return result
-    }
+    if (result.success) return result
     return null
   }
-  
-  // 加载可用的题目列表
+
+  // 题目
   async function loadPuzzles(themeId: string, difficulty?: TurtleSoupDifficulty) {
     loading.value = true
     error.value = null
-    
     try {
       const result = await turtleSoupService.getPuzzles(themeId, difficulty)
-      
       if (result.success && result.data) {
         availablePuzzles.value = result.data
         return result.data
@@ -211,23 +120,45 @@ export const useTurtleSoupStore = defineStore('turtlesoup', () => {
         return []
       }
     } catch (e) {
-      console.error('加载题目失败:', e)
       error.value = e instanceof Error ? e.message : '未知错误'
       return []
     } finally {
       loading.value = false
     }
   }
-  
-  // 加载主持人游戏视图
+
+  // 游戏主流程
+  async function createGame(settings: TurtleSoupGameSettings) {
+    submitting.value = true
+    error.value = null
+    try {
+      gameSettings.value = settings
+      const result = await turtleSoupService.createGame(settings)
+      if (result.success && result.data) {
+        return {
+          success: true,
+          gameId: result.data.gameId,
+          roomId: result.data.roomId
+        }
+      } else {
+        error.value = result.message || '创建游戏失败'
+        return { success: false, message: error.value }
+      }
+    } catch (e) {
+      error.value = e instanceof Error ? e.message : '创建游戏时发生错误'
+      return { success: false, message: error.value }
+    } finally {
+      submitting.value = false
+    }
+  }
+
+  // 加载房间
   async function loadHostGame(gameId: string) {
     loading.value = true
     error.value = null
     isHost.value = true
-    
     try {
       const result = await turtleSoupService.getHostGameData(gameId)
-      
       if (result.success && result.data) {
         hostView.value = result.data
         return true
@@ -236,23 +167,19 @@ export const useTurtleSoupStore = defineStore('turtlesoup', () => {
         return false
       }
     } catch (e) {
-      console.error('加载主持人游戏视图失败:', e)
       error.value = e instanceof Error ? e.message : '未知错误'
       return false
     } finally {
       loading.value = false
     }
   }
-  
-  // 加载玩家游戏视图
+
   async function loadPlayerGame(gameId: string) {
     loading.value = true
     error.value = null
     isHost.value = false
-    
     try {
       const result = await turtleSoupService.getPlayerGameData(gameId)
-      
       if (result.success && result.data) {
         playerView.value = result.data
         return true
@@ -261,15 +188,13 @@ export const useTurtleSoupStore = defineStore('turtlesoup', () => {
         return false
       }
     } catch (e) {
-      console.error('加载玩家游戏视图失败:', e)
       error.value = e instanceof Error ? e.message : '未知错误'
       return false
     } finally {
       loading.value = false
     }
   }
-  
-  // 转换游戏状态为房间状态
+
   function gameStatusToRoomStatus(status: TurtleSoupGameStatus): RoomStatus {
     switch (status) {
       case TurtleSoupGameStatus.CREATED:
@@ -284,320 +209,77 @@ export const useTurtleSoupStore = defineStore('turtlesoup', () => {
         return RoomStatus.WAITING
     }
   }
-  
-  // 创建新游戏 - 只处理游戏部分的数据
-  async function createGame(settings: TurtleSoupGameSettings) {
-    submitting.value = true
-    error.value = null
-    
-    try {
-      // 保存游戏设置
-      gameSettings.value = settings
-      
-      // 创建游戏
-      const result = await turtleSoupService.createGame(settings)
-      
-      if (result.success && result.data) {
-        return {
-          success: true,
-          gameId: result.data.gameId,
-          roomId: result.data.roomId
-        }
-      } else {
-        error.value = result.message || '创建游戏失败'
-        return { success: false, message: error.value }
-      }
-    } catch (e) {
-      console.error('创建游戏失败:', e)
-      error.value = e instanceof Error ? e.message : '创建游戏时发生错误'
-      return { success: false, message: error.value }
-    } finally {
-      submitting.value = false
-    }
-  }
-  
-  // 开始游戏
+
   async function startGame() {
     if (!isHost.value || !hostView.value) {
       error.value = '主持人视图未加载'
       return false
     }
-    
     submitting.value = true
     error.value = null
-    
     try {
       const result = await turtleSoupService.startGame(hostView.value.id)
-      
       if (result.success) {
-        // 更新游戏状态
-        if (hostView.value) {
-          hostView.value = {
-            ...hostView.value,
-            status: TurtleSoupGameStatus.ACTIVE,
-            startTime: Date.now(),
-            currentTime: Date.now()
-          }
+        hostView.value = {
+          ...hostView.value,
+          status: TurtleSoupGameStatus.ACTIVE,
+          startTime: Date.now(),
+          currentTime: Date.now()
         }
-        
         return true
       } else {
         error.value = result.message || '开始游戏失败'
         return false
       }
     } catch (e) {
-      console.error('开始游戏失败:', e)
       error.value = e instanceof Error ? e.message : '开始游戏时发生错误'
       return false
     } finally {
       submitting.value = false
     }
   }
-  
-  // 提交问题 (玩家)
-  async function submitQuestion(content: string) {
-    if (!playerView.value || !content.trim()) {
-      error.value = '无效的问题或游戏未加载'
-      return false
-    }
-    
-    submitting.value = true
-    error.value = null
-    
-    try {
-      const userStore = useUserStore()
-      const result = await turtleSoupService.submitQuestion(playerView.value.id, content)
-      
-      if (result.success && result.data) {
-        // 创建新问题对象
-        const newQuestion: TurtleSoupQuestion = {
-          id: result.data.questionId,
-          content,
-          askedBy: userStore.openid,
-          askedByName: userStore.nickname,
-          timestamp: Date.now(),
-          answered: false
-        }
-        
-        // 更新本地玩家视图
-        if (playerView.value) {
-          playerView.value = {
-            ...playerView.value,
-            myQuestions: [...playerView.value.myQuestions, newQuestion]
-          }
-        }
-        
-        // 清空草稿
-        localDraft.value = ''
-        return true
-      } else {
-        error.value = result.message || '提交问题失败'
-        return false
-      }
-    } catch (e) {
-      console.error('提交问题失败:', e)
-      error.value = e instanceof Error ? e.message : '提交问题时发生错误'
-      return false
-    } finally {
-      submitting.value = false
-    }
-  }
-  
-  // 回答问题 (主持人)
-  async function answerQuestion(questionId: string, answer: TurtleSoupAnswerType) {
-    if (!isHost.value || !hostView.value) {
-      error.value = '主持人视图未加载'
-      return false
-    }
-    
-    submitting.value = true
-    error.value = null
-    
-    try {
-      const result = await turtleSoupService.answerQuestion(questionId, answer)
-      
-      if (result.success) {
-        // 更新本地状态
-        if (hostView.value) {
-          const updatedQuestions = hostView.value.questions.map(q => {
-            if (q.id === questionId) {
-              return {
-                ...q,
-                answer,
-                answered: true,
-                answeredAt: Date.now()
-              }
-            }
-            return q
-          })
-          
-          hostView.value = {
-            ...hostView.value,
-            questions: updatedQuestions
-          }
-        }
-        return true
-      } else {
-        error.value = result.message || '回答问题失败'
-        return false
-      }
-    } catch (e) {
-      console.error('回答问题失败:', e)
-      error.value = e instanceof Error ? e.message : '回答问题时发生错误'
-      return false
-    } finally {
-      submitting.value = false
-    }
-  }
-  
-  // 公开提示 (主持人)
-  async function revealHint(hintId: string) {
-    if (!isHost.value || !hostView.value) {
-      error.value = '主持人视图未加载'
-      return false
-    }
-    
-    submitting.value = true
-    error.value = null
-    
-    try {
-      const result = await turtleSoupService.revealHint(hostView.value.id, hintId)
-      
-      if (result.success) {
-        // 更新本地状态
-        if (hostView.value) {
-          const updatedHints = hostView.value.hints.map(hint => {
-            if (hint.id === hintId) {
-              return {
-                ...hint,
-                revealed: true,
-                revealedAt: Date.now()
-              }
-            }
-            return hint
-          })
-          
-          hostView.value = {
-            ...hostView.value,
-            hints: updatedHints
-          }
-        }
-        return true
-      } else {
-        error.value = result.message || '公开提示失败'
-        return false
-      }
-    } catch (e) {
-      console.error('公开提示失败:', e)
-      error.value = e instanceof Error ? e.message : '公开提示时发生错误'
-      return false
-    } finally {
-      submitting.value = false
-    }
-  }
-  
-  // 提交解答 (玩家)
+
   async function submitSolution(solution: string) {
     if (!playerView.value || !solution.trim()) {
       error.value = '无效的解答或游戏未加载'
       return { success: false, correct: false }
     }
-    
     submitting.value = true
     error.value = null
-    
     try {
       const result = await turtleSoupService.submitSolution(playerView.value.id, solution)
-      
       if (result.success) {
-        // 解答正确
-        if (result.data?.correct) {
-          return { success: true, correct: true }
-        }
-        
-        // 解答错误
-        return { success: true, correct: false }
+        return { success: true, correct: !!result.data?.correct }
       } else {
         error.value = result.message || '提交解答失败'
         return { success: false, correct: false }
       }
     } catch (e) {
-      console.error('提交解答失败:', e)
       error.value = e instanceof Error ? e.message : '提交解答时发生错误'
       return { success: false, correct: false }
     } finally {
       submitting.value = false
     }
   }
-  
-  // 结束游戏 - 只更新状态，不处理房间
-  async function endGame(params: { 
-    gameId: string,
-    solved: boolean,
-    solvedBy?: string,
-    solvedByName?: string,
-    solution?: string
-  }) {
-    submitting.value = true
-    error.value = null
-    
-    try {
-      const { gameId, ...resultData } = params
-      const endResult = await turtleSoupService.endGame(gameId, resultData)
-      
-      if (endResult.success && endResult.data) {
-        // 更新游戏状态
-        if (isHost.value && hostView.value && hostView.value.id === gameId) {
-          hostView.value = {
-            ...hostView.value,
-            status: TurtleSoupGameStatus.COMPLETED,
-            currentTime: Date.now()
-          }
-        } else if (playerView.value && playerView.value.id === gameId) {
-          playerView.value = {
-            ...playerView.value,
-            status: TurtleSoupGameStatus.COMPLETED,
-            currentTime: Date.now()
-          }
-        }
-        
-        return endResult.data
-      } else {
-        error.value = endResult.message || '结束游戏失败'
-        return null
-      }
-    } catch (e) {
-      console.error('结束游戏失败:', e)
-      error.value = e instanceof Error ? e.message : '结束游戏时发生错误'
-      return null
-    } finally {
-      submitting.value = false
-    }
-  }
-  
-  // 保存问题草稿
+
+  // 保存草稿
   function saveDraft(content: string) {
     localDraft.value = content
   }
-  
-  // 更新游戏进度 (主持人)
+
+  // 更新进度
   async function updateProgress(progress: number) {
     if (!isHost.value || !hostView.value) {
       error.value = '主持人视图未加载'
       return false
     }
-    
     submitting.value = true
-    
     try {
       const result = await turtleSoupService.updateProgress(hostView.value.id, progress)
-      
       if (result.success) {
-        if (hostView.value) {
-          hostView.value = {
-            ...hostView.value,
-            progress
-          }
+        hostView.value = {
+          ...hostView.value,
+          progress
         }
         return true
       } else {
@@ -605,23 +287,18 @@ export const useTurtleSoupStore = defineStore('turtlesoup', () => {
         return false
       }
     } catch (e) {
-      console.error('更新游戏进度失败:', e)
       error.value = e instanceof Error ? e.message : '更新进度时发生错误'
       return false
     } finally {
       submitting.value = false
     }
   }
-  
-  // 刷新游戏数据
+
+  // 刷新数据
   async function refreshGameData(gameId: string) {
-    if (isHost.value) {
-      return loadHostGame(gameId)
-    } else {
-      return loadPlayerGame(gameId)
-    }
+    return isHost.value ? loadHostGame(gameId) : loadPlayerGame(gameId)
   }
-  
+
   return {
     // 状态
     hostView,
@@ -634,21 +311,16 @@ export const useTurtleSoupStore = defineStore('turtlesoup', () => {
     gameSettings,
     availableThemes,
     availablePuzzles,
-    
+
     // 计算属性
     currentView,
     gameStatus,
     isGameActive,
     isGameEnded,
-    revealedHints,
-    unrevealedHints,
-    sortedQuestions,
-    pendingQuestions,
-    myQuestions,
     gameDuration,
     gameProgress,
     roomCode,
-    
+
     // 操作方法
     resetState,
     setViewType,
@@ -661,11 +333,7 @@ export const useTurtleSoupStore = defineStore('turtlesoup', () => {
     loadPlayerGame,
     gameStatusToRoomStatus,
     startGame,
-    submitQuestion,
-    answerQuestion,
-    revealHint,
     submitSolution,
-    endGame,
     saveDraft,
     updateProgress,
     refreshGameData

src/types/games/turtlesoup.ts

@@ -1,5 +1,4 @@
 // types/games/turtlesoup.ts
-
 /**
  * 海龟汤游戏状态
  */
@@ -28,44 +27,11 @@ export enum TurtleSoupThemeType {
   PREMIUM = 'premium'       // 特色主题（付费）
 }
 
-/**
- * 海龟汤问题答案类型
- */
-export enum TurtleSoupAnswerType {
-  YES = 'yes',              // 是
-  NO = 'no',                // 否
-  IRRELEVANT = 'irrelevant' // 不重要
-}
-
-/**
- * 游戏提示结构
- */
-export interface TurtleSoupHint {
-  id: string;              // 提示ID
-  content: string;         // 提示内容
-  revealed: boolean;       // 是否已公开
-  revealedAt?: number;     // 公开时间戳
-}
-
-/**
- * 海龟汤问题
- */
-export interface TurtleSoupQuestion {
-  id: string;                     // 问题ID
-  content: string;                // 问题内容
-  answer?: TurtleSoupAnswerType;  // 回答类型：是/否/不重要
-  askedBy: string;                // 提问者ID
-  askedByName: string;            // 提问者名称
-  timestamp: number;              // 提问时间戳
-  answered: boolean;              // 是否已回答
-  answeredAt?: number;            // 回答时间戳
-}
-
 /**
  * 游戏主题
  */
 export interface TurtleSoupTheme {
-  id: string;                     // 主题ID
+  themeId: string;                // 主题ID
   name: string;                   // 主题名称
   description: string;            // 主题描述
   type: TurtleSoupThemeType;      // 主题类型
@@ -78,9 +44,16 @@ export interface TurtleSoupTheme {
  * 游戏题目
  */
 export interface TurtleSoupPuzzle {
-  id: string;                     // 题目ID
+  puzzleId: string;                // 题目ID
+  themeId: string;                // 主题ID
   title: string;                  // 题目标题
-  description: string;            // 题目描述
+  scenario: string;            // 汤面
+  truth: string;                  // 汤底
+  keyClues: string[];       // 关键线索
+  hints: {
+    keyword: string;              // 提示关键词，初级道具
+    sentence: string;             // 提示句子，高级道具
+  }[];
   difficulty: TurtleSoupDifficulty; // 题目难度
   averageDuration: number;        // 平均完成时间（分钟）
   price?: number;                  // 价格
@@ -96,89 +69,53 @@ export interface TurtleSoupGameSettings {
   puzzleId: string;               // 选择的题目ID
   difficulty: TurtleSoupDifficulty; // 游戏难度
   maxPlayers: number;             // 最大玩家数
-  isPrivate: boolean;             // 是否为私人游戏
   password?: string;              // 房间密码
 }
 
 /**
- * 海龟汤游戏 - 主持人视图
+ * 游戏基础视图
  */
-export interface TurtleSoupGameHostView {
-  id: string;                     // 游戏ID
-  roomId: string;                 // 房间ID
-  title: string;                  // 游戏标题
-  roomCode: string;               // 房间代码
-  description: string;            // 游戏描述/故事
-  solution: string;               // 解决方案（只有主持人可见）
-  hints: TurtleSoupHint[];        // 提示列表
-  questions: TurtleSoupQuestion[]; // 问题列表
-  status: TurtleSoupGameStatus;   // 游戏状态
-  createTime: number;             // 创建时间戳
-  startTime?: number;             // 开始时间戳
-  currentTime?: number;           // 当前时间戳
-  duration?: number;              // 已进行时长（分钟）
-  hostId: string;                 // 主持人ID
-  hostName: string;               // 主持人名称
-  players: {                      // 玩家列表
-    id: string;                   // 玩家ID
-    name: string;                 // 玩家名称
-    avatar?: string;              // 头像
-    joinedAt: number;             // 加入时间戳
-    questionCount: number;        // 提问次数
-  }[];
-  settings: TurtleSoupGameSettings; // 游戏设置
-  playerCount: number;            // 当前玩家数
-  progress: number;               // 解谜进度（百分比，主持人估计）
+interface TurtleSoupGameBaseView {
+  id: string;
+  roomId: string;
+  title: string;
+  theme: TurtleSoupTheme;
+  puzzle: TurtleSoupPuzzle;
+  status: TurtleSoupGameStatus;
+  startTime?: number;
+  currentTime?: number;
+  duration?: number;
+  hostId: string;
+  hostName: string;
+  progress: number;
+  difficulty: TurtleSoupDifficulty;
+  settings: TurtleSoupGameSettings;
 }
 
 /**
- * 海龟汤游戏 - 玩家视图
+ * 游戏主持人视图
  */
-export interface TurtleSoupGamePlayerView {
-  id: string;                     // 游戏ID
-  roomId: string;                 // 房间ID
-  title: string;                  // 游戏标题
-  description: string;            // 游戏描述/故事
-  revealedHints: {                // 已公开的提示
-    id: string;                   // 提示ID
-    content: string;              // 提示内容
-    revealedAt: number;           // 公开时间戳
-  }[];
-  myQuestions: TurtleSoupQuestion[]; // 我的问题
-  allQuestions: {                 // 所有已回答的问题
-    id: string;
-    content: string;
-    askedByName: string;
-    answer: TurtleSoupAnswerType;
-    timestamp: number;
-  }[];
-  status: TurtleSoupGameStatus;   // 游戏状态
-  startTime?: number;             // 开始时间戳
-  currentTime?: number;           // 当前时间戳
-  duration?: number;              // 已进行时长（分钟）
-  hostId: string;                 // 主持人ID
-  hostName: string;               // 主持人名称
-  progress: number;               // 解谜进度（百分比）
-  difficulty: TurtleSoupDifficulty; // 游戏难度
-  otherPlayers: {                 // 其他玩家列表
+export interface TurtleSoupGameHostView extends TurtleSoupGameBaseView {
+  players: {
     id: string;
     name: string;
     avatar?: string;
+    joinedAt: number;
+    questionCount: number;
   }[];
 }
 
-/**
- * 海龟汤游戏结果
- */
-export interface TurtleSoupGameResult {
-  gameId: string;                 // 游戏ID
-  solved: boolean;                // 是否解决
-  solvedBy?: string;              // 解决者ID
-  solvedByName?: string;          // 解决者名称
-  solution?: string;              // 提交的解答
-  duration: number;               // 游戏时长(分钟)
-  questionCount: number;          // 总提问次数
-  hintsRevealed: number;          // 使用的提示数
-  completionTime: number;         // 完成时间戳
-  playerCount: number;            // 参与玩家数
+export interface TurtleSoupGamePlayerView extends TurtleSoupGameBaseView {
+  myPlayerInfo: {
+    id: string;
+    name: string;
+    avatar?: string;
+    joinedAt: number;
+    questionCount: number;
+  };
+  otherPlayers: {
+    id: string;
+    name: string;
+    avatar?: string;
+  }[];
 }