仙侠游戏——C++基础的应用

于 2025-01-17 19:58:44 发布
阅读量224 收藏 5
点赞数 7
文章标签： 游戏 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acm10139/article/details/145213666
版权

项目需求

某仙侠游戏中，有以下需求：
这个游戏世界中，有妖兽，灵石，修仙者

妖兽有自己的种类。
妖兽分为不同的等级：
1级妖兽：价值 100：初阶灵石
2级妖兽：价值 200初阶灵石
3级妖兽：价值 500初阶灵石
4级妖兽：价值 1000初阶灵石
5级妖兽：价值 2000初阶灵石
6级妖兽：价值 5000初阶灵石
7级妖兽：价值 10000初阶灵石
8级妖兽：价值 20000初阶灵石
9级妖兽：价值 100000初阶灵石

灵石：是一种类似黄金的硬货币。
灵石有级别：
初阶灵石：
1中阶灵石： 10初阶灵石
1高阶灵石： 10中阶灵石

修仙者
姓名
门派：（黄枫谷，鬼灵门，落云宗，掩月宗，古剑门，御灵宗， 散修）
级别（练气期， 筑基期, 结丹期，元婴期， 化神期，炼虚期，合体期，大成期，渡劫期）
资产（不定数量的妖兽，不定数量的灵石）
状态：生，死

修仙者之间常常进行贸易活动，用灵石购买妖兽，或者用妖兽换取灵石。
修仙者可以通过采矿来获取灵石，每次只能获取100个初阶灵石。
修仙者可以捕获妖兽，能否捕获妖兽，取决于自己的战斗力是否大于妖兽

开发灵石类

SpriteStone.h

#pragma once
#include <string>

enum class SpriteStoneLevel{
	PRIMARY_LEVEL,
	MIDDLE_LEVEL,
	ADVANCE_LEVEL,
	SPRITE_STONE_LEVEL_COUNT
};
//灵石类
class SpriteStone
{
public:
	SpriteStone(int count = 0,
		SpriteStoneLevel level = SpriteStoneLevel::PRIMARY_LEVEL);
	std::string str()const;


	friend std::ostream& operator<<(std::ostream& os, 
		const SpriteStone& stone);
	SpriteStone operator+(const SpriteStone& stone);
	bool operator >= (const SpriteStone& stone);
	SpriteStone operator-(const SpriteStone& stone);

	int getCount();
private:
	int count;//灵石的数量，多少块
	SpriteStoneLevel level;//灵石的等级

};

std::ostream& operator<<(std::ostream& os, 
	const SpriteStone& stone);

SpriteStone.cpp

#include "SpriteStone.h"
#include <sstream>

SpriteStone::SpriteStone(int count, SpriteStoneLevel level)
{
	this->count = count;
	this->level = level;
}

std::string SpriteStone::str() const
{
	std::stringstream ret;
	ret << count << "块";
	switch (level) {
	case SpriteStoneLevel::PRIMARY_LEVEL:
		ret << "初阶灵石";
		break;
	case SpriteStoneLevel::MIDDLE_LEVEL:
		ret << "中阶灵石";
		break;
	case SpriteStoneLevel::ADVANCE_LEVEL:
		ret << "高阶灵石";
		break;
	}

	return ret.str();
}

SpriteStone SpriteStone::operator+(const SpriteStone& stone)
{
	int sum = 0;
	if (stone.level == SpriteStoneLevel::PRIMARY_LEVEL) {
		sum += stone.count;
	}
	else if (stone.level == SpriteStoneLevel::MIDDLE_LEVEL) {
		sum += stone.count * 10;
	}
	else if (stone.level == SpriteStoneLevel::ADVANCE_LEVEL) {
		sum += stone.count * 100;
	}

	if (this->level == SpriteStoneLevel::PRIMARY_LEVEL) {
		sum += this->count;
	}
	else if (this->level == SpriteStoneLevel::MIDDLE_LEVEL) {
		sum += this->count * 10;
	}
	else if (this->level == SpriteStoneLevel::ADVANCE_LEVEL) {
		sum += this->count * 100;
	}

	return SpriteStone(sum, SpriteStoneLevel::PRIMARY_LEVEL);
}

