一个接口需要统一的派生接口，这样做的好处在于能够统一的进行管理。我所知的脚本语言中，接口有多重接口，也还有所谓的虚基类，这些都是方便类的管理。在vengine（微引擎）中，统一的的接口管理为kernel模块，类的管理采取了节点管理的模式，就是所有类对象使用一个实例进行管理。那么什么是节点，什么是树？这里的核心就相当于树，所有子类都是树中的一个节点。这种做法已经成为了一种模式，如果大家想要深入了解的话可以去查询一些相关的资料，我在这里也没有必要再强调这个模式了。接下来我们看看，所有模块的基类以及管理节点是如何实现的。
CODE
模块kernel 文件base.h
/**
* PAP Engine ( -- )
* $Id config.h
* @link -- for the canonical source repository
* @copyright Copyright (c) 2013-2014 viticm( viticm@126.com )
* @license
* @user viticm<viticm@126.com/viticm.ti@gmail.com>
* @date 2014-3-12 11:15:08
* @uses the vengine kernel base class
*/
#ifndef PAP_VENGINE_KERNEL_BASE_H_
#define PAP_VENGINE_KERNEL_BASE_H_
#include "vengine/config.h"
#include "vengine/kernel/node.h" //插件必须导出一个名为DllMagicCode的U32整数,
//值等于 VENGINE_DLL_MAGIC_CODE|VENGINE_KERNEL_VERSION
#define VENGINE_DLL_MAGIC_CODE (static_cast<uint32_t>(0XC0DE0000)) namespace vengine_kernel { //for plugin
typedef void (__stdcall* function_dllinit)(void*);
typedef void (__stdcall* function_dllrelease)(void); class VENGINE_API Base { public:
Base();
virtual ~Base(); public:
//某个类注册到全局类检索表函数
void registerclass(class_t* newclass);
//检查两个类是否具有继承关系
bool isinheritance(const class_t* thisclass, const class_t* baseclass) const;
//根据类名获得定义类
class_t* getclass(const char* name); //node operator
public:
virtual Node* newnode(const char* classname,
const char* position,
const char* nodename);
virtual Node* newnode(const char* classname,
Node* parentnode,
const char* nodename);
//get node by node name, sample: getnode("bin\\data")
virtual Node* getnode(const char* name); //plugin
public:
bool loadplugin(const char* name, void* param);
void shutdown(); //kernel close public:
static Base* getself();
static void* get_userdata();
static void set_userdata(void* data); protected:
static Base* self_;
static void* userdata_;
std::map<STRING, class_t*> classmap_; //is a map not a list
class_t* firstclass_inmap_;
Node noderoot_; protected:
struct plugininfo_t {
HMODULE hmodule;
STRING pluginfile;
function_dllinit dllinit_pointer;
function_dllrelease dllrelease_pointer;
};
void free_allplugin();
std::vector<plugininfo_t> pluginlist_; //all plugin in a vector
}; }; //namespace vengine_kernel
#endif //PAP_VENGINE_KERNEL_BASE_H_
模块kernel 文件class.h
/**
* PAP Engine ( -- )
* $Id class.h
* @link -- for the canonical source repository
* @copyright Copyright (c) 2013-2014 viticm( viticm@126.com )
* @license
* @user viticm<viticm@126.com/viticm.ti@gmail.com>
* @date 2014-3-17 16:28:41
* @uses vengine kernel class module
*/
#ifndef VENGINE_KERNEL_CLASS_H_
#define VENGINE_KERNEL_CLASS_H_ #include "vengine/config.h"
#include "vengine/exception/base.h" namespace vengine_kernel { class Node; struct VENGINE_API class_t {
const char* name; //class name
int32_t objectsize; //class size
Node* (__stdcall* newobject_pointer)(); //函数指针，用于生成一个Node类实例
class_t* baseclass; //基类
class_t* nextclass; //下一个类
Node* newobject(const char* name); //生成对象方法
}; }; //namespace vengine_kernel //variableflag 为命名空间准备的变量标识，
//如name1::name2::class1 则此值在函数中为name1_name2_class1
//如果不是命名空间直接填写类名即可 //据类名取得定义类
#define VENGINE_KERNEL_GETCLASS(classname, variableflag) (&classname::class_##variableflag##_) //定义声明宏
#define VENGINE_KERNEL_DECLARE_DYNAMIC(variableflag) \
public: \
static vengine_kernel::class_t class_##variableflag##_; \
virtual const vengine_kernel::class_t* getclass() const; \
static vengine_kernel::Node* __stdcall newobject(); //定义实现宏
#define VENGINE_KERNEL_IMPLEMENT_DYNAMIC(classname, baseclass, variableflag) \
static char name_##variableflag[] = #classname; \
vengine_kernel::class_t classname::class_##variableflag##_ = { \
name_##variableflag, sizeof(classname), classname::newobject, baseclass, NULL \
}; \
const vengine_kernel::class_t* classname::getclass() const { \
return &classname::class_##variableflag##_; \
}; \
vengine_kernel::Node* classname::newobject() { \
return new classname; \
} //纯虚类类定义实现宏
#define VENGINE_KERNEL_IMPLEMENT_VIRTUAL_DYNAMIC(classname, baseclass, variableflag) \
static char name_##variableflag[] = #classname; \
vengine_kernel::class_t classname::class_##variableflag##_ = { \
name_##variableflag, sizeof(classname), classname::newobject, baseclass, NULL \
}; \
const vengine_kernel::class_t* classname::getclass() const { \
return &classname::class_##variableflag##_; \
}; \
vengine_kernel::Node* classname::newobject() { \
VENGINE_SHOW("pure a virtual class"); \
return NULL; \
} #define VENGINE_KERNEL_DECLARE_LOGICAL(havelogical) \
public: \
virtual inline bool is_havelogical() { return havelogical; } #endif //VENGINE_KERNEL_CLASS_H_
模块kernel 文件node.h
/**
* PAP Engine ( -- )
* $Id node.h
* @link -- for the canonical source repository
* @copyright Copyright (c) 2013-2014 viticm( viticm@126.com )
* @license
* @user viticm<viticm@126.com/viticm.ti@gmail.com>
* @date 2014-3-12 11:15:08
* @uses vengine kernel node class module
*/
#ifndef VENGINE_KERNEL_NODE_H_
#define VENGINE_KERNEL_NODE_H_ #include "vengine/config.h"
#include "vengine/kernel/class.h" namespace vengine_kernel { class VENGINE_API Node {
public:
Node();
Node(const char* name);
virtual ~Node();
//返回子节点数目
int32_t get_childnumber() const;
//获得子节点名称
virtual const STRING& getname() const;
//获得子节点列表
virtual std::list<Node*>& get_childlist();
//返回父节点
virtual Node* getparent() const;
//初始化节点
virtual void init(void*) {}; //空指针，子类可以用这个继承这个指针初始化
//逻辑轮循环
virtual void tick(); public:
//查找子节点,如果没有找到,返回NULL
virtual Node* lookup_child(const char* name);
//添加子节点
virtual void addchild(Node* node);
//删除子节点，如果该子节点存在则返回true,否则为false
virtual bool removechild(Node* node);
//删除所有子节点
virtual void remove_allchild();
//释放资源
virtual void release(); VENGINE_KERNEL_DECLARE_DYNAMIC(vengine_kernel_Node); //类节点自动定义实现 protected:
typedef std::list<Node*> childlist;
STRING name_; //节点名
childlist childlist_; //子节点列表
Node* parent_; //父节点指针
friend struct class_t; }; }; //namespace vengine_kernel #endif //VENGINE_KERNEL_NODE_H_
总结
其实如果一个代码有足够的注释，则不必过多的解释，否则会造成读者的困惑。不过这里面需要注意的是，几个实现的宏VENGINE_KERNEL_*，希望大家仔细去理解一下它实现的原理。这里的核心实现也是依赖于此宏来实现，如果你将这些宏弄清楚了则核心模块的原理也就掌握了。下一节讲的是客户端的游戏模块，是提供给游戏实现的基础接口，比较多，同时希望大家不会错过。