失败设计浴火重生

#include <iostream>
#include <time.h>
#include "CMD.h"
#include "Girl_Sword_NPC.h"
#include "NPCBuilder.h"


using namespace std;


void main()
{
	srand(time(0));
	Girl_Sword_NPC buildGirl;
	buildGirl.Create_Girl_Sword_NPC();
	do 
	{
		NPCSetManager::RunNPC();
	} while (NPCSetManager.g_NPCSet.size() > 0);
	NPCSetManager::Clear();

	system("pause");
}

#pragma once 


enum G_TO_CLIENT_CMD
{
	//指令开始
	TO_CLIENT_CMD_START					= 1,

	//死亡指令
	TO_CLIENT_DIE_ING_CMD				= TO_CLIENT_CMD_START,

	//移动指令
	TO_CLIENT_MOVE_ING_CMD,					

	//攻击指令
	TO_CLIENT_ATTACK_ING_CMD,
	TO_CLIENT_ATTACK_ED_CMD,

	//火焰术指令
	TO_CLIENT_FIRE_MAGIC_ING_CMD,
	TO_CLIENT_FIRE_MAGIC_ED_CMD,

	//指令结束
	TO_CLIENT_CMD_END					= TO_CLIENT_FIRE_MAGIC_ED_CMD
};



enum G_GAME_STATE
{
	//状态开始
	G_GAME_STATE_START					= 1,

	//女剑士 -------------------------------
	//女剑士_死亡态
	GIRL_SWORD_DIE_ING_STATE			= TO_CLIENT_CMD_START,
	//女剑士_移动态
	GIRL_SWORD_MOVE_ING_STATE,
	//女剑士_攻击态
	GIRL_ATTACK_ING_STATE,
	GIRL_ATTACK_ED_STATE,
	//女剑士_火焰术态
	GIRL_SWORD_FIRE_MAGIC_ING_STATE,
	GIRL_SWORD_FIRE_MAGIC_ED_STATE,


	//状态开始
	G_GAME_STATE_END					= GIRL_SWORD_FIRE_MAGIC_ED_STATE,
};

#pragma once
#include <string.h>
#include <iostream>
#include <map>
#include "CMD.h"
#include "State.h"


using namespace std;



class NPC
{
public:
	NPC(int _uID):m_pCurState(0),UID(_uID)
	{
		m_iPosX = rand()%800;
		m_iPosY = rand()%600;
	}
	~NPC()
	{
		map<int, State_Interface*>::iterator it = m_dStateSet.begin();
		for(; it != m_dStateSet.end(); it++)
		{
			if( 0 != it->second)
			{
				delete it->second;
				it->second = 0;
			}
		}
		m_dStateSet.clear();
	}
	//收到转换状态
	template<class T>
	void RecvCmd(T _Cmd){ _Cmd.Execute(this); }
	void Run()
	{
		if( NULL != m_pCurState) m_pCurState->Execute(this);
	}

public:
	//VS2005模板支持不够,只好把私有权限改为公有权限-_-!
	map<int, State_Interface*> m_dStateSet;
	State_Interface* m_pCurState;
	const int UID;
	int m_iPosX;
	int m_iPosY;
	friend class NPCBuilder;
};

#pragma once
#include "NPC.h"
#include "State.h"
#include <vector>

using namespace std;


class NPCSetManager
{
public:
	static vector<NPC*> g_NPCSet;
	static void RunNPC();
	static void DeleteNPC(const int _uID);
	static void Clear();

private:
	template<int s, int e>  
	class CmdSwitchCase  
	{  
	public:  
		static bool SwitchCase(NPC* _pNPC, int i);
	};  
	template<int v>  
	class CmdSwitchCase<v, v>  
	{  
	public:  
		static bool SwitchCase(NPC* _pNPC, int i);
	}; 
};


class NPCBuilder
{//建造者，对客户屏蔽目标的内部生成功能,暂时提供外部的生成选择，过后只提供目标的使用功能的权限。
public:
	//创建NPC
	void Build_NPC();
	void Add_State(int _CMD_ID, State_Interface* _pState_Interface);
	void Del_State(int _CMD_ID);
	//更新NPC数据
	void Update_NPC();
private:
	NPC* m_pNPC;
};

#include "NPCBuilder.h"


