Events¶

-- Subscribes a function to an event
Event.NPCEntityAdded.Subscribe("myRefName", function(npcAddedEvent) log("An NPC was added!") end)

-- Unsubscribes the previous function
Event.NPCEntityAdded.Unsubscribe("myRefName")

-- Multiple functions can be subscribed to the same event
Event.NPCEntityAdded.Subscribe("myRefName", function(npcAddedEvent) log("An NPC was added!") end)
Event.NPCEntityAdded.Subscribe("aDifferentRefName", function(npcAddedEvent) log("I can't believe it.") end)
Event.NPCEntityAdded.Subscribe("theThirdOne", function(npcAddedEvent) log("Just baffling stuff.") end)

-- Log output:
-- An NPC was added!
-- I can't believe it.
-- Just baffling stuff.

-- Unsubscribe order doesn't matter
Event.NPCEntityAdded.Unsubscribe("aDifferentRefName");
Event.NPCEntityAdded.Unsubscribe("myRefName");
Event.NPCEntityAdded.Unsubscribe("theThirdOne");

-- Subscribe first function
Event.NPCEntityAdded.Subscribe("myRefName", function(npcAddedEvent) log("An NPC was added!") end)

-- Subscribe another for a different event, using the same reference name
-- This doesn't overwrite the first function
Event.NPCEntityRemoved.Subscribe("myRefName", function(npcRemovedEvent) log("An NPC was removed!") end)

-- Subscribe to the first event again
-- This DOES overwrite the first function
Event.NPCEntityAdded.Subscribe("myRefName", function(npcAddedEvent) log("An NPC was added, at coord " .. to_string(npcAddedEvent.npcEntity.coordGrid) .. "!") end)

-- Unsubscribes both functions
Event.NPCEntityAdded.Unsubscribe("myRefName");
Event.NPCEntityRemoved.Unsubscribe("myRefName");

-- In plugin A
Event.NPCEntityAdded.Subscribe("myRefName", function(npcAddedEvent) log("I'm called from Plugin A!") end)

-- In plugin B
Event.NPCEntityAdded.Subscribe("myRefName", function(npcAddedEvent) log("I'm called from Plugin B!") end)

-- Log output:
-- I'm called from Plugin A!
-- I'm called from Plugin B!

function addHello(chatMessageEvent)
    chatMessageEvent.chatMessage = chatMessageEvent.chatMessage ... " Hello!"
    log(chatMessageEvent.chatMessage)
end

function addGoodbye(chatMessageEvent)
    chatMessageEvent.chatMessage = chatMessageEvent.chatMessage ... " Goodbye!"
    log(chatMessageEvent.chatMessage)
end

-- In plugin A
Event.ChatMessage.Subscribe("hello", addHello)

-- In plugin B
Event.ChatMessage.Subscribe("goodbye", addGoodbye)

-- For a new message received: "I'm a chat message."
-- Log output:
-- I'm a chat message. Hello!
-- I'm a chat message. Hello! Goodbye!

Event.Logic.Subscribe("myEvent", function(logicEvent) log("Client tick is currently " .. logicEvent.logicTick) end)

Event.ServerLogic.Subscribe("myEvent", function() log("Server tick has occurred") end)

Event.Draw.Subscribe("myEvent", function(drawEvent) log("My FPS is " .. (1.0 / drawEvent.timeDeltaSecs)) end)

function depChanged(optionalDependencyChangedEvent)
    log("Optional dependency", optionalDependencyChangedEvent.pluginIdentifier, "is now", optionalDependencyChangedEvent.enabled)
end
Event.OptionalDependencyChanged.Subscribe("myEvent", depChanged)

function permChanged(optionalPermissionChangedEvent)
    log("Optional permission", optionalPermissionChangedEvent.permissionName, "is now", optionalPermissionChangedEvent.enabled)
end
Event.OptionalPermissionChanged.Subscribe("myEvent", permChanged)

Event.KeyUp.Subscribe("myEvent", function(keyUpEvent) log("I just released the " .. GameKey.FromID(keyUpEvent.gameKey) .. " key!") end)

function keyDownFunc(keyDownEvent)
    if keyDownEvent.isRepeat then
        log("The " .. GameKey.FromID(keyDownEvent.gameKey) .. " key was held down and repeated!")
    else
        log("I just pressed the " .. GameKey.FromID(keyDownEvent.gameKey) .. " key!")
    end
end
Event.KeyDown.Subscribe("myEvent", keyDownFunc)

Event.KeyTyped.Subscribe("myEvent", function(keyTypedEvent) log("I just typed " .. string.char(keyTypedEvent.char)) end)

function varTest(varTransmitEvent)
    if varTransmitEvent.var == var.Player.COMBATV2_MELEE_DEFENCE then
        log("Value change: " .. (varTransmitEvent.oldValue or "nil") .. " -> " .. (varTransmitEvent.newValue or "nil"))
    end
end
Event.VarTransmit.Subscribe("myEvent", varTest)

