C++自制小游戏：fights1.0.1

最新推荐文章于 2025-12-06 19:00:36 发布
原创最新推荐文章于 2025-12-06 19:00:36 发布 · 274 阅读
0 ·
CC 4.0 BY-SA版权
文章标签：
#c++ #cocoa #开发语言
经过一段时间的编程，我开发出了一个小型格斗类游戏，fights
本游戏处于1.0.1版本，暂时没有办法联机，作者已经游玩测试过了，发现的bug已经修复（敌方血量变成负数是正常的，只是伤害超载了），可能还有一些小bug，下个版本将进行更改
游戏里加入了一些武器和护甲可以增加生命值和伤害，初始生命值为5000，伤害为360，敌方除了伤害外和玩家基本一致
按wasd移动，方向键射击，射击出的能量波暂时没有显示图像，玩家只能上下左右射击
本游戏敌人的强度会不断上升，打败150个敌人才能通关游戏，一个敌人被击败后等待10秒刷新出新的敌人，有的敌人可能会爆装备（第10，20，30，40，50，60，70，80，90，150个敌人会爆装备）
有存档，但是击败敌人次数不计其内，装备会保存，金币会刷新，存档会在桌面上生成一个txt文档，不要删除！这是存档文件否则存档会丢失！
下载地址：https://2010829.lanzoue.com/i3OWX2n8l4va
密码:ahq6
代码如下：
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <conio.h>  // 包含 _kbhit() 和 _getch() 函数
#include <windows.h>  // 包含 Sleep() 和 system("cls")
#include <cstdlib>
#include <ctime>
#include <shellapi.h>  // 用于打开网址
#include <fstream>
#include <vector>
#include <string>

// 设置控制台为 UTF-8 编码
void setConsoleToUTF8() {
    SetConsoleOutputCP(CP_UTF8);
    SetConsoleCP(CP_UTF8);
    std::ios::sync_with_stdio(false);
    std::wcout.imbue(std::locale(""));
    std::cout.imbue(std::locale(""));
}

// 地图的大小
const int MAP_WIDTH = 40;
const int MAP_HEIGHT = 20;
const int INFO_AREA_WIDTH = 20;

// 地图
char map[MAP_HEIGHT][MAP_WIDTH + INFO_AREA_WIDTH];

// 玩家初始位置
int playerX = MAP_WIDTH / 2;
int playerY = MAP_HEIGHT / 2;

// 小怪物的位置
int enemyX;
int enemyY;
// 小怪物的血量
int enemyHp = 5000;
// 小怪物的血量上限
int enemyHpMax = 5000;
// 小怪物的伤害
int enemyDamage = 300;
// 玩家的血量
int playerHp = 5000;
// 玩家的伤害
int playerDamage = 300;
// 能量，上限为 100
int energy = 100;
// 能量恢复间隔时间，0.5 秒对应的毫秒数，0.5 * 1000
const DWORD ENERGY_RECOVER_INTERVAL = 0.5 * 1000;
// 记录上次能量恢复的时间
DWORD lastEnergyRecoverTime = GetTickCount();
// 记录上次生成小怪物的时间
DWORD lastEnemySpawnTime = GetTickCount();
// 5 秒对应的毫秒数，5 * 1000
const DWORD ENEMY_SPAWN_INTERVAL = 5 * 1000;
// 击败小怪物的数量
int defeatedCount = 0;
// 回血道具数量
int healingItemCount = 10;
// 金币数量
int goldCount = 0;

// 声明函数
void showBackpack();
void showGameWin();
void showEquipmentWindow();
void showStore();
void saveGame();
void loadGame();

// 标志变量，表示是否处于背包界面
bool isInBackpack = false;
// 标志变量，表示打开背包时玩家与小怪物是否相邻
bool wasAdjacentWhenOpeningBackpack = false;
// 记录小怪物开始停留的时间
DWORD enemyStayStartTime = 0;
// 小怪物停留时间（10 秒，单位：毫秒）
const DWORD ENEMY_STAY_TIME = 10 * 1000;
// 记录玩家上一次的位置
int lastPlayerX = playerX;
int lastPlayerY = playerY;
// 标志小怪物是否需要停留
bool enemyShouldStay = false;

