类FNAF游戏后续

cmd版先出啦~

//wssb
#include <stdio.h>
#include <iostream>
#include <random>
#include <ctime>
#include <thread>
#include <atomic>
#include <chrono>
#include <conio.h>
#include <Windows.h>

#pragma warning(disable:4996)

// 游戏状态
std::atomic<bool> leftdoor(false);
std::atomic<bool> rightdoor(false);
std::atomic<bool> camddoor(false);
std::atomic<float> power(100.0f);
std::atomic<float> fanusepower(0.0f);
std::atomic<bool> gameRunning(true);
std::atomic<bool> p0title(true);
std::atomic<unsigned int> tempx(3);
std::atomic<bool> lock(false);

// Move方案实现(基于NetWork)
typedef struct movement {
    struct movement** next;
    int data, size;
} movement;

#define R1A -1
#define R1B -2
#define R1C -3

// 获取节点名称
const char* getNodeName(int data) {
    switch (data) {
    case R1A: return "cam1a";
    case R1B: return "cam1b";
    case R1C: return "cam1c";
    case -4: return "camr";
    case -5: return "camd";
    case 5: return "cam5";
    case 6: return "cam6";
    case 7: return "cam7";
    case 3: return "cam3";
    case 21: return "cam2a";
    case 22: return "cam2b";
    case 41: return "cam4a";
    case 42: return "cam4b";
    default: return "unknown";
    }
}