function messageFunc(chatMessageEvent)
    if chatMessageEvent.chatType == ChatType.PRIVATE_INCOMING then
        -- Wrap message in a red colour tag
        chatMessageEvent.chatMessage = "<col=FF0000>" .. chatMessageEvent.chatMessage .. "</col>"
    end
end
Event.ChatMessage.Subscribe("myEvent", messageFunc)

function playerFunc(playerEntityAddedEvent)
    log("Player " .. playerEntityAddedEvent.playerEntity.displayName .. " has appeared!")
end
Event.PlayerEntityAdded.Subscribe("myEvent", playerFunc)

function playerFunc(playerEntityRemovedEvent)
    log("Player " .. playerEntityRemovedEvent.playerEntity.displayName .. " has departed.")
end
Event.PlayerEntityRemoved.Subscribe("myEvent", playerFunc)

function npcFunc(npcEntityAddedEvent)
    log("NPC " .. npcEntityAddedEvent.npcEntity.displayName .. " has appeared!")
end
Event.NPCEntityAdded.Subscribe("myEvent", npcFunc)

function npcFunc(npcEntityRemovedEvent)
    log("NPC " .. npcEntityRemovedEvent.npcEntity.displayName .. " has departed.")
end
Event.NPCEntityRemoved.Subscribe("myEvent", npcFunc)

function objStackAddedFunc(objStackEntityAddedEvent)
    log("An objStack has been added, " .. objStackEntityAddedEvent.count .. "x of " .. objStackEntityAddedEvent.objType.name)
end
Event.ObjStackEntityAdded.Subscribe("myEvent", objStackAddedFunc)

function objStackRemovedFunc(objStackEntityRemovedEvent)
    log("An objStack has been removed, " .. objStackEntityRemovedEvent.count .. "x of " .. objStackEntityRemovedEvent.objType.name)
end
Event.ObjStackEntityRemoved.Subscribe("myEvent", objStackRemovedFunc)

function objStackChangedFunc(objStackEntityChangedEvent)
    log("An objStack has changed, " .. objStackEntityRemovedEvent.oldCount .. "x -> " .. objStackEntityRemovedEvent.newCount .. "x of " .. objStackEntityRemovedEvent.objType.name)
end
Event.ObjStackEntityChanged.Subscribe("myEvent", objStackChangedFunc)

function focusChangedFunc(windowFocusChangedEvent)
    log("Window focus changed: " .. (windowFocusChangedEvent.hasFocus and "in focus" or "not in focus"))
end
Event.WindowFocusChanged.Subscribe("myEvent", focusChangedFunc)

function gameStateChangedFunc(gameStateChangedEvent)
    log("Game state changed: " .. GameState.FromID(gameStateChangedEvent.oldState) .. " -> " .. GameState.FromID(gameStateChangedEvent.newState))
end
Event.GameStateChanged.Subscribe("myEvent", gameStateChangedFunc)

function hansHiderFunc(entityDrawEvent)
    -- If the entity is an NPC and has the config belonging to Hans
    if entityDrawEvent.entityType == EntityType.NPC and entityDrawEvent.npcEntity.configID == id.NPC.HANS
        -- Returning false tells the entity to skip drawing
        return false
    end
    -- Returning true tells the entity to continue drawing
    return true
end
Event.EntityDraw.Subscribe("myEvent", hansHiderFunc)

function windowSizeChangedFunc(windowSizeChangedEvent)
    log("Window size changed: " .. windowSizeChangedEvent.oldWidth .. " x " .. windowSizeChangedEvent.oldHeight .. " -> " .. windowSizeChangedEvent.newWidth .. " x " .. windowSizeChangedEvent.newHeight)
end
Event.WindowSizeChanged.Subscribe("myEvent", windowSizeChangedFunc)

function skillTransmitFunc(skillTransmitEvent)
    log("Skill transmit: (ID " .. skillTransmitEvent.skill .. " (" .. SkillType.FromID(skillTransmitEvent.skill) .. "), XP " .. skillTransmitEvent.oldXP .. " -> " .. skillTransmitEvent.newXP .. ", Gameplay Level " .. skillTransmitEvent.oldGameplayLevel .. " -> " .. skillTransmitEvent.newGameplayLevel)
end
Event.SkillTransmit.Subscribe("myEvent", skillTransmitFunc)

function runEnergyTransmitFunc(runEnergyTransmitEvent)
    log("Run energy: " .. runEnergyTransmitEvent.oldRunEnergy .. " -> " .. runEnergyTransmitEvent.newRunEnergy)
end
Event.RunEnergyTransmit.Subscribe("myEvent", runEnergyTransmitFunc)

function runWeightTransmitFunc(runWeightTransmitEvent)
    log("Weight: " .. runWeightTransmitEvent.oldRunWeight .. " -> " .. runWeightTransmitEvent.newRunWeight)
end
Event.RunWeightTransmit.Subscribe("myEvent", runWeightTransmitFunc)

function miniMenuOpenedFunc(miniMenuOpenedEvent)
    log("Entry count: " .. miniMenuOpenedEvent.miniMenu.entryCount)