// 成就标志
bool achievement_50 = false;
bool achievement_100 = false;
bool achievement_150 = false;
// 精英怪标志
bool isEliteEnemy = false;

// 装备结构体
struct Equipment {
    std::string name;
    int type;  // 0: 护甲，1: 武器
    int hpBoost;
    int damageBoost;
};

// 可获得的装备列表
std::vector<Equipment> availableEquipments = {
    {"战神圣衣（封神）", 0, 50000, 0},
    {"战神之剑（封神）", 1, 0, 2000},
    {"侍卫护甲（卓越）", 0, 8000, 0},
    {"小宝剑（卓越）", 1, 0, 500},
    {"黄铜护甲（普通）", 0, 4000, 0},
    {"长剑（普通）", 1, 0, 300},
    {"普通护甲（垃圾）", 0, 500, 0},
    {"塑料剑（垃圾）", 1, 0, 50},
    {"创世铠甲（max）", 0, 99999999, 0},
    {"创世神剑（max）", 1, 0, 99999999}
};

// 玩家拥有的装备
std::vector<Equipment> ownedEquipments;
// 玩家已装备的护甲和武器
Equipment* equippedArmor = nullptr;
Equipment* equippedWeapon = nullptr;

// 初始化地图
void initMap() {
    for (int y = 0; y < MAP_HEIGHT; y++) {
        for (int x = 0; x < MAP_WIDTH + INFO_AREA_WIDTH; x++) {
            if (y == 0 || y == MAP_HEIGHT - 1 || x == 0 || x == MAP_WIDTH - 1) {
                map[y][x] = '#';  // 边界
            }
            else if (x >= MAP_WIDTH) {
                map[y][x] = ' ';  // 信息显示区域
            }
            else {
                map[y][x] = ' ';  // 空白区域
            }
        }
    }
    map[playerY][playerX] = 'i';  // 初始化玩家的位置

    // 初始化玩家属性
    playerHp = 5000;
    playerDamage = 300;
    if (equippedArmor) {
        playerHp += equippedArmor->hpBoost;
    }
    if (equippedWeapon) {
        playerDamage += equippedWeapon->damageBoost;
    }

    // 初始化小怪物的位置
    srand(static_cast<unsigned int>(time(0)));
    bool valid;
    do {
        valid = true;
        enemyX = rand() % (MAP_WIDTH - 2) + 1;
        enemyY = rand() % (MAP_HEIGHT - 2) + 1;
        // 检查是否和玩家的位置重叠
        if (enemyX == playerX && enemyY == playerY) {
            valid = false;
        }
    } while (!valid);
    map[enemyY][enemyX] = '&';
}

// 更新信息显示区域
void updateInfo() {
    int infoX = MAP_WIDTH + 2;  // 信息显示区域的起始X坐标
    for (int y = 2; y < 12; y += 2) {
        for (int x = infoX; x < infoX + INFO_AREA_WIDTH - 2; x++) {
            map[y][x] = ' ';  // 清空信息显示区域
        }
    }

    // 显示能量数量
    int y = 2;
    sprintf(&map[y][infoX], "能量: %d", energy);

    // 显示血量
    y += 2;
    sprintf(&map[y][infoX], "血量: %d", playerHp);

    // 显示击败数量
    y += 2;
    sprintf(&map[y][infoX], "击败数量: %d", defeatedCount);

    // 显示成就提示
    y += 2;
    if (defeatedCount == 50 && !achievement_50) {
        achievement_50 = true;
        sprintf(&map[y][infoX], "解锁成就：超强之人");
    }
    if (defeatedCount == 100 && !achievement_100) {
        achievement_100 = true;
        sprintf(&map[y][infoX], "解锁成就：天外有天");
    }
    if (defeatedCount == 150 && !achievement_150) {
        achievement_150 = true;
        sprintf(&map[y][infoX], "解锁成就：一人之下，万人之上");
    }

    // 显示回血药数量
    y += 2;
    sprintf(&map[y][infoX], "回血药: %d", healingItemCount);

    // 显示金币数量
    y += 2;
    sprintf(&map[y][infoX], "金币: %d", goldCount);
}

