#include<bits/stdc++.h> #include<windows.h> #include<conio.h> #include #include // 补充GCC 4.9.2必需的头文件 #include // 新增文件操作头文件 using namespace std; // 游戏常量定义 const int game_day=0, game_task=1, game_meeting=2, game_siege=3; int round_num=0, current_phase=game_day; int player_count, my_id; HWND hwnd=GetForegroundWindow();

// 颜色定义
	const int blue=0,yellow=1,red=2,green=3,purple=4,white=5,cyan=6,orange=7;

// 身份定义
	const int crewmate=0, impostor=1, engineer=2, medic=3, detective=4;
	const int technician=5, watcher=6, spy=7; 
	const int tracker=8, bomber=9, cleaner=10, seer=11;
	const int decoy=12, hacker=13, guard=14, trickster=15;
	const int alive=0, dead=1, ejected=2;

// 房间/区域定义
	const int room_engine=0, room_electric=1, room_security=2, room_medbay=3, room_storage=4;
	const int room_count=5;
	bool room_destroyed[room_count]={false};
	int current_room=-1;

// 全局变量（修复trickster_fake_kill命名冲突）
	int impostor_count=0;          
	int engineer_id=-1, medic_id=-1, detective_id=-1;
	int technician_id=-1, watcher_id=-1, spy_id=-1; 
	int tracker_id=-1, bomber_id=-1, cleaner_id=-1, seer_id=-1;
	int decoy_id=-1, hacker_id=-1, guard_id=-1, trickster_id=-1;
	int impostor_ids[6]={-1,-1,-1,-1,-1,-1};
	int ejected_player=-1;          
	int killed_player=-1;           
	int shielded_player=-1;         
	int repaired_task=-1;           
	bool security_camera_active=false;
	bool bomb_planted=false;
	int bomb_room=-1;
	int bomb_timer=2;
	int cleaned_body=-1;
	int global_task_progress=0;
	bool trickster_fake_kill_flag=false; // 重命名全局变量，避免和函数名冲突
	int guard_protect_room=-1;

// 颜色设置函数
void color(int c){
    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    switch(c){
        case red:SetConsoleTextAttribute(hConsole, FOREGROUND_INTENSITY | FOREGROUND_RED);break;
        case green:SetConsoleTextAttribute(hConsole, FOREGROUND_INTENSITY | FOREGROUND_GREEN);break;
        case yellow:SetConsoleTextAttribute(hConsole, FOREGROUND_INTENSITY | FOREGROUND_RED |FOREGROUND_GREEN);break;
        case blue:SetConsoleTextAttribute(hConsole, FOREGROUND_INTENSITY | FOREGROUND_BLUE);break;
        case white:SetConsoleTextAttribute(hConsole, FOREGROUND_INTENSITY | FOREGROUND_RED |FOREGROUND_GREEN | FOREGROUND_BLUE);break;
        case purple:SetConsoleTextAttribute(hConsole, FOREGROUND_INTENSITY | FOREGROUND_RED |FOREGROUND_BLUE);break;
        case cyan:SetConsoleTextAttribute(hConsole, FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_BLUE);break;
        case orange:SetConsoleTextAttribute(hConsole, FOREGROUND_INTENSITY | FOREGROUND_RED | (FOREGROUND_GREEN/2));break;
    }
}

// 光标定位
void gotoxy(int x,int y){
    COORD position;
    position.X=x;
    position.Y=y;
    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), position);
}

// 窗口初始化
void init_window(){
    system("mode con lines=60 cols=188"); 
    ShowWindow(hwnd,SW_MAXIMIZE);
    DeleteMenu(GetSystemMenu(GetConsoleWindow(), FALSE), SC_CLOSE, MF_BYCOMMAND);
    DrawMenuBar(GetConsoleWindow());
}

// 玩家类
class Player{
public:
    int role;          
    int status;        
    int kill_count;    
    bool is_visible;   
    int current_room;
    int camera_time;
    int track_target;
    int seer_cooldown;
    bool decoy_fake_dead;
    int hacker_cooldown;
    int guard_cooldown;
    int trickster_cooldown;
    
    Player(){
        role=-1;
        status=alive;
        kill_count=0;
        is_visible=false;
        current_room=0;
        camera_time=0;
        track_target=-1;
        seer_cooldown=0;
        decoy_fake_dead=false;
        hacker_cooldown=0;
        guard_cooldown=0;
        trickster_cooldown=0;
    }
    
    int get_status(){
        return status;
    }
    
    // 序列化玩家数据（存档用）
    void save(ofstream &fout){
        fout.write((char*)&role, sizeof(role));
        fout.write((char*)&status, sizeof(status));
        fout.write((char*)&kill_count, sizeof(kill_count));
        fout.write((char*)&is_visible, sizeof(is_visible));
        fout.write((char*)&current_room, sizeof(current_room));
        fout.write((char*)&camera_time, sizeof(camera_time));
        fout.write((char*)&track_target, sizeof(track_target));
        fout.write((char*)&seer_cooldown, sizeof(seer_cooldown));
        fout.write((char*)&decoy_fake_dead, sizeof(decoy_fake_dead));
        fout.write((char*)&hacker_cooldown, sizeof(hacker_cooldown));
        fout.write((char*)&guard_cooldown, sizeof(guard_cooldown));
        fout.write((char*)&trickster_cooldown, sizeof(trickster_cooldown));
    }
    
    // 反序列化玩家数据（读档用）
    void load(ifstream &fin){
        fin.read((char*)&role, sizeof(role));
        fin.read((char*)&status, sizeof(status));
        fin.read((char*)&kill_count, sizeof(kill_count));
        fin.read((char*)&is_visible, sizeof(is_visible));
        fin.read((char*)&current_room, sizeof(current_room));
        fin.read((char*)&camera_time, sizeof(camera_time));
        fin.read((char*)&track_target, sizeof(track_target));
        fin.read((char*)&seer_cooldown, sizeof(seer_cooldown));
        fin.read((char*)&decoy_fake_dead, sizeof(decoy_fake_dead));
        fin.read((char*)&hacker_cooldown, sizeof(hacker_cooldown));
        fin.read((char*)&guard_cooldown, sizeof(guard_cooldown));
        fin.read((char*)&trickster_cooldown, sizeof(trickster_cooldown));
    }
};

Player players[20];

// 检查数组是否包含指定值
bool is_include(int arr[], int val, int len){
    for(int i=0;i<len;i++){
        if(arr[i]==val) return true;
    }
    return false;
}

// 打字任务函数
bool typing_task(){
    color(cyan);
    cout << "\n=== 精准打字任务 ===" << endl;
    string texts[] = {
        "repair the electrical system",
        "check the engine temperature",
        "calibrate the navigation system",
        "analyze the oxygen level",
        "verify the security protocol"
    };
    
    string target = texts[rand()%5];
    cout << "请准确输入以下内容：" << target << endl;
    cout << "输入：";
    
    string input;
    cin >> ws;
    getline(cin, input);
    
    if(input == target){
        color(green);
        cout << "输入正确！任务完成！" << endl;
        return true;
    }else{
        color(red);
        cout << "输入错误！任务失败！正确内容：" << target << endl;
        return false;
    }
}

// 房间名称转换
string get_room_name(int room_id){
    switch(room_id){
        case room_engine: return "引擎室";
        case room_electric: return "电力室";
        case room_security: return "监控室";
        case room_medbay: return "医疗室";
        case room_storage: return "储藏室";
        default: return "未知区域";
    }
}

