colorful

1、 游戏世界由很多个游戏对象组成（游戏角色、物品、NPC、技能等）；

2、 一个游戏对象的有效数据主要存放在客户端、游戏服务器和持久性数据库中；

3、 游戏对象的处理可划分为与位置有关的和与位置无关的，如公会处理、物品处理等主要行为可以看作是与位置无关的处理，而NPC（AI）、战斗、移动这类的主要行为可以看成是与位置有关的。

4、 从客户端的角度来看，游戏行为可分为四类动作：

a)         来自服务器端的动作，如另外一个玩家跳起来。

b)        本地动作。仅仅发生在本地客户端的动作，不需要与服务器端或其他客户端通讯。

c)         先执行后验证的可撤销的动作。客户端先执行，再提交服务器端验证，验证不成功通知客户端将执行的动作撤销。比如玩家控制的游戏角色执行移动处理。

d)        严格服务器端验证的动作。客户端执行动作前必须经过服务器端验证后才能执行。如交易行为、攻击其他玩家/NPC。

5、 客户端和服务器，服务器进程之间的相互的通信从逻辑上看就是就是向RemoteObject 发起的远程过程调用（RPC），RPC主要有两种类型：

a)         通知(Notify)。只通知对方，而不关心和需要对方返回结果。

b)        请求(Request)。向对方发起请求，对方处理请求后返回结果，发起请求和返回结果这个过程可以是同步或异步。游戏服务器中绝大部分RPC请求都是异步的。

6、 响应延迟主要是由于网络带宽和服务器处理效率引起的。应尽可能的通过一些技巧来隐藏和减少玩家的响应延迟。但不是所有的最新消息都能立刻发送出去（或接收处理到），因此，要在服务器端采用优先队列来减少重要消息的响应时间。延迟也会由客户端产生，如收到消息后的对消息的处理速度。

7、 服务器负载，除了升级硬件设备外，可以通过一些方式来提高服务器负载。

a)         保证足够的网络带宽。

b)        分布式运算，合理的集群式架构。

c)         游戏策划从游戏内容上避免设计高并发，高消耗的游戏行为。

8、 从服务器的可伸缩性，稳定性和高效率方面来考虑，要试着避免所有事情都在一个地方处理，尽量让系统分布式运行，但是过多的划分功能到不同的进程/机器上运行，又会带来数据的大量同步的问题。因此可以将游戏对象的处理主要划分为与位置无关和有关两种。像公会，玩家信息，物品信息，组队，拍卖等等这类与位置无关的但是占用CPU资源较少的处理可以尽可能的放在一个进程中，避免进程间对象同步，而像NPC，寻路，AOI运算，战斗处理等与位置有关的，处理过程中特别关心对象坐标位置的、运算量特别大的，但是进程间对象同步较少的，都可以单独划分成多个进程。

每类进程服务的功能尽量单一。负责路由的就尽量只负责网络包转发，而不再承担其他繁重的任务，负责游戏处理的就尽量让网络包流向简单。

1、是Header Plus Plus 的简写。

2、与*.h类似，hpp是C++程序头文件 。

3、是VCL 专用的头文件,已预编译。

4、是一般模板类的头文件。

5、一般来说，*.h里面只有声明，没有实现，而*.hpp里声明实现都有，后者可以减 少.cpp的数量。

6、*.h里面可以有using namespace std，而*.hpp里则无。

