Noble SDK

# EventManager

# 说明

EventManager命名空间提供了一系列事件处理功能，可以注册和移除各种游戏事件的回调函数。通过这些事件，您可以在游戏中的特定时刻执行自定义代码。

# 如何使用

#include "Noble.h"

void OnGameUpdateCallback()
{
    // 在游戏每帧更新时执行的代码
    Console::Add("Game update");
}

void OnLoadCallback()
{
    // 注册游戏更新事件
    EventManager::OnGameUpdate::Add(&OnGameUpdateCallback);
}

// 在插件初始化时注册OnLoad事件
EventManager::OnLoad::Add(&OnLoadCallback);

# OnLoad.Add

void EventManager::OnLoad::Add(void* function)

注册一个在插件加载时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnLoad()
void OnLoadCallback() 
{
    Console::Add("Plugin loaded");
}

EventManager::OnLoad::Add(&OnLoadCallback);

# OnLoad.Remove

void EventManager::OnLoad::Remove(void* function)

移除一个已注册的OnLoad回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnLoad::Remove(&OnLoadCallback);

# OnUnLoad.Add

void EventManager::OnUnLoad::Add(void* function)

注册一个在插件卸载时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnUnLoad()
void OnUnLoadCallback() 
{
    Console::Add("Plugin unloaded");
}

EventManager::OnUnLoad::Add(&OnUnLoadCallback);

# OnUnLoad.Remove

void EventManager::OnUnLoad::Remove(void* function)

移除一个已注册的OnUnLoad回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnUnLoad::Remove(&OnUnLoadCallback);

# OnGameUpdate.Add

void EventManager::OnGameUpdate::Add(void* function)

注册一个在每帧游戏更新时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnGameUpdate()
void OnGameUpdateCallback() 
{
    // 每帧执行的代码
}

EventManager::OnGameUpdate::Add(&OnGameUpdateCallback);

# OnGameUpdate.Remove

void EventManager::OnGameUpdate::Remove(void* function)

移除一个已注册的OnGameUpdate回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnGameUpdate::Remove(&OnGameUpdateCallback);

# OnRender.Add

void EventManager::OnRender::Add(void* function)

注册一个在游戏渲染时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnRender()
void OnRenderCallback() 
{
    // 绘制自定义图形
    Drawing::DrawText(Vector(100, 100), 20, MAKE_COLOR(255, 0, 0, 255), "Hello World");
}

EventManager::OnRender::Add(&OnRenderCallback);

# OnRender.Remove

void EventManager::OnRender::Remove(void* function)

移除一个已注册的OnRender回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnRender::Remove(&OnRenderCallback);

# OnWndProc.Add

void EventManager::OnWndProc::Add(void* function)

注册一个处理Windows消息的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnWndProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
void OnWndProcCallback(UINT uMsg, WPARAM wParam, LPARAM lParam) 
{
    // 处理Windows消息
    if (uMsg == WM_KEYDOWN && wParam == VK_SPACE)
    {
        Console::Add("Space key pressed");
    }
}

EventManager::OnWndProc::Add(&OnWndProcCallback);

# OnWndProc.Remove

void EventManager::OnWndProc::Remove(void* function)

移除一个已注册的OnWndProc回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnWndProc::Remove(&OnWndProcCallback);

# OnCreateObject.Add

void EventManager::OnCreateObject::Add(void* function)

注册一个在游戏对象创建时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnCreateObject(GameObject* sender)
void OnCreateObjectCallback(GameObject* sender) 
{
    // 处理新创建的游戏对象
    if (sender->IsAIHero() && sender->IsEnemy())
    {
        Console::Add("Enemy hero created: %s", sender->Name());
    }
}

EventManager::OnCreateObject::Add(&OnCreateObjectCallback);

# OnCreateObject.Remove

void EventManager::OnCreateObject::Remove(void* function)

移除一个已注册的OnCreateObject回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnCreateObject::Remove(&OnCreateObjectCallback);

# OnDeleteObject.Add

void EventManager::OnDeleteObject::Add(void* function)

注册一个在游戏对象删除时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnDeleteObject(GameObject* sender)
void OnDeleteObjectCallback(GameObject* sender) 
{
    // 处理被删除的游戏对象
    if (sender->IsAIHero())
    {
        Console::Add("Hero deleted: %s", sender->Name());
    }
}