// 初始化玩家身份
void init_players(){
    my_id=rand()%player_count;
    global_task_progress=0;
    
    if(player_count<=6) impostor_count=1;
    else if(player_count<=10) impostor_count=2;
    else if(player_count<=15) impostor_count=3;
    else impostor_count=4;
    
    for(int i=0;i<player_count;i++){
        players[i].status=alive;
        players[i].kill_count=0;
        players[i].is_visible=false;
        players[i].role=-1;
        players[i].current_room=rand()%room_count;
        players[i].camera_time=0;
        players[i].track_target=-1;
        players[i].seer_cooldown=0;
        players[i].decoy_fake_dead=false;
        players[i].hacker_cooldown=0;
        players[i].guard_cooldown=0;
        players[i].trickster_cooldown=0;
    }
    
    for(int i=0;i<impostor_count;i++){
        int p=rand()%player_count;
        if(!is_include(impostor_ids, p, 6)){
            impostor_ids[i]=p;
            players[p].role=impostor;
        }else{
            i--;
        }
        Sleep(rand()%80+100);
    }
    
    if(player_count>=10 && impostor_count>=2){
        do{
            bomber_id=rand()%player_count;
        }while(players[bomber_id].role!=-1);
        players[bomber_id].role=bomber;
        impostor_ids[impostor_count++] = bomber_id;
    }
    
    if(player_count>=12 && impostor_count>=2){
        do{
            cleaner_id=rand()%player_count;
        }while(players[cleaner_id].role!=-1);
        players[cleaner_id].role=cleaner;
        impostor_ids[impostor_count++] = cleaner_id;
    }
    
    if(player_count>=13 && impostor_count>=3){
        do{
            spy_id=rand()%player_count;
        }while(players[spy_id].role!=-1);
        players[spy_id].role=spy;
        impostor_ids[impostor_count++] = spy_id;
    }
    
    if(player_count>=15 && impostor_count>=3){
        do{
            trickster_id=rand()%player_count;
        }while(players[trickster_id].role!=-1);
        players[trickster_id].role=trickster;
        impostor_ids[impostor_count++] = trickster_id;
    }
    
    do{
        engineer_id=rand()%player_count;
    }while(players[engineer_id].role!=-1);
    players[engineer_id].role=engineer;
    
    if(player_count>=8){
        do{
            medic_id=rand()%player_count;
        }while(players[medic_id].role!=-1);
        players[medic_id].role=medic;
    }
    
    if(player_count>=10){
        do{
            detective_id=rand()%player_count;
        }while(players[detective_id].role!=-1);
        players[detective_id].role=detective;
    }
    
    if(player_count>=9){
        do{
            technician_id=rand()%player_count;
        }while(players[technician_id].role!=-1);
        players[technician_id].role=technician;
    }
    
    if(player_count>=11){
        do{
            watcher_id=rand()%player_count;
        }while(players[watcher_id].role!=-1);
        players[watcher_id].role=watcher;
    }
    
    if(player_count>=8){
        do{
            tracker_id=rand()%player_count;
        }while(players[tracker_id].role!=-1);
        players[tracker_id].role=tracker;
    }
    
    if(player_count>=11){
        do{
            seer_id=rand()%player_count;
        }while(players[seer_id].role!=-1);
        players[seer_id].role=seer;
    }
    
    if(player_count>=14){
        do{
            decoy_id=rand()%player_count;
        }while(players[decoy_id].role!=-1);
        players[decoy_id].role=decoy;
    }
    
    if(player_count>=16){
        do{
            hacker_id=rand()%player_count;
        }while(players[hacker_id].role!=-1);
        players[hacker_id].role=hacker;
    }
    
    if(player_count>=18){
        do{
            guard_id=rand()%player_count;
        }while(players[guard_id].role!=-1);
        players[guard_id].role=guard;
    }
    
    for(int i=0;i<player_count;i++){
        if(players[i].role==-1){
            players[i].role=crewmate;
        }
    }
    
    players[my_id].is_visible=true;
    if(players[my_id].role==impostor || players[my_id].role==spy || 
       players[my_id].role==bomber || players[my_id].role==cleaner ||
       players[my_id].role==trickster){
        for(int i=0;i<impostor_count;i++){
            players[impostor_ids[i]].is_visible=true;
        }
    }
}

// 打印游戏界面
void print_game(){
    gotoxy(0,0);
    cout<<"太空杀 | 新增角色+房间系统+精准打字任务+全局任务进度+存档读档功能";
    
    gotoxy(90,0);
    if(current_phase==game_meeting) color(red);
    else if(current_phase==game_task) color(cyan);
    else if(current_phase==game_siege) color(orange);
    else color(blue);
    
    printf("第%d回合 | ",round_num);
    if(current_phase==game_day) cout<<"日常阶段";
    else if(current_phase==game_task) cout<<"任务阶段";
    else if(current_phase==game_meeting) cout<<"紧急会议";
    else cout<<"破坏阶段";
    
    gotoxy(130,0);
    if(bomb_planted){
        color(red);
        cout<<"【炸弹警告】"<<get_room_name(bomb_room)<<" 剩余"<<bomb_timer<<"回合爆炸！";
    }
    
    gotoxy(0,3);
    color(blue);
    cout<<" 我的编号:"<<my_id+1;
    cout<<" | 当前房间:"<<get_room_name(players[my_id].current_room);
    
    gotoxy(0,4);
    color(green);
    cout<<" 全局任务进度："<<global_task_progress<<"% (船员需达到100%获胜)";
    
    gotoxy(60,3);
    color(yellow);
    cout<<"=== 区域状态 ===";
    for(int i=0;i<room_count;i++){
        gotoxy(60,4+i);
        if(room_destroyed[i]){
            color(red);
            cout<<get_room_name(i)<<": 已破坏";
        }else{
            color(green);
            cout<<get_room_name(i)<<": 正常";
        }
        if(guard_protect_room == i){
            color(cyan);
            cout<<" [守卫保护]";
        }
    }
    
    int col=0, row=10;
    for(int i=0;i<player_count;i++){
        gotoxy(col*12+1,row);
        color(blue);
        cout<<i+1<<"号"; 
        
        gotoxy(col*12+1,row+1);
        if(players[i].get_status()==dead){
            color(red);
            cout<<"已死亡";
        }else if(players[i].get_status()==ejected){
            color(yellow);
            cout<<"被驱逐";
        }else{
            color(green);
            cout<<"存活中";
            if(players[i].decoy_fake_dead){
                color(orange);
                cout<<"[假死]";
            }
        }
        
        gotoxy(col*12+1,row+2);
        color(cyan);
        cout<<"房间:"<<get_room_name(players[i].current_room);
        
        gotoxy(col*12+1,row+3);
        color(blue);
        if(players[i].is_visible){
            switch(players[i].role){
                case crewmate: cout<<"船员";break;
                case impostor: cout<<"内鬼";break;
                case engineer: cout<<"工程师";break;
                case medic: cout<<"医生";break;
                case detective: cout<<"侦探";break;
                case technician: cout<<"技术员";break;
                case watcher: cout<<"守望者";break;
                case spy: cout<<"间谍(内鬼)";break;
                case tracker: cout<<"追踪者";break;
                case bomber: cout<<"爆破手(内鬼)";break;
                case cleaner: cout<<"清洁工(内鬼)";break;
                case seer: cout<<"预言家";break;
                case decoy: cout<<"诱饵";break;
                case hacker: cout<<"黑客";break;
                case guard: cout<<"守卫";break;
                case trickster: cout<<"欺诈师(内鬼)";break;
            }
        }else{
            cout<<"未知";
        }
        
        col++;
        if(col >= 15){
            col=0;
            row+=5;
        }
    }
    
    gotoxy(0, 40);
    color(purple);
    cout<<"=== 监控系统 ===";
    if(security_camera_active){
        cout<<" [已开启]";
        color(white);
        cout<<"\n监控可见玩家位置：";
        for(int i=0;i<player_count;i++){
            if(players[i].status==alive){
                cout<<i+1<<"号("<<get_room_name(players[i].current_room)<<") ";
            }
        }
    }else{
        cout<<" [已关闭]";
    }
    
    if(players[my_id].role==tracker && players[my_id].track_target!=-1){
        gotoxy(0,42);
        color(orange);
        cout<<"=== 追踪信息 ===";
        cout<<"\n你追踪的"<<players[my_id].track_target+1<<"号当前位置："
            <<get_room_name(players[players[my_id].track_target].current_room);
    }
    
    gotoxy(0,48);
    color(white);
    cout<<"________________________";
    
    // 新增存档提示
    gotoxy(0, 50);
    color(yellow);
    cout<<"【存档功能】按 S 存档 | 按 L 读档";
}

