我们先看下构造函数的规则

构造函数调用规则

构造参数量: 0表示没有构造函数, 1表示有构造函数0个参数

普通函数重载规则

实际只用考虑最典型的一种行为: 实例化子类, 转为父类调用方法, 这个时候

如果方法是override, 调用的是子类

如果方法是virutal或者不指明, 调用的是父类

整个重载过程, 子类绝对不会隐式调用父类的行为

需要构造函数么?

构造函数的优点

• 本身属于一种特殊的成员函数
• 编译器帮你自动传导调用父级

构造函数的缺点

• 隐式的调用规则
• 虽然属于成员函数, 但是与其他成员函数调用规则完全不同, 需要特殊记忆
• 带参数的构造函数, 在父类参数多于子类时, 需要引用复杂语法来实现父级构造调用

其实我们对初始化函数的需求只有1条: 自定义

所以, 可以理解Golang不加入构造函数的设计是正确的 
即: 简单, 清晰, 有规律

生成好的协议报错找不到protobuf

在每个protoc-gen-lua生成的lua文件里, 都有一行

local protobuf = require "protobuf"

本身按照官方出的没问题, 但是在ulua的目录里, 总是报protobuf找不到的错误. 前后对比了下我生成的lua和ulua官方生成的代码里

发现居然他修改了地址改为了

local protobuf = require "protobuf/protobuf"

好吧, 只有修改生成器代码protoc-gen-lua\plugin\protoc-gen-lua中第412行改为

lua('local protobuf = require "protobuf/protobuf"\n')

生成消息无法找到Descriptor反射查信息

在LuaFramework\ToLua\Lua\protobuf\protobuf.lua的939行添加

message_meta._member.Descriptor = descriptor

在消息里就可以通过msg.Descriptor获得此消息的反射信息

由于proto文件定义的内容过多导致的lua local超过限制的警告

这个错误真是让我哭笑不得, protoc-gen-lua的可用性再一次被怀疑

我们的协议好歹分成了接近100个, 每个里面消息和数据是混合的, 更别说有些童鞋喜欢把一个项目的协议全写在一个文件里, 那生成的local数量简直是酸爽

后记

搜索protoc-gen-lua时, 无意间又搜到3年前自己的博文http://www.cppblog.com/sunicdavy/archive/2013/04/24/199693.html

记得那个时候准备在服务器使用lua, 还好没这么干, 转了go, 否则后果不堪设想

lua上使用pb其实并不容易, 云风的pbc写的不错, 但怕有坑, sproto直接不兼容现有项目, 风险大于易用性所以果断弃用

因此, 看来有必要自己写一个支持良好的lua pb库

            Action[] a = new Action[3];

            for (int i = 0; i < 3; i++)

            {

                a[i] = ( ) => { Console.WriteLine(i); };

            }

            for (int i = 0; i < 3; i++){

                a[i]();

            }

C#打印结果为3 3 3

Golang的例子

    a := make([]func(), 3 )

    for i := 0; i < 3; i++ {

        a[i]= func( ){

            fmt.Println(i)

        }    

    }

    for _, s := range a {

        s()

    }

Golang打印结果为3 3 3

最后是Lua的例子

a = {}

for i = 1, 3 do

    table.insert( a, function()

        print(i)

    end

    )

end

for _, v in ipairs(a) do

    v()

end

Lua打印结果为1 2 3

差异在于, C#和Golang将变量捕获到闭包内时, 均使用引用方式, 即当最后开始调用使用变量时, 由于变量已经结束循环, 所以是最终值

但是Lua捕获方式是值捕获, 因此比较容易理解, 是多少就是多少

在http://code.google.com/p/protobuf/下载protobuf-2.5版本

预备知识: 已经使用过protobuf, 熟练应用protobuf序列化在各语言间交互信息

目标: 获取proto内容而无需手动解析proto文件

为proto文件添加更多的meta信息, 并在运行期获取.

protoc编译器准备

通过protobuf-2.5的源码或者从官网下载, 可以获得protoc的protobuf编译器, 这个编译器由C++编写, 官方支持完整的protobuf特性. 编译器默认支持C++, python和java 三种语言的代码生成. 如需生成更多的语言, 可以通过官网的第三方页面获取.

protoc插件原理

但我们在日常使用中, 可能需要提取proto信息, 例如: 所有的枚举,消息等信息, 字段名称和导出号. 自己编写词法解析器来做是费力不讨好的. 官方推荐的方法是使用protoc外挂插件来实现.

protoc的插件设计比较独特, 不使用动态链接库或者java的jar包导入方式, 而是直接使用了命令行来交换数据.查看protobuf源码我们可以发现这样一个文件:

protobuf-2.5.0\src\google\protobuf\descriptor.proto

这个文件描述了一个proto文件的格式, 消息组成及枚举等完整信息. 这是一种自我描述的方法.

在找到这样一个文件

protobuf-2.5.0\src\google\protobuf\compiler\plugin.proto

这样一个文件描述: 插件如何与protoc进行交互的协议

protoc编译器在给定指定proto文件及搜索路径后, 将各种信息填充为descriptor.proto描述的结构后通过CodeGeneratorRequest消息系列化为二进制流后输出到命令行. 插件只用捕获protoc命令行输出的二进制流, 序列化化回CodeGeneratorRequest即可获得解析后的proto文件内容

这里需要注意的是: 插件可执行文件很有讲究, 必须为protoc-gen-$NAME,  而且输出文件名参数必须为--${NAME}_out

看一个栗子:

protoc.exe foo.proto --plugin=protoc-gen-go=..\tools\protoc-gen-go.exe --go_out foo.go --proto_path "."

这个栗子里: $NAME=go

protoc将foo.proto文件(搜索路径为当前路径)的内容通过命令行输出给位于..\tools\的插件protoc-gen-go.exe,  输出文件名字为 foo.go

descriptor.proto信息挖掘

我们注意到在descriptor.proto文件中包含有这样的一个message: SourceCodeInfo, 这个消息体里有如下字段

optional string leading_comments = 3;
    optional string trailing_comments = 4;

这两个字段对于我们获取proto文件的meta信息尤为重要, 所谓的meta信息, 理解理解为C#语言中的attribute

这个attribute功能可以为一个字段, 一个消息扩充一些描述. 比如: 当一个字段通过反射显示在gui上时, gui需要获取这个字段的中文描述

那么只需要如下编写

optional int32 somevalue = 1 //@ desc=”中文描述”

位于字段尾部的描述, 会被填充到SourceCodeInfo的 trailing_comments中, 而位于字段上方的字段, 会被填充到leading_comments中

SourceCodeInfo 并没有直接挂载在message或者字段的附近, 而是通过其下的path字段来描述与字段的关系, 这是个极为麻烦的设计.

其原理如下:

假设我有如下一个message

message foo

{

     optional int32 v = 1;  // comments

}

要获取v后的注释, 对应的path为 4, 0, 2, 0

4 表示descriptor中message_type所在的序号,由于message_type对应的类型DescriptorProto是一个数组, 所以0表示foo是在FileDescriptorProto的message_type数组类型的索引为0;

