游戏的基础结构。

原创 2004年09月25日 14:34:00
就像修房子一样,别管你用多贵的砖头,它只是一块砖头而已,并不是你想要的房子。砖头可以在开发的时候随时换,但是结构一旦定下来,就不好修改了。

那么一个基本,却又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之类的,都可以慢慢考虑了。

游戏的基础结构

就像修房子一样,别管你用多贵的砖头,它只是一块砖头而已,并不是你想要的房子。砖头可以在开发的时候随时换,但是结构一旦定下来,就不好修改了。 那么一个基本,却又efficient的结构究竟是什么样的呢?...
  • Garfield
  • Garfield
  • 2005年02月07日 02:28
  • 1070

游戏中数值部分的典型结构

游戏中有大量的 需要一些数值来控制的地方:hdr强度, 屏幕亮度, fog 的near 和far;对于这些小东西, 一般程序员即可调整,但是数量大起来之后,而且游戏品质要求高了,就需要让美工来调整最好...
  • ccanan
  • ccanan
  • 2007年05月19日 20:29
  • 1274

Windows Server2008、2012安装RAC报 [INS-20802]网格基础结构配置失败

之前有客户要求,在windows server2012上要求安装Oracle 11gR2 RAC,所以在自己的虚拟机上进行了测试。win 2012没有安装成功,使用2008报同样的错,如图 ...
  • u010587433
  • u010587433
  • 2014年12月29日 09:15
  • 4611

HTML页面基本结构

本文简要介绍HTML中的各种元素及其相关属性,读者需要有一个概念: HTML页面都是由基本元素及属性组成的。...
  • renfufei
  • renfufei
  • 2017年09月11日 09:52
  • 966

HTML5游戏制作之路_02_剖析项目目录结构&&在浏览器中输出helloworld

/* 上一篇:h5游戏制作之路1 声明: 使用的egret游戏引擎版本为2.5. 编辑器用的webstrom */ 复习一下新建一个工程: 1.打开node.js的cmd 2....
  • qq_23156791
  • qq_23156791
  • 2015年11月19日 00:33
  • 666

游戏平台网站系统架构 账号篇

游戏平台,这里指的是运营多款游戏的用户平台,类似腾讯,盛大。 游戏平台要维护多处账号登录:网站登录,游戏登录,应用登录,等等 所以这要求账号的统一。   通常的作法是每个游戏都有自己的账号库,各自维护...
  • cwqcwk1
  • cwqcwk1
  • 2013年08月19日 00:12
  • 3514

WCF之“有零个应用程序(非基础结构)终结点

前言               最近又要准备面试了,回头复习了一下WCF的内容,照着视频敲了一个例子,例子很简单,当我启动的时候,却不料出错了。给我来了个错手不及。                ...
  • u013044029
  • u013044029
  • 2016年07月04日 21:11
  • 1894

java小游戏基础设计参考代码

package thread;import java.awt.*;import java.awt.event.*;import javax.swing.*;public class ShootGame...
  • SHAHAIZI1101_JT
  • SHAHAIZI1101_JT
  • 2007年12月14日 17:06
  • 1036

HTML基本组成

1、DOCTYPE在页面中,用来指定页面所使用的HTML的版本。要想制作符合标准的页面,一个必不可少的关键组成部分就是DOCTYPE声明。 声明必须是 HTML 文档的第一行,位于 标签之前。...
  • Jackie_bupt
  • Jackie_bupt
  • 2017年06月09日 10:26
  • 480

《C++游戏与图形编程基础》第2版

部署链接: AGK__Windows__Create__Projects__Help常见问题vs2010设置lib/dll包含目录 VS中添加LIb库及头文件(外部依赖项)的步骤 在VS工程...
  • u011017860
  • u011017860
  • 2016年12月29日 12:47
  • 768
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:游戏的基础结构。
举报原因:
原因补充:

(最多只允许输入30个字)