quick-cocos2dx 组件管理器

接触过unity3D的都知道，unity里的对象，都是由一个空的gameObject附加上相应的组件构成的。quick-lua里也有这种功能。它是由Registry.lua，GameObject.lua和Component.lua协调完成的。如果想使用这套机制，只需要调一个函数：GameObject.extend(obj)，这样obj就能附加组件了。如果相用自定义组件，则要自定义Component的派生类

-- 定义Registry类，此类用于管理所有组件类。相当于一张注册表，所有的组件都要在这张表中注册。（当然
-- 不用去显示地注册，newObject会根据组件的名字，自动加载并注册组件
local Registry = class("Registry")

Registry.classes_ = {}

-- 注册组件，这里的组件实际上就是一个类，且要派生自Component。
function Registry.add(cls, name)
    assert(type(cls) == "table" and cls.__cname ~= nil, "Registry.add() - invalid class")
    if not name then name = cls.__cname end
    assert(Registry.classes_[name] == nil, "Registry.add() - class \"%s\" already exists", tostring(name))
    Registry.classes_[name] = cls
end

-- 删除组件
function Registry.remove(name)
    assert(Registry.classes_[name] ~= nil, "Registry.remove() - class \"%s\" not found", name)
    Registry.classes_[name] = nil
end

-- 实例化指定组件，并返回该实例化对象。若指定组件还未加载，则自动加载它。
function Registry.newObject(name)
    local cls = Registry.classes_[name]
    if not cls then
        -- auto load
        pcall(function()
            cls = require(name)
            Registry.add(cls, name)
        end)
    end
    assert(cls ~= nil, string.format("Registry.newObject() - invalid class \"%s\"", tostring(name)))
    return cls.new()
end

return Registry
           

local Registry = import(".Registry")

-- 负责为target对象拓展功能，使其能够附加各种组件
local GameObject = {}

function GameObject.extend(target)
    target.components_ = {}

    function target:checkComponent(name)
        return self.components_[name] ~= nil
    end

    function target:addComponent(name)
        local component = Registry.newObject(name)
        self.components_[name] = component
        component:bind_(self)
        return component
    end

    function target:removeComponent(name)
        local component = self.components_[name]
        if component then component:unbind_() end
        self.components_[name] = nil
    end

    function target:getComponent(name)
        return self.components_[name]
    end

    return target
end

return GameObject
           

-- 组件基类，所有组件都要派生自它
local Component = class("Component")

-- 构造函数， 
-- name为组件名称
-- depends为该组件需要依赖于哪些组件，
-- 当某对象附加该组件时，会自动为且附加所有的depends组件
function Component:ctor(name, depends)
    self.name_ = name
    self.depends_ = totable(depends)
end

function Component:getName()
    return self.name_
end

-- 获取所有的依赖组件(它是一个table)
function Component:getDepends()
    return self.depends_
end

-- 获取该组件被附加到哪个组件上
function Component:getTarget()
    return self.target_
end

-- 将该组件某些的方法导出到target上
-- methods为字符串数组，字符串名字就是函数名。
-- 有了这套机制，在调用addcomponent后接着调用此函数，
-- 则以后想使用该组件的功能，直接通过target就能调用，无需先获取组件，再调用函数
function Component:exportMethods_(methods)
    self.exportedMethods_ = methods
    local target = self.target_
    local name = self.name_
    local com = self
    for _, key in ipairs(methods) do
        if not target[key] then
            target[key] = function(__, ...)
                local r = {com[key](self, ...)}
                if r[1] == self then r[1] = target end
                return unpack(r)
            end
        end
    end
    return self
end

-- 将该组件绑到target对象上
function Component:bind_(target)
    self.target_ = target
    for _, name in ipairs(self.depends_) do
        if not target:checkComponent(name) then
            target:addComponent(name)
        end
    end
    self:onBind_(target)
end

-- 解绑该组件
function Component:unbind_()
    if self.exportedMethods_ then
        local target = self.target_
        for _, key in ipairs(self.exportedMethods_) do
            target[key] = nil
        end
    end
    self:onUnbind_()
end

function Component:onBind_()
end

function Component:onUnbind_()
end

return Component