如此类推: 2, 0 表示 v在DescriptorProto结构体的field成员序号为2的数组元素的索引为0

如果需要更多的参考, 可以获取https://github.com/golang/protobuf

github.com\golang\protobuf\protoc-gen-go工程内有详细代码解析

Decoda

    这是现今地球上调试lua5.1最方便的工具, 没有之一. 强大的注入式调试, 性能极高.支持 挂接进程, 变量展开, 断点等各种日常所需.

早期的Decoda是收费工具, 因此质量非常高.

    Decoda现在已经停止开发并开源了, 调试lua5.2会crash. 源代码可以作为一种技术参考, 很多dll注入修改技术, 灰常牛X

LuaStudio

   比较优秀的调试工具(因为收费), 可以调试lua5.1/5.2, 界面属于vs2008类型, 土豪可以考虑买几套试试

ZeroBrane Studio

对lua5.1支持较好, 5.2也能调但偶尔还是会crash, 基于远程调试方式, 所以性能略低.

RemDebug

没有IDE, 纯命令行方式调试器, 但因为简单, 所以可以参考后写一个自己的程序内建调试器

Babe Lua

把这货放在最后是有原因的, 还记得那句老话: 老外一开源, 我们就有自主研发了, 对的, 这货一定是参考了Decoda的代码后搞出个vs的插件来, 虽然不收费, 但是不提下参考对象的行为还是值得批斗的. 这货在中文博客上说, 不支持挂接到进程(Decoda支持), 不支持64位调试(LuaStudio支持), 调试30~50次偶尔挂1到2次. 哎, 毕竟只是代码搬运工, 不生产代码.

这货装上, 能用, 调5.2是不行的, 5.1比Decoda方便点, 毕竟vs支持悬浮显示变量.

说了那么多, 其实对于lua5.2版本的调试, 还是没有免费的比较合适的方案, 如果实在想调试, 还是可以参考下RemDebug的原理及lua官方调试文档, 自己通过c api调用写一套适合自己的远程调试工具. 其实没有多复杂, 但总比不调试的好

由于要使用protoc-gen-lua, 这东西生成出来的lua依然使用官方的module/package机制. 对于游戏项目来说, 想进行一些自定义读取, 加密等, 就变得不可能. 幸好官方在扩展上支持的还是不错的.

参考lua5.2的官方文档http://www.lua.org/manual/5.2/manual.html#pdf-require

require时, lua会自动根据一定的搜索规律找到加载代码的方法. 这个方法定义在package.searchers这个数组中. 一共有4个加载搜索顺序

1. preload, 对已加载的module进行直接返回, 对应package.preload[modname]

2. lualoader, 对lua文件进行加载, 搜索路径为package.path

3. cloader, 对lua标准dll进行加载, 搜索路径为package.cpath

4. croot, 官方文档说的是all-in-one加载器, 感觉很神奇, 感兴趣可以自行参考源码

那么, 如果只需要自己的加载器, 只需要这样做:

  package.searchers[2] = function( name )
        print("try to load", name )
    end
    package.searchers[3] = nil
    package.searchers[4] = nil
    
    require "libtest"

1. 去掉了全局性质的setfenv/getfenv系列函数, 语言层面提供_ENV语法糖, 这东西跟:操作符一样, 只存在于编译期.

官方建议自己实现module/require/package机制, 毕竟原生这套机制实现太弱智了..

2. 提供了无符号访问函数

3. 更多的lua api变化. 如果想兼容lua5.1的写法, 可以参考luabridge内LuaHelpers.h的实现

以下是本人使用lua5.2实现的一套package机制, 供大家参考

package = {}

-- 读取标记

package.loaded = {}

-- 搜索路径数组

package.path = {}

package.access =

{

    ["string"] = string,

    ["print"] = print,

    ["table"] = table,

    ["assert"] = assert,

    ["error"] = error,

    ["pairs"] = pairs,

    ["ipairs"] = ipairs,

    ["tonumber"] = tonumber,

    ["tostring"] = tostring,

    ["type"] = type,

    ["math"] = math,

}

local function getreadablepath( name, pathlist )

    for _, path in ipairs(pathlist) do

        local fullpath = path .. "/" .. name .. ".lua"

        local f = io.open( fullpath )

        if f then

            f:close()

            return fullpath

        end

    end

    return nil

end

function package.import( name )

    -- 已经读取的直接返回

    local existedenv = package.loaded[name]

    if existedenv then

        return existedenv

    end

    local access = package.access

    -- 设置访问控制权限

    local meta = 

    {

        __index = function( tab, key )

            -- 优先取包的空间

            local v = rawget( tab, key )

            if v then

                return v

            end

            -- 找不到时,从可访问的权限表中查找

            return access[key]             

        end,

    }

    -- 初始化一个包的全局环境, 并设置访问方法

    local env = setmetatable( {} , meta )

    --

    local readablepath = getreadablepath( name, package.path )

    if not readablepath then

        error(string.format("package '%s' not found \n%s", name, table.concat( package.path, "\n" ) ) )

    end

    local func = loadfile( readablepath, "bt",  env )

    if type(func) ~= "function" then

        return nil

    end

    -- 设置标记

    package.loaded[name] = env

    -- 执行全局空间

    func( )

    return env

end

package.path = {"E:/Download/t"}

local m = package.import "m"

m.foo()

以下是m模块(m.lua)的内容

function foo( )

    print("转载注明: 战魂小筑 http://www.cppblog.com/sunicdavy", io )    

end

测试结果中, io打印出nil, 显示权限已经被控制住

本package设计比原生package更灵活, 更强大

最近准备在手机项目客户端中使用lua, 以前一直在服务器使用luabind. 另外, tolua++也体验过, LuaPlus也在早年用过. 以下是本人对这些绑定库的个人感觉:

luabind

利用boost机制把绑定做到极致, 比较适合主c++, 弱lua的脚本框架.

作者已经停止更新, 在windows/linux编译没问题, 但是在ios的LLVM下, 无法编译

tolua++

像cocos2dx使用tolua++也是可以理解的, 那么多函数需要绑定, tolua++的头文件parse及自动代码生成节约了很多手动绑定的时间.

但是看到代码中有一部分bugfix就心存不安(纯个人感觉, 本人使用不多, 欢迎砖头伺候),另外, tolua++只能由脚本层驱动C++, 而没有将已经实例化的句柄注册到lua的功能也是煞笔啊

LuaPlus

接口较为简单, 适于初学者上手, 无任何的模板, 性能不高

luaBridge

项目地址: https://github.com/vinniefalco/LuaBridge

手册: http://vinniefalco.com/LuaBridge/Manual.html

纯头文件实现, 无需编译, 包含进入工程即可, 接口简洁高效

相比luabind, 唯一不能实现的常用功能就是枚举, 但是可以支持类成员静态变量注册, 这个就无所谓了, 手写一个枚举支持也很简单

看下演示代码:

class A
{
public:
    A( )
    {

    }
    virtual void foo( int a )
    {
        printf("foo base\n");
    }

    std::string Member;
};

class B : public A
{
public:
    virtual void foo( int a )
    {
        printf("foo inherited\n");
    }
};

void foo( int b )
{

}