// 存档函数
bool save_game(){
    color(white);
    cout << "\n\n=== 保存游戏进度 ===" << endl;
    cout << "请输入存档文件名（无需后缀，默认.sav）：";
    string filename;
    cin >> filename;
    filename += ".sav";
    
    ofstream fout(filename.c_str(), ios::binary);
    if(!fout){
        color(red);
        cout << "存档失败！无法创建文件！" << endl;
        Sleep(1500);
        return false;
    }
    
    // 保存基础数据
    fout.write((char*)&round_num, sizeof(round_num));
    fout.write((char*)&current_phase, sizeof(current_phase));
    fout.write((char*)&player_count, sizeof(player_count));
    fout.write((char*)&my_id, sizeof(my_id));
    fout.write((char*)&impostor_count, sizeof(impostor_count));
    fout.write((char*)&global_task_progress, sizeof(global_task_progress));
    
    // 保存身份ID
    fout.write((char*)&engineer_id, sizeof(engineer_id));
    fout.write((char*)&medic_id, sizeof(medic_id));
    fout.write((char*)&detective_id, sizeof(detective_id));
    fout.write((char*)&technician_id, sizeof(technician_id));
    fout.write((char*)&watcher_id, sizeof(watcher_id));
    fout.write((char*)&spy_id, sizeof(spy_id));
    fout.write((char*)&tracker_id, sizeof(tracker_id));
    fout.write((char*)&bomber_id, sizeof(bomber_id));
    fout.write((char*)&cleaner_id, sizeof(cleaner_id));
    fout.write((char*)&seer_id, sizeof(seer_id));
    fout.write((char*)&decoy_id, sizeof(decoy_id));
    fout.write((char*)&hacker_id, sizeof(hacker_id));
    fout.write((char*)&guard_id, sizeof(guard_id));
    fout.write((char*)&trickster_id, sizeof(trickster_id));
    
    // 保存内鬼ID数组
    fout.write((char*)impostor_ids, sizeof(impostor_ids));
    
    // 保存游戏状态变量
    fout.write((char*)&ejected_player, sizeof(ejected_player));
    fout.write((char*)&killed_player, sizeof(killed_player));
    fout.write((char*)&shielded_player, sizeof(shielded_player));
    fout.write((char*)&repaired_task, sizeof(repaired_task));
    fout.write((char*)&security_camera_active, sizeof(security_camera_active));
    fout.write((char*)&bomb_planted, sizeof(bomb_planted));
    fout.write((char*)&bomb_room, sizeof(bomb_room));
    fout.write((char*)&bomb_timer, sizeof(bomb_timer));
    fout.write((char*)&cleaned_body, sizeof(cleaned_body));
    fout.write((char*)&trickster_fake_kill_flag, sizeof(trickster_fake_kill_flag));
    fout.write((char*)&guard_protect_room, sizeof(guard_protect_room));
    
    // 保存房间状态
    fout.write((char*)room_destroyed, sizeof(room_destroyed));
    
    // 保存所有玩家数据
    for(int i=0; i<player_count; i++){
        players[i].save(fout);
    }
    
    fout.close();
    color(green);
    cout << "存档成功！文件已保存为：" << filename << endl;
    Sleep(1500);
    return true;
}

// 读档函数
bool load_game(){
    color(white);
    cout << "\n\n=== 加载游戏进度 ===" << endl;
    cout << "请输入存档文件名（无需后缀，默认.sav）：";
    string filename;
    cin >> filename;
    filename += ".sav";
    
    ifstream fin(filename.c_str(), ios::binary);
    if(!fin){
        color(red);
        cout << "读档失败！文件不存在或无法读取！" << endl;
        Sleep(1500);
        return false;
    }
    
    // 读取基础数据
    fin.read((char*)&round_num, sizeof(round_num));
    fin.read((char*)&current_phase, sizeof(current_phase));
    fin.read((char*)&player_count, sizeof(player_count));
    fin.read((char*)&my_id, sizeof(my_id));
    fin.read((char*)&impostor_count, sizeof(impostor_count));
    fin.read((char*)&global_task_progress, sizeof(global_task_progress));
    
    // 读取身份ID
    fin.read((char*)&engineer_id, sizeof(engineer_id));
    fin.read((char*)&medic_id, sizeof(medic_id));
    fin.read((char*)&detective_id, sizeof(detective_id));
    fin.read((char*)&technician_id, sizeof(technician_id));
    fin.read((char*)&watcher_id, sizeof(watcher_id));
    fin.read((char*)&spy_id, sizeof(spy_id));
    fin.read((char*)&tracker_id, sizeof(tracker_id));
    fin.read((char*)&bomber_id, sizeof(bomber_id));
    fin.read((char*)&cleaner_id, sizeof(cleaner_id));
    fin.read((char*)&seer_id, sizeof(seer_id));
    fin.read((char*)&decoy_id, sizeof(decoy_id));
    fin.read((char*)&hacker_id, sizeof(hacker_id));
    fin.read((char*)&guard_id, sizeof(guard_id));
    fin.read((char*)&trickster_id, sizeof(trickster_id));
    
    // 读取内鬼ID数组
    fin.read((char*)impostor_ids, sizeof(impostor_ids));
    
    // 读取游戏状态变量
    fin.read((char*)&ejected_player, sizeof(ejected_player));
    fin.read((char*)&killed_player, sizeof(killed_player));
    fin.read((char*)&shielded_player, sizeof(shielded_player));
    fin.read((char*)&repaired_task, sizeof(repaired_task));
    fin.read((char*)&security_camera_active, sizeof(security_camera_active));
    fin.read((char*)&bomb_planted, sizeof(bomb_planted));
    fin.read((char*)&bomb_room, sizeof(bomb_room));
    fin.read((char*)&bomb_timer, sizeof(bomb_timer));
    fin.read((char*)&cleaned_body, sizeof(cleaned_body));
    fin.read((char*)&trickster_fake_kill_flag, sizeof(trickster_fake_kill_flag));
    fin.read((char*)&guard_protect_room, sizeof(guard_protect_room));
    
    // 读取房间状态
    fin.read((char*)room_destroyed, sizeof(room_destroyed));
    
    // 读取所有玩家数据
    for(int i=0; i<20; i++){ // 最多20个玩家
        players[i].load(fin);
    }
    
    fin.close();
    color(green);
    cout << "读档成功！已恢复到第" << round_num << "回合进度！" << endl;
    Sleep(1500);
    
    // 重新绘制界面
    system("cls");
    print_game();
    return true;
}

// 内鬼破坏重要区域
void impostor_destroy_room(){
    color(red);
    cout<<"\n=== 内鬼破坏阶段 ==="<<endl;
    Sleep(1000);
    
    if(players[my_id].role==impostor || players[my_id].role==spy || 
       players[my_id].role==bomber || players[my_id].role==cleaner ||
       players[my_id].role==trickster){
        cout<<"选择要破坏的区域："<<endl;
        for(int i=0;i<room_count;i++){
            cout<<i+1<<". "<<get_room_name(i)<<" ("<<(room_destroyed[i]?"已破坏":"正常")<<")"<<endl;
        }
        
        int choice;
        cin>>choice;
        while(choice<1 || choice>room_count){
            color(yellow);
            cout<<"无效选择！重新输入：";
            cin>>choice;
        }
        choice--;
        
        if(guard_protect_room == choice){
            color(yellow);
            cout<<"该房间被守卫保护，无法破坏！"<<endl;
            Sleep(1500);
            return;
        }
        
        if(!room_destroyed[choice]){
            room_destroyed[choice]=true;
            color(red);
            cout<<"你破坏了"<<get_room_name(choice)<<"！船员需要尽快修复！"<<endl;
            
            if(choice==room_engine || choice==room_electric){
                color(orange);
                cout<<get_room_name(choice)<<"被破坏！全局任务进度停止增长，直到修复！"<<endl;
            }
        }else{
            color(yellow);
            cout<<get_room_name(choice)<<"已经被破坏了！"<<endl;
        }
    }else{
        int ai_choice;
        do{
            ai_choice=rand()%room_count;
        }while(room_destroyed[ai_choice] || guard_protect_room == ai_choice);
        
        room_destroyed[ai_choice]=true;
        color(red);
        cout<<"内鬼破坏了"<<get_room_name(ai_choice)<<"！"<<endl;
    }
    Sleep(2000);
}