bool SpriteStone::operator>=(const SpriteStone& stone)
{
	int sum1 = 0;
	if (this->level == SpriteStoneLevel::PRIMARY_LEVEL) {
		sum1 = this->count;
	}
	else if (this->level == SpriteStoneLevel::MIDDLE_LEVEL) {
		sum1 = this->count * 10;
	}
	else if (this->level == SpriteStoneLevel::ADVANCE_LEVEL) {
		sum1 = this->count * 100;
	}
	int sum2 = 0;

	if (stone.level == SpriteStoneLevel::PRIMARY_LEVEL) {
		sum2 = stone.count;
	}
	else if (stone.level == SpriteStoneLevel::MIDDLE_LEVEL) {
		sum2 = stone.count * 10;
	}
	else if (stone.level == SpriteStoneLevel::ADVANCE_LEVEL) {
		sum2 = stone.count * 100;
	}
	return sum1 >= sum2;

}

SpriteStone SpriteStone::operator-(const SpriteStone& stone)
{
	int sum1 = 0;
	if (this->level == SpriteStoneLevel::PRIMARY_LEVEL) {
		sum1 = this->count;
	}
	else if (this->level == SpriteStoneLevel::MIDDLE_LEVEL) {
		sum1 = this->count * 10;
	}
	else if (this->level == SpriteStoneLevel::ADVANCE_LEVEL) {
		sum1 = this->count * 100;
	}
	int sum2 = 0;

	if (stone.level == SpriteStoneLevel::PRIMARY_LEVEL) {
		sum2 = stone.count;
	}
	else if (stone.level == SpriteStoneLevel::MIDDLE_LEVEL) {
		sum2 = stone.count * 10;
	}
	else if (stone.level == SpriteStoneLevel::ADVANCE_LEVEL) {
		sum2 = stone.count * 100;
	}
	return SpriteStone(sum1-sum2,SpriteStoneLevel::PRIMARY_LEVEL);
}

int SpriteStone::getCount()
{
	return count;
}

std::ostream& operator<<(std::ostream& os, const SpriteStone& stone)
{
	// TODO: 在此处插入 return 语句
	os << stone.str();
	return os;
}

开发妖兽类

Monster.h

#pragma once
#include <string>
#include <iostream>

class SpriteStone;

//妖兽类
class Monster
{
public:
	Monster(int level = 1, const std::string& category="未知");
	SpriteStone getValue() const;
	int getPower() const;//获取该妖兽的战斗力
	friend std::ostream& operator<<(std::ostream& os, 
		const Monster& monster);
	friend bool operator == (const Monster& one, const Monster& other);
	//friend bool operator >= (const Monster& one, const Monster& other);

private:
	std::string category;//妖兽的种类
	int level;			 //1~9级

};

std::ostream& operator<<(std::ostream& os, const Monster& monster);
bool operator == (const Monster&one,const Monster& other);
//bool operator >= (const Monster& one, const Monster& other);

Monster.cpp

#include "Monster.h"
#include "SpriteStone.h"

#define MONSTER_LEVEL_FACTOR 1000

Monster::Monster(int level, const std::string& category)
{
	this->level = level;
	this->category = category;
}
/*
妖兽分为不同的等级：
1级妖兽：价值 100：初阶灵石
2级妖兽：价值 200初阶灵石
3级妖兽：价值 500初阶灵石
4级妖兽：价值 1000初阶灵石
5级妖兽：价值 2000初阶灵石 
6级妖兽：价值 5000初阶灵石
7级妖兽：价值 10000初阶灵石
8级妖兽：价值 20000初阶灵石
9级妖兽：价值 100000初阶灵石
*/
SpriteStone Monster::getValue() const
{
	int stoneCount[] = { 100,200,500,1000,2000,5000,10000,20000,100000 };

	int count = stoneCount[level - 1];

	return SpriteStone(count,SpriteStoneLevel::PRIMARY_LEVEL);
}

int Monster::getPower() const
{
	int ret = level * MONSTER_LEVEL_FACTOR;
	return ret;
}

std::ostream& operator<<(std::ostream& os, const Monster& monster)
{
	// TODO: 在此处插入 return 语句
	os << monster.level << "级" << monster.category << "妖兽";
	return os;
}

