魔兽世界程序设计-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_44274276/article/details/128448065

程序设计-魔兽世界系列大作业

上一篇作业解析与代码：魔兽世界-备战

思路与类架构

1. 设计原则

（1）不改动测试代码，测试代码反映了用户的使用，尽量用户不改动原有的调用程序。
（2）不改动基础代码，在基础代码之上继承开发出新的功能。例如，尽量少的改动阵营和武士类，尽量在新增武士和装备的情况下，能快速适应新功能。

2.类架构与功能

（1）因为不同的武士装备和属性发生了变化，所以需要由武士Warrior类继承出具体的不同的武士，但是构造函数上，忠诚度和士气都可以从生命元算出，所以给Warrior类增加剩余生命元的属性，但需要注意：此时的Warrior类应是抽象类，属性是为了具体子类的计算，并非实例。
（2）设计了创建武士的函数，并与武士类分离开，为了后续如果有第三方需要调用武士，不需要依赖类代码。
（3）采用多态性，如果新的武士开发出来了：对用户而言。不需要更改调用方法，只需要知道有哪些武士名称即可；对于开发者而言，不需要修改基础类，只需要开发对应新武士的代码，以及在创建武士的函数上增加选项即可。

3.改进的设想

有一些设想，但是没有实现，不知道能不能实现。

设想：设计一个哈希表，武士名字符串，映射到武士的工厂类，工厂类构造出实例。但是，这个逻辑，还是需要在创建新武士时，更新哈希表。这和写一个创建武士的方法，没有本质区别。

C++代码实现

#include <cstdio>
#include <string>
#include <vector>
#include <memory>
#include <unordered_map>

static
std::unordered_map<std::string, int> warriorStrength;

class Warrior {
protected:
	std::string name, camp;
	int id, strength, remMeta;

public:
	Warrior(
		const std::string& name_,
		const std::string& camp_,
		int id_, int strength_, int remMeta_
	) : name(name_), camp(camp_), id(id_), 
		strength(strength_), remMeta(remMeta_) { }

	virtual
	void born(int timeStamp, int numsInCamp) {
		printf("%03d %s %s %d born with strength %d,"
			"%d %s in %s headquarter\n", timeStamp, camp.c_str(),
			name.c_str(), id, strength, numsInCamp, name.c_str(),
			camp.c_str());
	}

	virtual ~Warrior() {  }
};

const std::vector<std::string> WEAPON = {
	"sword", "bomb", "arrow"
};

class Dragon : public Warrior {
private:
	std::string weapon;
	double morale;

public:
	Dragon(
		const std::string& name_,
		const std::string& camp_,
		int id_, int strength_, int remMeta_
	) : Warrior(name_, camp_, id_, strength_, remMeta_),
		weapon(WEAPON[(id_ % 3)]), 
		morale(1.0 * remMeta_ / strength_) { }

	void born(int timeStamp, int numsInCamp) {
		Warrior::born(timeStamp, numsInCamp);
		printf("It has a %s,and it's morale is %.2lf\n",
			weapon.c_str(), morale);
	}

	virtual ~Dragon() {  }
};

class Ninja : public Warrior {
private:
	std::string weapon1;
	std::string weapon2;

public:
	Ninja(
		const std::string& name_,
		const std::string& camp_,
		int id_, int strength_, int remMeta_
	) : Warrior(name_, camp_, id_, strength_, remMeta_),
		weapon1(WEAPON[(id_ % 3)]), 
		weapon2(WEAPON[((id_ + 1) % 3)]) { }

	void born(int timeStamp, int numsInCamp) {
		Warrior::born(timeStamp, numsInCamp);
		printf("It has a %s and a %s\n",
			weapon1.c_str(), weapon2.c_str());
	}

	virtual ~Ninja() {  }
};

class Iceman : public Warrior {
private:
	std::string weapon;

public:
	Iceman(
		const std::string& name_,
		const std::string& camp_,
		int id_, int strength_, int remMeta_
	) : Warrior(name_, camp_, id_, strength_, remMeta_),
		weapon(WEAPON[(id_ % 3)]) { }

	void born(int timeStamp, int numsInCamp) {
		Warrior::born(timeStamp, numsInCamp);
		printf("It has a %s\n", weapon.c_str());
	}
};

