一个失败的设计。 搭建初步框架后, 发现采用模板偏特化的方式, 虽然扩展新类更方便灵活了,但是在面对执行期的问题时,转换执行期的变量为类真的是一个大问题。。。
#pragma once
enum G_TO_CLIENT_CMD
{
//死亡指令
TO_CLIENT_DIE_ING_CMD = 1,
//移动指令
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,
};
enum G_GAME_STATE
{
//女剑士 -------------------------------
//女剑士_死亡态
GIRL_SWORD_DIE_ING_STATE = 0,
//女剑士_移动态
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,
};
#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();
};
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;
void NPCSetManager::RunNPC()
{
for(int i=0; i<g_NPCSet.size(); i++)
{
g_NPCSet[i]->RecvCmd(CMD<G_TO_CLIENT_CMD::TO_CLIENT_DIE_ING_CMD>());
g_NPCSet[i]->Run();
}
}
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
class Fire_Magic_State
{
};
#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];
}
#include <iostream>
#include "CMD.h"
#include "Girl_Sword_NPC.h"
#include "NPCBuilder.h"
using namespace std;
void main()
{
Girl_Sword_NPC buildGirl;
buildGirl.Create_Girl_Sword_NPC();
do
{
NPCSetManager::RunNPC();
} while (NPCSetManager.g_NPCSet.size() > 0);
NPCSetManager::Clear();
system("pause");
}