我将为您创建一个模块化的三打白骨精游戏。以下是完整的实现：
项目结构
three_fights_baigujing/
├── main.cpp
├── game.h
├── game.cpp
├── character.h
├── character.cpp
├── battle.h
├── battle.cpp
├── utils.h
├── utils.cpp
└── README.md
1. character.h (角色类定义)
#ifndef CHARACTER_H
#define CHARACTER_H
#include <string>
#include <vector>
// 角色类型枚举
enum class CharacterType {
MONKEY_KING, // 孙悟空
TANG_SENG, // 唐僧
BAIGUJING_WOMAN, // 白骨精(美少妇)
BAIGUJING_OLDWOMAN, // 白骨精(老妇人)
BAIGUJING_OLDMAN, // 白骨精(老头)
MONSTER_GROUP // 怪物群体
};
// 战斗结果枚举
enum class BattleResult {
WIN, // 胜利
FAIL, // 失败
CONTINUE // 继续
};
// 基础角色类
class Character {
protected:
std::string name;
int health;
int maxHealth;
CharacterType type;
public:
Character(const std::string& n, int h, CharacterType t);
virtual ~Character() = default;
// 获取角色信息
std::string getName() const { return name; }
int getHealth() const { return health; }
int getMaxHealth() const { return maxHealth; }
CharacterType getType() const { return type; }
// 设置生命值
void setHealth(int h);
// 判断是否存活
bool isAlive() const { return health > 0; }
// 攻击方法（纯虚函数）
virtual int attack() = 0;
// 受到伤害
virtual void takeDamage(int damage);
// 显示状态
virtual void displayStatus() const;
};
// 孙悟空类
class MonkeyKing : public Character {
private:
int stickPower; // 金箍棒威力
int wisdomLevel; // 智慧等级（影响判断）
public:
MonkeyKing();
int attack() override;
void useWisdom(); // 使用火眼金睛识别妖怪
int getStickPower() const { return stickPower; }
};
// 唐僧类
class TangSeng : public Character {
private:
int mercyLevel; // 慈悲程度
public:
TangSeng();
int attack() override;
void reciteSutra(); // 念紧箍咒
int getMercyLevel() const { return mercyLevel; }
};
// 白骨精变形类基类
class BaigujingForm : public Character {
protected:
bool isRealForm; // 是否为真实形态
public:
BaigujingForm(const std::string& n, int h, CharacterType t, bool real = false);
virtual ~BaigujingForm() = default;
bool getIsRealForm() const { return isRealForm; }
};
// 美少妇形态
class WomanForm : public BaigujingForm {
public:
WomanForm();
int attack() override;
std::vector<std::string> getMonstersWhenFail() const;
};
// 老妇人形态
class OldWomanForm : public BaigujingForm {
public:
OldWomanForm();
int attack() override;
std::vector<std::string> getMonstersWhenFail() const;
};
// 老头形态
class OldManForm : public BaigujingForm {
public:
OldManForm();
int attack() override;
std::vector<std::string> getMonstersWhenFail() const;
};
#endif
2. character.cpp
#include "character.h"
#include <iostream>
#include <random>
#include <algorithm>
// 基础角色构造函数
Character::Character(const std::string& n, int h, CharacterType t)
: name(n), health(h), maxHealth(h), type(t) {}
void Character::setHealth(int h) {
health = std::max(0, std::min(h, maxHealth));
}
void Character::takeDamage(int damage) {
health -= damage;
if (health < 0) health = 0;
}
void Character::displayStatus() const {
std::cout << name << " - 生命值: " << health << "/" << maxHealth;
if (!isAlive()) std::cout << " [已死亡]";
std::cout << std::endl;
}
// 孙悟空实现
MonkeyKing::MonkeyKing()
: Character("孙悟空", 100, CharacterType::MONKEY_KING),
stickPower(25), wisdomLevel(80) {}
int MonkeyKing::attack() {
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> dis(15, stickPower + (wisdomLevel / 10));
return dis(gen);
}
void MonkeyKing::useWisdom() {
std::cout << "🔍 孙悟空使用火眼金睛仔细观察..." << std::endl;
wisdomLevel += 10;
if (wisdomLevel > 100) wisdomLevel = 100;
}
// 唐僧实现
TangSeng::TangSeng()
: Character("唐僧", 60, CharacterType::TANG_SENG),
mercyLevel(90) {}
int TangSeng::attack() {
// 唐僧攻击力很低
return rand() % 5 + 1;
}
void TangSeng::reciteSutra() {
std::cout << "🙏 唐僧开始念紧箍咒..." << std::endl;
mercyLevel += 20;
}
// 白骨精形态基类实现
BaigujingForm::BaigujingForm(const std::string& n, int h, CharacterType t, bool real)
: Character(n, h, t), isRealForm(real) {}
// 美少妇形态实现
WomanForm::WomanForm()
: BaigujingForm("美少妇", 40, CharacterType::BAIGUJING_WOMAN) {}
int WomanForm::attack() {
return rand() % 8 + 3;
}
std::vector<std::string> WomanForm::getMonstersWhenFail() const {
std::vector<std::string> monsters = {
"数百只大黄蜂", "一群野猪", "毒蛇和蝎子", "山贼团伙", "迷雾幻象"
};
return monsters;
}
// 老妇人形态实现
OldWomanForm::OldWomanForm()
: BaigujingForm("老妇人", 50, CharacterType::BAIGUJING_OLDWOMAN) {}
int OldWomanForm::attack() {
return rand() % 10 + 5;
}
std::vector<std::string> OldWomanForm::getMonstersWhenFail() const {
std::vector<std::string> monsters = {
"无数蜈蚣", "饥饿的狼群", "飞沙走石的狂风", "石巨人", "怨灵军团"
};
return monsters;
}
// 老头形态实现
OldManForm::OldManForm()
: BaigujingForm("老头", 60, CharacterType::BAIGUJING_OLDMAN) {}
int OldManForm::attack() {
return rand() % 12 + 8;
}
std::vector<std::string> OldManForm::getMonstersWhenFail() const {
std::vector<std::string> monsters = {
"吸血虫群", "老鹰和乌鸦", "地刺陷阱", "毒雾沼泽", "石像鬼军团"
};
return monsters;
}
3. battle.h (战斗系统)
#ifndef BATTLE_H
#define BATTLE_H
#include "character.h"
#include <memory>
#include <vector>
class BattleSystem {
private:
std::shared_ptr<Character> player;
std::shared_ptr<Character> enemy;
int roundCount;
bool gameEnded;
public:
BattleSystem(std::shared_ptr<Character> p, std::shared_ptr<Character> e);
~BattleSystem() = default;
// 开始战斗
void startBattle();
// 单轮战斗
BattleResult fightRound();
// 处理战斗结果
void handleBattleResult(BattleResult result);
// 检查游戏是否结束
bool isGameEnded() const { return gameEnded; }
// 获取回合数
int getRoundCount() const { return roundCount; }
private:
// 显示战斗信息
void displayBattleInfo() const;
// 玩家行动
void playerAction(int damage);
// 敌人行动
void enemyAction(int damage);
// 处理失败情况
void handleFailure();
// 检查是否应该结束游戏
bool shouldEndGame() const;
};
#endif
4. battle.cpp
#include "battle.h"
#include "utils.h"
#include <iostream>
#include <random>
#include <algorithm>
BattleSystem::BattleSystem(std::shared_ptr<Character> p, std::shared_ptr<Character> e)
: player(p), enemy(e), roundCount(0), gameEnded(false) {}
void BattleSystem::startBattle() {
std::cout << "\n⚔️ 战斗开始！" << std::endl;
std::cout << "==========================================" << std::endl;
while (!gameEnded && !shouldEndGame()) {
roundCount++;
std::cout << "\n📊 第 " << roundCount << " 回合" << std::endl;
BattleResult result = fightRound();
handleBattleResult(result);
// 检查游戏结束条件
if (player->getType() == CharacterType::MONKEY_KING &&
enemy->getType() == CharacterType::BAIGUJING_OLDMAN &&
enemy->getHealth() <= 0) {
std::cout << "\n🎉 恭喜！孙悟空终于识破并打败了白骨精的真实形态！" << std::endl;
gameEnded = true;
break;
}
displayBattleInfo();
// 简单的输入延迟
std::cout << "\n按回车继续...";
std::cin.get();
}
}
BattleResult BattleSystem::fightRound() {
displayBattleInfo();
// 玩家攻击
int playerDamage = player->attack();
std::cout << player->getName() << " 攻击造成 " << playerDamage << " 点伤害！" << std::endl;
// 如果是孙悟空，有几率使用火眼金睛
if (player->getType() == CharacterType::MONKEY_KING) {
auto monkey = std::dynamic_pointer_cast<MonkeyKing>(player);
if (rand() % 100 < 30) { // 30%几率使用火眼金睛
monkey->useWisdom();
}
}
enemy->takeDamage(playerDamage);
playerAction(playerDamage);
// 检查敌人是否死亡
if (!enemy->isAlive()) {
// 检查是否是白骨精的真实形态
if (auto baigujing = std::dynamic_pointer_cast<BaigujingForm>(enemy)) {
if (baigujing->getIsRealForm()) {
return BattleResult::WIN;
} else {
// 假形态被打败，出现怪物
return BattleResult::FAIL;
}
}
return BattleResult::WIN;
}
// 敌人反击
int enemyDamage = enemy->attack();
std::cout << enemy->getName() << " 反击造成 " << enemyDamage << " 点伤害！" << std::endl;
player->takeDamage(enemyDamage);
enemyAction(enemyDamage);
if (!player->isAlive()) {
return BattleResult::FAIL;
}
return BattleResult::CONTINUE;
}
void BattleSystem::handleBattleResult(BattleResult result) {
switch (result) {
case BattleResult::WIN:
std::cout << "✅ 战斗胜利！" << std::endl;
break;
case BattleResult::FAIL:
handleFailure();
break;
case BattleResult::CONTINUE:
// 继续下一回合
break;
}
}
void BattleSystem::displayBattleInfo() const {
std::cout << "\n当前状态：" << std::endl;
player->displayStatus();
enemy->displayStatus();
}
void BattleSystem::playerAction(int damage) {
// 玩家行动逻辑可以在这里扩展
}
void BattleSystem::enemyAction(int damage) {
// 敌人行动逻辑可以在这里扩展
}
void BattleSystem::handleFailure() {
std::cout << "\n💀 战斗失败！" << std::endl;
if (auto woman = std::dynamic_pointer_cast<WomanForm>(enemy)) {
auto monsters = woman->getMonstersWhenFail();
std::string monster = getRandomElement(monsters);
std::cout << "❌ 美少妇倒下后现出白骨原形，但无法彻底消灭！" << std::endl;
std::cout << "🌪️ 突然出现了：" << monster << "！" << std::endl;
}
else if (auto oldWoman = std::dynamic_pointer_cast<OldWomanForm>(enemy)) {
auto monsters = oldWoman->getMonstersWhenFail();
std::string monster = getRandomElement(monsters);
std::cout << "❌ 老妇人被打倒，但白骨精逃走了！" << std::endl;
std::cout << "🌪️ 突然出现了：" << monster << "！" << std::endl;
}
else if (auto oldMan = std::dynamic_pointer_cast<OldManForm>(enemy)) {
auto monsters = oldMan->getMonstersWhenFail();
std::string monster = getRandomElement(monsters);
std::cout << "❌ 老头被打倒，但白骨精再次逃走了！" << std::endl;
std::cout << "🌪️ 突然出现了：" << monster << "！" << std::endl;
}
// 唐僧可能会念经
if (player->getType() == CharacterType::MONKEY_KING) {
std::cout << "\n🙏 唐僧看到这种情况，开始念紧箍咒..." << std::endl;
auto tangSeng = std::make_shared<TangSeng>();
tangSeng->reciteSutra();
if (tangSeng->getMercyLevel() > 95) {
std::cout << "😵 孙悟空头痛欲裂，差点被紧箍咒制服！" << std::endl;
}
}
}
bool BattleSystem::shouldEndGame() const {
return !player->isAlive() || !enemy->isAlive();
}
5. utils.h (工具函数)
#ifndef UTILS_H
#define UTILS_H
#include <string>
#include <vector>
#include <random>
#include <memory>
// 随机工具函数
template<typename T>
T getRandomElement(const std::vector<T>& vec) {
static std::random_device rd;
static std::mt19937 gen(rd());
std::uniform_int_distribution<> dis(0, vec.size() - 1);
return vec[dis(gen)];
}
// 延时函数
void delay(int milliseconds);
// 清屏函数
void clearScreen();
// 打印分隔线
void printSeparator();
// 获取用户输入
int getUserChoice(const std::string& prompt, int min, int max);
#endif
6. utils.cpp
#include "utils.h"
#include <iostream>
#include <chrono>
#include <thread>
#ifdef _WIN32
#include <windows.h>
#else
#include <cstdlib>
#endif
void delay(int milliseconds) {
std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
}
void clearScreen() {
#ifdef _WIN32
system("cls");
#else
system("clear");
#endif
}
void printSeparator() {
std::cout << "==========================================" << std::endl;
}
int getUserChoice(const std::string& prompt, int min, int max) {
int choice;
while (true) {
std::cout << prompt;
std::cin >> choice;
if (choice >= min && choice <= max) {
break;
}
std::cout << "❌ 无效选择，请重新输入 (" << min << "-" << max << ")" << std::endl;
}
return choice;
}
7. game.h (游戏主逻辑)
#ifndef GAME_H
#define GAME_H
#include "character.h"
#include "battle.h"
#include <memory>
#include <vector>
class Game {
private:
std::shared_ptr<MonkeyKing> monkeyKing;
std::shared_ptr<TangSeng> tangSeng;
std::vector<std::shared_ptr<BaigujingForm>> baigujingForms;
int currentStage;
bool gameCompleted;
public:
Game();
~Game() = default;
// 初始化游戏
void initializeGame();
// 运行游戏
void run();
// 显示欢迎信息
void showWelcome();
// 显示游戏说明
void showInstructions();
// 执行三打白骨精流程
void executeThreeFights();
// 检查游戏是否完成
bool isGameCompleted() const { return gameCompleted; }
private:
// 第一战：美少妇
void firstFight();
// 第二战：老妇人
void secondFight();
// 第三战：老头
void thirdFight();
// 最终决战
void finalBattle();
// 显示当前进度
void showProgress() const;
};
#endif
8. game.cpp
#include "game.h"
#include "utils.h"
#include <iostream>
Game::Game()
: currentStage(0), gameCompleted(false) {
initializeGame();
}
void Game::initializeGame() {
// 创建角色
monkeyKing = std::make_shared<MonkeyKing>();
tangSeng = std::make_shared<TangSeng>();
// 创建白骨精的三个形态
baigujingForms.push_back(std::make_shared<WomanForm>());
baigujingForms.push_back(std::make_shared<OldWomanForm>());
baigujingForms.push_back(std::make_shared<OldManForm>());
// 创建白骨精真实形态（血量更高）
auto realBaigujing = std::make_shared<OldManForm>();
realBaigujing->setHealth(120); // 真实形态血量更高
baigujingForms.push_back(realBaigujing);
}
void Game::run() {
showWelcome();
showInstructions();
char choice = getUserChoice("\n开始游戏吗？(y/n): ", 'y', 'n');
if (choice != 'y' && choice != 'Y') {
std::cout << "👋 再见！" << std::endl;
return;
}
executeThreeFights();
if (gameCompleted) {
std::cout << "\n🎊 恭喜通关！孙悟空成功保护唐僧西天取经！" << std::endl;
}
}
void Game::showWelcome() {
clearScreen();
std::cout << R"(
╔══════════════════════════════════════╗
║ 三打白骨精游戏 ║
║ 孙悟空智斗千年白骨精 ║
╚══════════════════════════════════════╝
)" << std::endl;
}
void Game::showInstructions() {
printSeparator();
std::cout << "📖 游戏说明：" << 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;
printSeparator();
}
void Game::executeThreeFights() {
std::cout << "\n🎯 游戏正式开始！" << std::endl;
// 第一战
firstFight();
if (!monkeyKing->isAlive()) {
std::cout << "\n💀 孙悟空阵亡，游戏结束！" << std::endl;
return;
}
// 第二战
secondFight();
if (!monkeyKing->isAlive()) {
std::cout << "\n💀 孙悟空阵亡，游戏结束！" << std::endl;
return;
}
// 第三战
thirdFight();
if (!monkeyKing->isAlive()) {
std::cout << "\n💀 孙悟空阵亡，游戏结束！" << std::endl;
return;
}
// 最终决战
finalBattle();
if (monkeyKing->isAlive()) {
gameCompleted = true;
}
}
void Game::firstFight() {
currentStage = 1;
showProgress();
std::cout << "\n🥊 第一战：美少妇" << std::endl;
std::cout << "白骨精化作美貌少妇，手提竹篮前来..." << std::endl;
auto battle = BattleSystem(monkeyKing, baigujingForms[0]);
battle.startBattle();
if (baigujingForms[0]->getHealth() <= 0) {
std::cout << "💀 美少妇倒下了，但地上只有一堆白骨..." << std::endl;
std::cout << "⚠️ 白骨精逃走了！" << std::endl;
}
}
void Game::secondFight() {
currentStage = 2;
showProgress();
std::cout << "\n🥊 第二战：老妇人" << std::endl;
std::cout << "白骨精又化作寻找女儿的老妇人..." << std::endl;
// 恢复孙悟空生命值
monkeyKing->setHealth(monkeyKing->getMaxHealth());
auto battle = BattleSystem(monkeyKing, baigujingForms[1]);
battle.startBattle();
if (baigujingForms[1]->getHealth() <= 0) {
std::cout << "💀 老妇人被打倒了..." << std::endl;
std::cout << "⚠️ 白骨精再次逃走了！" << std::endl;
}
}
void Game::thirdFight() {
currentStage = 3;
showProgress();
std::cout << "\n🥊 第三战：老头" << std::endl;
std::cout << "白骨精最后化作寻找妻女的老头..." << std::endl;
// 恢复孙悟空生命值
monkeyKing->setHealth(monkeyKing->getMaxHealth());
auto battle = BattleSystem(monkeyKing, baigujingForms[2]);
battle.startBattle();
if (baigujingForms[2]->getHealth() <= 0) {
std::cout << "💀 老头被打倒了..." << std::endl;
std::cout << "⚠️ 白骨精还是逃走了！唐僧开始怀疑..." << std::endl;
}
}
void Game::finalBattle() {
currentStage = 4;
showProgress();
std::cout << "\n⚡ 最终决战：白骨精真身" << std::endl;
std::cout << "孙悟空火眼金睛看穿真相，与白骨精真身决一死战！" << std::endl;
// 恢复孙悟空生命值
monkeyKing->setHealth(monkeyKing->getMaxHealth());
auto battle = BattleSystem(monkeyKing, baigujingForms[3]);
battle.startBattle();
}
void Game::showProgress() {
std::cout << "\n📈 当前进度：第 " << currentStage << " 阶段" << std::endl;
printSeparator();
}
9. main.cpp (主程序)
#include "game.h"
#include "utils.h"
int main() {
try {
Game game;
game.run();
std::cout << "\n感谢游玩三打白骨精游戏！" << std::endl;
std::cout << "按回车键退出...";
std::cin.get();
} catch (const std::exception& e) {
std::cerr << "游戏发生错误: " << e.what() << std::endl;
return 1;
}
return 0;
}
10. README.md
# 三打白骨精游戏
一个基于C++开发的文字冒险游戏，改编自《西游记》中孙悟空三打白骨精的经典故事。
## 🎮 游戏特色
- **经典剧情重现**：完整还原三打白骨精的故事情节
- **策略战斗系统**：每次战斗都有不同的挑战和策略
- **丰富剧情分支**：不同形态的敌人带来不同的战斗体验
- **模块化设计**：代码结构清晰，易于扩展和维护
## 🚀 游戏玩法
1. **第一战**：对战美少妇形态的白骨精
- 看似容易击败，但无法彻底消灭
- 失败后会出现各种怪物阻挠
2. **第二战**：对战老妇人形态的白骨精
- 更加凶险的战斗
- 失败后会有更强大的怪物出现
3. **第三战**：对战老头形态的白骨精
- 最后的考验
- 唐僧可能会念紧箍咒干扰
4. **最终决战**：识破白骨精真身
- 必须彻底击败才能获胜
- 火眼金睛是关键
## 🛠️ 编译和运行
### 环境要求
- C++11 或更高版本
- 支持标准库的开发环境
### 编译命令
bash
g++ -std=c++11 main.cpp game.cpp character.cpp battle.cpp utils.cpp -o three_fights_baigujing
### 运行游戏
bash
./three_fights_baigujing
## 📁 项目结构
├── main.cpp # 主程序入口
├── game.h/.cpp # 游戏主逻辑
├── character.h/.cpp # 角色类定义
├── battle.h/.cpp # 战斗系统
├── utils.h/.cpp # 工具函数
└── README.md # 说明文档
## 🎯 核心特性
- **面向对象设计**：使用继承和多态实现角色系统
- **智能指针管理**：使用shared_ptr自动内存管理
- **随机数生成**：增加游戏的不可预测性
- **模块化架构**：各功能模块独立，便于测试和维护
## 🔧 扩展建议
1. 添加更多白骨精的形态变化
2. 增加道具和技能系统
3. 实现存档读档功能
4. 添加音效和更丰富的文本描述
5. 实现图形界面版本
## 👥 开发者
本游戏展示了C++面向对象编程、游戏逻辑设计和模块化开发的实践应用。
核心知识点卡片
1. 面向对象编程 (OOP)
- 封装: 将数据和操作封装在类中
- 继承: Character → BaigujingForm → 具体形态
- 多态: 虚函数和动态绑定实现运行时多态
- 抽象类: Character作为抽象基类定义接口
2. 智能指针
- shared_ptr: 自动内存管理，避免内存泄漏
- 多态与智能指针: dynamic_pointer_cast进行类型转换
- 资源共享: 多个对象可以共享同一资源
3. 设计模式
- 策略模式: 不同角色的攻击策略
- 状态模式: 角色的不同状态（存活/死亡）
- 模板方法: BattleSystem中的固定战斗流程
4. 随机数生成
- random_device: 真随机数种子
- mt19937: 梅森旋转算法伪随机数生成器
- uniform_int_distribution: 均匀分布
5. 异常处理
- 异常安全: try-catch块处理运行时错误
- 资源管理: RAII原则确保资源正确释放
6. 模块化设计
- 头文件保护: #ifndef/#define/#endif防止重复包含
- 分离编译: .h声明，.cpp实现
- 接口与实现分离: 清晰的API设计
这个游戏完整地实现了您要求的所有功能，包括三打白骨精的完整剧情、各种怪物出现的效果、唐僧念经的影响，以及最终的胜利条件。代码结构清晰，注释详细，易于理解和扩展。
关注我，有更多实用程序等着你！