EventManager::OnDeleteObject::Add(&OnDeleteObjectCallback);

# OnDeleteObject.Remove

void EventManager::OnDeleteObject::Remove(void* function)

移除一个已注册的OnDeleteObject回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnDeleteObject::Remove(&OnDeleteObjectCallback);

# OnProcessSpellCast.Add

void EventManager::OnProcessSpellCast::Add(void* function)

注册一个在技能施放开始时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnProcessSpellCast(Spellbook* args)
void OnProcessSpellCastCallback(Spellbook* args) 
{
    // 处理技能施放事件
    if (args->Sender()->IsEnemy() && args->Sender()->IsAIHero())
    {
        Console::Add("Enemy casting spell: %s", args->SData()->Name());
    }
}

EventManager::OnProcessSpellCast::Add(&OnProcessSpellCastCallback);

# OnProcessSpellCast.Remove

void EventManager::OnProcessSpellCast::Remove(void* function)

移除一个已注册的OnProcessSpellCast回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnProcessSpellCast::Remove(&OnProcessSpellCastCallback);

# OnDoCast.Add

void EventManager::OnDoCast::Add(void* function)

注册一个在技能施放完成时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnDoCast(Spellbook* args)
void OnDoCastCallback(Spellbook* args) 
{
    // 处理技能施放完成事件
    if (args->Sender()->IsMe())
    {
        Console::Add("I finished casting: %s", args->SData()->Name());
    }
}

EventManager::OnDoCast::Add(&OnDoCastCallback);

# OnDoCast.Remove

void EventManager::OnDoCast::Remove(void* function)

移除一个已注册的OnDoCast回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnDoCast::Remove(&OnDoCastCallback);

# OnStopCast.Add

void EventManager::OnStopCast::Add(void* function)

注册一个在技能施放被中断时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnStopCast(AIBaseClient* sender)
void OnStopCastCallback(AIBaseClient* sender) 
{
    // 处理技能施放中断事件
    if (sender->IsMe())
    {
        Console::Add("My spell cast was interrupted");
    }
}

EventManager::OnStopCast::Add(&OnStopCastCallback);

# OnStopCast.Remove

void EventManager::OnStopCast::Remove(void* function)

移除一个已注册的OnStopCast回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnStopCast::Remove(&OnStopCastCallback);

# OnNewPath.Add

void EventManager::OnNewPath::Add(void* function)

注册一个在单位获得新路径时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnNewPath(AIBaseClient* sender, std::vector<Vector> const& path, bool IsDash, float dashSpeed)
void OnNewPathCallback(AIBaseClient* sender, std::vector<Vector> const& path, bool IsDash, float dashSpeed) 
{
    // 处理新路径事件
    if (sender->IsEnemy() && sender->IsAIHero() && IsDash)
    {
        Console::Add("Enemy hero dashing with speed: %f", dashSpeed);
    }
}

EventManager::OnNewPath::Add(&OnNewPathCallback);

# OnNewPath.Remove

void EventManager::OnNewPath::Remove(void* function)

移除一个已注册的OnNewPath回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnNewPath::Remove(&OnNewPathCallback);

# OnIssueOrder.Add

void EventManager::OnIssueOrder::Add(void* function)

注册一个在发出移动或攻击命令时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnIssueOrder(eGameObjectOrder Order, AIBaseClient* m_target, Vector const& TargetPosition, bool& Process)
void OnIssueOrderCallback(eGameObjectOrder Order, AIBaseClient* m_target, Vector const& TargetPosition, bool& Process) 
{
    // 处理发出命令事件
    if (Order == eGameObjectOrder::AttackUnit && m_target && m_target->IsAIHero())
    {
        Console::Add("Attacking enemy hero");
    }
}

EventManager::OnIssueOrder::Add(&OnIssueOrderCallback);

# OnIssueOrder.Remove

void EventManager::OnIssueOrder::Remove(void* function)

移除一个已注册的OnIssueOrder回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnIssueOrder::Remove(&OnIssueOrderCallback);

# OnCastSpell.Add

void EventManager::OnCastSpell::Add(void* function)