// 显示地图及小怪物血条
void displayMap() {
    system("cls");  // 清屏
    updateInfo();  // 更新信息显示区域
    for (int y = 0; y < MAP_HEIGHT; y++) {
        for (int x = 0; x < MAP_WIDTH + INFO_AREA_WIDTH; x++) {
            std::cout << map[y][x];
        }
        std::cout << std::endl;
    }
    // 显示小怪物血条（改为数字显示）
    std::cout << "小怪物血量: " << enemyHp << std::endl;
}

// 判断两个位置是否相邻
bool isAdjacent(int x1, int y1, int x2, int y2) {
    return (abs(x1 - x2) <= 1 && abs(y1 - y2) <= 1) && !(x1 == x2 && y1 == y2);
}

// 发射能量
void shootEnergy(int dx, int dy) {
    if (energy >= 1) {
        energy -= 1;
        int bulletX = playerX + dx;
        int bulletY = playerY + dy;
        while (bulletX > 0 && bulletX < MAP_WIDTH - 1 && bulletY > 0 && bulletY < MAP_HEIGHT - 1) {
            if (bulletX == enemyX && bulletY == enemyY) {
                enemyHp -= playerDamage + (equippedWeapon ? equippedWeapon->damageBoost : 0);
                if (enemyHp <= 0) {
                    map[enemyY][enemyX] = ' ';
                    enemyX = -1;
                    enemyY = -1;
                    defeatedCount++;
                    energy = (energy + 5 > 100) ? 100 : energy + 5;
                    lastEnemySpawnTime = GetTickCount();
                    // 每击败一个小怪物，获得 1 个血量回满包和 10 个金币
                    healingItemCount += 1;
                    goldCount += 10;

                    // 特定小怪物属性提升
                    if (defeatedCount % 10 == 0 && defeatedCount <= 100) {
                        enemyHpMax += 50000;
                        enemyDamage += 5000;
                    }

                    // 特定小怪物掉落装备
                    if (defeatedCount % 10 == 0 && defeatedCount <= 100) {
                        int numEquipments = 1;
                        for (int i = 0; i < numEquipments; i++) {
                            int randNum = rand() % 100000;
                            if (randNum < 100) {  // 0.1% 的概率掉落“创世铠甲（max）”或“创世神剑（max）”
                                ownedEquipments.push_back(availableEquipments[8 + rand() % 2]);
                            }
                            else if (randNum < 5000) {  // 4.9% 的概率掉落其他装备
                                ownedEquipments.push_back(availableEquipments[rand() % 8]);
                            }
                        }
                    }

                    if (defeatedCount == 149) {
                        isEliteEnemy = true;
                        enemyHpMax = 100000;
                        enemyDamage = 5000;
                    }
                    else if (defeatedCount < 149) {
                        enemyHpMax += 500;
                        enemyDamage += 50;
                    }
                    if (defeatedCount == 150) {
                        showGameWin();
                        return;
                    }
                }
                return;
            }
            bulletX += dx;
            bulletY += dy;
        }
    }
}

// 处理玩家移动和操作
void handleMovement(char input) {
    if (isInBackpack) return;

    map[playerY][playerX] = ' ';  // 清空当前位置

    int newX = playerX;
    int newY = playerY;

    switch (input) {
    case 'w':
        if (playerY > 1) newY--;
        break;
    case 's':
        if (playerY < MAP_HEIGHT - 2) newY++;
        break;
    case 'a':
        if (playerX > 1) newX--;
        break;
    case 'd':
        if (playerX < MAP_WIDTH - 2) newX++;
        break;
    case 72: // 上箭头
        shootEnergy(0, -1);
        break;
    case 75: // 左箭头
        shootEnergy(-1, 0);
        break;
    case 77: // 右箭头
        shootEnergy(1, 0);
        break;
    case 80: // 下箭头
        shootEnergy(0, 1);
        break;
    case 'b':
        wasAdjacentWhenOpeningBackpack = isAdjacent(playerX, playerY, enemyX, enemyY);
        showBackpack();
        return;
    case 'c':
        showEquipmentWindow();
        return;
    }

    // 检查新位置是否和小怪物重叠
    bool valid = true;
    if (enemyX != -1 && newX == enemyX && newY == enemyY) {
        valid = false;
    }

    if (valid) {
        lastPlayerX = playerX;
        lastPlayerY = playerY;
        playerX = newX;
        playerY = newY;
    }

    // 检查是否和小怪物相邻
    if (enemyX != -1 && isAdjacent(playerX, playerY, enemyX, enemyY)) {
        playerHp -= enemyDamage;
        if (playerHp < 0) {
            playerHp = 0;
        }
        if (playerX != lastPlayerX || playerY != lastPlayerY) {
            enemyShouldStay = true;
            enemyStayStartTime = GetTickCount();
        }
    }

    map[playerY][playerX] = 'i';  // 更新位置
}