bool operator==(const Monster& one, const Monster& other)
{
	if (one.category == other.category &&
		one.level == other.level) {
		return true;
	}
	else {
		return false;
	}
}

//bool operator>=(const Monster& one, const Monster& other)
//{
//	int sum1 = 0;
//	if (one.level == SpriteStoneLevel::PRIMARY_LEVEL) {
//		sum1 = one->count;
//	}
//	return false;
//}

开发仙侠类

Immortal.h

#pragma once
#include <string>
#include <vector>

class SpriteStone;
class Monster;
//级别（练气期，筑基期，结丹期，元婴期，化神期，炼虚期，合体期，大成期，渡劫期）


//修仙者类
enum class ImmortalLevel {
	LIAN_QI,
	ZHU_JI,
	JIE_DAN,
	YUAN_YING,
	HUA_SHEN,
	LIAN_XU,
	HE_TI,
	DA_CHENG,
	DU_JIE
};

class Immortal
{
public:
	Immortal(const char* name, const char* menPai, ImmortalLevel level);

	//挖矿
	void mining();
	//到市场售卖所有的妖兽
	bool trade();
	//到市场售卖指定的妖兽
	bool trade(const Monster& monster);
	//用自己的灵石，来购买其他休闲者的指定妖兽
	bool trade(Immortal& other, const Monster& monster);
	//用自己指定的妖兽，来和其他修仙者的指定妖兽
	bool trade(const Monster& monsterSource,
		Immortal& other,
		const Monster& monsterDest);
	//把自己的妖兽，售卖给其他的修仙者,以换取灵石
	bool trade(const Monster& monster, Immortal& other);

	int getPower()const;

	//捕获妖兽
	void fight(const Monster& monster);

	friend std::ostream& operator<<(std::ostream& os, const Immortal& immortal);

	void dead();//修仙者死亡后的处理

private:
	std::string name;
	std::string menPai; //门派
	ImmortalLevel level; //修仙者的级别
	std::vector<SpriteStone> stones; //灵石资产
	std::vector<Monster> monsters;    //妖兽资产
	bool alive;//生死状态

	bool hadMonster(const Monster& monster);//判断是否有指定的妖兽
	bool removeMonster(const Monster& monster);//移除指定的妖兽

};

std::ostream& operator<<(std::ostream& os, const Immortal& immortal);
std::ostream& operator<<(std::ostream& os, const ImmortalLevel& level);

Immortal.cpp

#include "Immortal.h"
#include "SpriteStone.h"
#include "Monster.h"

#define IMMORTAL_LEVEL_FACTOR 1000
#define SPRITE_FACTOR 0.1
#define MONSTER_FACTOR 0.1
Immortal::Immortal(const char* name, const char* menPai, ImmortalLevel level)
{
	this->name = name;
	this->menPai = menPai;
	this->level = level;
	this->alive = true;
}

void Immortal::mining()
{
	stones.push_back(SpriteStone(100,
		SpriteStoneLevel::PRIMARY_LEVEL));
}

