C++ 设计模式在 KBEngine 中的实践

// KBEngine 单例模式实现
// src/server/dbmgr.cpp

class DBMgr
{
public:
    // 获取单例实例
    static DBMgr& instance()
    {
        static DBMgr instance;
        return instance;
    }

    // 禁止拷贝和赋值
    DBMgr(const DBMgr&) = delete;
    DBMgr& operator=(const DBMgr&) = delete;

private:
    // 私有构造函数
    DBMgr()
        : pNetworkInterface_(NULL)
        , bufferSize_(0)
    {
    }

    // 成员变量
    NetworkInterface* pNetworkInterface_;
    uint32 bufferSize_;
};

// 使用方式
DBMgr& dbmgr = DBMgr::instance();

// KBEngine 实体工厂
// src/server/entitydef/entitydef.cpp

class EntityDef
{
public:
    // 创建实体
    Entity* createEntity(Entity* pParent, ENTITY_ID entityID)
    {
        // 根据类型创建实体
        Entity* entity = NULL;

        // 通过脚本创建
        if (scriptModuleName_.size() > 0)
        {
            // 调用 Python 脚本创建
            entity = ScriptModule::getInstance()->createEntity(
                scriptModuleName_,
                this,
                pParent,
                entityID
            );
        }
        else
        {
            // C++ 内置实体
            entity = new Entity();
        }

        if (entity)
        {
            // 初始化属性
            entity->initializeProperty(*this);
        }

        return entity;
    }

private:
    std::string scriptModuleName_;  // Python 模块名
    std::map<std::string, PropertyDescription> properties_;
};

// 使用示例
EntityDef* accountDef = EntityDefs::findEntityDef("Account");
Entity* account = accountDef->createEntity(NULL, entityID);

// KBEngine Watcher 系统
// src/server/watcher.h

class Watcher
{
public:
    // 注册观察者
    template<typename T>
    void addWatch(const std::string& path, T* watcher)
    {
        watches_[path].push_back(static_cast<void*>(watcher));
    }

    // 移除观察者
    void removeWatch(const std::string& path, void* watcher)
    {
        auto it = watches_.find(path);
        if (it != watches_.end())
        {
            auto& vec = it->second;
            vec.erase(std::remove(vec.begin(), vec.end(), watcher), vec.end());
        }
    }

    // 通知所有观察者
    void notify(const std::string& path, const boost::any& value)
    {
        auto it = watches_.find(path);
        if (it != watches_.end())
        {
            for (void* watcher : it->second)
            {
                static_cast<WatcherInterface*>(watcher)->onWatch(path, value);
            }
        }
    }

    // 获取监控值
    boost::any get(const std::string& path)
    {
        // 解析路径: "stats/cpuUsage"
        // 返回对应的值
        return getValueFromPath(path);
    }

private:
    std::map<std::string, std::vector<void*>> watches_;
};

// 使用示例
class ComponentMonitor : public WatcherInterface
{
public:
    void init()
    {
        Watcher::instance().addWatch("stats/cpuUsage", this);
        Watcher::instance().addWatch("stats/memoryUsage", this);
    }

    void onWatch(const std::string& path, const boost::any& value) override
    {
        if (path == "stats/cpuUsage")
        {
            float cpu = boost::any_cast<float>(value);
            if (cpu > 80.0f)
            {
                WARNING_MSG("High CPU usage: {}", cpu);
            }
        }
    }
};

// KBEngine 实体代理
// src/entitydef/entity.h

class Entity
{
public:
    // Base 实体 (客户端代理)
    class BaseEntity : public Entity
    {
    public:
        // 远程调用 Cell 方法
        void callCellMethod(const std::string& method, const MemoryStream& args)
        {
            // 通过网络转发到 CellApp
            NetworkInterface* network = NetworkInterface::instance();
            network->sendToCell(entityID_, method, args);
        }

        // 属性访问
        int32 getHP() const
        {
            // 返回缓存的值
            return cachedHP_;
        }

        void setHP(int32 value)
        {
            cachedHP_ = value;
            // 同步到 Cell
            callCellMethod("setHP", MemoryStream() << value);
        }

    private:
        ENTITY_ID entityID_;
        int32 cachedHP_;  // 缓存的属性值
    };

    // Cell 实体 (真实数据)
    class CellEntity : public Entity
    {
    public:
        int32 getHP() const
        {
            return hp_;  // 真实值
        }

        void setHP(int32 value)
        {
            hp_ = value;
            // 通知 Base 更新
            notifyBase("hp", value);
            // 通知客户端
            if (hasClient())
            {
                sendToClient("onHPChanged", value);
            }
        }

    private:
        int32 hp_;
    };
};

// KBEngine 命令模式
// src/network/bundle.h

class MessageHandler
{
public:
    // 抽象命令
    class Command
    {
    public:
        virtual ~Command() {}
        virtual void execute(MemoryStream& stream) = 0;
        virtual size_t getID() const = 0;
    };