注册一个在通过API施放技能时调用的回调函数（注意：只对Noble内部请求有效，用户手动施放技能不会触发此事件）。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnCastSpell(eSpellSlot Slot, AIBaseClient* Target, Vector const& StartPosition, Vector const& EndPosition, bool& Process)
void OnCastSpellCallback(eSpellSlot Slot, AIBaseClient* Target, Vector const& StartPosition, Vector const& EndPosition, bool& Process) 
{
    // 处理施放技能事件
    if (Slot == eSpellSlot::R && Target && Target->IsEnemy() && Target->IsAIHero())
    {
        Console::Add("Casting ultimate on enemy hero");
    }
}

EventManager::OnCastSpell::Add(&OnCastSpellCallback);

# OnCastSpell.Remove

void EventManager::OnCastSpell::Remove(void* function)

移除一个已注册的OnCastSpell回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnCastSpell::Remove(&OnCastSpellCallback);

# OnMinionProcessSpellCast.Add

void EventManager::OnMinionProcessSpellCast::Add(void* function)

注册一个在小兵开始施放技能时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnMinionProcessSpellCast(AIBaseClient* sender, AIBaseClient* Target, float MissileSpeed)
void OnMinionProcessSpellCastCallback(AIBaseClient* sender, AIBaseClient* Target, float MissileSpeed) 
{
    // 处理小兵施放技能事件
    if (sender->IsMinion() && Target && Target->IsMe())
    {
        Console::Add("Minion attacking me with missile speed: %f", MissileSpeed);
    }
}

EventManager::OnMinionProcessSpellCast::Add(&OnMinionProcessSpellCastCallback);

# OnMinionProcessSpellCast.Remove

void EventManager::OnMinionProcessSpellCast::Remove(void* function)

移除一个已注册的OnMinionProcessSpellCast回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnMinionProcessSpellCast::Remove(&OnMinionProcessSpellCastCallback);

# OnMinionOnDoCast.Add

void EventManager::OnMinionOnDoCast::Add(void* function)

注册一个在小兵完成施放技能时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnMinionOnDoCast(AIBaseClient* sender)
void OnMinionOnDoCastCallback(AIBaseClient* sender) 
{
    // 处理小兵完成施放技能事件
    if (sender->IsMinion())
    {
        Console::Add("Minion finished casting");
    }
}

EventManager::OnMinionOnDoCast::Add(&OnMinionOnDoCastCallback);

# OnMinionOnDoCast.Remove

void EventManager::OnMinionOnDoCast::Remove(void* function)

移除一个已注册的OnMinionOnDoCast回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnMinionOnDoCast::Remove(&OnMinionOnDoCastCallback);

# OnMinionOnStopCast.Add

void EventManager::OnMinionOnStopCast::Add(void* function)

注册一个在小兵中断施放技能时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnMinionOnStopCast(AIBaseClient* sender)
void OnMinionOnStopCastCallback(AIBaseClient* sender) 
{
    // 处理小兵中断施放技能事件
    if (sender->IsMinion())
    {
        Console::Add("Minion stopped casting");
    }
}

EventManager::OnMinionOnStopCast::Add(&OnMinionOnStopCastCallback);

# OnMinionOnStopCast.Remove

void EventManager::OnMinionOnStopCast::Remove(void* function)

移除一个已注册的OnMinionOnStopCast回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnMinionOnStopCast::Remove(&OnMinionOnStopCastCallback);

# OnAttackDelay.Add

void EventManager::OnAttackDelay::Add(void* function)

注册一个在攻击延迟计算时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnAttackDelay(bool& Process, AIBaseClient* lastTarget, int LastAAFinishTick)
void OnAttackDelayCallback(bool& Process, AIBaseClient* lastTarget, int LastAAFinishTick) 
{
    // 处理攻击延迟事件
    if (lastTarget && lastTarget->IsEnemy() && lastTarget->IsAIHero())
    {
        Console::Add("Attack delay on enemy hero");
    }
}

EventManager::OnAttackDelay::Add(&OnAttackDelayCallback);

# OnAttackDelay.Remove

void EventManager::OnAttackDelay::Remove(void* function)

移除一个已注册的OnAttackDelay回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnAttackDelay::Remove(&OnAttackDelayCallback);

# AfterAttack.Add

void EventManager::AfterAttack::Add(void* function)

注册一个在攻击完成后调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void AfterAttack(AIBaseClient* target)
void AfterAttackCallback(AIBaseClient* target) 
{
    // 处理攻击完成后事件
    if (target && target->IsEnemy() && target->IsAIHero())
    {
        Console::Add("Finished attacking enemy hero");
    }
}

