game.js

// 狼人杀游戏引擎

import { GAME_CONFIG, AI_PERSONALITIES } from './config.js';

export class WerewolfGame {
  constructor() {
    this.config = GAME_CONFIG;
    this.players = [];
    this.round = 0;
    this.phase = null;
    this.history = [];
    this.nightActions = {};
    this.voteResults = {};
    this.winner = null;
    this.logs = [];
    this.speeches = [];
  }

  // 初始化游戏
  init() {
    this.players = this.createPlayers();
    this.assignRoles();
    this.assignPersonalities();
    this.round = 1;
    this.phase = this.config.phases.NIGHT;
    this.addLog('gameStart', '🎮 游戏开始！12位玩家已就座，天黑请闭眼...');
    return this;
  }

  // 创建玩家
  createPlayers() {
    const players = [];
    const names = [
      '张三', '李四', '王五', '赵六', 
      '孙七', '周八', '吴九', '郑十',
      '陈一', '刘二', '杨三', '黄四'
    ];
    
    for (let i = 1; i <= this.config.totalPlayers; i++) {
      players.push({
        id: i,
        seat: i,
        name: names[i - 1],
        role: null,
        alive: true,
        personality: null,
        // 特殊角色状态
        hasPoison: true,        // 女巫毒药
        hasAntidote: true,      // 女巫解药
        lastGuarded: null,      // 守卫上次守护的人
        checkedPlayers: []      // 预言家查验记录
      });
    }
    
    return players;
  }

  // 分配角色
  assignRoles() {
    const roles = [];
    Object.entries(this.config.roles).forEach(([roleKey, roleConfig]) => {
      for (let i = 0; i < roleConfig.count; i++) {
        roles.push(roleKey);
      }
    });

    // 洗牌算法
    for (let i = roles.length - 1; i > 0; i--) {
      const j = Math.floor(Math.random() * (i + 1));
      [roles[i], roles[j]] = [roles[j], roles[i]];
    }

    // 分配给玩家
    this.players.forEach((player, index) => {
      player.role = roles[index];
    });
  }

  // 分配性格
  assignPersonalities() {
    const shuffledPersonalities = [...AI_PERSONALITIES];
    for (let i = shuffledPersonalities.length - 1; i > 0; i--) {
      const j = Math.floor(Math.random() * (i + 1));
      [shuffledPersonalities[i], shuffledPersonalities[j]] = 
        [shuffledPersonalities[j], shuffledPersonalities[i]];
    }

    this.players.forEach((player, index) => {
      player.personality = shuffledPersonalities[index % shuffledPersonalities.length];
    });
  }

  // 获取存活玩家
  getAlivePlayers() {
    return this.players.filter(p => p.alive);
  }

  // 获取特定角色的玩家
  getPlayersByRole(roleKey) {
    return this.players.filter(p => p.role === roleKey);
  }

  // 获取存活狼人
  getAliveWolves() {
    return this.players.filter(p => p.role === 'WEREWOLF' && p.alive);
  }

  // 获取存活好人
  getAliveVillagers() {
    return this.players.filter(p => p.role !== 'WEREWOLF' && p.alive);
  }

  // 检查游戏是否结束
  checkGameOver() {
    const aliveWolves = this.getAliveWolves().length;
    const aliveVillagers = this.getAliveVillagers().length;

    if (aliveWolves === 0) {
      this.winner = 'village';
      this.phase = this.config.phases.GAME_OVER;
      this.addLog('gameEnd', '🎉 游戏结束！好人阵营获胜！');
      return true;
    }

    if (aliveWolves >= aliveVillagers) {
      this.winner = 'wolf';
      this.phase = this.config.phases.GAME_OVER;
      this.addLog('gameEnd', '🎉 游戏结束！狼人阵营获胜！');
      return true;
    }

    return false;
  }

  // 添加日志
  addLog(type, message, data = {}) {
    const log = {
      type,
      message,
      timestamp: new Date().toISOString(),
      round: this.round,
      phase: this.phase,
      data
    };
    this.logs.push(log);
    return log;
  }

  // 添加发言记录
  addSpeech(playerId, content, round = this.round) {
    const speech = {
      playerId,
      playerName: this.players.find(p => p.id === playerId)?.name,
      seat: this.players.find(p => p.id === playerId)?.seat,
      content,
      round,
      phase: this.phase,
      timestamp: new Date().toISOString()
    };
    this.speeches.push(speech);
    return speech;
  }

  // 记录夜晚行动
  recordNightAction(playerId, action, target) {
    if (!this.nightActions[this.round]) {
      this.nightActions[this.round] = {};
    }
    
    this.nightActions[this.round][playerId] = {
      action,
      target,
      timestamp: new Date().toISOString()
    };
  }

  // 记录投票
  recordVote(voterId, targetId, reason = '') {
    if (!this.voteResults[this.round]) {
      this.voteResults[this.round] = [];
    }
    
    this.voteResults[this.round].push({
      voterId,
      voterSeat: this.players.find(p => p.id === voterId)?.seat,
      targetId,
      targetSeat: this.players.find(p => p.id === targetId)?.seat,
      reason,
      timestamp: new Date().toISOString()
    });
  }

  // 玩家死亡
  killPlayer(playerId, cause = 'unknown') {
    const player = this.players.find(p => p.id === playerId);
    if (player && player.alive) {
      player.alive = false;
      player.deathRound = this.round;
      player.deathCause = cause;
      
      const roleConfig = this.config.roles[player.role];
      this.addLog('playerDeath', 
        `💀 ${player.seat}号玩家【${player.name}】死亡，身份是【${roleConfig.name}】`, 
        { playerId, cause }
      );
      
      return true;
    }
    return false;
  }

  // 进入下一轮
  nextRound() {
    this.round++;
    this.addLog('roundStart', `📍 第${this.round}轮开始`);
    return this;
  }

  // 获取游戏状态
  getState() {
    return {
      round: this.round,
      phase: this.phase,
      players: this.players.map(p => ({
        id: p.id,
        seat: p.seat,
        name: p.name,
        alive: p.alive,
        role: p.role,
        roleInfo: this.config.roles[p.role],
        personality: p.personality,
        deathRound: p.deathRound,
        deathCause: p.deathCause
      })),
      aliveCount: {
        total: this.getAlivePlayers().length,
        wolves: this.getAliveWolves().length,
        villagers: this.getAliveVillagers().length
      },
      winner: this.winner,
      recentLogs: this.logs.slice(-10),
      recentSpeeches: this.speeches.slice(-20)
    };
  }

  // 导出游戏记录
  exportGame() {
    return {
      config: this.config,
      players: this.players,
      rounds: this.round,
      winner: this.winner,
      history: this.history,
      logs: this.logs,
      speeches: this.speeches,
      nightActions: this.nightActions,
      voteResults: this.voteResults
    };
  }

  // 从存档恢复游戏
  loadGame(savedGame) {
    this.players = savedGame.players;
    this.round = savedGame.rounds;
    this.winner = savedGame.winner;
    this.history = savedGame.history || [];
    this.logs = savedGame.logs || [];
    this.speeches = savedGame.speeches || [];
    this.nightActions = savedGame.nightActions || {};
    this.voteResults = savedGame.voteResults || {};
    return this;
  }
}