// 移动小怪物
void moveEnemies() {
    if (isInBackpack || enemyX == -1) return;

    if (enemyShouldStay) {
        DWORD currentTime = GetTickCount();
        if (currentTime - enemyStayStartTime < ENEMY_STAY_TIME) {
            // 小怪物停留 10 秒，不移动
            return;
        }
        else {
            // 10 秒过去，重置标志
            enemyShouldStay = false;
        }
    }

    map[enemyY][enemyX] = ' ';  // 清空当前位置

    int newX = enemyX;
    int newY = enemyY;

    // 朝玩家的方向移动小怪物
    if (enemyX < playerX && enemyX < MAP_WIDTH - 2) {
        newX++;
    }
    else if (enemyX > playerX && enemyX > 1) {
        newX--;
    }
    else if (enemyY < playerY && enemyY < MAP_HEIGHT - 2) {
        newY++;
    }
    else if (enemyY > playerY && enemyY > 1) {
        newY--;
    }

    // 检查新位置是否和玩家的位置重叠
    if (newX == playerX && newY == playerY) {
        newX = enemyX;
        newY = enemyY;
    }

    enemyX = newX;
    enemyY = newY;

    // 检查是否和玩家相邻
    if (isAdjacent(playerX, playerY, enemyX, enemyY)) {
        playerHp -= enemyDamage;
        if (playerHp < 0) {
            playerHp = 0;
        }
    }

    map[enemyY][enemyX] = isEliteEnemy ? '￥' : '&';  // 更新位置
}

// 生成新的小怪物
void spawnEnemy() {
    if (isInBackpack) return;

    DWORD currentTime = GetTickCount();
    if (enemyX == -1 && currentTime - lastEnemySpawnTime >= ENEMY_SPAWN_INTERVAL) {
        bool valid;
        do {
            valid = true;
            enemyX = rand() % (MAP_WIDTH - 2) + 1;
            enemyY = rand() % (MAP_HEIGHT - 2) + 1;
            // 检查是否和玩家的位置重叠
            if (enemyX == playerX && enemyY == playerY) {
                valid = false;
            }
        } while (!valid);
        map[enemyY][enemyX] = isEliteEnemy ? '￥' : '&';
        enemyHp = enemyHpMax;
        if (!isEliteEnemy) {
            enemyDamage += 50;
        }
    }
}

// 恢复能量
void recoverEnergy() {
    DWORD currentTime = GetTickCount();
    if (currentTime - lastEnergyRecoverTime >= ENERGY_RECOVER_INTERVAL && energy < 100) {
        energy++;
        lastEnergyRecoverTime = currentTime;
    }
}

// 显示游戏结束信息
void showGameOver() {
    system("cls");  // 清屏
    const char* gameOverText = "game over";
    for (int i = 0; gameOverText[i] != '\0'; i++) {
        std::cout << gameOverText[i];
        std::cout.flush();  // 立即输出字符
        Sleep(200);  // 延迟 200 毫秒
    }
    Sleep(5000);  // 等待 5 秒
}