// 玩家输入处理线程
void inputThread() {
    while (gameRunning) {
        if (_kbhit()) {
            char key = _getch();
            switch (tolower(key)) {
            case 'a':
                leftdoor = !leftdoor;
                std::cout << "Left door " << (leftdoor ? "closed" : "opened") << "\n";
                break;
            case 'd':
                rightdoor = !rightdoor;
                std::cout << "Right door " << (rightdoor ? "closed" : "opened") << "\n";
                break;
            case 'f':
                camddoor = !camddoor;
                std::cout << "CAM door " << (camddoor ? "closed" : "opened") << "\n";
                break;
            case 'q':
                gameRunning = false;
                break;
            }
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

// 游戏主循环
void gameLoop() {
    // 初始化摄像头
    movement cam1a, cam1b, cam1c, cam5, cam6, cam7, cam3, camr, camd, cam2a, cam2b, cam4a, cam4b;

    // 设置数据
    cam1a.data = R1A;
    cam1b.data = R1B;
    cam1c.data = R1C;
    cam5.data = 5;
    cam6.data = 6;
    cam7.data = 7;
    cam3.data = 3;
    camr.data = -4;
    camd.data = -5;
    cam2a.data = 21;
    cam2b.data = 22;
    cam4a.data = 41;
    cam4b.data = 42;

    // 设置连接关系
    cam1a.next = new movement * [1] { &cam1b };
    cam1a.size = 1;

    cam1b.next = new movement * [4] { &cam1a, & cam1c, & cam5, & camr };
    cam1b.size = 4;

    cam1c.next = new movement * [4] { &cam1b, & cam6, & cam2a, & cam4a };
    cam1c.size = 4;

    cam5.next = new movement * [1] { &cam1b };
    cam5.size = 1;

    cam6.next = new movement * [1] { &cam1c };
    cam6.size = 1;

    camr.next = new movement * [2] { &cam1b, & cam7 };
    camr.size = 2;

    cam7.next = new movement * [3] { &camr, & cam4a, & camd };
    cam7.size = 3;

    cam3.next = new movement * [1] { &cam2a };
    cam3.size = 1;

    camd.next = new movement * [1] { &cam7 };
    camd.size = 1;

    cam2a.next = new movement * [3] { &cam1c, & cam2b, & cam3 };
    cam2a.size = 3;

    cam2b.next = new movement * [1] { &cam2a };
    cam2b.size = 1;

    cam4a.next = new movement * [3] { &cam1c, & cam7, & cam4b };
    cam4a.size = 3;

    cam4b.next = new movement * [1] { &cam4a };
    cam4b.size = 1;

    // 初始化随机数生成器
    std::mt19937 rng(static_cast<unsigned int>(std::time(nullptr)));

    // 开始位置
    movement* current = &cam1a;
    movement* previous = nullptr;
    std::cout << "Starting at: " << getNodeName(current->data) << "\n";
    std::cout << "Controls: A - Left door, D - Right door, F - CAM door, Q - Quit\n";

    // 游戏时间（6AM为结束时间）
    int hour = 12;
    int minute = 0;
    auto lastTimeUpdate = std::chrono::steady_clock::now();

    // 主游戏循环
    while (gameRunning) {
        // 更新时间（每30秒游戏时间）
        auto now = std::chrono::steady_clock::now();
        if (std::chrono::duration_cast<std::chrono::seconds>(now - lastTimeUpdate).count() >= 30) {
            lastTimeUpdate = now;
            minute += 30;
            if (minute >= 60) {
                minute = 0;
                hour++;
                if (hour > 6) {
                    hour = 12;
                }
            }
            std::cout << "Time: " << hour << ":" << (minute < 10 ? "0" : "") << minute << " AM\n";
        }

        // 处理摄像头移动
        if (camddoor) {
            power = power - 0.5;
            camd.next[0] = &camd;
            cam7.size = 2;
        }
        else {
            camd.next[0] = &cam7;
            cam7.size = 3;
        }

        if (leftdoor) {
            power = power - 0.5;
        }

        if (rightdoor) {
            power = power - 0.5;
        }

        // Bonnie行为
        if (current->data == 22) {
            std::uniform_int_distribution<int> dist(0, 2);
            int att = dist(rng);

            if (lock) att = 1;

            if (att == 1 || att == 2) {
                if (!leftdoor) {
                    lock = true;
                    if (tempx <= 0) {
                        std::cout << "Jumpscare!\n";
                        std::cout << "+0.5 coins, You've been caught by Bonnie.\n";
                        gameRunning = false;
                        break;
                    }
                    tempx--;
                }
                else {
                    std::cout << "Bonnie gets stuck in the door\n";
                    std::cout << "+2 coins, Perfect to close the door!\n";
                    lock = false;
                    tempx = 3;
                }
            }
        }

        // 电力耗尽处理
        if (power <= 0) {
            if (p0title) {
                std::cout << "Power: 0!\n";
                p0title = false;
            }
            leftdoor = false;
            rightdoor = false;
            camddoor = false;
        }

        // 随机移动
        if (!lock) {
            int nextIndex;
            int attempts = 0;
            const int max_attempts = 10;

            do {
                std::uniform_int_distribution<int> dist(0, current->size - 1);
                nextIndex = dist(rng);
                attempts++;
            } while (attempts < max_attempts &&
                current->next[nextIndex] == previous &&
                current->size > 1);

            previous = current;
            current = current->next[nextIndex];
        }

        // 显示状态
        system("cls");
        std::cout << "Current camera: " << getNodeName(current->data) << "\n";
        std::cout << "Power: " << power << "%\n";
        std::cout << "Doors: Left " << (leftdoor ? "closed" : "open")
            << ", Right " << (rightdoor ? "closed" : "open")
            << ", CAM " << (camddoor ? "closed" : "open") << "\n";

        // 等待6秒
        std::this_thread::sleep_for(std::chrono::seconds(6));
    }

    // 清理资源
    delete[] cam1a.next;
    delete[] cam1b.next;
    delete[] cam1c.next;
    delete[] cam5.next;
    delete[] cam6.next;
    delete[] camr.next;
    delete[] cam7.next;
    delete[] cam3.next;
    delete[] camd.next;
    delete[] cam2a.next;
    delete[] cam2b.next;
    delete[] cam4a.next;
    delete[] cam4b.next;
}

int main() {
    // 启动输入线程
    std::thread input(inputThread);

    // 启动游戏主循环
    gameLoop();

    // 等待输入线程结束
    input.join();

    std::cout << "Game over!\n";
    return 0;
}

写不下去了，Ctrl + c和Ctrl + v都要磨烂了，到时候自己把监控改成调频道或者叫几个好心人帮忙写吧