vector<NPC*> NPCSetManager::g_NPCSet;

 
template<int s, int e>  
bool NPCSetManager::CmdSwitchCase<s, e>::SwitchCase(NPC* _pNPC, int i)  
{  
	if( i<s || i>=e) return false;  
	const int POS = (s+e)/2;  
	if( POS == i)
	{ 
		_pNPC->RecvCmd(CMD<POS>());
		_pNPC->Run();
		return true; 
	}
	else if( POS > i){ return CmdSwitchCase<s,POS>::SwitchCase(_pNPC, i); }  
	else{ return CmdSwitchCase<POS,e>::SwitchCase(_pNPC, i); }  
}
template<int v>  
bool NPCSetManager::CmdSwitchCase<v, v>::SwitchCase(NPC* _pNPC, int i)
{ 
	return false; 
}  


void NPCSetManager::RunNPC()
{


	for(int i=0; i<g_NPCSet.size(); i++)
	{
		int iRandCmd = rand()%(G_TO_CLIENT_CMD::TO_CLIENT_CMD_END);
		CmdSwitchCase<G_TO_CLIENT_CMD::TO_CLIENT_CMD_START, G_TO_CLIENT_CMD::TO_CLIENT_CMD_END>::SwitchCase(g_NPCSet[i], iRandCmd);
	}
}

void NPCSetManager::DeleteNPC(const int _uID)
{
	for(int i=0; i<g_NPCSet.size(); i++)
	{
		if( _uID == g_NPCSet[i]->UID)
		{
			delete g_NPCSet[i];
			g_NPCSet[i] = g_NPCSet[g_NPCSet.size()-1];
			g_NPCSet.pop_back();
			break;
		}
	}
}

void NPCSetManager::Clear()
{
	for(int i=0; i<g_NPCSet.size(); i++)
	{
		delete g_NPCSet[i];
	}
	g_NPCSet.clear();
}



//创建NPC
void NPCBuilder::Build_NPC()
{ 
	m_pNPC = new NPC( NPCSetManager::g_NPCSet.size() );
}

void NPCBuilder::Add_State(int _CMD_ID, State_Interface* _pState_Interface)
{ 
	m_pNPC->m_dStateSet[_CMD_ID] = _pState_Interface; 
}

void NPCBuilder::Del_State(int _CMD_ID)
{ 
	m_pNPC->m_dStateSet[_CMD_ID] = 0; 
}

//更新NPC数据
void NPCBuilder::Update_NPC()
{
	NPCSetManager::g_NPCSet.push_back(m_pNPC);
	m_pNPC = NULL;
}

#pragma once


class NPC;

class State_Interface
{
public:
	virtual ~State_Interface(){}
	virtual void Execute(NPC* _pNPC) = 0;
	const int STATE_ID;
protected:
	State_Interface(int _STATE_ID):STATE_ID(_STATE_ID){}

};

template<int v>  
class State: public State_Interface
{  
public:
	State():State_Interface(-1){}
	void Execute(NPC* _pNPC){ cout<<"未定义状态: "<<value<<endl; }  
};

#pragma once
#include "G_DEFINE.h"
#include "State.h"


//女剑士死亡态
template<>  
class State<G_GAME_STATE::GIRL_SWORD_DIE_ING_STATE>: public State_Interface
{  
public: 
	State():State_Interface(G_GAME_STATE::GIRL_SWORD_DIE_ING_STATE){}
	~State();
	void Execute(NPC* _pNPC);
}; 

//女剑士移动态
template<>  
class State<G_GAME_STATE::GIRL_SWORD_MOVE_ING_STATE>: public State_Interface
{  
public: 
	State():State_Interface(G_GAME_STATE::GIRL_SWORD_MOVE_ING_STATE){}
	void Execute(NPC* _pNPC);
}; 

//女剑士_攻击态
template<>  
class State<G_GAME_STATE::GIRL_ATTACK_ING_STATE>: public State_Interface
{  
public: 
	State():State_Interface(G_GAME_STATE::GIRL_ATTACK_ING_STATE){}
	void Execute(NPC* _pNPC);
}; 
template<>  
class State<G_GAME_STATE::GIRL_ATTACK_ED_STATE>: public State_Interface
{  
public: 
	State():State_Interface(G_GAME_STATE::GIRL_ATTACK_ED_STATE){}
	void Execute(NPC* _pNPC);
}; 