// 显示游戏胜利信息
void showGameWin() {
    system("cls");  // 清屏
    const char* gameWinText = "游戏胜利！";
    for (int i = 0; gameWinText[i] != '\0'; i++) {
        std::cout << gameWinText[i];
        std::cout.flush();  // 立即输出字符
        Sleep(200);  // 延迟 200 毫秒
    }
    Sleep(10000);  // 等待 10 秒
    exit(0);
}

// 显示背包界面
void showBackpack() {
    isInBackpack = true;
    system("cls");
    std::cout << "x.返回" << std::endl;
    std::cout << "1.回血药 " << healingItemCount << std::endl;
    std::cout << "2.血量回满包 " << healingItemCount << std::endl;

    char input;
    while (true) {
        input = _getch();
        if (input == 'x') {
            break;
        }
        else if (input == '1') {
            if (healingItemCount > 0) {
                playerHp = (playerHp + 200 > 5000) ? 5000 : playerHp + 200;
                healingItemCount--;
                std::cout << "使用回血药，当前血量: " << playerHp << std::endl;
                std::cout << "回血药剩余数量: " << healingItemCount << std::endl;
            }
            else {
                std::cout << "回血药数量不足！" << std::endl;
            }
        }
        else if (input == '2') {
            if (healingItemCount > 0) {
                playerHp = 5000;  // 血量回满
                healingItemCount--;
                std::cout << "使用血量回满包，当前血量: " << playerHp << std::endl;
                std::cout << "血量回满包剩余数量: " << healingItemCount << std::endl;
            }
            else {
                std::cout << "血量回满包数量不足！" << std::endl;
            }
        }
    }
    isInBackpack = false;
}

// 显示装备界面
void showEquipmentWindow() {
    system("cls");
    std::cout << "x.返回" << std::endl;
    std::cout << "1.装备护甲" << std::endl;
    std::cout << "2.装备武器" << std::endl;

    char input;
    while (true) {
        input = _getch();
        if (input == 'x') {
            break;
        }
        else if (input == '1') {
            // 显示可装备的护甲
            system("cls");
            std::cout << "x.返回" << std::endl;
            for (size_t i = 0; i < ownedEquipments.size(); i++) {
                if (ownedEquipments[i].type == 0) {
                    std::cout << i + 1 << ". " << ownedEquipments[i].name << std::endl;
                }
            }
            std::cout << "选择装备的编号: ";
            int choice;
            std::cin >> choice;
            if (choice >= 1 && choice <= ownedEquipments.size() && ownedEquipments[choice - 1].type == 0) {
                equippedArmor = &ownedEquipments[choice - 1];
                playerHp += equippedArmor->hpBoost;
                std::cout << "装备了 " << equippedArmor->name << std::endl;
            }
            else {
                std::cout << "无效选择！" << std::endl;
            }
        }
        else if (input == '2') {
            // 显示可装备的武器
            system("cls");
            std::cout << "x.返回" << std::endl;
            for (size_t i = 0; i < ownedEquipments.size(); i++) {
                if (ownedEquipments[i].type == 1) {
                    std::cout << i + 1 << ". " << ownedEquipments[i].name << std::endl;
                }
            }
            std::cout << "选择装备的编号: ";
            int choice;
            std::cin >> choice;
            if (choice >= 1 && choice <= ownedEquipments.size() && ownedEquipments[choice - 1].type == 1) {
                equippedWeapon = &ownedEquipments[choice - 1];
                playerDamage += equippedWeapon->damageBoost;
                std::cout << "装备了 " << equippedWeapon->name << std::endl;
            }
            else {
                std::cout << "无效选择！" << std::endl;
            }
        }
    }
}