7、*.hpp要注意的问题有：

      a)不可包含全局对象和全局函数

     由于hpp本质上是作为.h被调用者include，所以当hpp文件中存在全局对象或者全局函数，而该hpp被多个

    调用者include时，将在链接时导致符号重定义错误。要避免这种情况，需要去除全局对象，将全局函数封

    装为类的静态方法。

      b)类之间不可循环调用

      在.h和.cpp的场景中，当两个类或者多个类之间有循环调用关系时，只要预先在头文件做被调用类的声明

    即可，如下：

    class B;

    class A{

    public:

         void someMethod(B b);

    };

    class B{

    public:

         void someMethod(A a);

    };

    在hpp场景中，由于定义与实现都已经存在于一个文件，调用者必需明确知道被调用者的所有定义，而不能等到cpp

    中去编译。因此hpp中必须整理类之间调用关系，不可产生循环调用。同理，对于当两个类A和B分别定义在各自的

    hpp文件中，形如以下的循环调用也将导致编译错误：

    //a.hpp

    #include "b.hpp"

    class A{

    public:

        void someMethod(B b);

    };

    //b.hpp

    #include "a.hpp"

    class B{

    public:

        void someMethod(A a);

    }

      c)不可使用静态成员

      静态成员的使用限制在于如果类含有静态成员，则在hpp中必需加入静态成员初始化代码，当该hpp被多个文档include时，将产生符号重定义错误。唯 一的例外是const static整型成员，因为在vs2003中，该类型允许在定义时初始化，如：

    class A{

     public:

       const static int intValue = 123;

     };

    由于静态成员的使用是很常见的场景，无法强制清除，因此可以考虑以下几种方式（以下示例均为同一类中方法）

   一、类中仅有一个静态成员时，且仅有一个调用者时，可以通过局域静态变量模拟

    //方法模拟获取静态成员

    someType getMember()

    {

       static someType value(xxx);//作用域内静态变量

       return value;

    }

   二、.类中有多个方法需要调用静态成员，而且可能存在多个静态成员时，可以将每个静态成员封装一个模拟方法，供其他方法调用。

    someType getMemberA()

    {

       static someType value(xxx);//作用域内静态变量

       return value;

    }

    someType getMemberB()

    {

       static someType value(xxx);//作用域内静态变量

       return value;

    }

   void accessMemberA()

    {

       someType member = getMemberA();//获取静态成员

     };

    //获取两个静态成员

    void accessStaticMember()

    {

       someType a = getMemberA();//获取静态成员

       someType b = getMemberB();

     };

    三、第二种方法对于大部分情况是通用的，但是当所需的静态成员过多时，编写封装方法的工作量将非常

    巨大，在此种情况下，建议使用Singleton模式，将被调用类定义成普通类，然后使用Singleton将其变为

   全局唯一的对象进行调用。

     如原h+cpp下的定义如下：

     class A{

     public:

        type getMember(){

           return member;

        }

        static type member;//静态成员

    }

    采用singleton方式，实现代码可能如下（singleton实现请自行查阅相关文档）

    //实际实现类

     class Aprovider{

     public:

        type getMember(){

           return member;

        }

       type member;//变为普通成员

    }

    //提供给调用者的接口类

     class A{

     public:

        type getMember(){

           return Singleton<AProvider>::getInstance()->getMember();

        }

    }

　　那么到底如何查找文件呢？我们需要一个结构体和几个大家可能不太熟悉的函数。这些函数和结构体在<io.h>的头文件中，结构体为 struct _finddata_t ，函数为_findfirst、_findnext和_fineclose.具体如何使用，我会慢慢讲来～

　　首先讲这个结构体吧～struct _finddata_t ，这个结构体是用来存储文件各种信息的。说实话，这个结构体的具体定义代码，我没有找到，不过还好，文档里面在_find里有比较详细的成员变量介绍。我基本上就把文档翻译过来讲吧：

　　unsigned atrrib：文件属性的存储位 置。它存储一个unsigned单元，用于表示文件的属性。文件属性是用位表示的，主要有以下一些：_A_ARCH（存档）、_A_HIDDEN（隐 藏）、_A_NORMAL（正常）、_A_RDONLY（只读）、_A_SUBDIR（文件夹）、_A_SYSTEM（系统）。这些都是 在<io.h>中定义的宏，可以直接使用，而本身的意义其实是一个无符号整型（只不过这个整型应该是2的几次幂，从而保证只有一位为1，而其 他位为0）。既然是位表示，那么当一个文件有多个属性时，它往往是通过位或的方式，来得到几个属性的综合。例如只读+隐藏+系统属性，应该 为：_A_HIDDEN | _A_RDONLY |_A_SYSTEM .

　　time_t time_create：这里的time_t是一个变量类型（长整型？相当于long int？），用来存储时间的，我们暂时不用理它，只要知道，这个time_create变量是用来存储文件创建时间的就可以了。

　　time_t time_access：文件最后一次被访问的时间。

　　time_t time_write：文件最后一次被修改的时间。

　　_fsize_t size：文件的大小。这里的_fsize_t应该可以相当于unsigned整型，表示文件的字节数。

　　char name[_MAX_FNAME]：文件的文件名。这里的_MAX_FNAME是一个常量宏，它在<stdlib.h>头文件中被定义，表示的是文件名的最大长度。

　　以此，我们可以推测出，struct_finddata_t ，大概的定义如下：

　　struct _finddata_t

　　{

　　unsigned attrib；

　　time_t time_create；

　　time_t time_access；

　　time_t time_write；

　　_fsize_t size；

　　char name[_MAX_FNAME]；

　　}；

　　前面也说了，这个结构体是用来存储文件信息的，那么如何把一个硬盘文件的文件信息“存到”这个结构体所表示的内存空间里去呢？这就要靠_findfirst、_findnext和_fineclose三个函数的搭配使用了。