// 爆破手布置炸弹
void bomber_plant_bomb(){
    if(players[my_id].role==bomber && players[my_id].status==alive && !bomb_planted){
        color(red);
        cout<<"\n=== 爆破手技能 ==="<<endl;
        cout<<"选择布置炸弹的区域："<<endl;
        for(int i=0;i<room_count;i++){
            cout<<i+1<<". "<<get_room_name(i)<<endl;
        }
        
        int choice;
        cin>>choice;
        while(choice<1 || choice>room_count){
            color(yellow);
            cout<<"无效选择！重新输入：";
            cin>>choice;
        }
        choice--;
        
        bomb_planted=true;
        bomb_room=choice;
        bomb_timer=2;
        color(red);
        cout<<"你在"<<get_room_name(choice)<<"布置了定时炸弹！2回合后爆炸！"<<endl;
        cout<<"船员需要拆除炸弹，否则该区域永久破坏且炸死区域内所有船员！"<<endl;
    }else if(bomb_planted && players[my_id].role==bomber){
        color(yellow);
        cout<<"\n炸弹已布置！剩余"<<bomb_timer<<"回合爆炸！"<<endl;
    }
    Sleep(2000);
}

// 拆除炸弹
void defuse_bomb(){
    if(!bomb_planted) return;
    
    color(orange);
    cout<<"\n=== 拆除炸弹 ==="<<endl;
    cout<<get_room_name(bomb_room)<<"发现炸弹！需要拆除！"<<endl;
    Sleep(1000);
    
    if(players[my_id].status==alive && players[my_id].current_room==bomb_room && 
       players[my_id].role!=impostor && players[my_id].role!=spy && 
       players[my_id].role!=bomber && players[my_id].role!=cleaner &&
       players[my_id].role!=trickster){
        cout<<"你在炸弹所在房间，是否尝试拆除？(1=是/2=否)：";
        int choice;
        cin>>choice;
        
        if(choice==1){
            color(cyan);
            cout<<"拆除炸弹需要完成精准打字任务！"<<endl;
            if(typing_task()){
                bomb_planted=false;
                bomb_room=-1;
                color(green);
                cout<<"炸弹拆除成功！全局任务进度+5%！"<<endl;
                global_task_progress +=5;
                if(global_task_progress>100) global_task_progress=100;
            }else{
                color(red);
                cout<<"拆除失败！炸弹继续倒计时！"<<endl;
            }
        }
    }
    
    for(int i=0;i<player_count;i++){
        if(i!=my_id && players[i].status==alive && players[i].current_room==bomb_room && 
           players[i].role!=impostor && players[i].role!=spy && 
           players[i].role!=bomber && players[i].role!=cleaner &&
           players[i].role!=trickster){
            bool ai_success = (rand()%100)<60;
            if(players[i].role==technician || players[i].role==engineer) ai_success=true;
            
            if(ai_success){
                bomb_planted=false;
                bomb_room=-1;
                color(green);
                cout<<i+1<<"号成功拆除了炸弹！全局任务进度+5%！"<<endl;
                global_task_progress +=5;
                if(global_task_progress>100) global_task_progress=100;
                break;
            }
        }
    }
    Sleep(1500);
}

// 炸弹爆炸逻辑
void bomb_explode(){
    if(!bomb_planted) return;
    
    bomb_timer--;
    if(bomb_timer<=0){
        color(red);
        cout<<"\n=== 炸弹爆炸！ ==="<<endl;
        cout<<get_room_name(bomb_room)<<"炸弹爆炸！该区域永久破坏！"<<endl;
        room_destroyed[bomb_room]=true;
        
        int kill_count=0;
        for(int i=0;i<player_count;i++){
            if(players[i].status==alive && players[i].current_room==bomb_room && 
               players[i].role!=impostor && players[i].role!=spy && 
               players[i].role!=bomber && players[i].role!=cleaner &&
               players[i].role!=trickster && guard_protect_room != bomb_room){
                players[i].status=dead;
                kill_count++;
                cout<<i+1<<"号在爆炸中死亡！"<<endl;
            }
        }
        
        if(kill_count>0){
            color(red);
            cout<<"共"<<kill_count<<"名船员在爆炸中死亡！"<<endl;
        }else{
            color(green);
            cout<<"该房间被守卫保护，无人伤亡！"<<endl;
        }
        
        bomb_planted=false;
        bomb_room=-1;
    }
    Sleep(2000);
}

// 清洁工清理尸体
void cleaner_clean_body(){
    if(killed_player==-1) return;
    
    if(players[my_id].role==cleaner && players[my_id].status==alive){
        color(yellow);
        cout<<"\n=== 清洁工技能 ==="<<endl;
        cout<<"是否清理"<<killed_player+1<<"号的尸体？(1=是/2=否)：";
        int choice;
        cin>>choice;
        
        if(choice==1){
            cleaned_body=killed_player;
            color(red);
            cout<<"尸体清理成功！不会触发紧急会议！"<<endl;
            killed_player=-1;
        }
    }else if(cleaner_id!=-1 && players[cleaner_id].status==alive && killed_player!=-1){
        cleaned_body=killed_player;
        color(red);
        cout<<"清洁工清理了"<<killed_player+1<<"号的尸体！"<<endl;
        killed_player=-1;
    }
Sleep(1500);
}

// 追踪者追踪目标
void tracker_track_target(){
    if(players[my_id].role==tracker && players[my_id].status==alive){
        color(orange);
        cout<<"\n=== 追踪者技能 ==="<<endl;
        cout<<"选择要追踪的玩家（可查看其位置）："<<endl;
        
        int target;
        cin>>target;
        while(target<1 || target>player_count){
            color(yellow);
            cout<<"无效目标！重新输入：";
            cin>>target;
        }
        target--;
        
        players[my_id].track_target=target;
        color(green);
        cout<<"你开始追踪"<<target+1<<"号！本回合可查看其位置！"<<endl;
        players[target].is_visible=true;
        global_task_progress +=3;
        if(global_task_progress>100) global_task_progress=100;
        cout<<"追踪成功！全局任务进度+3%（当前："<<global_task_progress<<"%）"<<endl;
    }
Sleep(1500);
}

// 预言家查验身份
void seer_check_role(){
    if(players[my_id].role==seer && players[my_id].status==alive && players[my_id].seer_cooldown<=0){
        color(purple);
        cout<<"\n=== 预言家技能 ==="<<endl;
        cout<<"选择要查验的玩家："<<endl;
        
        int target;
        cin>>target;
        while(target<1 || target>player_count){
            color(yellow);
            cout<<"无效目标！重新输入：";
            cin>>target;
        }
        target--;
        
        bool error = (rand()%100)<10;
        color(white);
        cout<<"查验结果：";
        
        if(error){
            if(players[target].role==impostor || players[target].role==spy || 
               players[target].role==bomber || players[target].role==cleaner ||
               players[target].role==trickster){
                color(green);
                cout<<target+1<<"号是船员（查验出错）！"<<endl;
            }else{
                color(red);
                cout<<target+1<<"号是内鬼（查验出错）！"<<endl;
            }
        }else{
            if(players[target].role==impostor || players[target].role==spy || 
               players[target].role==bomber || players[target].role==cleaner ||
               players[target].role==trickster){
                color(red);
                cout<<target+1<<"号是内鬼！"<<endl;
                players[target].is_visible=true;
                global_task_progress +=8;
                if(global_task_progress>100) global_task_progress=100;
                cout<<"查验成功！全局任务进度+8%（当前："<<global_task_progress<<"%）"<<endl;
            }else{
                color(green);
                cout<<target+1<<"号是船员！"<<endl;
            }
        }
        
        players[my_id].seer_cooldown=2;
    }else if(players[my_id].role==seer && players[my_id].seer_cooldown>0){
        color(yellow);
        cout<<"\n预言家技能冷却中！剩余"<<players[my_id].seer_cooldown<<"回合！"<<endl;
        players[my_id].seer_cooldown--;
    }
Sleep(2000);
}