//女剑士_火焰术态
template<>  
class State<G_GAME_STATE::GIRL_SWORD_FIRE_MAGIC_ING_STATE>: public State_Interface
{  
public: 
	State():State_Interface(G_GAME_STATE::GIRL_SWORD_FIRE_MAGIC_ING_STATE){}
	void Execute(NPC* _pNPC);
}; 
template<>  
class State<G_GAME_STATE::GIRL_SWORD_FIRE_MAGIC_ED_STATE>: public State_Interface
{  
public: 
	State():State_Interface(G_GAME_STATE::GIRL_SWORD_FIRE_MAGIC_ED_STATE){}
	void Execute(NPC* _pNPC);
}; 

#include "Girl_Sword_State.h"
#include <iostream>
#include "NPC.h"
#include "NPCBuilder.h"



using namespace std;



//女剑士死亡态
State<G_GAME_STATE::GIRL_SWORD_DIE_ING_STATE>::~State()
{
	cout<<"女剑士死亡态进行析构!"<<endl;
}
void State<G_GAME_STATE::GIRL_SWORD_DIE_ING_STATE>::Execute(NPC* _pNPC)
{
	cout<<"run -> 女剑士死亡态"<<endl;
	NPCSetManager::DeleteNPC(_pNPC->UID);
}

//女剑士移动态
void State<G_GAME_STATE::GIRL_SWORD_MOVE_ING_STATE>::Execute(NPC* _pNPC)
{
	cout<<"run -> 女剑士移动态"<<endl;
}

//女剑士_攻击态
void State<G_GAME_STATE::GIRL_ATTACK_ING_STATE>::Execute(NPC* _pNPC)
{
	cout<<"run -> 女剑士进行攻击"<<endl;
}
void State<G_GAME_STATE::GIRL_ATTACK_ED_STATE>::Execute(NPC* _pNPC)
{
	cout<<"run -> 女剑士被攻击"<<endl;
}

//女剑士_火焰术态
void State<G_GAME_STATE::GIRL_SWORD_FIRE_MAGIC_ING_STATE>::Execute(NPC* _pNPC)
{
	cout<<"run -> 女剑士施放火焰术"<<endl;
}
void State<G_GAME_STATE::GIRL_SWORD_FIRE_MAGIC_ED_STATE>::Execute(NPC* _pNPC)
{
	cout<<"run -> 女剑士受到火焰术"<<endl;
}

#pragma once
#include "NPCBuilder.h"
#include "G_DEFINE.h"
#include "Girl_Sword_State.h"



//女剑士_NPC   
class Girl_Sword_NPC  
{ 
public:
	static void Create_Girl_Sword_NPC()
	{
		NPCBuilder builder;
		builder.Build_NPC();
		builder.Add_State(TO_CLIENT_DIE_ING_CMD, new State<G_GAME_STATE::GIRL_SWORD_DIE_ING_STATE>);
		builder.Add_State(TO_CLIENT_MOVE_ING_CMD, new State<G_GAME_STATE::GIRL_SWORD_MOVE_ING_STATE>);
		builder.Add_State(TO_CLIENT_ATTACK_ING_CMD, new State<G_GAME_STATE::GIRL_ATTACK_ING_STATE>);
		builder.Add_State(TO_CLIENT_ATTACK_ED_CMD, new State<G_GAME_STATE::GIRL_ATTACK_ED_STATE>);
		builder.Add_State(TO_CLIENT_FIRE_MAGIC_ING_CMD, new State<G_GAME_STATE::GIRL_SWORD_FIRE_MAGIC_ING_STATE>);
		builder.Add_State(TO_CLIENT_FIRE_MAGIC_ED_CMD, new State<G_GAME_STATE::GIRL_SWORD_FIRE_MAGIC_ED_STATE>);
		builder.Update_NPC();
	}
};

#pragma once 
#include "G_DEFINE.h"
#include "NPC.h"

class NPC;

class CMD_Interface
{
public:
	virtual ~CMD_Interface(){}
	virtual void Execute(NPC* _pNPC) = 0;
	const int CMD_ID;
protected:
	CMD_Interface(int _CMD_ID):CMD_ID(_CMD_ID){}
};