　　首先还是对这三个函数一一介绍一番吧……

　　long _findfirst（ char *filespec， struct _finddata_t *fileinfo ）；

　　返回值：如果查找成功的话，将返回一个long型的唯一的查找用的句柄（就是一个唯一编号）。这个句柄将在_findnext函数中被使用。若失败，则返回-1.

　　参数：

　　filespec：标明文件的字符串，可支持通配符。比如：*.c，则表示当前文件夹下的所有后缀为C的文件。

　　fileinfo ：这里就是用来存放文件信息的结构体的指针。这个结构体必须在调用此函数前声明，不过不用初始化，只要分配了内存空间就可以了。函数成功后，函数会把找到的文件的信息放入这个结构体中。

　　int _findnext（ long handle， struct _finddata_t *fileinfo ）；

　　返回值：若成功返回0，否则返回-1.

　　参数：

　　handle：即由_findfirst函数返回回来的句柄。

　　fileinfo：文件信息结构体的指针。找到文件后，函数将该文件信息放入此结构体中。

　　int _findclose（ long handle ）；

　　返回值：成功返回0，失败返回-1.

　　参数：

　　handle ：_findfirst函数返回回来的句柄。

　　大家看到这里，估计都能猜到个大概了吧？先用_findfirst查找第一个文件，若成功则用返回的句柄调用_findnext函数查找其他的 文件，当查找完毕后用，用_findclose函数结束查找。恩，对，这就是正确思路。下面我们就按照这样的思路来编写一个查找C：\WINDOWS文件 夹下的所有exe可执行文件的程序。

　　#include <stdio.h>

　　#include <io.h>

　　const char *to_search="C：\\WINDOWS\\*.exe"；        //欲查找的文件，支持通配符

　　int main（）

　　{

　　long handle；                                               //用于查找的句柄

　　struct _finddata_t fileinfo；                          //文件信息的结构体

　　handle=_findfirst（to_search，&fileinfo）；         //第一次查找

　　if（-1==handle）return -1；

　　printf（"%s\n"，fileinfo.name）；                         //打印出找到的文件的文件名

　　while（！_findnext（handle，&fileinfo））               //循环查找其他符合的文件，知道找不到其他的为止

　　{

　　printf（"%s\n"，fileinfo.name）；

　　}

　　_findclose（handle）；                                      //别忘了关闭句柄

　　system（"pause"）；

　　return 0；

　　}

　　当然，这个文件的查找是在指定的路径中进行，如何遍历硬盘，在整个硬盘中查找文件呢？大家可以在网络上搜索文件递归遍历等方法，这里不再做进一步介绍。

　　细心的朋友可能会注意到我在程序的末尾用了一个system函数。这个与程序本身并没有影响，和以前介绍给大家的使用getchar（）函数的 作用相同，只是为了暂停一下，让我们能看到命令提示符上输出的结果而已。不过system函数本身是一个非常强大的函数。大家可以查查MSDN看看～简单 来说，它是一个C语言与操作系统的相互平台，可以在程序里通过这个函数，向操作系统传递command命令

int main()
{
     printf(STR(vck));            // 输出字符串"vck"
     printf("%d\n", CONS(2,3));   // 2e3 输出:2000
     return 0;
}

二、当宏参数是另一个宏的时候
需要注意的是凡宏定义里有用'#'或'##'的地方宏参数是不会再展开.

1, 非'#'和'##'的情况
#define TOW       (2)
#define MUL(a,b) (a*b)

printf("%d*%d=%d\n", TOW, TOW, MUL(TOW,TOW));
这行的宏会被展开为：
printf("%d*%d=%d\n", (2), (2), ((2)*(2)));
MUL里的参数TOW会被展开为(2).

2, 当有'#'或'##'的时候
#define A           (2)
#define STR(s)      #s
#define CONS(a,b)   int(a##e##b)

printf("int max: %s\n",   STR(INT_MAX));     // INT_MAX ＃i nclude<climits>
这行会被展开为：
printf("int max: %s\n", "INT_MAX");

printf("%s\n", CONS(A, A));                // compile error
这一行则是：
printf("%s\n", int(AeA));

INT_MAX和A都不会再被展开, 然而解决这个问题的方法很简单. 加多一层中间转换宏.
加这层宏的用意是把所有宏的参数在这层里全部展开, 那么在转换宏里的那一个宏(_STR)就能得到正确的宏参数.

#define A            (2)
#define _STR(s)      #s
#define STR(s)       _STR(s)           // 转换宏
#define _CONS(a,b)   int(a##e##b)
#define CONS(a,b)    _CONS(a,b)        // 转换宏

