引擎雏形

就像修房子一样，别管你用多贵的砖头，它只是一块砖头而已，并不是你想要的房子。砖头可以在开发的时候随时换，但是结构一旦定下来，就不好修改了。
那么一个基本，却又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[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之类的，都可以慢慢考虑了。