luabridge::getGlobalNamespace(L)
        .beginClass<A>("Sobj")
            .addConstructor<void (*) (void)> ()
            .addFunction("foo", &A::foo)
            .addData("Member",&A::Member)
        .endClass()
        .deriveClass<B, A>("SSec")
            .addFunction("foo",&B::foo )
        .endClass();

    luabridge::getGlobalNamespace(L).addFunction("foo", foo );


    B ins;
    ins.Member = "data";
    luabridge::setGlobal(L, ins, "ins");

lua侧的代码

local a = Sobj()
a:foo(2)
a.Member = "hello"


ins:foo(3)

文本格式的解析错误不能使用捕获错误来获取, 因此,我们需要使用自定义的错误收集器进行收集, 看代码:

#include <google/protobuf/text_format.h>

#include <google/protobuf/io/zero_copy_stream_impl_lite.h>

#include <google/protobuf/io/tokenizer.h>

class PBTextErrorCollector : public google::protobuf::io::ErrorCollector

{

public:

    PBTextErrorCollector( const std::string& FileName )

        : mFileName( FileName )

    {

    }

    virtual void AddError(int line, int column, const string& message)

    {

        CCLog("%s(%d:%d) %s ", mFileName.c_str(), line, column, message.c_str() );

    }

    virtual void AddWarning(int line, int column, const string& message) 

    {

        CCLog("%s(%d:%d) %s ", mFileName.c_str(), line, column, message.c_str() );

    }

private:

    std::string mFileName;

};

解析代码

google::protobuf::TextFormat::Parser P;        

    P.RecordErrorsTo( &PEC );

    P.Parse( &AIS, &AF );

另外: 文本格式的注释使用unix shell风格: 以#开头

下面是我的文本格式的配置文件

AnchorPointX: 0.5
AnchorPointY: 0

SpriteScale: 2

ComponentName: "ActorActionManager"
ComponentName: "ActorFrameEventDispatcher"
#ComponentName: "SoundFXController"
ComponentName: "RoleDeltaMoveController"
ComponentName: "RoleBehaviorDirector"

InitAction: AA_Idle

Animations 
{
  AnimationName: "mai_idle"
  AnimationInterval: 0.067
}

编译python版的protobuf模块

在https://code.google.com/p/protobuf/downloads/list 下载官方的原生版本protobuf, 这里发文时使用的是2.4.1版本

编译出protoc执行文件, 放一份在protobuf-2.4.1\src\下

下载python2.7版本, 在protobuf-2.4.1\python下运行python setup.py install(如果找不到python请给python绝对路径)

这一步, python会下一个蛋( 真的是一个python的egg文件 ), 然后编译出python版本的protobuf模块放置在python下

制作protoc-gen-lua的批处理

放一份protoc在protoc-gen-lua的plugin目录

编写批处理:protoc-gen-lua.bat

@python "%~dp0protoc-gen-lua"

协议目录生成脚本

在你需要放置协议的目录编写如下批处理

buildproto.bat

rd /S /Q .\%1%
"..\..\src\protoc-gen-lua\plugin\protoc.exe" --plugin=protoc-gen-lua="..\..\src\protoc-gen-lua\plugin\protoc-gen-lua.bat" --lua_out=. %1%.proto

注意protoc.exe及protoc-gen-lua.bat的路径符合你的路径

再编写要编译的proto协议的批处理generate.bat

call buildproto.bat loginsvc

执行generate.bat后, 将会编译同目录下的loginsvc.proto,输出loginsvc_pb.lua

编译链接lua的pb库

将protoc-gen-lua\protobuf\目录拷贝到之前的协议目录

将其下的pb.c链入你的工程, 注意VS2010的VC下需要修改源码

1.将 #include <endian.h>修改为

#ifndef _WIN32
     #include <endian.h>
     #endif

避免在windows下缺失文件报错.

2. 调整struct_unpack函数前几行为

static int struct_unpack(lua_State *L)
{
    uint8_t format = luaL_checkinteger(L, 1);
    size_t len;
    const uint8_t* buffer = (uint8_t*)luaL_checklstring(L, 2, &len);
    size_t pos = luaL_checkinteger(L, 3);
    uint8_t out[8];   

    buffer += pos;

避免VS2010的VC编译器过于标准, 严格要求C风格函数变量前置声明

在lua_State声明后添加如下代码

extern "C" { int luaopen_pb (lua_State *L);}   // 注意防在命名空间外的全局声明

    luaopen_pb( L );   // 直接注入全局pb, 避免动态加载pb.dll造成的一系列跨平台问题

lua中使用pb

local loginsvc_pb = require “loginsvc_pb”

local REQ = loginsvc_pb.CheckVersionREQ()

local Data = REQ:SerializeToString( )

local ACK = loginsvc_pb.CheckVersionACK()

ACK:ParseFromString( Data )

.csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; }

我的工程目录

script\
        protobuf\
            buildproto.bat
            generate.bat
            loginsvc_pb.lua
            loginsvc.proto
        Main.lua
    src\
        protoc-gen-lua\
            example\
            plugin\
            protobuf\

这里我们讨论的是lua的事件派发机制, 我将此写成lua模块, 方便配合cocos2dx进行逻辑处理

local Global = _G

local package = _G.package

local setmetatable = _G.setmetatable

local assert = _G.assert

local table = _G.table

local pairs = _G.pairs

local ipairs = _G.ipairs

module "Core.EventDispatcher"

--[[

数据层次

["EventName1"] =

{

    ["_StaticFunc"] = { Func1, Func2 },

    [Object1] = { Func1, Func2 },

    [Object2] = { Func1, Func2 },

},

["EventName2"] =

{

    ...

}

]]

-- 默认调用函数

local function PreInvoke( EventName, Func, Object, UserData, ... )

    if Object then

        Func( Object, EventName, ... )

    else

        Func( EventName, ... )

    end

end

function New( )    

    local NewObj = setmetatable( {}, { __index = package.loaded["Core.EventDispatcher"] } )

    -- 对象成员初始化

    NewObj.mPreInvokeFunc = PreInvoke

    NewObj.mEventTable = {}

    return NewObj

end

-- 添加

function Add( Self, EventName, Func, Object, UserData )

    assert( Func )

    Self.mEventTable[ EventName ] = Self.mEventTable[ EventName ] or {}

    local Event = Self.mEventTable[ EventName ]

    if not Object then

        Object = "_StaticFunc"

    end

    Event[Object] = Event[Object] or {}

    local ObjectEvent = Event[Object]

    ObjectEvent[Func] = UserData or true

end

-- 设置调用前回调

function SetDispatchHook( Self, HookFunc )

    Self.mPreInvokeFunc = HookFunc

end

-- 派发

function Dispatch( Self, EventName, ... )

    assert( EventName )

    local Event = Self.mEventTable[ EventName ]

    for Object,ObjectFunc in pairs( Event ) do

        if Object == "_StaticFunc" then

            for Func, UserData in pairs( ObjectFunc ) do

                Self.mPreInvokeFunc( EventName, Func, nil, UserData, ... )    

            end

        else

            for Func, UserData in pairs( ObjectFunc ) do

                Self.mPreInvokeFunc( EventName, Func, Object, UserData, ... )

            end

        end

    end