// 显示商店界面
void showStore() {
    system("cls");
    std::cout << "x.返回" << std::endl;
    std::cout << "金币: " << goldCount << std::endl;
    std::cout << "1.侍卫护甲（卓越） - 100金币" << std::endl;
    std::cout << "2.小宝剑（卓越） - 100金币" << std::endl;
    std::cout << "3.战神圣衣（超神） - 1000金币" << std::endl;
    std::cout << "4.战神之剑（超神） - 1000金币" << std::endl;

    char input;
    while (true) {
        input = _getch();
        if (input == 'x') {
            break;  // 返回开始界面
        }
        else if (input == '1') {
            if (goldCount >= 100) {
                ownedEquipments.push_back(availableEquipments[2]);  // 侍卫护甲（卓越）
                goldCount -= 100;
                std::cout << "购买成功！剩余金币: " << goldCount << std::endl;
            }
            else {
                std::cout << "金币不足！" << std::endl;
            }
        }
        else if (input == '2') {
            if (goldCount >= 100) {
                ownedEquipments.push_back(availableEquipments[3]);  // 小宝剑（卓越）
                goldCount -= 100;
                std::cout << "购买成功！剩余金币: " << goldCount << std::endl;
            }
            else {
                std::cout << "金币不足！" << std::endl;
            }
        }
        else if (input == '3') {
            if (goldCount >= 1000) {
                ownedEquipments.push_back(availableEquipments[0]);  // 战神圣衣（超神）
                goldCount -= 1000;
                std::cout << "购买成功！剩余金币: " << goldCount << std::endl;
            }
            else {
                std::cout << "金币不足！" << std::endl;
            }
        }
        else if (input == '4') {
            if (goldCount >= 1000) {
                ownedEquipments.push_back(availableEquipments[1]);  // 战神之剑（超神）
                goldCount -= 1000;
                std::cout << "购买成功！剩余金币: " << goldCount << std::endl;
            }
            else {
                std::cout << "金币不足！" << std::endl;
            }
        }
    }
}

// 保存游戏进度到文件
void saveGame() {
    std::ofstream saveFile("savegame.txt");
    if (saveFile.is_open()) {
        // 保存装备
        saveFile << ownedEquipments.size() << std::endl;
        for (const auto& equipment : ownedEquipments) {
            saveFile << equipment.name << " " << equipment.type << " " << equipment.hpBoost << " " << equipment.damageBoost << std::endl;
        }
        // 保存成就
        saveFile << achievement_50 << " " << achievement_100 << " " << achievement_150 << std::endl;
        // 保存已装备的装备
        if (equippedArmor) {
            saveFile << equippedArmor->name << std::endl;
        }
        else {
            saveFile << "none" << std::endl;
        }
        if (equippedWeapon) {
            saveFile << equippedWeapon->name << std::endl;
        }
        else {
            saveFile << "none" << std::endl;
        }
        // 保存击败小怪物的数量
        saveFile << defeatedCount << std::endl;
        // 保存背包内的物品种类及其数量
        saveFile << healingItemCount << std::endl;
        saveFile << goldCount << std::endl;
        saveFile.close();
        std::cout << "游戏进度已保存到 savegame.txt" << std::endl;
    }
    else {
        std::cout << "无法打开保存文件！" << std::endl;
    }
}

// 从文件加载游戏进度
void loadGame() {
    std::ifstream loadFile("savegame.txt");
    if (loadFile.is_open()) {
        // 加载装备
        size_t numEquipments;
        loadFile >> numEquipments;
        ownedEquipments.clear();
        for (size_t i = 0; i < numEquipments; i++) {
            Equipment equipment;
            loadFile >> equipment.name >> equipment.type >> equipment.hpBoost >> equipment.damageBoost;
            ownedEquipments.push_back(equipment);
        }
        // 加载成就
        loadFile >> achievement_50 >> achievement_100 >> achievement_150;
        // 加载已装备的装备
        std::string equippedArmorName, equippedWeaponName;
        loadFile >> equippedArmorName >> equippedWeaponName;
        equippedArmor = nullptr;
        equippedWeapon = nullptr;
        for (auto& equipment : ownedEquipments) {
            if (equipment.name == equippedArmorName) {
                equippedArmor = &equipment;
                playerHp += equippedArmor->hpBoost;
            }
            if (equipment.name == equippedWeaponName) {
                equippedWeapon = &equipment;
                playerDamage += equippedWeapon->damageBoost;
            }
        }
        // 加载击败小怪物的数量
        loadFile >> defeatedCount;
        // 加载背包内的物品种类及其数量
        loadFile >> healingItemCount >> goldCount;
        loadFile.close();
        std::cout << "游戏进度已加载" << std::endl;
    }
    else {
        std::cout << "无法打开加载文件！" << std::endl;
    }
}