bool Immortal::trade()
{
	if (!alive) {
		return false;
	}
	SpriteStone stone;
	for (int i = 0; i < monsters.size(); i++) {
		// += 是违法的，因为只重载了+
		stone = stone + monsters[i].getValue();
	}
	stones.push_back(stone);
	monsters.erase(monsters.begin(), monsters.end());
	return true;
}
//到市场售卖指定的妖兽
bool Immortal::trade(const Monster& monster)
{
	if (!alive) {
		return false;
	}
	//判断有没有这个指定的妖兽
	if (!hadMonster(monster)) {
		std::cout << name << "没有" << monster << std::endl;
		return false;
	}
	SpriteStone stone = monster.getValue();
	stones.push_back(stone);
	removeMonster(monster);

	return true;
}
//用自己的灵石，来购买其他休闲者的指定妖兽
bool Immortal::trade(Immortal& other, const Monster& monster)
{
	if (alive == false || other.alive == false) {
		return false;
	}
	if (!other.hadMonster(monster)) {
		std::cout << other.name << "没有" << monster << std::endl;
		return false;
	}

	//计算当前的所有灵石总价
	SpriteStone stone;
	for (int i = 0; i < stones.size(); i++) {
		stone = stone + stones[i];
	}

	if (stone >= monster.getValue()) {
		//购买
		SpriteStone valueStone = monster.getValue();
		stone = stone - valueStone;
		stones.clear();
		stones.push_back(stone);
		monsters.push_back(monster);


		other.removeMonster(monster);
		other.stones.push_back(valueStone);

		return true;
	}
	else {
		std::cout << "抱歉！" << name << "的灵石不够买"
			<< monster << std::endl;
		return false;
	}

	
}
//用自己指定的妖兽，来换其他修仙者的指定妖兽
bool Immortal::trade(const Monster& monsterSource, Immortal& other, const Monster& monsterDest)
{
	if (alive == false || other.alive == false) {
		return false;
	}
	if (monsterSource == monsterDest ||
		!hadMonster(monsterSource) ||
		!(monsterSource.getValue() >= monsterDest.getValue())) {
		return false;
	}
	removeMonster(monsterSource);
	other.removeMonster(monsterDest);
	monsters.push_back(monsterDest);
	other.monsters.push_back(monsterSource);

	return false;
}
//把自己的妖兽，售卖给其他的修仙者,以换取灵石
bool Immortal::trade(const Monster& monster, Immortal& other)
{
	if (alive == false || other.alive == false) {
		return false;
	}

	if (!hadMonster(monster)) {
		std::cout << name << "没有" << monster << std::endl;
		return false;
	}

	SpriteStone otherStone;
	for (int i = 0; i < other.stones.size(); i++) {
		otherStone = otherStone + other.stones[i];
	}
	if (!(otherStone >= monster.getValue())) {
		return false;
	}

	//对方付钱
	otherStone = otherStone - monster.getValue();
	other.stones.clear();
	other.stones.push_back(otherStone);
	//自己交货
	removeMonster(monster);
	//自己收钱
	stones.push_back(monster.getValue());
	//对方收货
	other.monsters.push_back(monster);

	return true;
}
//战斗力
int Immortal::getPower() const
{
	//计算修仙者级别的战斗力
	int ret = ((int)level + 1)* IMMORTAL_LEVEL_FACTOR;//枚举类型是从0开始的
	
	//计算灵石助攻的战斗力
	SpriteStone stone;
	for (int i = 0; i < stones.size(); i++) {
		stone = stone + stones[i];
	}
	ret += stone.getCount() * SPRITE_FACTOR;
	
	//计算所有妖兽的助攻战斗力
	for (int i = 0; i < monsters.size(); i++) {
		ret += monsters[i].getPower() * MONSTER_FACTOR;
	}
	return ret;
}

void Immortal::fight(const Monster& monster)
{
	int selfPower = getPower();
	int monsterPower = monster.getPower();

	if (selfPower > monsterPower) {
		monsters.push_back(monster);
	}
	else if(selfPower < monsterPower){
		dead();
	}

}

void Immortal::dead()
{
	alive = false;
	stones.erase(stones.begin(),stones.end());
	monsters.erase(monsters.begin(), monsters.end());

}
bool Immortal::hadMonster(const Monster& monster)
{
	for (int i = 0; i < monsters.size(); i++) {
		if (monsters[i] == monster) {
			return true;
		}
	}
	return false;
}
bool Immortal::removeMonster(const Monster& monster)
{
	for (std::vector<Monster>::iterator it = monsters.begin();
		it != monsters.end(); ) {
		if (*it == monster) {
			it = monsters.erase(it);
			return true;
		}
		else {
			it++;
		}
	}
	return false;
}
/*
	std::string name;
	std::string menPai; //门派
	ImmotalLevel level; //修仙者的级别
	std::vector<SpriteStone> stones; //灵石资产
	std::vector<Monster> monsters;    //妖兽资产
	bool alive;//生死状态
*/
std::ostream& operator<<(std::ostream& os, const Immortal& immortal)
{
	// TODO: 在此处插入 return 语句
	os << "[修仙者]：" << immortal.name
		<< (immortal.alive ? "\t[在修]" : "\t[已亡]")
		<< "\t门派：" << immortal.menPai
		<< "\t级别：" << immortal.level;
	SpriteStone stone;
	for (int i = 0; i < immortal.stones.size(); i++) {
		stone = stone + immortal.stones[i];
	}
	os << "\t灵石：折合" << stone;

	os << "\t妖兽：";
	if (immortal.monsters.size() == 0) {
		os << "无";
	}
	else {
		for (int i = 0; i < immortal.monsters.size(); i++) {
			os << immortal.monsters[i] << " ";
		}
	}
	return os;
}
//级别（练气期，筑基期，结丹期，元婴期，化神期，炼虚期，合体期，大成期，渡劫期）