end
Event.MiniMenuOpened.Subscribe("myEvent", miniMenuOpenedFunc)

function miniMenuClosedFunc(miniMenuClosedEvent)
    log("Entry count: " .. miniMenuClosedEvent.miniMenu.entryCount)
end
Event.MiniMenuClosed.Subscribe("myEvent", miniMenuClosedFunc)

function miniMenuReadyFunc(miniMenuReadyEvent)
    -- Make changes to the minimenu
    local count = miniMenuReadyEvent.miniMenu.entryCount
    if count > 1 then
        -- Swap the highest priority entries
        miniMenuReadyEvent.miniMenu:Swap(count - 1, count)
    end
end
Event.MiniMenuReady.Subscribe("myEvent", miniMenuReadyFunc)

function miniMenuEntryAddedFunc(miniMenuEntryAddedEvent)
    if miniMenuEntryAddedEvent.entry.actionEntryType == MiniMenuEntryType.NPC then
        local npcEntity = miniMenuEntryAddedEvent.entry.npcData.entity
        -- Do something with the NPC
    end
end
Event.MiniMenuEntryAdded.Subscribe("myEvent", miniMenuEntryAddedFunc)

function miniMenuEntrySelectedFunc(miniMenuEntrySelectedEvent)
    if miniMenuEntrySelectedEvent.entry.actionEntryType == MiniMenuEntryType.NPC then
        local npcEntity = miniMenuEntrySelectedEvent.entry.npcData.entity
        -- Do something with the NPC that was selected
    end
end
Event.MiniMenuEntrySelected.Subscribe("myEvent", miniMenuEntrySelectedFunc)

function locAddedFunc(locAddedEvent)
    log("Location " .. locAddedEvent.config.configName .. " has been added to " .. tostring(locAddedEvent.coordGrid) .. "!")
end
Event.LocAdded.Subscribe("myEvent", locAddedFunc)

function locRemovedFunc(locRemovedEvent)
    log("A location has been removed from " .. tostring(locRemovedEvent.coordGrid) .. "!")
end
Event.LocRemoved.Subscribe("myEvent", locRemovedFunc)

function locRemovedFunc(locRemovedEvent)
    log("A location has been removed from " .. tostring(locRemovedEvent.coordGrid) .. "!")
end
Event.LocRemoved.Subscribe("myEvent", locRemovedFunc)

function locAnimationFunc(locAnimationEvent)
    log("A location is now playing animation " .. tostring(locAnimationEvent.animation))
end
Event.LocRemoved.Subscribe("myEvent", locAnimationFunc)

function onInventoryAdded(inventoryAddedEvent)
    local addedInvID = inventoryAddedEvent.inv
    -- Do something with the added inventory config
end
Event.InventoryAdded.Subscribe("myEvent", onInventoryAdded)

function onInventoryUpdated(inventoryUpdatedEvent)
    local updatedInvID = inventoryUpdatedEvent.inv
    -- Do something with the updated inventory config
    for i,slot in ipairs(inventoryUpdatedEvent.slotsUpdated) do
        -- Do something with the updated slots
    end
end
Event.InventoryUpdated.Subscribe("myEvent", onInventoryUpdated)

function onInventoryRemoved(inventoryRemovedEvent)
    local removedInvID = inventoryRemovedEvent.inv
    -- Do something with the removed inventory ID
end
Event.InventoryRemoved.Subscribe("myEvent", onInventoryRemoved)

function onGEOfferUpdated(slotUpdatedEvent)
    local slot = slotUpdatedEvent.slot
    -- Do something with the slot ID where applicable
end
Event.GrandExchangeOfferUpdated.Subscribe("myEvent", onGEOfferUpdated)

function onWorldCreated(worldCreatedEvent)
    local worldAreaWidth = worldCreatedEvent.mapSquareMaxX - worldCreatedEvent.mapSquareMinX + 1
    local worldAreaLength = worldCreatedEvent.mapSquareMaxZ - worldCreatedEvent.mapSquareMinZ + 1
end
Event.WorldCreated.Subscribe("myEvent", onWorldCreated)

function onWorldUpdated()
    -- No payload
    -- Act on world build changes
end
Event.WorldUpdated.Subscribe("myEvent", onWorldUpdated)

function onRegionCreated(regionCreatedEvent)
    --
end
Event.RegionCreated.Subscribe("myEvent", onRegionCreated)

function onRegionUpdated()
    -- No payload
    -- Act on region build changes
end
Event.RegionUpdated.Subscribe("myEvent", onRegionUpdated)

function onSettingsLayerReady(settingsLayerReadyEvent)
    local rootLayer = settingsLayerReadyEvent.component
    -- Populate the root layer with settings
end
Event.SettingsLayerReady.Subscribe("myEvent", onSettingsLayerReady)

function onContentLayerReady(contentLayerReadyEvent)
    local rootLayer = contentLayerReadyEvent.component
    -- Populate the root layer with settings
end
Event.ContentLayerReady.Subscribe("myEvent", onContentLayerReady)