    // 具体命令
    class LoginCommand : public Command
    {
    public:
        static size_t ID() { return 100; }

        void execute(MemoryStream& stream) override
        {
            std::string account, password;
            stream >> account >> password;

            // 执行登录逻辑
            Account* pAccount = AccountLogin(account, password);

            // 返回结果
            MemoryStream reply;
            reply << pAccount->getID();
            sendToClient(reply);
        }

        size_t getID() const override { return ID(); }
    };

    // 命令注册器
    void registerCommand(Command* cmd)
    {
        handlers_[cmd->getID()] = cmd;
    }

    // 处理消息
    void processMessage(NetworkInterface* network, const Packet* packet)
    {
        // 解析消息头
        uint16 msgID;
        MemoryStream stream(packet->data(), packet->length());
        stream >> msgID;

        // 查找处理器
        auto it = handlers_.find(msgID);
        if (it != handlers_.end())
        {
            it->second->execute(stream);
        }
        else
        {
            ERROR_MSG("Unknown message ID: {}", msgID);
        }
    }

private:
    std::map<size_t, Command*> handlers_;
};

// KBEngine 对象池
// src/lib/helpers/objectpool.h

template<typename TYPE, size_t PRE_ALLOC = 64>
class ObjectPool
{
public:
    ObjectPool()
        : pool_(nullptr)
        , numAllocs_(0)
        , numFrees_(0)
    {
    }

    ~ObjectPool()
    {
        clear();
    }

    // 获取对象
    TYPE* alloc()
    {
        TYPE* obj = nullptr;

        if (freeList_.empty())
        {
            // 池为空，创建新对象
            obj = new TYPE();
            ++numAllocs_;
        }
        else
        {
            // 从池中取
            obj = freeList_.back();
            freeList_.pop_back();
        }

        return obj;
    }

    // 释放对象
    void free(TYPE* obj)
    {
        if (obj)
        {
            freeList_.push_back(obj);
            ++numFrees_;
        }
    }

    // 清空池
    void clear()
    {
        for (TYPE* obj : freeList_)
        {
            delete obj;
        }
        freeList_.clear();
    }

    // 统计信息
    size_t getNumAllocs() const { return numAllocs_; }
    size_t getNumFrees() const { return numFrees_; }
    size_t getPoolSize() const { return freeList_.size(); }

private:
    std::vector<TYPE*> freeList_;
    size_t numAllocs_;
    size_t numFrees_;
};

// 使用示例
ObjectPool<Packet, 1024> packetPool;

Packet* packet = packetPool.alloc();
// ... 使用 ...
packetPool.free(packet);

// KBEngine 网络桥接
// src/lib/network/channel.h

// 抽象接口
class Channel
{
public:
    virtual ~Channel() {}

    virtual bool send(const Packet* packet) = 0;
    virtual Packet* receive() = 0;
    virtual bool isConnected() const = 0;

protected:
    Endpoint* pEndpoint_;
};

// TCP 实现
class TCPChannel : public Channel
{
public:
    bool send(const Packet* packet) override
    {
        // TCP 发送逻辑
        return pEndpoint_->sendtcp(packet);
    }

    Packet* receive() override
    {
        // TCP 接收逻辑
        return pEndpoint_->recvtp();
    }
};

// UDP 实现
class UDPChannel : public Channel
{
public:
    bool send(const Packet* packet) override
    {
        // UDP 发送逻辑
        return pEndpoint_->sendudp(packet);
    }

    Packet* receive() override
    {
        // UDP 接收逻辑
        return pEndpoint_->recvudp();
    }
};

// 信道管理器
class ChannelManager
{
public:
    Channel* createChannel(ProtocolType type, Endpoint* endpoint)
    {
        switch (type)
        {
        case PROTOCOL_TCP:
            return new TCPChannel(endpoint);
        case PROTOCOL_UDP:
            return new UDPChannel(endpoint);
        case PROTOCOL_TCP_UDP:
            return new TCPUDPChannel(endpoint);
        default:
            return nullptr;
        }
    }
};

// KBEngine 实体生命周期
// src/server/entitydef/entity.h

class Entity
{
public:
    // 模板方法：完整生命周期
    bool initialize(const EntityDef& def)
    {
        // 1. 创建
        if (!onCreate())
        {
            return false;
        }

        // 2. 加载数据
        if (!onLoad(def))
        {
            onDestroy();
            return false;
        }

        // 3. 进入场景
        if (!onEnterSpace())
        {
            onDestroy();
            return false;
        }

        // 4. 完成初始化
        onInitialized();

        return true;
    }

    // 销毁流程
    void destroy()
    {
        // 1. 离开场景
        onLeaveSpace();

        // 2. 销毁
        onDestroy();

        // 3. 清理
        onCleanup();
    }

protected:
    // 钩子方法，子类可重写
    virtual bool onCreate() { return true; }
    virtual bool onLoad(const EntityDef& def) { return true; }
    virtual bool onEnterSpace() { return true; }
    virtual void onInitialized() {}
    virtual void onLeaveSpace() {}
    virtual void onDestroy() {}
    virtual void onCleanup() {}
};