class Lion : public Warrior {
private:
	int loyalty;

public:
	Lion(
		const std::string& name_,
		const std::string& camp_,
		int id_, int strength_, int remMeta_
	) : Warrior(name_, camp_, id_, strength_, remMeta_),
		loyalty(remMeta_) { }

	void born(int timeStamp, int numsInCamp) {
		Warrior::born(timeStamp, numsInCamp);
		printf("It's loyalty is %d\n", loyalty);
	}

	virtual ~Lion() {  }
};

using Wolf = Warrior;

std::shared_ptr<Warrior>
createWarrior(
	const std::string& warriorName,
	const std::string& headquarterName,
	int curID, int curStrength, int remMeta
) {
	if ("dragon" == warriorName) {
		return std::make_shared<Dragon>(
			warriorName, headquarterName, curID, curStrength, remMeta);
	}
	else if ("ninja" == warriorName) {
		return std::make_shared<Ninja>(
			warriorName, headquarterName, curID, curStrength, remMeta);
	}
	else if ("iceman" == warriorName) {
		return std::make_shared<Iceman>(
			warriorName, headquarterName, curID, curStrength, remMeta);
	}
	else if ("lion" == warriorName) {
		return std::make_shared<Lion>(
			warriorName, headquarterName, curID, curStrength, remMeta);
	}
	else if ("wolf" == warriorName) {
		return std::make_shared<Wolf>(
			warriorName, headquarterName, curID, curStrength, remMeta);
	}
	else {
		throw "Error: Nonexistent warroir name.";
	}
}

class Headquarter {
private:
	std::string name;
	std::vector<std::string> order;
	std::unordered_map<std::string, int> cntWarrior;
	int healthMeta, curID;
	size_t curIdx;

public:
	Headquarter(
		const std::string& name_,
		const std::vector<std::string>& order_,
		int healthMeta_, int curID_ = 1, size_t curIdx_ = 0
	) : name(name_), order(order_),
		healthMeta(healthMeta_), curID(curID_), curIdx(curIdx_) { }

	std::string getNextWarriorName() {
		size_t orderSize = order.size();
		for (size_t i = 0; i < orderSize; ++i) {
			std::string curName = order[curIdx];
			if (healthMeta >= warriorStrength[curName]) {
				return curName;
			}
			curIdx = (curIdx + 1) % orderSize;
		}
		return "NULL";
	}

	bool bornWarrior(int timeStamp) {
		std::string curName = getNextWarriorName();
		if ("NULL" == curName) {
			printf("%03d %s headquarter stops making warriors\n",
				timeStamp, name.c_str());
			return false;
		}
		int curStrength = warriorStrength[curName];
		healthMeta -= curStrength;
		int curNumsInCamp = ++cntWarrior[curName];
		try {
			createWarrior(
				curName, name, curID, curStrength, healthMeta
			)->born(timeStamp, curNumsInCamp);
		}
		catch (const char* errorMsg) {
			printf("%s\n", errorMsg);
			return false;
		}
		curID++;
		curIdx = (curIdx + 1) % order.size();
		return true;
	}
};

int main() {
	int caseNums;
	scanf("%d", &caseNums);
	for (int cs = 1; cs <= caseNums; ++cs) {
		int meta, dragon, ninja, iceman, lion, wolf;
		scanf("%d%d%d%d%d%d", &meta, &dragon, &ninja,
			&iceman, &lion, &wolf);
		warriorStrength = {
			{"dragon", dragon}, {"ninja", ninja}, {"iceman", iceman},
			{"lion", lion}, {"wolf", wolf}
		};
		Headquarter red(
			"red", { "iceman", "lion", "wolf", "ninja", "dragon" }, meta);
		Headquarter blue(
			"blue", { "lion", "dragon", "ninja", "iceman","wolf" }, meta);
		printf("Case:%d\n", cs);
		bool redOK = true, blueOK = true;
		for (int curTime = 0; ; ++curTime) {
			if (redOK) {
				redOK = red.bornWarrior(curTime);
			}
			if (blueOK) {
				blueOK = blue.bornWarrior(curTime);
			}
			if (!redOK && !blueOK) {
				break;
			}
		}
	}
	return 0;
}