武侠-event

最新推荐文章于 2024-05-17 11:15:35 发布

转载最新推荐文章于 2024-05-17 11:15:35 发布 · 114 阅读

文章标签：

#lua

一武侠的event是个比较强的系统，个人感觉也是做的比较好的，结合lua使用起来很不错

二实现

1 定义结构

struct EVENT_DEFINE
{
    typedef std::list< std::pair< FUNC_EVENT_HANDLE, UINT > > REGISTER_STRUCT;

    GAME_EVENT_ID        idEvent;
    LPCTSTR                szEvent;
    BOOL                delayProcess;
    REGISTER_STRUCT        listFuncNotify;
};

struct EVENT
{
    EVENT_DEFINE*        pEventDef;
    std::vector<STRING>    vArg;

    bool operator == (const EVENT& other)
    {
        if(other.pEventDef != pEventDef)
            return false;
        if(other.vArg.size() != vArg.size())
            return false;

        for(register size_t i=0; i<vArg.size(); i++)
        {
            if(vArg[i] != other.vArg[i])
                return false;
        }

        return true;
    }
};

变量

//通过事件名称检索表
std::map< STRING, EVENT_DEFINE* > m_mapEventIndex_AsName;
//通过事件ID检索表
std::map< GAME_EVENT_ID, EVENT_DEFINE* > m_mapEventIndex_AsID;

保存了所有注册的事件，可以通过ID和Name索引

//事件队列
std::list< EVENT > m_queueEvent;

//慢速处理队列, 每桢一个，防止过多的消息同时涌现
std::list< EVENT > m_delayQueueEvent;

保存了当前需要处理的事件

2 lua注册接口

INT CUIWindowItem::LUA_RegisterEvent(LuaPlus::LuaState* pState)
{
    LuaStack args(pState);
    if(!(args[2].IsString()))
        return 0;

    if(m_bLayoutLoaded)
    {
        KLThrow("%s Must register event in \"***PreLoad\" Function ", m_strWindowName.c_str());
    }

    STRING strEventName = args[2].GetString();

    g_pEventSys->RegisterEventHandle(strEventName, _OnGameEvent, (DWORD)(DWORD_PTR)this);

    return 0;
}

// 注册事件处理函数
VOID CEventSystem::RegisterEventHandle(const STRING& nameEvent, FUNC_EVENT_HANDLE funHandle, UINT uOwnerData)
{
    if(!funHandle)
        return;

    EVENT_DEFINE* pEvent = m_mapEventIndex_AsName[nameEvent];
    if(!pEvent)
        return;

    pEvent->listFuncNotify.push_back( std::make_pair(funHandle, uOwnerData) );
}

3 添加处理事件

VOID CEventSystem::PushEvent(STRING& eventName, LPCTSTR szArg0, LPCTSTR szArg1, INT iArg2, INT iArg3)
{
    if(m_mapEventIndex_AsName.find(eventName) == m_mapEventIndex_AsName.end()) return;

    EVENT event;
    event.pEventDef=m_mapEventIndex_AsName[eventName];

    event.vArg.push_back(szArg0);
    event.vArg.push_back(szArg1);

    CHAR szTemp[32];
    _snprintf(szTemp, 32, "%d", iArg2);
    event.vArg.push_back(szTemp);
    _snprintf(szTemp, 32, "%d", iArg3);
    event.vArg.push_back(szTemp);

    _PushEvent(event);
}

void CEventSystem::_PushEvent(const EVENT& event)
{
    if(!event.pEventDef)
        return;

    // 如果是慢速处理的事件
    if(event.pEventDef->delayProcess)
    {
        m_delayQueueEvent.push_back(event);
    }
    else
    {
        m_queueEvent.push_back(event);
    }
}

            // 距离发生改变，产生事件
            std::vector< STRING > vParam;
            CHAR szTemp[MAX_PATH];

            _snprintf(szTemp, MAX_PATH, "%d", pObject->GetID());
            vParam.push_back(szTemp);

            vParam.push_back("distance");

            _snprintf(szTemp, MAX_PATH, "%.3f", fDistance);
            vParam.push_back(szTemp);

            CEventSystem::GetMe()->PushEvent(GE_OBJECT_CARED_EVENT, vParam);

4 执行事件

VOID CEventSystem::ProcessAllEvent(VOID)
{
    // 处理慢速队列
    if(!(m_delayQueueEvent.empty()))
    {
        const UINT WORK_STEP = 2;
        UINT nTickCountNow = CGameProcedure::s_pTimeSystem->GetTickCount();
        UINT nTickCountStep = CGameProcedure::s_pTimeSystem->CalSubTime(m_dwLastTickCount, nTickCountNow);
        if(nTickCountStep >= WORK_STEP)
        {
            m_dwLastTickCount = nTickCountNow;

            const EVENT& event = *(m_delayQueueEvent.begin());

            _ProcessEvent(event);

            m_delayQueueEvent.erase(m_delayQueueEvent.begin());
        }
    }

    register std::list< EVENT >::iterator it;
    for(it=m_queueEvent.begin(); it!=m_queueEvent.end(); it++)
    {
        const EVENT& event = *it;

        // 检测是否有同样的Event已经被处理
        bool bMultiPushed = false;
        for(register std::list< EVENT >::iterator itPrev=m_queueEvent.begin(); itPrev !=it; itPrev++)
        {
            if(*itPrev == *it)
            {
                bMultiPushed = true;
                break;
            }
        }

        if(bMultiPushed)
            continue;

        _ProcessEvent(event);
    }

    m_queueEvent.clear();
}

void CEventSystem::_ProcessEvent(const EVENT& event)
{
    // 查找事件定义
    EVENT_DEFINE* pEventDef = event.pEventDef;
    if(!pEventDef)
        return;

    // 调用处理函数
    if(!(pEventDef->listFuncNotify.empty()))
    {
        EVENT_DEFINE::REGISTER_STRUCT::iterator it;
        for(it=pEventDef->listFuncNotify.begin(); it!=pEventDef->listFuncNotify.end(); it++)
        {
            if((*it).first)
                ((*it).first)(&event, (*it).second);
        }
    }
}

另外有一个回调函数，执行具体的lua调用

VOID WINAPI    CUIWindowItem::_OnGameEvent(const EVENT* pEvent, UINT dwOwnerData)
{
    KLAssert(pEvent);

    //--------------------------------------------------------
    // 分发
    CUIWindowItem* pWinItem = (CUIWindowItem*)(DWORD_PTR)(dwOwnerData);
    if(!pWinItem)
        return;

    // 加载
    if(!(pWinItem->m_bLayoutLoaded))
    {
        pWinItem->LoadWindow();
    }

    //--------------------------------------------------------
    // 参数
    for(INT i=0; i<(INT)pEvent->vArg.size(); i++)
    {
        CHAR szTemp[MAX_PATH];
        _snprintf(szTemp, MAX_PATH, "arg%d", i);
        g_pScriptSys->GetLuaState()->GetGlobals().SetString(szTemp, pEvent->vArg[i].c_str());
    }

    //--------------------------------------------------------
    // 调用脚本
    CHAR szFunctionName[MAX_PATH];
    _snprintf(szFunctionName, MAX_PATH, "%s_OnEvent", pWinItem->m_strWindowName.c_str());

    CHAR szFunctionParam[MAX_PATH];
    _snprintf(szFunctionParam, MAX_PATH, "\"%s\"", pEvent->pEventDef->szEvent);

    pWinItem->m_pScriptEnv->DoFunction(szFunctionName, szFunctionParam);
}