// 显示开始界面
void showStartMenu() {
    system("cls");
    std::cout << "fights 1.0.1" << std::endl;
    std::cout << "1.开始游戏" << std::endl;
    std::cout << "2.查看成就" << std::endl;
    std::cout << "3.查看官网" << std::endl;
    std::cout << "4.相关信息" << std::endl;
    std::cout << "5.退出游戏" << std::endl;
    std::cout << "6.查看装备" << std::endl;
    std::cout << "7.进入商店" << std::endl;
}

// 显示成就界面
void showAchievementMenu() {
    system("cls");
    std::cout << "x.返回" << std::endl;
    std::cout << "已获得的成就：" << std::endl;
    if (achievement_50) {
        std::cout << "- 超强之人" << std::endl;
    }
    if (achievement_100) {
        std::cout << "- 天外有天" << std::endl;
    }
    if (achievement_150) {
        std::cout << "- 一人之下，万人之上" << std::endl;
    }
}

// 显示相关信息界面
void showRelatedInfo() {
    system("cls");
    std::cout << "作者：山岚" << std::endl;
    std::cout << "编码：喵星人工作室" << std::endl;
    std::cout << "x.返回" << std::endl;
}

// 打开网站
void openWebsite() {
    const char* url = "https://blog.youkuaiyun.com/zhaozirui8290?spm=1000.2115.3001.5343";
    HINSTANCE result = ShellExecuteA(NULL, "open", url, NULL, NULL, SW_SHOWNORMAL);
    if ((INT_PTR)result <= 32) {
        std::cout << "打开网站失败！错误代码: " << (INT_PTR)result << std::endl;
        Sleep(2000);  // 等待 2 秒
    }
}

int main() {
    setConsoleToUTF8();
    srand(static_cast<unsigned int>(time(0)));

    char input;
    loadGame();  // 加载游戏进度
    while (true) {
        showStartMenu();
        input = _getch();  // 获取输入

        if (input == '1') {
            // 开始游戏
            energy = 100;
            playerHp = 5000;
            enemyHp = 5000;
            enemyHpMax = 5000;
            enemyDamage = 300;
            defeatedCount = 0;
            healingItemCount = 10;
            goldCount = 0;  // 初始化金币数量
            lastEnemySpawnTime = GetTickCount();
            lastEnergyRecoverTime = GetTickCount();
            enemyStayStartTime = 0;
            enemyShouldStay = false;
            lastPlayerX = playerX;
            lastPlayerY = playerY;
            initMap();
            displayMap();
            while (true) {
                if (_kbhit()) {  // 检查是否有按键输入
                    input = _getch();  // 获取输入
                    if (input == 'w' || input == 'a' || input == 's' || input == 'd' ||
                        input == 72 || input == 75 || input == 77 || input == 80 || input == 'b' || input == 'c') {
                        handleMovement(input);
                        if (!isInBackpack) {
                            moveEnemies();
                            spawnEnemy();
                        }
                        displayMap();
                    }
                    else if (input == 27) {  // 按 ESC 退出
                        break;
                    }
                }
                recoverEnergy();
                if (playerHp == 0) {
                    showGameOver();
                    break;
                }
                Sleep(100);  // 暂停一下，减少 CPU 占用
            }
            saveGame();  // 保存游戏进度
        }
        else if (input == '2') {
            // 查看成就
            showAchievementMenu();
            while (true) {
                input = _getch();  // 获取输入
                if (input == 'x') {
                    break;  // 返回开始界面
                }
            }
        }
        else if (input == '3') {
            // 查看官网
            openWebsite();
        }
        else if (input == '4') {
            showRelatedInfo();
            while (true) {
                input = _getch();  // 获取输入
                if (input == 'x') {
                    break;  // 返回开始界面
                }
            }
        }
        else if (input == '5') {
            // 退出游戏
            saveGame();  // 保存游戏进度
            break;
        }
        else if (input == '6') {
            // 查看装备
            showEquipmentWindow();
        }
        else if (input == '7') {
            // 进入商店
            showStore();
        }
    }

    return 0;
}