printf("int max: %s\n", STR(INT_MAX));           // INT_MAX,int型的最大值，为一个变量 ＃i nclude<climits>
输出为: int max: 0x7fffffff
STR(INT_MAX) -->   _STR(0x7fffffff) 然后再转换成字符串；

printf("%d\n", CONS(A, A));
输出为：200
CONS(A, A)   -->   _CONS((2), (2))   --> int((2)e(2))

三、'#'和'##'的一些应用特例
1、合并匿名变量名
#define   ___ANONYMOUS1(type, var, line)   type   var##line
#define   __ANONYMOUS0(type, line)   ___ANONYMOUS1(type, _anonymous, line)
#define   ANONYMOUS(type)   __ANONYMOUS0(type, __LINE__)
例：ANONYMOUS(static int);   即: static int _anonymous70;   70表示该行行号；
第一层：ANONYMOUS(static int);   -->   __ANONYMOUS0(static int, __LINE__);
第二层：                         -->   ___ANONYMOUS1(static int, _anonymous, 70);
第三层：                         -->   static int   _anonymous70;
即每次只能解开当前层的宏，所以__LINE__在第二层才能被解开；

2、填充结构
#define   FILL(a)    {a, #a}

enum IDD{OPEN, CLOSE};
typedef struct MSG{
   IDD id;
   const char * msg;
}MSG;

MSG _msg[] = {FILL(OPEN), FILL(CLOSE)};
相当于：
MSG _msg[] = {{OPEN, "OPEN"},
               {CLOSE, "CLOSE"}};

3、记录文件名
#define   _GET_FILE_NAME(f)    #f
#define   GET_FILE_NAME(f)     _GET_FILE_NAME(f)
static char   FILE_NAME[] = GET_FILE_NAME(__FILE__);

4、得到一个数值类型所对应的字符串缓冲大小
#define   _TYPE_BUF_SIZE(type)   sizeof #type
#define   TYPE_BUF_SIZE(type)    _TYPE_BUF_SIZE(type)
char   buf[TYPE_BUF_SIZE(INT_MAX)];
      -->   char   buf[_TYPE_BUF_SIZE(0x7fffffff)];
      -->   char   buf[sizeof "0x7fffffff"];
这里相当于：
char   buf[11];

//////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////

自定义事件实现步骤有如下几步：

1、定义自定义事件id

enum CustomEventId
{
    ENUM_CUSTOMEVENT_ID_Id1=7000,
    ENUM_CUSTOMEVENT_ID_Id2,
    ENUM_CUSTOMEVENT_ID_Id3
};

2、申明自定义事件(.h文件中)

BEGIN_DECLARE_EVENT_TYPES()
    DECLARE_EVENT_TYPE(ENUM_CUSTOMEVENT_NAME1, ENUM_CUSTOMEVENT_ID_Id1)
    DECLARE_EVENT_TYPE(ENUM_CUSTOMEVENT_NAME2, ENUM_CUSTOMEVENT_ID_Id2)
    DECLARE_EVENT_TYPE(ENUM_CUSTOMEVENT_NAME3, ENUM_CUSTOMEVENT_ID_Id3)
END_DECLARE_EVENT_TYPES()

3、定义自定义事件(.cpp文件中)

DEFINE_EVENT_TYPE(ENUM_CUSTOMEVENT_NAME1)
DEFINE_EVENT_TYPE(ENUM_CUSTOMEVENT_NAME2)
DEFINE_EVENT_TYPE(ENUM_CUSTOMEVENT_NAME3)

4、在BEGIN_EVENT_TABLE与END_EVENT_TABLE()添加事件映射

    EVT_COMMAND(wxID_ANY, ENUM_CUSTOMEVENT_NAME1, Frame::OnSetName1)
    EVT_COMMAND(wxID_ANY, ENUM_CUSTOMEVENT_NAME2, Frame::OnSetName2)
    EVT_COMMAND(wxID_ANY, ENUM_CUSTOMEVENT_NAME3, Frame::OnSetName3)

5、在Frame中，申明、实现OnSetName1、OnSetName2、OnSetName3

申明：

    void  OnSetName1(wxCommandEvent& event);

    void  OnSetName2(wxCommandEvent& event);

    void  OnSetName3(wxCommandEvent& event);

实现：代码就不在此列举

6、自定义事件调用

     wxCommandEvent eventCustom(ENUM_CUSTOMEVENT_NAME1);
     wxPostEvent(this->GetParent()->GetEventHandler(), eventCustom); //子窗口

    如果是当前窗口可以写成

   wxPostEvent(this->GetEventHandler(), eventCustom);