std::ostream& operator<<(std::ostream& os, const ImmortalLevel& level)
{

	// TODO: 在此处插入 return 语句
	switch (level) {
	case ImmortalLevel::LIAN_QI:
		os << "练气期";
		break;
	case ImmortalLevel::ZHU_JI:
		os << "筑基期";
		break;
	case ImmortalLevel::JIE_DAN:
		os << "结丹期";
		break;
	case ImmortalLevel::YUAN_YING:
		os << "元婴期";
		break;
	case ImmortalLevel::HUA_SHEN:
		os << "化神期";
		break;
	case ImmortalLevel::LIAN_XU:
		os << "炼虚期";
		break;
	case ImmortalLevel::HE_TI:
		os << "合体期";
		break;
	case ImmortalLevel::DA_CHENG:
		os << "大成期";
		break;
	case ImmortalLevel::DU_JIE:
		os << "渡劫期";
		break;
	}
	return os;
}

main.cpp测试 文件

#include "SpriteStone.h"
#include "Monster.h"
#include "Immortal.h"

#include <iostream>

using namespace std;

void testSpriteStone() {
	SpriteStone stone(100, SpriteStoneLevel::MIDDLE_LEVEL);
	cout << stone << endl;
}
void testMonster() {
	Monster monster(5, "蛟龙");
	cout << monster << std::endl;
}
void testImmortal() {
	Immortal immortal("rock", "奇牛", ImmortalLevel::LIAN_QI);
	cout << immortal << endl;

	for (int i = 0; i < 50; i++) {
		immortal.mining();
	}

	cout << immortal << endl;
	
	Monster monster(1, "蛟龙");
	immortal.fight(monster);
	cout << "捕获" << monster << "之后: " << endl;
	cout << immortal << endl;

	Monster monster2(1, "蜘蛛");
	immortal.fight(monster2);
	Monster monster3(1, "壁虎");
	immortal.fight(monster3);
	cout << "捕获" << monster2 << " 和 " << monster3 << "之后: " << endl;
	cout << immortal << endl;

	immortal.trade(monster2);
	cout << "售卖" << monster2 << "之后" << endl;
	cout << immortal << endl;

	immortal.trade();
	cout << "售卖所有妖兽之后" << endl;
	cout << immortal << endl;

	
	Immortal hanli("韩立", "黄枫谷", ImmortalLevel::JIE_DAN);
	cout << hanli << endl;
	
	Monster monster4(2, "蛟龙");
	hanli.fight(monster4);
	cout << hanli << endl;

	immortal.trade(hanli, monster4);
	cout << "贸易之后" << endl;
	cout << immortal << endl;
	cout << hanli << endl;

	cout << "-------------test trade-------------" << endl;

	//用自己指定的妖兽，来和其他修仙者的指定妖兽
	//把自己的妖兽，售卖给其他的修仙者,以换取灵石
	Monster monster5(1, "天蚕");
	hanli.fight(monster5);
	cout << "韩立" << "捕获" << monster5 << endl;
	cout << hanli << endl;
	immortal.trade(monster4, hanli, monster5);
	cout << "rock使用" << monster4 << "和韩立交换" << monster5 << endl;
	cout << immortal << endl;
	cout << hanli << endl;

	hanli.trade(monster4, immortal);

	cout << "韩立卖" << monster4 << "给rock" << endl;
	cout << immortal << endl;
	cout << hanli << endl;


}
int main(void) {
	testSpriteStone();
	testMonster();
	testImmortal();

	system("pause");

	return 0; 
}

项目总结：

为了便于实现贸易活动，
在灵石类中重载加法+运算
在灵石类中重载减法-运算
在灵石类中重载比较运算>=
在灵石类中添加获取块数的方法

在妖兽类中重载==运算
在妖兽类中添加获取战斗力的方法

Chasing追～
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值