end

-- 回调是否存在

function Exist( Self, EventName )

    assert( EventName )

    local Event = Self.mEventTable[ EventName ]

    if not Event then

        return false

    end

    -- 需要遍历下map, 可能有事件名存在, 但是没有任何回调的

    for Object,ObjectFunc in pairs( Event ) do

        for Func, _ in pairs( ObjectFunc ) do

            -- 居然有一个

            return true

        end

    end

    return false

end

-- 清除

function Remove( Self, EventName, Func, Object )

    assert( Func )

    local Event = Self.mEventTable[ EventName ]

    if not Event then

        return

    end

    if not Object then

        Object = "_StaticFunc"

    end

    local ObjectEvent = Event[Object]

    if not ObjectEvent then

        return

    end

    ObjectEvent[Func] = nil

end

-- 清除对象的所有回调

function RemoveObjectAllFunc( Self, EventName, Object )

    assert( Object )

    local Event = Self.mEventTable[ EventName ]

    if not Event then

        return

    end

    Event[Object] = nil

end

这里注意下, 我是将EventDispatcher.lua放置在Core目录下, 因此需要使用require “Core.EventDispatcher”进行调用

使用用例

    local EventDispatcher = require 'Core.EventDispatcher'

    local E = EventDispatcher.New()

    E:Add( "a", function( a, b )   print( a, b ) end )

    local Func = function( a )   print( a ) end 

    E:Add( "a", Func )

    E:Dispatch("a", 1, 2 )

    print( E:Exist("a"), E:Exist("b"))

    E:Remove("a", Func )

    E:Dispatch("a", 1, 2 )

    print( E:Exist("a"), E:Exist("b"))

Private Sub ConvFile(InputFile As String, OutputFile As String)

    Dim ReadStream As Object

    Set ReadStream = CreateObject("ADODB.Stream")

    Dim FileContent As String

    With ReadStream

        .Type = 2               'adTypeText

        .Charset = "UNICODE"

        .Open

        .LoadFromFile InputFile

        FileContent = .ReadText

        .Close

    End With

    Set ReadStream = Nothing

    Dim WriteStream As Object

    Set WriteStream = CreateObject("ADODB.Stream")

    With WriteStream

        .Type = 2               'adTypeText

        .Charset = "UTF-8"

        .Open

        .WriteText FileContent

        .SaveToFile OutputFile, 2  'adSaveCreateOverWrite

        .Flush

        .Close

    End With

    Set WriteStream = Nothing

End Sub

上半截是读取文件, 下半截是写入文件, 需要转换不同格式, 请自行更换

ServicePath=/usr/local/bin

ServiceList=(
"wkcenterd --toc /home/davy/dev/kaze/Config/CenterService.toc --logfile /tmp/centerd.log"
"wkagentd --toc /home/davy/dev/kaze/Config/AgentService.toc --logfile /tmp/agentd.log"
)

StartAll()
{
    for((i = 0;i<${#ServiceList[*]};i=i+1))
    do

     echo "start:" $ServicePath/${ServiceList[i]}
     $ServicePath/${ServiceList[i]} > /dev/null &

    done
}

StopAll()
{
    for((i = 0;i<${#ServiceList[*]};i=i+1))
    do

     echo "stop:" $ServicePath/${ServiceList[i]}
     svcname=`echo ${ServiceList[i]} | awk '{print $1}'`
     killall $svcname > /dev/null

    done
}

RestartAll()
{
    StopAll
    StartAll
}


InstallService()
{
    svcname=`basename $0`
    chmod +x $svcname
    cp $svcname /etc/init.d
    ln /etc/init.d/$svcname /etc/rc3.d/S03$svcname
    ln /etc/init.d/$svcname /etc/rc0.d/K03$svcname
    chkconfig --add $svcname
    chkconfig $svcname on
    chkconfig --list | grep $svcname
}

UninstallService()
{
    svcname=`basename $0`
    chkconfig --del $svcname
    rm -f /etc/init.d/$svcname
    rm -f /etc/rc3.d/S03$svcname
    rm -f /etc/rc3.d/K03$svcname
}



case "$1" in
    start)
    StartAll
    ;;
    stop)
    StopAll
    ;;
    restart)
    RestartAll
    ;;
    install)
    InstallService
    ;;
    uninstall)
    UninstallService
    ;;
    *)
           echo "Usage: service $EXEC {install|start|stop|restart|uninst}"
       exit 1
esac
 
exit $? 

另外一种获取方法是table.getn(obj), 但是这个方法已经标记为废除了, 尽量使用通用且简洁的#操作符

使用lua api实现此功能就需要用到lua_objlen( ),但是这个功能未在luabind中提供.所以我们顺手添加一个

首先找到luabind源码的object.hpp中取对象类型的type函数,在其下添加以下代码

  1: template<class ValueWrapper>
  2: inline int obj_size(ValueWrapper const& value)
  3: {
  4:     lua_State* interpreter = value_wrapper_traits<ValueWrapper>::interpreter(
  5:         value
  6:         );
  7: 
  8:     value_wrapper_traits<ValueWrapper>::unwrap(interpreter, value);
  9:     detail::stack_pop pop(interpreter, 1);
 10:     return lua_objlen(interpreter, -1);
 11: }
 

   1: void ScriptManagedChannel::OnServiceInitialize()

   2: {    

   3:     try

   4:     {        

   5:         mThread = lua_newthread( GScriptScriptContext->GetVM() );

   6:  

   7:         luabind::resume_function<void>( mThread, "ScriptMain", this );

   8:  

   9:         Resume();

  10:     }

  11:     catch (std::exception& e)

  12:     {

  13:         const char* ErrorMsg = lua_tostring( GScriptScriptContext->GetVM(), -1 );            

  14:         printf("%s\n", e.what() );

  15:     }

  16:  

  17:     

  18: }

  19:  

  20: void ScriptManagedChannel::Resume( )

  21: {

  22:     luabind::resume<void>( mThread );

  23: }

  24:  

  25: void ScriptManagedChannel::StopTest( )

  26: {

  27:     lua_yield( mThread, 0 );

  28: }

  29:  

  30:  

代码中, mThread类型为lua_State*类型

GScriptScriptContext->GetVM()是加载了代码的lua_State*

StopTest为注册为ScriptManagedChannel类成员函数到lua中的定义

接下来看lua端的测试代码:

   1: function ScriptMain( Channel )

   2:  

   3:     

   4:     for i = 1, 5 do

   5:     

   6:     print("done", i)

   7:     

   8:     Channel:StopTest( )

   9:     

  10:     

  11:     

  12:     end

  13: end

刚开始,在测试代码时, lua中有个手误而造成的错误, 导致C++代码运行到第7行时弹出assert