// 诱饵假死技能
void decoy_fake_death(){
    if(players[my_id].role==decoy && players[my_id].status==alive && !players[my_id].decoy_fake_dead){
        color(orange);
        cout<<"\n=== 诱饵技能 ==="<<endl;
        cout<<"是否使用假死技能（迷惑内鬼，全局任务进度+5%）？(1=是/2=否)：";
        int choice;
        cin>>choice;
        
        if(choice==1){
            players[my_id].decoy_fake_dead=true;
            color(yellow);
            cout<<"你进入假死状态！内鬼会误以为你已死亡！"<<endl;
            global_task_progress +=5;
            if(global_task_progress>100) global_task_progress=100;
            cout<<"假死成功！全局任务进度+5%（当前："<<global_task_progress<<"%）"<<endl;
        }
    }else if(players[my_id].role==decoy && players[my_id].decoy_fake_dead){
        color(green);
        cout<<"\n=== 诱饵技能 ==="<<endl;
        cout<<"是否解除假死状态？(1=是/2=否)：";
        int choice;
        cin>>choice;
        
        if(choice==1){
            players[my_id].decoy_fake_dead=false;
            color(green);
            cout<<"你解除了假死状态！"<<endl;
        }
    }
Sleep(1500);
}

// 黑客干扰内鬼技能
void hacker_jammer(){
    if(players[my_id].role==hacker && players[my_id].status==alive && players[my_id].hacker_cooldown<=0){
        color(blue);
        cout<<"\n=== 黑客技能 ==="<<endl;
        cout<<"是否使用干扰技能（禁用所有内鬼技能1回合，全局任务进度+7%）？(1=是/2=否)：";
        int choice;
        cin>>choice;
        
        if(choice==1){
            color(red);
            cout<<"你启动了电子干扰！所有内鬼本回合无法使用技能！"<<endl;
            global_task_progress +=7;
            if(global_task_progress>100) global_task_progress=100;
            cout<<"干扰成功！全局任务进度+7%（当前："<<global_task_progress<<"%）"<<endl;
            players[my_id].hacker_cooldown=3;
            bomb_planted=false;
            trickster_fake_kill_flag=false; // 修复变量名
        }
    }else if(players[my_id].role==hacker && players[my_id].hacker_cooldown>0){
        color(yellow);
        cout<<"\n黑客技能冷却中！剩余"<<players[my_id].hacker_cooldown<<"回合！"<<endl;
        players[my_id].hacker_cooldown--;
    }
Sleep(1500);
}

// 守卫保护房间
void guard_protect(){
    if(players[my_id].role==guard && players[my_id].status==alive && players[my_id].guard_cooldown<=0){
        color(cyan);
        cout<<"\n=== 守卫技能 ==="<<endl;
        cout<<"选择要保护的房间（该房间无法被破坏/爆炸，全局任务进度+4%）："<<endl;
        for(int i=0;i<room_count;i++){
            cout<<i+1<<". "<<get_room_name(i)<<endl;
        }
        
        int choice;
        cin>>choice;
        while(choice<1 || choice>room_count){
            color(yellow);
            cout<<"无效选择！重新输入：";
            cin>>choice;
        }
        choice--;
        
        guard_protect_room=choice;
        color(green);
        cout<<"你保护了"<<get_room_name(choice)<<"！该房间本回合无法被破坏/爆炸！"<<endl;
        global_task_progress +=4;
        if(global_task_progress>100) global_task_progress=100;
        cout<<"保护成功！全局任务进度+4%（当前："<<global_task_progress<<"%）"<<endl;
        players[my_id].guard_cooldown=2;
    }else if(players[my_id].role==guard && players[my_id].guard_cooldown>0){
        color(yellow);
        cout<<"\n守卫技能冷却中！剩余"<<players[my_id].guard_cooldown<<"回合！"<<endl;
        players[my_id].guard_cooldown--;
        if(players[my_id].guard_cooldown == 0){
            guard_protect_room=-1;
            cout<<"房间保护状态已解除！"<<endl;
        }
    }
Sleep(1500);
}

// 欺诈师假击杀技能（修复GCC 4.9.2兼容性问题）
void trickster_fake_kill(){
    // 清空输入缓冲区错误状态，避免输入异常
    cin.clear();
    cin.ignore(numeric_limits<streamsize>::max(), '\n');
    
    if(players[my_id].role==trickster && players[my_id].status==alive && players[my_id].trickster_cooldown<=0){
        color(red);
        cout<<"\n=== 欺诈师技能 ==="<<endl;
        cout<<"是否使用假击杀技能（制造击杀假象，触发紧急会议）？(1=是/2=否)：";
        int choice;
        // 严格校验输入合法性
        while(!(cin >> choice) || choice < 1 || choice > 2){
            color(yellow);
            cout<<"输入无效！请输入 1 或 2：";
            cin.clear();
            cin.ignore(numeric_limits<streamsize>::max(), '\n');
        }
        
        if(choice==1){
            trickster_fake_kill_flag=true; // 使用重命名后的全局变量
            color(orange);
            cout<<"你制造了假击杀假象！船员会触发紧急会议！"<<endl;
            players[my_id].trickster_cooldown=3;
        }
    }else if(players[my_id].role==trickster && players[my_id].trickster_cooldown>0){
        color(yellow);
        cout<<"\n欺诈师技能冷却中！剩余"<<players[my_id].trickster_cooldown<<"回合！"<<endl;
        players[my_id].trickster_cooldown--;
    }
Sleep(1500);
}

// 船员修复破坏区域
void repair_room(){
    color(green);
    cout<<"\n=== 修复破坏区域 ==="<<endl;
Sleep(1000);

    bool has_destroyed=false;
    for(int i=0;i<room_count;i++){
        if(room_destroyed[i]){
            has_destroyed=true;
            break;
        }
    }
    
    if(!has_destroyed){
        cout<<"当前没有被破坏的区域！"<<endl;
        Sleep(1000);
        return;
    }
    
    if(players[my_id].status==alive && players[my_id].role!=impostor && players[my_id].role!=spy && 
       players[my_id].role!=bomber && players[my_id].role!=cleaner &&
       players[my_id].role!=trickster){
        cout<<"选择要修复的区域："<<endl;
        int idx=1;
        int repair_choices[room_count];
        memset(repair_choices, -1, sizeof(repair_choices));
        for(int i=0;i<room_count;i++){
            if(room_destroyed[i]){
                repair_choices[idx-1]=i;
                cout<<idx<<". "<<get_room_name(i)<<endl;
                idx++;
            }
        }
        
        int choice;
        cin>>choice;
        while(choice<1 || choice>=idx){
            color(yellow);
            cout<<"无效选择！重新输入：";
            cin>>choice;
        }
        choice=repair_choices[choice-1];
        
        bool success;
        if(players[my_id].role==technician){
            success=true;
        }else{
            success=typing_task();
        }
        
        if(success){
            room_destroyed[choice]=false;
            color(green);
            cout<<"你成功修复了"<<get_room_name(choice)<<"！"<<endl;
            
            int progress_add = (players[my_id].role==technician) ? 10 : 5;
            global_task_progress += progress_add;
            if(global_task_progress>100) global_task_progress=100;
            cout<<"修复成功！全局任务进度+"<<progress_add<<"%（当前："<<global_task_progress<<"%）"<<endl;
        }
    }
    
    for(int i=0;i<player_count;i++){
        if(i!=my_id && players[i].status==alive && players[i].role!=impostor && players[i].role!=spy && 
           players[i].role!=bomber && players[i].role!=cleaner &&
           players[i].role!=trickster){
            for(int j=0;j<room_count;j++){
                if(room_destroyed[j]){
                    bool ai_success = (rand()%100)<70;
                    if(players[i].role==technician) ai_success=true;
                    
                    if(ai_success){
                        room_destroyed[j]=false;
                        color(green);
                        cout<<i+1<<"号修复了"<<get_room_name(j)<<"！"<<endl;
                        global_task_progress +=3;
                        if(global_task_progress>100) global_task_progress=100;
                        break;
                    }
                }
            }
        }
    }
Sleep(2000);
}