// 使用：Account 实体
class Account : public Entity
{
protected:
    bool onCreate() override
    {
        // 账号特定创建逻辑
        return Entity::onCreate();
    }

    bool onLoad(const EntityDef& def) override
    {
        // 加载账号数据
        return Entity::onLoad(def);
    }
};

// KBEngine 负载均衡策略
// src/server/baseappmgr/baseappmgr.cpp

class LoadBalanceStrategy
{
public:
    virtual ~LoadBalanceStrategy() {}

    // 选择 BaseApp
    virtual BaseApp* selectBaseApp(const std::vector<BaseApp*>& apps) = 0;
};

// 轮询策略
class RoundRobinStrategy : public LoadBalanceStrategy
{
public:
    BaseApp* selectBaseApp(const std::vector<BaseApp*>& apps) override
    {
        size_t index = currentIndex_ % apps.size();
        ++currentIndex_;
        return apps[index];
    }

private:
    size_t currentIndex_ = 0;
};

// 最少连接策略
class LeastConnectionStrategy : public LoadBalanceStrategy
{
public:
    BaseApp* selectBaseApp(const std::vector<BaseApp*>& apps) override
    {
        BaseApp* selected = nullptr;
        size_t minConnections = SIZE_MAX;

        for (BaseApp* app : apps)
        {
            if (app->getConnectionCount() < minConnections)
            {
                minConnections = app->getConnectionCount();
                selected = app;
            }
        }

        return selected;
    }
};

// BaseAppMgr 使用策略
class BaseAppMgr
{
public:
    void setStrategy(LoadBalanceStrategy* strategy)
    {
        strategy_.reset(strategy);
    }

    BaseApp* findBestBaseApp()
    {
        return strategy_->selectBaseApp(baseApps_);
    }

private:
    std::unique_ptr<LoadBalanceStrategy> strategy_;
    std::vector<BaseApp*> baseApps_;
};

// KBEngine 消息处理链
// src/server/components/components.cpp

class MessageHandler
{
public:
    using HandlerFunc = std::function<bool(MemoryStream&)>;

    MessageHandler(): next_(nullptr) {}

    // 设置下一个处理器
    void setNext(MessageHandler* next)
    {
        next_ = next;
    }

    // 处理消息
    bool handle(MemoryStream& stream)
    {
        // 尝试自己处理
        if (handleMessage(stream))
        {
            return true;
        }

        // 传递给下一个
        if (next_)
        {
            return next_->handle(stream);
        }

        return false;
    }

    // 注册处理器
    void registerHandler(const std::string& msgName, HandlerFunc func)
    {
        handlers_[msgName] = func;
    }

protected:
    virtual bool handleMessage(MemoryStream& stream)
    {
        std::string msgName;
        stream >> msgName;

        auto it = handlers_.find(msgName);
        if (it != handlers_.end())
        {
            return it->second(stream);
        }

        return false;
    }

private:
    MessageHandler* next_;
    std::map<std::string, HandlerFunc> handlers_;
};

// 使用示例：构建处理链
MessageHandler* buildHandlerChain()
{
    // 创建各级处理器
    MessageHandler* authHandler = new MessageHandler();
    MessageHandler* logicHandler = new MessageHandler();
    MessageHandler* dbHandler = new MessageHandler();

    // 构建链
    authHandler->setNext(logicHandler);
    logicHandler->setNext(dbHandler);

    // 注册处理器
    authHandler->registerHandler("Login", handleLogin);
    logicHandler->registerHandler("Move", handleMove);
    dbHandler->registerHandler("Save", handleSave);

    return authHandler;
}

// KBEngine 空间组合模式
// src/server/cellapp/space.h

class Space
{
public:
    virtual ~Space() {}

    // 添加子空间
    virtual void addSpace(Space* space)
    {
        // 基础空间不实现
    }

    // 移除子空间
    virtual void removeSpace(Space* space)
    {
        // 基础空间不实现
    }

    // 更新空间
    virtual void update(float delta)
    {
        // 更新自身
    }
};

// 复合空间
class CompositeSpace : public Space
{
public:
    void addSpace(Space* space) override
    {
        children_.push_back(space);
    }

    void removeSpace(Space* space) override
    {
        children_.erase(
            std::remove(children_.begin(), children_.end(), space),
            children_.end()
        );
    }

    void update(float delta) override
    {
        // 更新所有子空间
        for (Space* child : children_)
        {
            child->update(delta);
        }

        // 更新自身
        updateSelf(delta);
    }

private:
    void updateSelf(float delta)
    {
        // 自身更新逻辑
    }

    std::vector<Space*> children_;
};

// 叶子空间（实际游戏空间）
class CellSpace : public Space
{
public:
    void update(float delta) override
    {
        // 更新空间内的实体
        updateEntities(delta);
    }

private:
    std::vector<Entity*> entities_;
};