位于:luabind-0.9.1\luabind\detail\call_function.hpp 第264行,对应以下代码第13行

   1: ~proxy_function_void_caller()

   2: {

   3:     if (m_called) return;

   4:  

   5:     m_called = true;

   6:     lua_State* L = m_state;

   7:  

   8:     int top = lua_gettop(L);

   9:  

  10:     push_args_from_tuple<1>::apply(L, m_args);

  11:     if (m_fun(L, boost::tuples::length<Tuple>::value, 0))

  12:     {

  13:         assert(lua_gettop(L) == top - m_params + 1);

  14:  

  15: NO_EXCEPTIONS

  16:         throw luabind::error(L);

  17: #else

  18:         error_callback_fun e = get_error_callback();

  19:         if (e) e(L);

  20:     

  21:         assert(0 && "the lua function threw an error and exceptions are disabled."

  22:                 " If you want to handle the error you can use luabind::set_error_callback()");

  23:         std::terminate();

  24: #endif

  25:     }

  26:     // pops the return values from the function call

  27:     stack_pop pop(L, lua_gettop(L) - top + m_params);

  28: }

11行代码中调用的是lua_resume, 返回的是运行错误, 但是被13行的assert挡住了, 无法通过第16行抛出异常被外面捕获.

因此,尝试注释第13行, 再测试, 可以在lua抛出错误后, 在栈顶捕获到coroutine函数resume时报出的错误信息.问题解决

对于lua的coroutine, 网上资料不多, 这里有一篇比较详细的代码

我比较疑惑的是, 有没有必要将代码在dofile或者dobuffer时, 必须传入newthread出的state? 如果还是传入原始的state会有什么影响?

欢迎各位有此经验的讨论

废话不多说, 看代码

   1:  -- 创建沙盒

   2:  function SpawnSandBox( )

   3:   

   4:      local SandBoxGlobals = {}

   5:      

   6:      -- 基础函数添加

   7:      SandBoxGlobals.print             = print

   8:      SandBoxGlobals.table             = table

   9:      SandBoxGlobals.string             = string     

  10:      SandBoxGlobals.math               = math 

  11:      SandBoxGlobals.assert             = assert 

  12:      SandBoxGlobals.getmetatable    = getmetatable 

  13:      SandBoxGlobals.ipairs             = ipairs 

  14:      SandBoxGlobals.pairs             = pairs 

  15:      SandBoxGlobals.pcall             = pcall 

  16:      SandBoxGlobals.setmetatable    = setmetatable 

  17:      SandBoxGlobals.tostring        = tostring 

  18:      SandBoxGlobals.tonumber        = tonumber 

  19:      SandBoxGlobals.type            = type 

  20:      SandBoxGlobals.unpack             = unpack 

  21:      SandBoxGlobals.collectgarbage     = collectgarbage

  22:      SandBoxGlobals._G                = SandBoxGlobals

  23:      

  24:      return SandBoxGlobals

  25:  end

  26:   

  27:  -- 在沙盒内执行脚本, 出错时返回错误, nil表示正确

  28:  function ExecuteInSandBox( SandBox, Script )

  29:      

  30:      local ScriptFunc, CompileError = loadstring( Script )

  31:      

  32:      if CompileError then

  33:          return CompileError

  34:      end

  35:      

  36:      setfenv( ScriptFunc, SandBox )

  37:      

  38:      local Result, RuntimeError = pcall( ScriptFunc )

  39:      if RuntimeError then

  40:          return RuntimeError

  41:      end

  42:      

  43:      return nil

  44:  end

  45:   

  46:  function ProtectedFunction( )

  47:      print("protected func")

  48:  end

  49:   

  50:   

  51:  local SandBox = SpawnSandBox( )

  52:   

  53:   

  54:  print ( "Response=", ExecuteInSandBox( SandBox, "table.foreach( _G, print )" ) )

  55:   

  56:  print ( "Response=", ExecuteInSandBox( SandBox, "ProtectedFunction()" ) )

  57:   

  58:  SandBox.ProtectedFunction = ProtectedFunction

  59:   

  60:  print ( "Response=", ExecuteInSandBox( SandBox, "ProtectedFunction()" ) )

54行执行结果是

   1:  _G    table: 00421258

   2:  string    table: 00421050

   3:  pairs    function: 00567F58

   4:  collectgarbage    function: 005675F0

   5:  unpack    function: 004217E8

   6:  assert    function: 005675B0

   7:  print    function: 00567830

   8:  ipairs    function: 00567F28

   9:  type    function: 004217A8

  10:  tonumber    function: 00421768

  11:  tostring    function: 00421788

  12:  table    table: 00420DA8

  13:  math    table: 004210C8

  14:  setmetatable    function: 00421748

  15:  getmetatable    function: 00567710

  16:  pcall    function: 005677F0

  17:  Response=    nil

这里是一个Shell可以将依赖列表中的文件拷贝到指定目录

deplist=$( ldd $1 | awk '{if (match($3,"/")){ print $3}}' )
cp $deplist $2

代码解释: ldd导出列表, 这个列表打印出来很丑

linux-gate.so.1 =>  (0x00ed2000)
    liblog4cpp.so.4 => /usr/local/lib/liblog4cpp.so.4 (0x00657000)
    libprotobuf.so.7 => /usr/local/lib/libprotobuf.so.7 (0x00360000)
    libboost_filesystem.so.1.48.0 => /usr/local/lib/libboost_filesystem.so.1.48.0 (0x00a9a000)
    libboost_program_options.so.1.48.0 => /usr/local/lib/libboost_program_options.so.1.48.0 (0x00110000)
    libboost_system.so.1.48.0 => /usr/local/lib/libboost_system.so.1.48.0 (0x00a85000)
    libboost_thread.so.1.48.0 => /usr/local/lib/libboost_thread.so.1.48.0 (0x00179000)
    libunwind-x86.so.7 => /usr/lib/libunwind-x86.so.7 (0x00821000)
    libluabindd.so.0.9.0 => /usr/local/lib/libluabindd.so.0.9.0 (0x00bb3000)
    libmysqlpp.so.3 => /usr/local/lib/libmysqlpp.so.3 (0x00de5000)
    libstdc++.so.6 => /usr/lib/i386-linux-gnu/libstdc++.so.6 (0x001a9000)
    libm.so.6 => /lib/i386-linux-gnu/libm.so.6 (0x00782000)
    libgcc_s.so.1 => /lib/i386-linux-gnu/libgcc_s.so.1 (0x00aea000)
    libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00447000)
    libpthread.so.0 => /lib/i386-linux-gnu/libpthread.so.0 (0x00abd000)
    librt.so.1 => /lib/i386-linux-gnu/librt.so.1 (0x00193000)
    libnsl.so.1 => /lib/i386-linux-gnu/libnsl.so.1 (0x00294000)
    libunwind.so.7 => /usr/lib/libunwind.so.7 (0x002ab000)
    libdl.so.2 => /lib/i386-linux-gnu/libdl.so.2 (0x00e8a000)
    libmysqlclient_r.so.16 => /usr/lib/libmysqlclient_r.so.16 (0x0083b000)
    /lib/ld-linux.so.2 (0x00608000)
    libz.so.1 => /lib/i386-linux-gnu/libz.so.1 (0x002c0000)

我们发现第一行的so没有对应的库地址, 因此我们使用awk的脚本功能,判断第三个参数,也就是=>之后的路径必须包含/

之后将第一行的输出重定向到变量中, 再使用cp指令从列表拷贝到指定目录