// 守望者开启监控
void watcher_activate_camera(){
    if(players[my_id].role==watcher && players[my_id].status==alive){
        color(purple);
        cout<<"\n=== 守望者技能 ==="<<endl;
        cout<<"是否开启监控室摄像头？(1=是/2=否)：";
        
        int choice;
        cin>>choice;
        if(choice==1){
            security_camera_active=true;
            players[my_id].camera_time=3;
            color(green);
            cout<<"监控已开启！你可以看到所有玩家的位置（持续3回合）"<<endl;
            global_task_progress +=4;
            if(global_task_progress>100) global_task_progress=100;
            cout<<"监控开启！全局任务进度+4%（当前："<<global_task_progress<<"%）"<<endl;
        }else{
            cout<<"你选择不开启监控"<<endl;
        }
    }
Sleep(1500);
}

// 检查游戏是否结束
int check_game_end(){
    int alive_crew=0, alive_impostor=0;
    int total_crew=player_count-impostor_count;
    
    for(int i=0;i<player_count;i++){
        if(players[i].get_status()==alive && !players[i].decoy_fake_dead){
            if(players[i].role==impostor || players[i].role==spy || 
               players[i].role==bomber || players[i].role==cleaner ||
               players[i].role==trickster) alive_impostor++;
            else alive_crew++;
        }
    }
    
    bool all_destroyed=true;
    for(int i=0;i<room_count;i++){
        if(!room_destroyed[i]){
            all_destroyed=false;
            break;
        }
    }
    if(all_destroyed) return 1;
    
    if(alive_crew<=alive_impostor && alive_impostor>0) return 1;
    if(alive_impostor==0) return 2;
    if(global_task_progress>=100) return 2;
    return 0;
}

// 游戏初始化
void game_init(){
    srand(time(NULL));
    init_window();
    
    color(green);
    cout<<"欢迎来到太空杀游戏！\n";
    cout<<"===== 新增角色 =====\n";
    cout<<"1. 技术员(修复速度翻倍)、守望者(可开监控)、间谍(伪装内鬼)\n";
    cout<<"2. 追踪者(查看玩家位置)、预言家(查验阵营)、爆破手(布置炸弹)\n";
    cout<<"3. 清洁工(清理尸体，不触发会议)、诱饵(假死)、黑客(干扰)、守卫(保护房间)、欺诈师(假击杀)\n";
    cout<<"===== 新增机制 =====\n";
    cout<<"1. 精准打字任务：必须准确输入字符才能完成\n";
    cout<<"2. 重要区域破坏：内鬼可破坏区域，船员需修复\n";
    cout<<"3. 定时炸弹：爆破手布置，船员需拆除否则爆炸\n";
    cout<<"4. 房间系统：引擎室/电力室/监控室/医疗室/储藏室\n";
    cout<<"5. 全局任务进度：船员需共同完成100%任务获胜\n";
    cout<<"6. 存档读档：按S存档，按L读档\n";
    cout<<"====================\n";
    cout<<"规则：内鬼需要杀死船员/破坏区域，船员需要完成全局任务/修复区域/找出内鬼\n";
    cout<<"______________________\n";
    cout<<"请选择模式：1=新游戏 2=读取存档：";
    int mode_choice;
    cin>>mode_choice;
    
    if(mode_choice == 2){
        if(load_game()){
            return; // 读档成功直接返回
        }else{
            color(yellow);
            cout<<"读档失败，将创建新游戏！"<<endl;
            Sleep(1500);
        }
    }
    
    cout<<"请输入玩家人数(4-20人):";
    cin>>player_count;
    
    while(player_count<4||player_count>20){
        cout<<"请重新输入(4-20)！\n"; 
        cin>>player_count;
    }
    
    system("cls");
    cout<<"初始化身份中，请稍等.";
    for(int i=0;i<6;i++){
        for(int j=0;j<12;j++){
            cout<<".";
            Sleep(50);
        }
        cout<<"\b\b\b\b\b\b\b\b\b\b\b\b            \b\b\b\b\b\b\b\b\b\b\b\b";
    }
    
    system("cls");
    init_players();
    
    cout<<"我的编号:"<<my_id+1<<endl
        <<"我的身份:";
    switch(players[my_id].role){
        case crewmate: cout<<"普通船员\n";break;
        case impostor: cout<<"内鬼\n";break;
        case engineer: cout<<"工程师\n";break;
        case medic: cout<<"医生\n";break;
        case detective: cout<<"侦探\n";break;
        case technician: cout<<"技术员\n";break;
        case watcher: cout<<"守望者\n";break;
        case spy: cout<<"间谍(内鬼)\n";break;
        case tracker: cout<<"追踪者\n";break;
        case bomber: cout<<"爆破手(内鬼)\n";break;
        case cleaner: cout<<"清洁工(内鬼)\n";break;
        case seer: cout<<"预言家\n";break;
        case decoy: cout<<"诱饵\n";break;
        case hacker: cout<<"黑客\n";break;
        case guard: cout<<"守卫\n";break;
        case trickster: cout<<"欺诈师(内鬼)\n";break;
    }
    cout<<"初始房间："<<get_room_name(players[my_id].current_room)<<endl;
    
    round_num=1;
    current_phase=game_day;
    
    system("pause");
    system("cls");
    cout<<"游戏加载中.";
    int load_time=rand()%3+2;
    for(int i=0;i<load_time;i++){
        for(int j=0;j<6;j++){
            cout<<".";
            Sleep(rand()%100+150);
        }
        cout<<"\b\b\b\b\b\b      \b\b\b\b\b\b";
    }
    
    print_game();
}

// 内鬼行动：杀人
int impostor_action(){
    int target=-1;
    color(red);
    cout<<"内鬼~请行动~~\n";
Sleep(1500);
cout<<"你要袭击谁？\n";

    if((players[my_id].role==impostor || players[my_id].role==spy || 
        players[my_id].role==bomber || players[my_id].role==cleaner ||
        players[my_id].role==trickster) && 
        players[my_id].get_status()==alive){
        cin>>target;
        while(!(target>=1&&target<=player_count&&players[target-1].get_status()==alive&&
               !players[target-1].decoy_fake_dead&&
               players[target-1].role!=impostor&&players[target-1].role!=spy&&
               players[target-1].role!=bomber&&players[target-1].role!=cleaner&&
               players[target-1].role!=trickster)){
            cout<<"无效目标！重新输入：\n";
            cin>>target;
        }
        target--;
        if(players[my_id].role==trickster && !trickster_fake_kill_flag){ // 修复变量名
            color(orange);
            cout<<"你选择对"<<target+1<<"号使用假击杀！"<<endl;
            trickster_fake_kill_flag=true; // 修复变量名
            target=-1;
        }else{
            cout<<"你选择袭击"<<target+1<<"号船员！"<<endl;
        }
    Sleep(2000);
    }else{
        while(target==-1 || players[target].get_status()!=alive || players[target].decoy_fake_dead || 
              players[target].role==impostor || players[target].role==spy || 
              players[target].role==bomber || players[target].role==cleaner ||
              players[target].role==trickster){
            target=rand()%player_count;
        }
    Sleep(2000);
    }
    
    cout<<"内鬼行动完成！\n\n";
    return target;
}