template<int v>  
class CMD: public CMD_Interface
{  
public:
	CMD():CMD_Interface(-1){}
	virtual void Execute(NPC* _pNPC){ cout<<"未定义指令: "<<CMD_ID<<endl; }  
};

//死亡指令
template<>  
class CMD<G_TO_CLIENT_CMD::TO_CLIENT_DIE_ING_CMD>: public CMD_Interface
{  
public:
	CMD():CMD_Interface(G_TO_CLIENT_CMD::TO_CLIENT_DIE_ING_CMD){}
	~CMD();
	virtual void Execute(NPC* _pNPC);
}; 

//移动指令
template<>  
class CMD<G_TO_CLIENT_CMD::TO_CLIENT_MOVE_ING_CMD>: public CMD_Interface
{  
public:
	CMD():CMD_Interface(G_TO_CLIENT_CMD::TO_CLIENT_MOVE_ING_CMD){}
	virtual void Execute(NPC* _pNPC);
}; 

//攻击指令
template<>  
class CMD<G_TO_CLIENT_CMD::TO_CLIENT_ATTACK_ING_CMD>: public CMD_Interface
{  
public:
	CMD():CMD_Interface(G_TO_CLIENT_CMD::TO_CLIENT_ATTACK_ING_CMD){}
	virtual void Execute(NPC* _pNPC);
}; 
template<>  
class CMD<G_TO_CLIENT_CMD::TO_CLIENT_ATTACK_ED_CMD>: public CMD_Interface
{  
public:
	CMD():CMD_Interface(G_TO_CLIENT_CMD::TO_CLIENT_ATTACK_ED_CMD){}
	virtual void Execute(NPC* _pNPC);
}; 


//火焰术指令
template<>  
class CMD<G_TO_CLIENT_CMD::TO_CLIENT_FIRE_MAGIC_ING_CMD>: public CMD_Interface
{  
public: 
	CMD():CMD_Interface(G_TO_CLIENT_CMD::TO_CLIENT_FIRE_MAGIC_ING_CMD){}
	virtual void Execute(NPC* _pNPC);
}; 
template<>  
class CMD<G_TO_CLIENT_CMD::TO_CLIENT_FIRE_MAGIC_ED_CMD>: public CMD_Interface
{  
public: 
	CMD():CMD_Interface(G_TO_CLIENT_CMD::TO_CLIENT_FIRE_MAGIC_ED_CMD){}
	virtual void Execute(NPC* _pNPC);
}; 

#include "CMD.h"
#include <iostream>



using namespace std;

//死亡指令
CMD<G_TO_CLIENT_CMD::TO_CLIENT_DIE_ING_CMD>::~CMD()
{
	//cout<<"死亡指令指令进行析构!"<<endl;
}
void CMD<G_TO_CLIENT_CMD::TO_CLIENT_DIE_ING_CMD>::Execute(NPC* _pNPC)
{
	_pNPC->m_pCurState = _pNPC->m_dStateSet[this->CMD_ID];
}


//移动指令
void CMD<G_TO_CLIENT_CMD::TO_CLIENT_MOVE_ING_CMD>::Execute(NPC* _pNPC)
{
	_pNPC->m_pCurState = _pNPC->m_dStateSet[this->CMD_ID];
}

//攻击指令
void CMD<G_TO_CLIENT_CMD::TO_CLIENT_ATTACK_ING_CMD>::Execute(NPC* _pNPC)
{
	_pNPC->m_pCurState = _pNPC->m_dStateSet[this->CMD_ID];
}
void CMD<G_TO_CLIENT_CMD::TO_CLIENT_ATTACK_ED_CMD>::Execute(NPC* _pNPC)
{
	_pNPC->m_pCurState = _pNPC->m_dStateSet[this->CMD_ID];
}

//火焰术指令
void CMD<G_TO_CLIENT_CMD::TO_CLIENT_FIRE_MAGIC_ING_CMD>::Execute(NPC* _pNPC)
{
	_pNPC->m_pCurState = _pNPC->m_dStateSet[this->CMD_ID];
}
void CMD<G_TO_CLIENT_CMD::TO_CLIENT_FIRE_MAGIC_ED_CMD>::Execute(NPC* _pNPC)
{
	_pNPC->m_pCurState = _pNPC->m_dStateSet[this->CMD_ID];
}