BuildProtoCC.bat

@echo off

set protofile=%1%.proto
set output_cc=%1%.pb.cc

"protoc.exe" %protofile% --cpp_out .
@echo 使用%protofile%生成%output_cc%

if exist "pchheader.txt" goto 合并预编译头 else echo pchheader.txt NOT EXIST

:合并预编译头
@echo 尝试删除以前的中间文件
del *.pched
@echo 合并编译头文件pchheader.txt到生成%output_cc%
copy pchheader.txt+"%output_cc%" "%output_cc%.pched" /y
@echo 等待protoc.exe结束
@ping -n 2 127.1>nul
echo 清理文件
del "%output_cc%"
ren "%output_cc%.pched" "%output_cc%"

这段批处理这样使用:

假设你有一个叫login.proto文件和批处理放在一起

在同一目录再放置一个pchheader.txt文件,并在里面写入#include "stdafx.h”

调用一下批处理

call BuildProtoCC.bat login

注意login不能带后缀

将使用protoc.exe生成login.pb.cc和login.pb.h 然后使用批处理合并文件功能自动合并预编译头

不过官网也提到过ActionScript3的支持,点击看这里

protobuf-actionscript3包括ActionScript3的序列号及反序列化的as源码.以及protoc的as3代码生成器的C++代码

另外, protobuf-actionscript3还需要一个加密库as3crypto支持,需要一并下载

当然, protobuf 库也是最重要的.

下面说明如何编译出支持as3的protoc代码生成器:

1. 将protobuf-actionscript3库中compiler\as3目录拷贝到protobuf库的src\google\protobuf\compiler下.目录结构如下:

as3\
    cpp\
    java\
    python\
    code_generator.cc
    command_line_interface.cc

...

2.打开protobuf工程中的sln, 在libprotoc添加刚才添加的as3目录下的所有文件

3. 在protoc工程的main.cc中添加

  google::protobuf::compiler::as3::As3Generator as3_generator;
  cli.RegisterGenerator("--as3_out", &as3_generator,
      "Generate ActionScript source file."); 

4. 打开as3_file.h

注释掉以下代码

namespace protobuf {
  class FileDescriptor;        // descriptor.h
  namespace io {
    class Printer;             // printer.h
  }
  namespace compiler {
    class OutputDirectory;     // code_generator.h
  }
}

包含内添加

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/compiler/code_generator.h>
#include <google/protobuf/io/printer.h>

5. 编译出protoc.exe

6. 准备proto文件, 使用protoc.exe使用类似CPP生成的方式进行生成

7. 将protobuf-actionscript里的as3-lib及下载好的加密的swc整合到自己的flash工程即可开始使用

松鼠脚本可以说是Lua的超级增强版,作者在Crysis项目使用Lua多年,深知Lua的优缺点.之后自己编写了松鼠脚本来解决诸如class,attribute,delegation,更强大的thread,exception等等功能.

松鼠脚本本身对Windows开发人员极为照顾,第三方库可谓丰富,远程调试,代码加色及语法检查都可以直接在VS2008的IDE中进行.

简单的远程调试功能需要以下步骤:

1. 下载松鼠脚本3.0版本

2. 在松鼠脚本Wiki中下载SQDBG远程调试库

3. 将sqdbg工程放到SQUIRREL3之下,打开SQUIRREL3\squirrel.sln,将sqdbg添加到工程,编译所有

4. 在这个Solution下,创建一个Squirrel松鼠工程

5. 在新创建的松鼠工程属性中如下图设置

Interpreter其实就是启动调试器(不是sq.exe)

WorkingDirectory 就是main.nut所在的目录(官网的路径设置有点误导)

Command Line Options 就是传入sqdbg.exe的命令行参数

修改下main.nut文件,例如:

for(local i = 1;i<10;i++)
{
    print( i );
}

在print语句前打上断点,调试松鼠工程,即可看到调试结果

有关于SQDBG多文件调试:

SQDBG默认只能调试1个文件,显然是个玩具,不能应对游戏和其他领域的多文件调试. 分析了下SQDBG的代码

   1:  int main(int argc, char *argv[])

   2:  {

   3:      if(argc < 2){

   4:          scprintf(_SC("SQDBG error : no file specified"));

   5:          return -1;

   6:      }

   7:          

   8:      HSQUIRRELVM v = sq_open(1024);

   9:      sqstd_seterrorhandlers(v);

  10:   

  11:      //!! INITIALIZES THE DEBUGGER ON THE TCP PORT 1234

  12:      //!! ENABLES AUTOUPDATE

  13:      HSQREMOTEDBG rdbg = sq_rdbg_init(v,1234,SQTrue);

  14:      if(rdbg) {

  15:   

  16:          //!! ENABLES DEBUG INFO GENERATION(for the compiler)

  17:          sq_enabledebuginfo(v,SQTrue);

  18:   

  19:          sq_setprintfunc(v,printfunc,errorfunc);

  20:   

  21:          //!! SUSPENDS THE APP UNTIL THE DEBUGGER CLIENT CONNECTS

  22:          if(SQ_SUCCEEDED(sq_rdbg_waitforconnections(rdbg))) {

  23:              scprintf(_SC("connected\n"));

  24:   

  25:              const SQChar *fname=NULL;

  26:  #ifdef _UNICODE

  27:              SQChar sTemp[256];

  28:              mbstowcs(sTemp,argv[1],(int)strlen(argv[1])+1);

  29:              fname=sTemp;

  30:  #else

  31:              fname=argv[1];

  32:  #endif 

  33:              //!!REGISTERS STANDARDS LIBS

  34:              sq_pushroottable(v);

  35:              sqstd_register_bloblib(v);

  36:              sqstd_register_iolib(v);

  37:              //!!EXECUTE A SCTIPT

  38:              if(SQ_FAILED(sqstd_dofile(v,fname,SQFalse,SQTrue))) {

  39:                  PrintError(v);

  40:                  _getch();

  41:              }

  42:          }

  43:          //!! CLEANUP

  44:          sq_rdbg_shutdown(rdbg);

  45:      }

  46:      else {

  47:          PrintError(v);

  48:      }

  49:      sq_close(v);

发现写这个库的老外还是很认真的,使用了sq_rdbg作为debugger的api前缀,意味着这个库代码是可以复用的.

sqstd_dofile(v,fname,SQFalse,SQTrue)

这就是SQDBG只能debug 1个文件的原因.

如果需要在项目中做远程调试,只需要将这句代码换为工程中加载所有脚本的代码和注册系统API代码即可

当然,最简单的方法,直接在代码顶端添加dofile引用另外的代码即可

1. Lua

Lua用了5,6年的样子,从LuaPlus到lua-tinker再到lua_bind. 虽然lua本身很小巧方便,但是其不支持面向对象特性,让很多人在使用时模拟了很多面向对象的特性,但是这种做法在调试时简直是噩梦.

我觉得游戏脚本最好是能预编译成byte code,让编译器在编译期将很多的bug暴露出来,而不是像lua那样.很多空访问错误必须要等到runtime才能暴露.让调试效率大大降低.这点,mono C#就是极好的选择.

2. Mono

由于Unity的流行,Mono被带入游戏开发者的视线内.其内置的很多系统脚本都是用C#写成,而且逻辑脚本用C#编写也是非常清晰严谨的.

据说Mono在Windows下编译异常麻烦,而且嵌入方式也没有太多例子,现在这块严重缺乏资料.

3. V8

Google V8正是由于Chrome而风靡起来.直接JIT方式就是Chrome速度飞快的原因.

最近down了一个下来试了下,果然名不虚传,API也非常的易用.不过由于不是很熟悉JavaScript的原因, 自己用scons编译出一个v8的shell,跑了一个带类继承的例子,居然不识别class关键字.这才感叹还不如用小巧的lua呢.在我看来,JavaScript与Lua比较,也就是个能new,但是没class的语言.也被别人称为半吊子面向对象,都是使用prototype方式来实现类功能.

4. JavaScriptCore

在Google V8的类测试碰壁后,马上研究了下Unity下的JavaScript到底用了什么库,没错就是Apple Safari里的JavaScriptCore. 这东西资料比Mono还少,都是高龄库了.想必整合不是一般的麻烦.但是还是不确定这个脚本引擎是否原生支持类

5. Python

Python? 没想过这种格式诡异的语言,正如Unity里支持Boo(一种很类似Python的语言)很少有人用一样, 上次用过Python是在一个build系统里, 游戏里是不会考虑这种脚本系统的,效率也是很大的原因.

6. AngleScript, GameMonkey

这两种语言都是很老的游戏脚本语言,不过都是类c++方式的,不过由于项目使用不多,或许是有一定的bug,资料也相对较少,所以可能最后考虑

更新了文档（这是必须的）

新的无符号整数C API

位处理函数重命名

更好及更快的支持双精度浮点数转换为整型

原文在此

可以看到，我在年初发文指出的lua数字处理方面的bug已经得到很好的解决，不过这种解决方法只是添加了api而已，看来还是没有松鼠脚本处理的彻底，原文在此

1. 去掉Effect系统，改用HLSL + 渲染脚本

2. 优化渲染接口，使用材质统一shader和渲染状态

随即参考了DirectX SDK的Graphics部分文档：DirectX9 时代的Effect系统纯粹只是一个HLSL的简单渲染脚本实现，除了DXUT，FXComposer等极少程序使用这套东西外，大型的引擎很少使用这种半成品系统。到了DirectX10甚至11，因为架构更改，去掉固定管线，因此Effect成为较为高效和便捷的渲染脚本，如果不是要求较高的3d引擎，一般的游戏使用DirectX10的Effect渲染脚本还是很不错的。

DX10的fx脚本与DX9的差异在于

渲染状态，采样器状态等都变为对象，并与API高度统一

在脚本与API中均可以设置

DepthStencilState EnableDepth
{
    DepthEnable = TRUE;
    DepthWriteMask = ALL;
    DepthFunc = LESS_EQUAL;
};

BlendState NoBlending
{
    AlphaToCoverageEnable = FALSE;
    BlendEnable[0] = FALSE;
};

technique10 Render
{
    pass P0
    {

        SetDepthStencilState( EnableDepth, 0 );
        SetBlendState( NoBlending, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
    }
}

本人觉得，这样的设计让图形API更为敏捷与归类化，另外，也便于StateManager或者自己做渲染状态转移及差异比较时更为高效

Vista操作系统推出很久后，DX10的显卡也占有了大量的市场份额。但是由于DX10仍然是一个过渡API（类似于DX8)，因此，很多3D游戏要么仍然支持DX9，要不然即支持DX9也支持DX10，甚至DX11.

   看博客上有达人组团编写类似DX10接口和系统的软渲染，DX10的设计是优秀的。因此，在DX9 HLSL基础上，结合自己编写的渲染脚本会是非常好的选择。

    渲染脚本我的设计思路是这样的：

1. 只是一种预处理脚本，并非实时运行脚本。

编译器将文本解析后，转化为一些运行指令，比如：本pass使用一块小纹理，下一pass的target是这个纹理，并且开启哪些渲染状态。

2. 自定义格式的解析脚本。

使用lua，python等脚本其实也是可以的。但是在出现错误时，报出的错可能会让不熟悉这个脚本语言的人莫名其妙。

使用松鼠sq脚本语言？可惜其在lua基础上，对table的slot初次赋值时必须使用<-而不是统一使用=，因此会让你的脚本稀奇古怪

XML脚本？ XML可以避免复杂的语法检查，写完就是归整的，但也是罗嗦的，本来Texture[2]可以表达完毕的，非要<Texture index = 2/>来罗嗦下。

OGRE的compositor脚本和材质脚本就是自己解析的，不过出乎预料的使用了BNF范式这类较为正规的方法。这就是说，需要先解析BNF表达式，然后再输入脚本解析，编写过程和系统复杂度会变得异常复杂。

最终选择还是使用自己解析的脚本，使用一些具体代码结构来替代BNF这类高深的东西

决定以后，下一步需要制定渲染脚本具体各部分及制作过程

1. 基本lexer

   从文本得到各种token

1. 渲染状态对象

   照着DX10抄就好

2. Shader导入口

     shader文件来自于何处，入口怎样定义

3. 渲染脚本VM及指令

  决定一个纹理怎样设置，RenderTarget怎样使用等的指令

Lemon系统特性：

1. 支持 Canvas,Sprite,ImageSet（图片帧存储于一张图片，等大小）

2. ImageSetEx（自由摆放的图片帧于一张图片）*

3. 支持对象无关键帧时使用静态属性进行设置，类似于HGE里的精灵

4. 每个对象均可成为Container，并拥有Child Node

5. 动画关键帧类型支持：缩放，旋转，位移，颜色，动画帧，锚点，音效*

6. 支持拾取

7. 基于XML存储的文件格式

8. 基于Squirrel松鼠脚本的高速面向对象脚本*

9. 图形系统Graphics抽象，适用于任何渲染设备

10. 控件系统*

11. 视频回放*

所有对象均由RTTI创建，枚举均有NamePool+Hash，并由于PropertySet的反射系统

 

LemonComposer编辑器特性

界面基于我去年开发的MotionUI，lua

8+1控制点点对象调节属性

类Adobe Flash的帧编辑。

类3DS Max的分轨道关键帧编辑，有助于优化art assert

自由调节对象层级及父子关系

全功能无限制自由Redo,Undo

 

*将在未来版本支持

2D游戏是独立游戏的主流，也是创意，投入比最小的一个维度。但是基于2D的大多是一些类似于HGE，IndieLib等开源免费2D引擎。但是面对游戏中大量的动画而言，开发者大多是使用图片帧来制作，虽然效果很好，但是设备资源好用和制作难度也是很难控制的。

流行于去年的植物对僵尸和2004年发行的RO Offline经过资源分析，就是使用类似于Lemon系统，或者说Flash的系统制作而成，因此效果和扩展性非常好。

这就是Lemon存在的理由。

Flash面向的是GDI+Web，那么Lemon就是针对游戏专有的，基于硬件加速的游戏框架

Flash Action Script 对应的就是Lemon的Squirrel脚本

FlashIDE 对应的就是Lemon Composer

Lemon的目标就是让2D游戏开发更简单，让游戏中充满更多的动画, 让游戏开发难度降低

例子：

for /r publish\ui\ %%i in (*.lua) do luac -o %%i %%i

lua中，数值使用double来存储，包含整形和double。而解析出来的整形也是被强转为double进行存储，这样就会出问题。

举一个简单的例子：

double f = (double)0xffffffff;
int a = int(f);

这里的文章说明这个类型转换问题的缘由。

在Squirrel脚本中就不会有这个问题

local a = 0xffffffff

print( a )

结果为-1

查看其源代码：

typedef union tagSQObjectValue
{
    struct SQTable *pTable;
    struct SQArray *pArray;
    struct SQClosure *pClosure;
    struct SQGenerator *pGenerator;
    struct SQNativeClosure *pNativeClosure;
    struct SQString *pString;
    struct SQUserData *pUserData;
    SQInteger nInteger;
    SQFloat fFloat;
    SQUserPointer pUserPointer;
    struct SQFunctionProto *pFunctionProto;
    struct SQRefCounted *pRefCounted;
    struct SQDelegable *pDelegable;
    struct SQVM *pThread;
    struct SQClass *pClass;
    struct SQInstance *pInstance;
    struct SQWeakRef *pWeakRef;
    SQRawObjectVal raw;
}SQObjectValue;

可以看到

SQInteger nInteger;
SQFloat fFloat;

是分开存储的，因此就不会有这个问题

lua解决方法：

1. 将十六进制换为10进制存储

2. 等待大侠或者官方修改代码，做出patch

lua代码：

t = {}

t.FillColor = 0xFFFFFFFF

foo( t )

在C++中注册一个foo函数，然后获取table t中的FillColor成员

发现取得的值居然为0x80000000

使用lua c api测试代码

lua_newtable( L );
lua_setglobal( L, "t");

lua_getglobal( L, "t");
lua_pushstring(L,"FillColor");
lua_pushinteger( L, 0xffffffff );
lua_pushinteger( L, -1 );
lua_settable( L, -3 );

lua_getglobal( L, "t");
lua_pushstring( L, "FillColor");
lua_gettable( L, -2 );
int t = lua_tointeger( L, -1 );

结果t也是0x80000000

然后将十六进制的0xFFFFFFFF换成十进制的4294967295，测试结果正确显示-1

再使用几个样本测试

0xFF5F5F5F = 4284440415 会被改成0xFF5F5F00

这个bug倒是很好解决，将代码中的十六进制数全换为10进制即可。但是为什么只在Release版本发生呢？

本人使用的是lua 5.1.4 原生

1. 纯C API方式导出，类似于Windows API方式

优点：简洁，可以供C/C#乃至其他可以导入C DLL的语言使用

缺点：C++的系统转化为C会遇到很多性能以及架构的折损，对于对象控制类功能导出比较多的系统，这种方式简直是噩梦

2. C++方式导出，宏方式实现RTTI以及C++反射系统

优点：强大，易用。

缺点：对象生命周期不容易控制，反射系统设计比较费时，可能暴露很多类的细节，只能给C++使用

3. COM方式，类DirectX的接口方式

优点：商业项目已经证明这种接口方式的强大地方。无论是多个对象的类功能导出，还是COM接口重载都非常方便。而且，可以极为容易的让.NET访问。XBOX SDK里的XUI就是采用这种方式，而且还设计了一套C API搭配的强大C++反射系统，支持动态类创建，RTTI，动态类型转换等等。

缺点：需要系统注册，不能跨平台。COM标准学习起来需要时间

4. 脚本绑定

优点：保持你的系统对外C/C++接口的干净，简洁。通过脚本类绑定，可以很快的将C++功能注册到脚本中。

缺点：脚本如果没有调试器，将会让开发中碰到的棘手问题，甚至于在后期维护系统以及系统架构大变动变得异常复杂。脚本的性能决定了不能让其做实时处理，例如：渲染

最终选择下来，由于有自己的界面系统Motion使用lua的函数绑定的前例，因此还是决定选择一款脚本语言来做系统的对外接口，这里有几个选择：

1. Lua

  可以说最好的游戏系统脚本语言。稳定，高效，bug几乎没有（即便有，普通开发者也是很难察觉的）。配上LuaPlus的强大C++绑定系统，你的系统开发效率可以提高很多。这里推荐notepad++来做lua开发，稍微配置下，弹出提示给你感觉在使用Visual Studio，：）

   同时需要指出的是，lua的类功能确实比较弱。虽然可以用metatable方式来模拟。但逼近跟native class支持还差很远，实际开发中，你能体会出class中的权限控制（private，protected）有多么重要。

2. Python

   诚然，这是个最OO的脚本。但是对于游戏，它太慢了。虽然本人只是用python写过一些build系统，但从很多朋友反应的情况来看，Python嵌入游戏系统，确实太慢。用Stackless Python？ 用第三方开源产品，还是认准品牌，呵呵，这里如果有用过的同学，欢迎提供感受。

3. C#

   语言和系统都很美，但是想嵌入游戏，还是很痛的。.net平台可惜就在于，到现在为止，可能还不是所有机器默认安装有.net平台。如果你的游戏是C++写成，但却要安装.net以便你的脚本能运行，这很奇怪吧？所以，如果要用C#，还不如不用脚本，全盘.net就好了。Managed DX？ 那东西几年前就被MS打入冷宫了。XNA？ 那东西只是一个玩具，别摸。

4.Squirrel松鼠脚本

   这是个好东西。类lua的语法，C/C++/Java的语言结构，纯正的native class外加OO支持。拥有开源的C++类绑定系统。最爽的是，SQDEV支持日食（Eclipse）下的远程调试，开发环境还支持动态语法检查。oh,my god。还说不定哪天这脚本被MS招安，跟IronPython一样弄个.net绑定。

这是一个简单的教学，告诉你Kismet是怎么运行的

http://udn.epicgames.com/Three/KismetUserGuide.html

这是Kismet的资料

http://udn.epicgames.com/Three/KismetReference.html

让我们来熟悉下

这是一个Event节点，一般用于创建输入流，事件可以从Actor或者其他地方进入

这是一个Action节点，动态的搭接输入条件，可以快速的输出你需要的结果

这是一个Condition节点，用于根据输入，输出结果

这是一个普通的变量，存储任何可以存储的对象

第一个例子：

这个例子要实现的是，玩家点击后，打开一盏灯

玩家通过Event节点，产生一个输入流，这个流被连接到Togger（Action）的Turn On节点，注意，黑色的连接线表示“操作流”，而Togger的执行目标被接到了灯上，这样一个简单的逻辑就执行出来了

动态绑定事件

有时你需要绑定的对象是不在编辑器里的，这个例子就是在游戏中动态创建一个Actor，要解决这个问题，就必须将物体连接到一个变量。

当Actor Factory执行后，其生成一个新的Actor，并将其放置在一个对象数组中（图中的问号），然后，他会调用AttachToEvent action，将死亡事件连接到这个变量。 那么当这个Actor死亡时，事件就会被触发。

先讲这些，呵呵，吃饭吃饭