// 工程师行动：修复设施
int engineer_action(){
    color(cyan);
    cout<<"工程师~请行动~~\n";
Sleep(1500);

    int repair=-1;
    if(players[my_id].role==engineer && players[my_id].get_status()==alive){
        cout<<"发现设施损坏，是否修复？(1=修复/2=不修复)\n";
        int choice;
        cin>>choice;
        if(choice==1){
            repair=1;
            if(typing_task()){
                cout<<"你修复了损坏的设施！\n";
                global_task_progress +=8;
                if(global_task_progress>100) global_task_progress=100;
                cout<<"修复成功！全局任务进度+8%（当前："<<global_task_progress<<"%）"<<endl;
            }else{
                repair=0;
            }
        }else{
            repair=0;
            cout<<"你选择不修复设施！\n";
        }
    Sleep(1500);
    }else{
        repair=rand()%2;
        if(repair==1){
            global_task_progress +=5;
            if(global_task_progress>100) global_task_progress=100;
        }
    }
    
    cout<<"工程师行动完成！\n\n";
    return repair;
}

// 医生行动：保护船员
int medic_action(){
    color(green);
    cout<<"医生~请行动~~\n";
Sleep(1500);

    int protect=-1;
    if(players[my_id].role==medic && players[my_id].get_status()==alive){
        cout<<"选择一名船员进行保护：\n";
        cin>>protect;
        while(!(protect>=1&&protect<=player_count&&players[protect-1].get_status()==alive&&
               !players[protect-1].decoy_fake_dead)){
            cout<<"无效目标！重新输入：\n";
            cin>>protect;
        }
        protect--;
        cout<<"你保护了"<<protect+1<<"号船员！\n";
        global_task_progress +=3;
        if(global_task_progress>100) global_task_progress=100;
        cout<<"保护成功！全局任务进度+3%（当前："<<global_task_progress<<"%）"<<endl;
    Sleep(1500);
    }else{
        while(protect==-1 || players[protect].get_status()!=alive || players[protect].decoy_fake_dead){
            protect=rand()%player_count;
        }
    }
    
    cout<<"医生行动完成！\n\n";
    return protect;
}

// 侦探行动：调查线索
void detective_action(){
    color(purple);
    cout<<"侦探~请行动~~\n";
Sleep(1500);

    if(players[my_id].role==detective && players[my_id].get_status()==alive){
        cout<<"你发现了可疑线索，选择调查哪位玩家？\n";
        int suspect;
        cin>>suspect;
        while(!(suspect>=1&&suspect<=player_count)){
            cout<<"无效目标！重新输入：\n";
            cin>>suspect;
        }
        suspect--;
        
        cout<<"调查结果：";
        if(players[suspect].role==impostor){
            color(red);
            cout<<suspect+1<<"号行为异常，可能是内鬼！\n";
            players[suspect].is_visible=true;
            global_task_progress +=6;
            if(global_task_progress>100) global_task_progress=100;
            cout<<"调查成功！全局任务进度+6%（当前："<<global_task_progress<<"%）"<<endl;
        }else if(players[suspect].role==spy || players[suspect].role==bomber || 
                 players[suspect].role==cleaner || players[suspect].role==trickster){
            color(green);
            cout<<suspect+1<<"号行为正常，是船员！\n";
        }else{
            color(green);
            cout<<suspect+1<<"号行为正常，是船员！\n";
        }
    Sleep(2000);
    }
    
    cout<<"侦探行动完成！\n\n";
}

// 船员完成任务
void crewmate_tasks(){
    color(white);
    cout<<"船员开始执行全局任务！\n";
Sleep(1000);

    bool task_blocked = (room_destroyed[room_engine] || room_destroyed[room_electric]);
    
    if(players[my_id].status==alive && players[my_id].role!=impostor && players[my_id].role!=spy && 
       players[my_id].role!=bomber && players[my_id].role!=cleaner &&
       players[my_id].role!=trickster){
        cout<<"\n你需要完成全局任务：";
        int task_choice;
        cout<<"1=维修电路(打字任务) 2=清理管道 3=检查引擎\n";
        cin>>task_choice;
        
        int add_progress=0;
        if(task_choice==1){
            if(typing_task() && !task_blocked){
                add_progress=rand()%8+5;
            }
        }else if(!task_blocked){
            add_progress=rand()%5+2;
        }
        
        if(add_progress>0){
            global_task_progress += add_progress;
            if(global_task_progress>100) global_task_progress=100;
            cout<<"任务完成！全局任务进度+"<<add_progress<<"%（当前："<<global_task_progress<<"%）\n";
        }
        
        if(task_blocked){
            color(orange);
            cout<<"警告：重要区域被破坏！全局任务进度未增长！\n";
        }
    }
    
    for(int i=0;i<player_count;i++){
        if(i!=my_id && (players[i].role!=impostor && players[i].role!=spy && 
            players[i].role!=bomber && players[i].role!=cleaner &&
            players[i].role!=trickster) && 
            players[i].get_status()==alive && !task_blocked){
            int ai_add=rand()%4+1;
            global_task_progress += ai_add;
            if(global_task_progress>100) global_task_progress=100;
        Sleep(300);
        }
    }
    
    cout<<"\n全局任务阶段结束！当前进度："<<global_task_progress<<"%\n";
Sleep(1500);
}

// 紧急会议：投票环节
int emergency_meeting(){
    system("cls");
    print_game();
    
    color(red);
    gotoxy(0,52);
    cout<<"________________________\n";
    cout<<"紧急会议！全体船员集合！\n";
Sleep(2000);

    int votes[20]={0};
    memset(votes,0,sizeof(votes));
    
    color(white);
    cout<<"开始投票！选择你怀疑的内鬼：\n";
Sleep(1000);

vote_again:
    for(int i=0;i<player_count;i++){
        if(players[i].get_status()==alive && !players[i].decoy_fake_dead){
            if(i==my_id){
                cout<<"\n你的投票：";
                int vote;
                cin>>vote;
                while(!(vote>=1&&vote<=player_count)){
                    cout<<"无效投票！重新输入：\n";
                    cin>>vote;
                }
                vote--;
                votes[vote]++;
                cout<<"你投票给了"<<vote+1<<"号！\n";
            }else{
                int ai_vote=rand()%player_count;
                votes[ai_vote]++;
                cout<<i+1<<"号投票给了"<<ai_vote+1<<"号！\n";
            }
        Sleep(800);
        }
    }
    
    int max_votes=-1, eject_id=-1, tie_count=0;
    int tie_ids[20]={-1};
    
    for(int i=0;i<player_count;i++){
        if(votes[i]>max_votes){
            max_votes=votes[i];
            eject_id=i;
            tie_count=0;
            tie_ids[0]=i;
        }else if(votes[i]==max_votes && max_votes>0){
            tie_count++;
            tie_ids[tie_count]=i;
        }
    }
    
    if(tie_count>0){
        color(yellow);
        cout<<"\n投票平票！重新投票：\n";
        memset(votes,0,sizeof(votes));
    Sleep(1500);
        goto vote_again;
    }
    
    if(max_votes==0){
        color(blue);
        cout<<"\n无人获得票数，会议结束！\n";
    Sleep(2000);
        return -1;
    }
    
    color(red);
    cout<<"\n"<<eject_id+1<<"号获得最高票数！\n";
Sleep(1500);
    cout<<eject_id+1<<"号被驱逐出飞船！\n";
    players[eject_id].status=ejected;
    
    color(white);
    cout<<"真实身份：";
    switch(players[eject_id].role){
        case crewmate: color(green);cout<<"船员\n";break;
        case impostor: color(red);cout<<"内鬼\n";break;
        case engineer: color(cyan);cout<<"工程师\n";break;
        case medic: color(green);cout<<"医生\n";break;
        case detective: color(purple);cout<<"侦探\n";break;
        case technician: color(orange);cout<<"技术员\n";break;
        case watcher: color(blue);cout<<"守望者\n";break;
        case spy: color(red);cout<<"间谍(内鬼)\n";break;
        case tracker: color(orange);cout<<"追踪者\n";break;
        case bomber: color(red);cout<<"爆破手(内鬼)\n";break;
        case cleaner: color(red);cout<<"清洁工(内鬼)\n";break;
        case seer: color(purple);cout<<"预言家\n";break;
        case decoy: color(orange);cout<<"诱饵\n";break;
        case hacker: color(blue);cout<<"黑客\n";break;
        case guard: color(cyan);cout<<"守卫\n";break;
        case trickster: color(red);cout<<"欺诈师(内鬼)\n";break;
    }
    
    Sleep(3000);
    return eject_id;
}