EventManager::AfterAttack::Add(&AfterAttackCallback);

# AfterAttack.Remove

void EventManager::AfterAttack::Remove(void* function)

移除一个已注册的AfterAttack回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::AfterAttack::Remove(&AfterAttackCallback);

# BeforeAttack.Add

void EventManager::BeforeAttack::Add(void* function)

注册一个在攻击开始前调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void BeforeAttack(bool& Process, AIBaseClient* target)
void BeforeAttackCallback(bool& Process, AIBaseClient* target) 
{
    // 处理攻击开始前事件
    if (target && target->IsMinion() && target->Health() > 100)
    {
        // 取消攻击
        Process = false;
    }
}

EventManager::BeforeAttack::Add(&BeforeAttackCallback);

# BeforeAttack.Remove

void EventManager::BeforeAttack::Remove(void* function)

移除一个已注册的BeforeAttack回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::BeforeAttack::Remove(&BeforeAttackCallback);

# OnAttack.Add

void EventManager::OnAttack::Add(void* function)

注册一个在攻击开始时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnAttack(AIBaseClient* target)
void OnAttackCallback(AIBaseClient* target) 
{
    // 处理攻击开始事件
    if (target && target->IsEnemy() && target->IsAIHero())
    {
        Console::Add("Started attacking enemy hero");
    }
}

EventManager::OnAttack::Add(&OnAttackCallback);

# OnAttack.Remove

void EventManager::OnAttack::Remove(void* function)

移除一个已注册的OnAttack回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnAttack::Remove(&OnAttackCallback);

# OnNonKillableMinion.Add

void EventManager::OnNonKillableMinion::Add(void* function)

注册一个在无法击杀小兵时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnNonKillableMinion(AIBaseClient* minion)
void OnNonKillableMinionCallback(AIBaseClient* minion) 
{
    // 处理无法击杀小兵事件
    if (minion && minion->IsMinion())
    {
        Console::Add("Cannot last hit minion with health: %f", minion->Health());
    }
}

EventManager::OnNonKillableMinion::Add(&OnNonKillableMinionCallback);

# OnNonKillableMinion.Remove

void EventManager::OnNonKillableMinion::Remove(void* function)

移除一个已注册的OnNonKillableMinion回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnNonKillableMinion::Remove(&OnNonKillableMinionCallback);

# OnTargetChange.Add

void EventManager::OnTargetChange::Add(void* function)

注册一个在目标改变时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnTargetChange(AIBaseClient* newTarget)
void OnTargetChangeCallback(AIBaseClient* newTarget) 
{
    // 处理目标改变事件
    if (newTarget && newTarget->IsEnemy() && newTarget->IsAIHero())
    {
        Console::Add("Target changed to enemy hero: %s", newTarget->ChampionName());
    }
}

EventManager::OnTargetChange::Add(&OnTargetChangeCallback);

# OnTargetChange.Remove

void EventManager::OnTargetChange::Remove(void* function)

移除一个已注册的OnTargetChange回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnTargetChange::Remove(&OnTargetChangeCallback);

# OnEnemyGapcloser.Add

void EventManager::OnEnemyGapcloser::Add(void* function)

注册一个在敌人使用位移技能时调用的回调函数。

参数名字 参数类型 描述
function void* 回调函数指针，函数原型为 void OnEnemyGapcloser(AIBaseClient* sender, const ActiveGapcloser& args)
void OnEnemyGapcloserCallback(AIBaseClient* sender, const ActiveGapcloser& args) 
{
    // 处理敌人位移技能事件
    if (sender && sender->IsEnemy() && sender->IsAIHero())
    {
        Console::Add("Enemy gapclosing from %f,%f to %f,%f", 
            args.StartPosition.X, args.StartPosition.Z, 
            args.EndPosition.X, args.EndPosition.Z);
    }
}

EventManager::OnEnemyGapcloser::Add(&OnEnemyGapcloserCallback);

# OnEnemyGapcloser.Remove

void EventManager::OnEnemyGapcloser::Remove(void* function)

移除一个已注册的OnEnemyGapcloser回调函数。

参数名字 参数类型 描述
function void* 先前注册的回调函数指针
EventManager::OnEnemyGapcloser::Remove(&OnEnemyGapcloserCallback);

← Evade 命名空间 →