游戏的基础结构

就像修房子一样，别管你用多贵的砖头，它只是一块砖头而已，并不是你想要的房子。砖头可以在开发的时候随时换，但是结构一旦定下来，就不好修改了。

那么一个基本，却又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 <stdio.h>
#include <assert.h>

template <class T>
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<class T>
CMemoryMag<T>::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<class T>
CMemoryMag<T>::~CMemoryMag()
{
delete [] m_data;
delete [] m_freed;
}

template<class T>
T *CMemoryMag<T>::GetNew()
{
if(!m_freedSize)
{
if(m_curSize < m_maxSize)
return &m_data[m_curSize++];

return NULL;
}

return &m_data[m_freed[--m_freedSize]];
}

template<class T>
int CMemoryMag<T>::Free(T *var)
{
int i,j;
int found = 0;

for(j=0; j<m_freedSize; j++)
if(&m_data[m_freed[j]] == var) found = 1;

if(found) return 0;

for(i=0; i<m_curSize; i++)
{
if(&m_data[i] == var)
{
found = i;
break;
}
}

if(!found) return 0;

if(found != (m_curSize - 1))
{
m_freed[m_freedSize++] = found;
return 1;
}

m_curSize --;
return 1;
}

#endif
==================================================
//然后你需要一个hash表
//hasher.h
#ifndef __HASHER_H__
#define __HASHER_H__

#include "MemoryMag.h"

class CHasher
{
public:
CHasher(int size);
~CHasher();

int Enter(const char *pStr, void *node);
int Remove(const char *pStr);
void *Find(const char *pStr);

private:

int GetHash(const char *pStr);

typedef struct hashNode
{
char *name;
void *ptr;
struct hashNode *next;
} HASHNODE;

CMemoryMag<HASHNODE> *m_hashArr;
HASHNODE **m_hashTable;
int m_h;
int m_objTable;
int m_size;
};

#endif
==================================================
//hasher.cpp
#include "Hasher.h"
#include <string>

static int T[] =
{
1, 87, 49, 12, 176, 178, 102, 166, 121, 193, 6, 84, 249, 230, 44, 163,
14, 197, 213, 181, 161, 85, 218, 80, 64, 239, 24, 226, 236, 142, 38, 200,
110, 177, 104, 103, 141, 253, 255, 50, 77, 101, 81, 18, 45, 96, 31, 222,
25, 107, 190, 70, 86, 237, 240, 34, 72, 242, 20, 214, 244, 227, 149, 235,
97, 234, 57, 22, 60, 250, 82, 175, 208, 5, 127, 199, 111, 62, 135, 248,
174, 169, 211, 58, 66, 154, 106, 195, 245, 171, 17, 187, 182, 179, 0, 243,
132, 56, 148, 75, 128, 133, 158, 100, 130, 126, 91, 13, 153, 246, 216, 219,
119, 68, 223, 78, 83, 88, 201, 99, 122, 11, 92, 32, 136, 114, 52, 10,
138, 30, 48, 183, 156, 35, 61, 26, 143, 74, 251, 94, 129, 162, 63, 152,
170, 7, 115, 167, 241, 206, 3, 150, 55, 59, 151, 220, 90, 53, 23, 131,
125, 173, 15, 238, 79, 95, 89, 16, 105, 137, 225, 224, 217, 160, 37, 123,
118, 73, 2, 157, 46, 116, 9, 145, 134, 228, 207, 212, 202, 215, 69, 229,
27, 188, 67, 124, 168, 252, 42, 4, 29, 108, 21, 247, 19, 205, 39, 203,
233, 40, 186, 147, 198, 192, 155, 33, 164, 191, 98, 204, 165, 180, 117, 76,
140, 36, 210, 172, 41, 54, 159, 8, 185, 232, 113, 196, 231, 47, 146, 120,
51, 65, 28, 144, 254, 221, 93, 189, 194, 139, 112, 43, 71, 109, 184, 209,
};

int hashstr(const char * s, int maxn)
{
register unsigned char oh, h;
register unsigned char *p;
register int i;

if (!*s) return 0;
p = (unsigned char *) s;
oh = T[*p];
h = (*(p++) + 1) & 0xff;

for (i = maxn - 1; *p && --i >= 0; ) {
oh = T[oh ^ *p];
h = T[h ^ *(p++)];
}

return (oh << 8) + h;
}

inline int CHasher::GetHash(const char *pStr)
{
return hashstr(pStr, 16) & m_objTable;
}

CHasher::CHasher(int size) :
m_hashArr(NULL),
m_size(size)
{
int realSize;

for (realSize = 1; realSize < size; realSize *= 2);

m_objTable = realSize - 1;

m_hashArr = new CMemoryMag<HASHNODE>(realSize);
m_hashTable = new HASHNODE*[size];
}

CHasher::~CHasher()
{
delete m_hashArr;
while(m_size --)
{
HASHNODE *next = m_hashTable[m_size];
while(next)
{
if(next->name != NULL)
{
delete [] next->name;
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
;

newNode->ptr = node;
newNode->name = GetNewStr(pStr);
newNode->next = m_hashTable
;
m_hashTable
= newNode;
return 1;
}

void *CHasher::Find(const char *pStr)
{
int n = GetHash(pStr);
HASHNODE *node = m_hashTable
;
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之类的，都可以慢慢考虑了。