// 处理击杀逻辑
void process_kill(){
    killed_player=impostor_action();
    
    if(trickster_fake_kill_flag){ // 修复变量名
        color(orange);
        cout<<"欺诈师制造了假击杀假象！触发紧急会议！"<<endl;
        trickster_fake_kill_flag=false; // 修复变量名
        killed_player=-1;
        Sleep(2000);
        return;
    }
    
    if(killed_player==shielded_player){
        color(green);
        cout<<killed_player+1<<"号被医生保护，袭击失败！\n";
        killed_player=-1;
    }else if(killed_player!=-1){
        if(players[killed_player].current_room == guard_protect_room){
            color(cyan);
            cout<<killed_player+1<<"号所在房间被守卫保护，袭击失败！\n";
            killed_player=-1;
        }else{
            color(red);
            cout<<killed_player+1<<"号被内鬼袭击！已死亡！\n";
            players[killed_player].status=dead;
            // 修复击杀计数：内鬼击杀后计数+1
            for(int i=0; i<impostor_count; i++){
                if(impostor_ids[i] == my_id && players[my_id].status==alive){
                    players[my_id].kill_count++;
                    break;
                }
            }
            
            if(players[my_id].role==spy || players[my_id].role==bomber || 
               players[my_id].role==cleaner || players[my_id].role==trickster){
                color(yellow);
                cout<<"你（特殊内鬼）的伪装生效！没有玩家发现你的身份！\n";
            }
            
            cleaner_clean_body();
        }
    }
    Sleep(2000);
}

// 玩家移动房间
void player_move_room(){
    color(cyan);
    cout<<"\n=== 移动房间 ==="<<endl;
    cout<<"当前房间："<<get_room_name(players[my_id].current_room)<<endl;
    cout<<"选择要移动到的房间："<<endl;
    for(int i=0;i<room_count;i++){
        cout<<i+1<<". "<<get_room_name(i)<<endl;
    }
    
    int choice;
    cin>>choice;
    while(choice<1 || choice>room_count){
        color(yellow);
        cout<<"无效选择！重新输入：";
        cin>>choice;
    }
    choice--;
    
    players[my_id].current_room=choice;
    if(players[my_id].role==decoy && players[my_id].decoy_fake_dead){
        players[my_id].decoy_fake_dead=false;
        color(green);
        cout<<"你移动后自动解除假死状态！"<<endl;
    }
    color(green);
    cout<<"你移动到了"<<get_room_name(choice)<<"！"<<endl;
    
    for(int i=0;i<player_count;i++){
        if(i!=my_id && players[i].status==alive){
            int ai_move=rand()%room_count;
            players[i].current_room=ai_move;
            if(players[i].role==decoy && players[i].decoy_fake_dead){
                players[i].decoy_fake_dead=false;
            }
        }
    }
    Sleep(1000);
}

// 检查按键触发存档/读档
void check_keyboard_input(){
    if(_kbhit()){ // 检测是否有按键按下
        char key = _getch();
        if(key == 's' || key == 'S'){
            save_game(); // 按S存档
        }else if(key == 'l' || key == 'L'){
            load_game(); // 按L读档
        }
    }
}

// 游戏回合流程
void game_round(){
    current_phase=game_day;
    system("cls");
    print_game();
    
    // 回合开始前检查按键（存档/读档）
    check_keyboard_input();
    
    color(blue);
    gotoxy(0,52);
    cout<<"________________________\n";
    cout<<"日常阶段 | 船员自由活动中...\n";
    Sleep(2000);
    
    player_move_room();
    
    watcher_activate_camera();
    tracker_track_target();
    seer_check_role();
    decoy_fake_death();
    hacker_jammer();
    guard_protect();
    
    current_phase=game_siege;
    system("cls");
    print_game();
    // 破坏阶段前检查按键
    check_keyboard_input();
    impostor_destroy_room();
    bomber_plant_bomb();
    trickster_fake_kill();
    
    current_phase=game_task;
    system("cls");
    print_game();
    // 任务阶段前检查按键
    check_keyboard_input();
    
    color(cyan);
    gotoxy(0,52);
    cout<<"________________________\n";
    cout<<"任务阶段开始！\n";
    
    defuse_bomb();
    bomb_explode();
    
    repair_room();
    
    shielded_player=-1;
    killed_player=-1;
    
    if(player_count>=12) repaired_task=engineer_action();
    if(player_count>=8) shielded_player=medic_action();
    if(player_count>=10) detective_action();
    
    process_kill();
    
    if(killed_player==-1){
        crewmate_tasks();
    }
    
    if(security_camera_active){
        players[watcher_id].camera_time--;
        if(players[watcher_id].camera_time<=0){
            security_camera_active=false;
            color(yellow);
            cout<<"监控时间结束！摄像头已关闭！"<<endl;
            Sleep(1000);
        }
    }
    
    // 修复紧急会议触发条件中的变量名
    if(killed_player!=-1 || trickster_fake_kill_flag || rand()%3==0 || room_destroyed[room_engine] || 
       room_destroyed[room_electric] || (bomb_planted && bomb_timer<=1)){
        current_phase=game_meeting;
        ejected_player=emergency_meeting();
    }
    
    round_num++;
}

// 游戏主函数
int main(){
    game_init();
    
    while(true){
        game_round();
        
        int game_result=check_game_end();
        if(game_result!=0){
            system("cls");
            color(white);
            cout<<"==================== 游戏结束 ====================\n";
            if(game_result==1){
                color(red);
                cout<<"内鬼获得胜利！\n";
                cout<<"存活内鬼：";
                for(int i=0;i<impostor_count;i++){
                    if(players[impostor_ids[i]].status==alive){
                        cout<<impostor_ids[i]+1<<"号 ";
                    }
                }
                cout<<endl;
                // 显示内鬼击杀统计
                cout<<"内鬼击杀统计：";
                for(int i=0;i<impostor_count;i++){
                    if(players[impostor_ids[i]].status==alive){
                        cout<<impostor_ids[i]+1<<"号("<<players[impostor_ids[i]].kill_count<<"次) ";
                    }
                }
                cout<<endl;
            }else{
                color(green);
                cout<<"船员获得胜利！\n";
                cout<<"全局任务进度："<<global_task_progress<<"%\n";
                cout<<"存活船员：";
                for(int i=0;i<player_count;i++){
                    if(players[i].status==alive && players[i].role!=impostor && 
                       players[i].role!=spy && players[i].role!=bomber && 
                       players[i].role!=cleaner && players[i].role!=trickster){
                        cout<<i+1<<"号 ";
                    }
                }
                cout<<endl;
            }
            color(white);
            cout<<"==================================================\n";
            
            // 游戏结束后提供存档选项
            color(yellow);
            cout<<"是否保存最终游戏进度？(1=是/2=否)：";
            int save_choice;
            cin>>save_choice;
            if(save_choice == 1){
                save_game();
            }
            
            break;
        }
        
        system("pause");
        system("cls");
        print_game();
    }
    
    color(white);
    cout<<"\n游戏结束！按任意键退出...\n";
    _getch();
    return 0;
}