核心设定与背景
游戏背景设定在一个被遗忘的古老地牢中，玩家扮演一名勇敢的探险者，不慎闯入这片充满危险与宝藏的地下世界。地牢由多个神秘区域组成，从阴暗潮湿的洞穴到布满灰尘的大厅，每个区域都隐藏着未知的危险和机遇。玩家的终极目标是穿越 5x5 的地牢地图，找到位于右下角的神秘出口，成功逃离这个危险之地。
核心游戏系统
-
角色成长系统
- 玩家拥有生命值、攻击力、防御力等核心属性，通过战斗获得经验值升级
- 每次升级会全面提升各项属性（生命值 + 20、攻击力 + 3、防御力 + 2）
- 升级系统提供清晰的成长反馈，让玩家感受到实力的提升
-
多样化敌人系统
- 四种特色敌人：地精、兽人、骷髅兵和最终区域可能遇到的巨龙
- 每种敌人都有独特的战斗机制：
- 地精：10% 几率几率造成暴击，造成双倍伤害
- 骷髅兵：20% 几率减免一半伤害
- 巨龙（BOSS）：30% 几率使用火焰喷射，50% 几率减免伤害
- 不同敌人提供不同数量的经验值奖励和独特战利品
-
物品与装备系统
- 武器类：生锈的匕首、兽人战斧、长剑等，提供攻击力加成
- 防具类：骨头碎片、龙鳞铠甲、皮甲、钢盾等，提供防御力加成
- 消耗品：小型治疗药水（+20HP）、中型治疗药水（+50HP）
- 完整的装备管理：可查看物品描述、使用消耗品、装备 / 卸下武器防具
-
地图与探索系统
- 5x5 的网格地图，每个房间随机生成
- 五种不同类型的房间描述，增强探索沉浸感
- 小地图功能显示已探索区域、玩家位置和出口位置
- 房间随机生成敌人（50% 几率）和物品（40% 几率）
-
回合制战斗系统
- 清晰的战斗状态显示（双方生命值）
- 玩家回合可选择：攻击、使用物品或查看状态
- 敌人拥有独特攻击模式，战斗策略性强
- 伤害计算考虑双方攻防属性，形成有趣的数值博弈
游戏流程与目标
- 玩家输入名字创建角色，从地牢入口开始冒险
- 通过 WASD 键在地图上移动，探索各个房间
- 与遇到的敌人战斗，获取经验值和战利品
- 管理背包物品，合理使用药水和装备
- 提升等级增强实力，为挑战更强大的敌人做准备
- 找到位于地图右下角的出口，成功逃离地牢
游戏特色
- 随机性与重玩价值：每次游戏的地图布局、敌人分布和物品位置都是随机生成的
- 策略深度：需要根据敌人类型选择合适的战斗策略和物品使用时机
- 渐进式难度：随着探索深入，可能遇到更强大的敌人
- 成就感：通过战斗升级、获取强力装备带来明确的成长体验
- 简单易上手的操作：直观的菜单系统和明确的操作提示
一、基础操作
- 角色移动：使用 W（上）、A（左）、S（下）、D（右）键控制方向
- 确认操作：所有选择后按回车键确认
- 数值输入：根据菜单选择时输入对应数字，移动时输入对应方向键
二、主界面菜单（非战斗状态）
-
移动（输入 1）
- 选择后提示输入方向（W/A/S/D）
- 若撞击墙壁会提示 "不能向那个方向移动"
-
查看背包（输入 2）
- 显示所有持有的物品列表及编号
- 输入物品编号后可选择：
- 1：使用该物品（仅对药水有效）
- 2：装备为武器（仅对武器类物品有效）
- 3：装备为防具（仅对防具类物品有效）
- 0：取消操作
-
查看状态（输入 3）
- 显示角色详细信息：等级、生命值、攻击力、防御力
- 显示当前装备的武器和防具
- 显示当前经验值及升级所需经验
-
查看小地图（输入 4）
- 显示 5x5 网格地图
- 标识说明：
- P：玩家当前位置
- E：出口位置
- .：已探索过的房间
- ?：未探索的房间
-
退出游戏（输入 5）
- 直接结束游戏进程
三、战斗状态操作
遇到敌人时自动进入战斗模式，战斗菜单：
-
攻击（输入 1）
- 对当前敌人发起普通攻击
- 伤害值根据双方攻防属性计算
-
使用物品（输入 2）
- 显示背包物品列表
- 输入物品编号使用（通常用于使用治疗药水）
- 输入 0 取消使用
-
查看状态（输入 3）
- 战斗中查看自身属性状态
- 不消耗回合数
四、特殊交互
-
发现物品时：
- 输入 y（或 Y）拾取物品
- 输入 n（或 N）放弃拾取
-
游戏开始时：
- 输入玩家名称后按回车确认
所有操作均有明确的文字提示引导，新手可通过多次使用 "查看状态" 和 "查看小地图" 来熟悉游戏进度和自身状况。
编辑
这款游戏的战斗操作是怎样的？
游戏中可以获得哪些类型的物品？
这款游戏支持多人对战吗？
《地牢探险者：深渊回响》适合喜欢回合制战斗和地牢探索的玩家，游戏难度适中且具有良好的成长曲线，既适合休闲玩家体验探险乐趣，也能让核心玩家感受到策略战斗的挑战。每次冒险都是一次全新的体验，充满了未知与惊喜。
那么，废话不多说，不多说废话，废话多说了还是废话所以直接上代码：
#include <iostream>
#include <vector>
#include <string>
#include <cstdlib>
#include <ctime>
#include <algorithm>
#include <limits>
using namespace std;
// 前向声明
class Item;
class Enemy;
class Player;
// 物品类
class Item {
private:
string name;
string description;
int attackBonus;
int defenseBonus;
int healthBonus;
bool isPotion;
public:
Item(string n, string d, int ab, int db, int hb, bool ip)
: name(n), description(d), attackBonus(ab), defenseBonus(db),
healthBonus(hb), isPotion(ip) {}
string getName() const { return name; }
string getDescription() const { return description; }
int getAttackBonus() const { return attackBonus; }
int getDefenseBonus() const { return defenseBonus; }
int getHealthBonus() const { return healthBonus; }
bool isPotionItem() const { return isPotion; }
void use(Player& player);
};
// 敌人基类
class Enemy {
protected:
string name;
int health;
int maxHealth;
int attack;
int defense;
int experienceReward;
Item* loot;
public:
Enemy(string n, int h, int a, int d, int exp, Item* l)
: name(n), health(h), maxHealth(h), attack(a), defense(d),
experienceReward(exp), loot(l) {}
virtual ~Enemy() {
delete loot; // 释放战利品内存
}
string getName() const { return name; }
int getHealth() const { return health; }
int getMaxHealth() const { return maxHealth; }
int getAttack() const { return attack; }
int getDefense() const { return defense; }
int getExperienceReward() const { return experienceReward; }
Item* getLoot() const { return loot; }
void setLoot(nullptr_t) { loot = nullptr; }
// 声明为虚函数，允许派生类重写
virtual void takeDamage(int damage) {
if (damage > 0) {
health -= damage;
if (health < 0) health = 0;
}
}
bool isAlive() const { return health > 0; }
virtual int attackPlayer(Player& player);
virtual void display() const;
};
// 玩家类
class Player {
private:
string name;
int health;
int maxHealth;
int attack;
int defense;
int level;
int experience;
int experienceToNextLevel;
vector<Item*> inventory;
Item* equippedWeapon;
Item* equippedArmor;
public:
Player(string n)
: name(n), health(100), maxHealth(100), attack(10), defense(5),
level(1), experience(0), experienceToNextLevel(100),
equippedWeapon(nullptr), equippedArmor(nullptr) {}
~Player() {
for (Item* item : inventory) {
delete item;
}
delete equippedWeapon;
delete equippedArmor;
}
string getName() const { return name; }
int getHealth() const { return health; }
int getMaxHealth() const { return maxHealth; }
int getAttack() const {
int total = attack;
if (equippedWeapon) total += equippedWeapon->getAttackBonus();
return total;
}
int getDefense() const {
int total = defense;
if (equippedArmor) total += equippedArmor->getDefenseBonus();
return total;
}
int getLevel() const { return level; }
int getExperience() const { return experience; }
int getExperienceToNextLevel() const { return experienceToNextLevel; }
void takeDamage(int damage) {
int damageTaken = max(0, damage - getDefense() / 2);
health -= damageTaken;
if (health < 0) health = 0;
cout << name << "受到了" << damageTaken << "点伤害!" << endl;
}
void heal(int amount) {
health += amount;
if (health > maxHealth) health = maxHealth;
cout << name << "恢复了" << amount << "点生命值!" << endl;
}
void addExperience(int amount) {
cout << "获得了" << amount << "点经验值!" << endl;
experience += amount;
while (experience >= experienceToNextLevel) {
levelUp();
}
}
void levelUp() {
level++;
experience -= experienceToNextLevel;
experienceToNextLevel = static_cast<int>(experienceToNextLevel * 1.5);
maxHealth += 20;
health = maxHealth;
attack += 3;
defense += 2;
cout << endl << "恭喜! " << name << "升级到了" << level << "级!" << endl;
cout << "属性提升: 生命值+" << 20 << ", 攻击力+" << 3 << ", 防御力+" << 2 << endl << endl;
}
bool isAlive() const { return health > 0; }
void addItem(Item* item) {
inventory.push_back(item);
cout << "获得了" << item->getName() << "!" << endl;
}
void displayInventory() const {
if (inventory.empty()) {
cout << "你的背包是空的。" << endl;
return;
}
cout << "===== 背包 (" << inventory.size() << ") =====" << endl;
for (size_t i = 0; i < inventory.size(); i++) {
cout << i+1 << ". " << inventory[i]->getName() << " - " << inventory[i]->getDescription() << endl;
}
cout << "==================================" << endl;
}
void useItem(int index) {
if (index < 1 || index > static_cast<int>(inventory.size())) {
cout << "无效的物品编号!" << endl;
return;
}
Item* item = inventory[index-1];
item->use(*this);
// 如果是消耗品，使用后移除
if (item->isPotionItem()) {
inventory.erase(inventory.begin() + index - 1);
delete item;
}
}
void equipWeapon(int index) {
if (index < 1 || index > static_cast<int>(inventory.size())) {
cout << "无效的物品编号!" << endl;
return;
}
Item* item = inventory[index-1];
if (item->getAttackBonus() <= 0) {
cout << "这不是武器，不能装备!" << endl;
return;
}
// 如果已经装备了武器，放回背包
if (equippedWeapon) {
inventory.push_back(equippedWeapon);
}
equippedWeapon = item;
inventory.erase(inventory.begin() + index - 1);
cout << "装备了" << item->getName() << "!" << endl;
}
void equipArmor(int index) {
if (index < 1 || index > static_cast<int>(inventory.size())) {
cout << "无效的物品编号!" << endl;
return;
}
Item* item = inventory[index-1];
if (item->getDefenseBonus() <= 0) {
cout << "这不是防具，不能装备!" << endl;
return;
}
// 如果已经装备了防具，放回背包
if (equippedArmor) {
inventory.push_back(equippedArmor);
}
equippedArmor = item;
inventory.erase(inventory.begin() + index - 1);
cout << "装备了" << item->getName() << "!" << endl;
}
void displayStatus() const {
cout << endl << "===== " << name << " 的状态 =====" << endl;
cout << "等级: " << level << endl;
cout << "生命值: " << health << "/" << maxHealth << endl;
cout << "攻击力: " << getAttack() << (equippedWeapon ? " (+"+to_string(equippedWeapon->getAttackBonus())+")" : "") << endl;
cout << "防御力: " << getDefense() << (equippedArmor ? " (+"+to_string(equippedArmor->getDefenseBonus())+")" : "") << endl;
cout << "经验值: " << experience << "/" << experienceToNextLevel << endl;
cout << "装备: " << endl;
cout << " 武器: " << (equippedWeapon ? equippedWeapon->getName() : "无") << endl;
cout << " 防具: " << (equippedArmor ? equippedArmor->getName() : "无") << endl;
cout << "==============================" << endl << endl;
}
};
// 实现Item的use方法
void Item::use(Player& player) {
if (isPotion) {
cout << "使用了" << name << "!" << endl;
player.heal(healthBonus);
} else {
cout << name << "不能被直接使用，可以尝试装备它。" << endl;
}
}
// 实现Enemy的攻击方法
int Enemy::attackPlayer(Player& player) {
int damage = max(0, attack - player.getDefense() / 3);
player.takeDamage(damage);
return damage;
}
// 显示敌人信息
void Enemy::display() const {
cout << name << " (生命值: " << health << "/" << maxHealth << ", 攻击力: " << attack << ", 防御力: " << defense << ")" << endl;
}
// 派生敌人类型
class Goblin : public Enemy {
public:
Goblin() : Enemy("地精", 30, 8, 2, 20,
new Item("生锈的匕首", "一把生锈的匕首，攻击力+3", 3, 0, 0, false)) {}
int attackPlayer(Player& player) override {
// 地精有10%几率造成双倍伤害
int damage = max(0, getAttack() - player.getDefense() / 3);
if (rand() % 10 == 0) {
damage *= 2;
cout << "地精的暴击!" << endl;
}
player.takeDamage(damage);
return damage;
}
};
class Orc : public Enemy {
public:
Orc() : Enemy("兽人", 60, 12, 5, 50,
new Item("兽人战斧", "一把沉重的战斧，攻击力+5", 5, 0, 0, false)) {}
};
class Skeleton : public Enemy {
public:
Skeleton() : Enemy("骷髅兵", 40, 10, 3, 30,
new Item("骨头碎片", "可以用来制作简易武器，攻击力+2", 2, 0, 0, false)) {}
// 正确重写基类的虚函数
void takeDamage(int damage) override {
// 骷髅兵有20%几率减免一半伤害
if (rand() % 5 == 0) {
damage /= 2;
cout << "骷髅兵的骨头吸收了部分伤害!" << endl;
}
Enemy::takeDamage(damage);
}
};
class Dragon : public Enemy {
public:
Dragon() : Enemy("巨龙", 200, 25, 15, 500,
new Item("龙鳞铠甲", "由巨龙鳞片制成的铠甲，防御力+10", 0, 10, 0, false)) {}
int attackPlayer(Player& player) override {
// 巨龙有30%几率使用火焰喷射
if (rand() % 10 < 3) {
int fireDamage = getAttack() + 10;
player.takeDamage(fireDamage);
cout << "巨龙使用了火焰喷射!" << endl;
return fireDamage;
}
return Enemy::attackPlayer(player);
}
// 正确重写基类的虚函数
void takeDamage(int damage) override {
// 巨龙有50%几率减免少量伤害
if (rand() % 2 == 0) {
int reduced = damage - 5;
if (reduced < 0) reduced = 0;
cout << "巨龙的鳞甲减少了伤害!" << endl;
Enemy::takeDamage(reduced);
} else {
Enemy::takeDamage(damage);
}
}
};
// 房间类，表示地图中的一个区域
class Room {
private:
string description;
bool hasEnemy;
Enemy* enemy;
bool hasItem;
Item* item;
bool visited;
bool isExit;
public:
Room(string desc, bool enemy, bool item, bool exit)
: description(desc), hasEnemy(enemy), enemy(nullptr),
hasItem(item), item(nullptr), visited(false), isExit(exit) {
// 随机生成敌人
if (hasEnemy) {
int enemyType = rand() % 4; // 包含巨龙的四种敌人
switch (enemyType) {
case 0: enemy = new Goblin(); break;
case 1: enemy = new Orc(); break;
case 2: enemy = new Skeleton(); break;
case 3: enemy = new Dragon(); break;
default: enemy = new Goblin();
}
}
// 随机生成物品
if (hasItem) {
int itemType = rand() % 5;
switch (itemType) {
case 0: item = new Item("小型治疗药水", "恢复20点生命值", 0, 0, 20, true); break;
case 1: item = new Item("中型治疗药水", "恢复50点生命值", 0, 0, 50, true); break;
case 2: item = new Item("长剑", "一把锋利的长剑，攻击力+7", 7, 0, 0, false); break;
case 3: item = new Item("皮甲", "由坚韧皮革制成的护甲，防御力+4", 0, 4, 0, false); break;
case 4: item = new Item("钢盾", "坚固的钢盾，防御力+6", 0, 6, 0, false); break;
default: item = new Item("小型治疗药水", "恢复20点生命值", 0, 0, 20, true);
}
}
}
~Room() {
delete enemy;
delete item;
}
string getDescription() const { return description; }
bool hasEnemyHere() const { return hasEnemy && enemy && enemy->isAlive(); }
Enemy* getEnemy() const { return enemy; }
void setEnemy(Enemy* e) { enemy = e; } // 添加setter方法
bool hasItemHere() const { return hasItem && item; }
Item* getItem() const { return item; }
bool isVisited() const { return visited; }
bool isExitRoom() const { return isExit; }
void setVisited(bool v) { visited = v; }
// 拾取物品
void pickUpItem(Player& player) {
if (hasItemHere()) {
player.addItem(item);
item = nullptr;
hasItem = false;
} else {
cout << "这个房间里没有可以拾取的物品了。" << endl;
}
}
};
// 游戏地图类
class Map {
private:
vector<vector<Room*>> grid;
int width;
int height;
int playerX;
int playerY;
public:
Map(int w, int h) : width(w), height(h), playerX(0), playerY(0) {
// 初始化地图
grid.resize(height, vector<Room*>(width, nullptr));
// 随机生成地图
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
// 50%几率有敌人，40%几率有物品
bool hasEnemy = (rand() % 10 < 5);
bool hasItem = (rand() % 10 < 4);
bool isExit = (x == width - 1 && y == height - 1); // 出口在右下角
// 生成房间描述
string desc;
vector<string> roomTypes = {
"一个阴暗潮湿的洞穴",
"一个布满灰尘的大厅",
"一条狭窄的走廊",
"一个宽敞的石室",
"一个神秘的密室"
};
desc = roomTypes[rand() % roomTypes.size()];
if (isExit) {
desc = "一个宏伟的大厅，尽头有一扇发光的门——这是出口!";
}
grid[y][x] = new Room(desc, hasEnemy, hasItem, isExit);
}
}
// 修复第465行问题：使用setter方法安全设置敌人指针为nullptr
Enemy* startEnemy = grid[0][0]->getEnemy();
delete startEnemy; // 先删除原有敌人
grid[0][0]->setEnemy(nullptr); // 使用setter方法设置为nullptr
}
~Map() {
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
delete grid[y][x];
}
}
}
Room* getCurrentRoom() const {
return grid[playerY][playerX];
}
bool movePlayer(char direction) {
int newX = playerX;
int newY = playerY;
switch (direction) {
case 'w': newY--; break;
case 's': newY++; break;
case 'a': newX--; break;
case 'd': newX++; break;
default: return false;
}
// 检查是否在地图范围内
if (newX >= 0 && newX < width && newY >= 0 && newY < height) {
playerX = newX;
playerY = newY;
grid[playerY][playerX]->setVisited(true);
return true;
}
return false;
}
void displayMiniMap() const {
cout << endl << "===== 小地图 =====" << endl;
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
if (x == playerX && y == playerY) {
cout << "P "; // 玩家位置
} else if (grid[y][x]->isExitRoom()) {
cout << "E "; // 出口
} else if (grid[y][x]->isVisited()) {
cout << ". "; // 已访问
} else {
cout << "? "; // 未访问
}
}
cout << endl;
}
cout << "==================" << endl << endl;
}
};
// 战斗系统
bool battle(Player& player, Enemy* enemy) {
if (!enemy || !enemy->isAlive()) return true; // 防御性检查
cout << endl << "一场战斗开始了! " << enemy->getName() << "向你发起了攻击!" << endl;
while (player.isAlive() && enemy->isAlive()) {
// 显示战斗状态
cout << endl << "----- 战斗状态 -----" << endl;
cout << player.getName() << ": " << player.getHealth() << "/" << player.getMaxHealth() << " HP" << endl;
cout << enemy->getName() << ": " << enemy->getHealth() << "/" << enemy->getMaxHealth() << " HP" << endl;
cout << "---------------------" << endl;
// 玩家回合
cout << endl << "你的回合! 请选择动作:" << endl;
cout << "1. 攻击" << endl;
cout << "2. 使用物品" << endl;
cout << "3. 查看状态" << endl;
int choice;
// 处理无效输入
while (!(cin >> choice)) {
cin.clear();
cin.ignore(numeric_limits<streamsize>::max(), '\n');
cout << "无效输入，请输入数字: ";
}
switch (choice) {
case 1: {
// 玩家攻击
int damage = max(0, player.getAttack() - enemy->getDefense() / 3);
enemy->takeDamage(damage);
cout << "你对" << enemy->getName() << "造成了" << damage << "点伤害!" << endl;
if (!enemy->isAlive()) {
cout << "你击败了" << enemy->getName() << "!" << endl;
player.addExperience(enemy->getExperienceReward());
// 掉落物品
if (enemy->getLoot()) {
player.addItem(enemy->getLoot());
enemy->setLoot(nullptr); // 防止重复释放
}
return true;
}
break;
}
case 2: {
// 使用物品
player.displayInventory();
cout << "请选择要使用的物品编号 (0取消): ";
int itemChoice;
cin >> itemChoice;
if (itemChoice != 0) {
player.useItem(itemChoice);
}
break;
}
case 3: {
// 查看状态
player.displayStatus();
break;
}
default:
cout << "无效的选择，你浪费了一次攻击机会!" << endl;
}
// 敌人回合
if (enemy->isAlive()) {
cout << endl << enemy->getName() << "的回合!" << endl;
enemy->attackPlayer(player);
if (!player.isAlive()) {
cout << "你被" << enemy->getName() << "击败了!" << endl;
return false;
}
}
}
return player.isAlive();
}
// 游戏主函数
void playGame() {
srand(time(0));
cout << "欢迎来到地牢探险者：深渊回响!" << endl;
cout << "请输入你的名字: ";
string playerName;
cin >> playerName;
Player player(playerName);
Map map(5, 5); // 创建一个5x5的地图
cout << endl << "你发现自己身处一个神秘的地牢入口。你的目标是找到出口并活着离开!" << endl;
cout << "使用WASD键移动，输入命令来进行各种操作。" << endl;
// 标记起始房间为已访问
map.getCurrentRoom()->setVisited(true);
while (player.isAlive()) {
Room* currentRoom = map.getCurrentRoom();
cout << endl << "===== 新的区域 =====" << endl;
cout << currentRoom->getDescription() << endl;
// 检查是否有敌人
if (currentRoom->hasEnemyHere()) {
Enemy* enemy = currentRoom->getEnemy();
enemy->display();
// 开始战斗
bool victory = battle(player, enemy);
if (!victory) {
// 战斗失败，游戏结束
break;
}
}
// 检查是否是出口
if (currentRoom->isExitRoom()) {
cout << endl << "恭喜你找到了出口! 你成功逃离了地牢!" << endl;
cout << "游戏结束。你的最终等级是: " << player.getLevel() << endl;
break;
}
// 检查是否有物品
if (currentRoom->hasItemHere()) {
cout << endl << "你发现了一个物品: " << currentRoom->getItem()->getName() << endl;
cout << "要拾取这个物品吗? (y/n): ";
char choice;
cin >> choice;
if (choice == 'y' || choice == 'Y') {
currentRoom->pickUpItem(player);
}
}
// 显示可用命令
cout << endl << "请选择下一步行动:" << endl;
cout << "1. 移动 (WASD)" << endl;
cout << "2. 查看背包" << endl;
cout << "3. 查看状态" << endl;
cout << "4. 查看小地图" << endl;
cout << "5. 退出游戏" << endl;
int choice;
// 处理无效输入
while (!(cin >> choice)) {
cin.clear();
cin.ignore(numeric_limits<streamsize>::max(), '\n');
cout << "无效输入，请输入数字: ";
}
switch (choice) {
case 1: {
cout << "请输入移动方向 (WASD): ";
char direction;
cin >> direction;
if (map.movePlayer(direction)) {
cout << "你向" << direction << "方向移动了。" << endl;
} else {
cout << "不能向那个方向移动，那里是墙壁!" << endl;
}
break;
}
case 2: {
player.displayInventory();
cout << "要使用物品吗? (输入编号，0取消): ";
int itemChoice;
cin >> itemChoice;
if (itemChoice > 0) {
cout << "1. 使用 2. 装备为武器 3. 装备为防具: ";
int action;
cin >> action;
switch (action) {
case 1: player.useItem(itemChoice); break;
case 2: player.equipWeapon(itemChoice); break;
case 3: player.equipArmor(itemChoice); break;
default: cout << "无效选择。" << endl;
}
}
break;
}
case 3:
player.displayStatus();
break;
case 4:
map.displayMiniMap();
break;
case 5:
cout << "感谢游玩! 再见!" << endl;
return;
default:
cout << "无效的选择，请重试。" << endl;
}
}
// 如果玩家死亡
if (!player.isAlive()) {
cout << endl << "游戏结束。你的冒险到此为止。" << endl;
cout << "你的最终等级是: " << player.getLevel() << endl;
}
}
int main() {
playGame();
return 0;
}
扫一扫
1687
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
