就像修房子一样，别管你用多贵的砖头，它只是一块砖头而已，并不是你想要的房子。砖头可以在开发的时候随时换，但是结构一旦定下来，就不好修改了。
那么一个基本，却又efficient的结构究竟是什么样的呢？很简单。所有你所需要的就是引擎，无限状态机和内存池。这三个东西一点都不复杂，你可以从头开始写：
首先是你的引擎类，需要些什么呢？
class CEngine
{
public:
CEngine();
~CEngine();
int Initialize();
int Start();
int Restart();
int Pause();
int Shutdown();
int AddModule(CModuleBase *newModule, int moduleID, int updateFrequency);
int RemoveModule(int moduleID);
};
这就是一个引擎需要具备的基本功能，不要管图形，也不要管网络，什么都不要管。只是负责加入一个模块，加入的模块在指定的时间内刷新。这样网络也好，图形也好，人工智能也好，都是以模块的形式在初试化的时候加入到引擎的刷新列表里面。
那么无限状态机又是什么呢，无限状态机就是一个给你储存状态的库，不过可以储存所有你想要的状态。比如你在刷新网络的时候，接收到新的玩家的坐标，那么就需要把坐标的值修改，那么坐标的值放在哪呢？无限状态机里面，在网络模块更新的时候，只需要写Set("坐标", &myCurPos);然后在图形模块更新的时候，只需要写myCurPos = Get("坐标")。那么myCurPos的值存放在什么地方呢？就是存放在内存池里面。内存池在游戏初始化的时候被创建，在游戏结束的时候销毁，提供游戏中所有数据的存放，而无限状态机则是提供字符串到数据指针的映射。
下面就来看看无限状态机的实现：
首先你需要一个内存池：
// MemoryMag.h
#ifndef __MEMORY_MAG_H__
#define __MEMORY_MAG_H__
#include
#include
template
class CMemoryMag
{
public:
CMemoryMag(int size);
~CMemoryMag();
T *GetNew();
int Free(T *var);
private:
T *m_data;
int *m_freed;
int m_freedSize;
int m_maxSize;
int m_curSize;
};
template
CMemoryMag::CMemoryMag(int size) :
m_maxSize(size),
m_curSize(0),
m_freedSize(0)
{
m_data = new T[size];
assert(m_data != NULL);
m_freed = new int[size];
assert(m_freed != NULL);
}
template
CMemoryMag::~CMemoryMag()
{
delete [] m_data;
delete [] m_freed;
}
template
T *CMemoryMag::GetNew()
{
if(!m_freedSize)
{
if(m_curSize < m_maxSize)
return &m_data[m_curSize++];
return NULL;
}
return &m_data[m_freed[--m_freedSize]];
}
template
int CMemoryMag::Free(T *var)
{
int i,j;
int found = 0;
for(j=0; jname;
next->name = NULL;
}
next = next->next;
}
}
delete []m_hashTable;
}
char *GetNewStr(const char *pStr)
{
int len(strlen(pStr));
if(len >= 0)
{
char *p = new char[len];
assert(p != NULL);
memcpy(p, pStr, len);
return p;
}
return NULL;
}
int CHasher::Enter(const char *pStr, void *node)
{
HASHNODE *newNode = m_hashArr->GetNew();
int n = GetHash(pStr);
newNode->next = m_hashTable[n];
newNode->ptr = node;
newNode->name = GetNewStr(pStr);
newNode->next = m_hashTable[n];
m_hashTable[n] = newNode;
return 1;
}
void *CHasher::Find(const char *pStr)
{
int n = GetHash(pStr);
HASHNODE *node = m_hashTable[n];
while(node)
{
if(!strcmp(node->name, pStr)) return node->ptr;
node = node->next;
}
return NULL;
}
int CHasher::Remove(const char *pStr)
{
HASHNODE *prev, *curr;
m_h = GetHash(pStr);
curr = m_hashTable[m_h];
prev = 0;
while (curr) {
if (!strcmp(curr->name, pStr))
{
if (prev) prev->next = curr->next;
delete [] curr->name;
curr->name = NULL;
m_hashArr->Free(curr);
return 1;
}
prev = curr;
curr = curr->next;
}
return 0;
}
//然后看看FSM（Finite Status Machine）
//fsm.h
// Finite State Machine
#ifndef __MYFSM_H__
#define __MYFSM_H__
#define FSM_D (CFiniteStateMachine::GetInstance())
#define MAX_VARIABLE_NUM 512
#include "Hasher.h"
class CFiniteStateMachine
{
public:
CFiniteStateMachine();
~CFiniteStateMachine();
static CFiniteStateMachine *GetInstance();
int Set(const char *varName, void *varvalue);
void* Get(const char *varName);
private:
CHasher m_hasher;
static CFiniteStateMachine *m_myInstance;
};
#endif
================================================
//以及FSM的实现
#include "FSM.h"
CFiniteStateMachine *CFiniteStateMachine::m_myInstance = NULL;
CFiniteStateMachine *CFiniteStateMachine::GetInstance()
{
if(m_myInstance == NULL)
{
m_myInstance = new CFiniteStateMachine();
return m_myInstance;
}
return m_myInstance;
}
CFiniteStateMachine::CFiniteStateMachine() :
m_hasher(MAX_VARIABLE_NUM)
{
}
CFiniteStateMachine::~CFiniteStateMachine()
{
}
int CFiniteStateMachine::Set(const char *varName, void *varvalue)
{
if(m_hasher.Find(varName) != NULL)
{
m_hasher.Remove(varName);
return m_hasher.Enter(varName, varvalue);
}
return m_hasher.Enter(varName, varvalue);
}
void* CFiniteStateMachine::Get(const char *varName)
{
void *var;
if((var = m_hasher.Find(varName)) != NULL) return var;
return NULL;
}
==================================================
至此，一个简单的游戏引擎部分就已经基本完成了，剩下的事就是看看你的这个是客户端还是服务器，需要图形模块或者网络模块，或者NPC之类的，都可以慢慢考虑了。
|
|手机版|小黑屋|九艺游戏动画论坛
( 津ICP备2022000452号-1 )