Merge remote-tracking branch 'upstream/master'

Author: hydrozoa-yt

src/main/java/io/luna/game/action/ActionQueue.java

@@ -224,11 +224,9 @@ public void interruptAll() {
     }
 
     /**
-     * Returns the total number of actions currently registered in the processing set.
-     *
-     * @return The processing action count.
+     * @return The active action count.
      */
     public int size() {
-        return processing.size();
+        return executing.size() + processing.size();
     }
 }

src/main/java/io/luna/net/msg/GameMessageReader.java

@@ -142,8 +142,7 @@ private void handleInteractableEvent(Player player, E event) {
 
         Iterator<InteractionAction> actions = player.getActions().getAll(InteractionAction.class).iterator();
         Entity target = ((InteractableEvent) event).target();
-        // todo spam click fix: try removing and interrupting regardless instead of setting listeners and target to
-        //  avoid weird behaviour
+
         if (!actions.hasNext()) {
             // We have no interaction action, submit a new one.
             player.submitAction(new InteractionAction(player, listeners, target, (InteractableEvent) event));
@@ -155,7 +154,7 @@ private void handleInteractableEvent(Player player, E event) {
             first.setListeners(listeners);
             first.setTarget(target);
 
-            // Remove any potential duplicate actions (just in case).
+            // Remove any potential duplicate actions (shouldn't happen, but just in case).
             while (actions.hasNext()) {
                 actions.next().interrupt();
                 actions.remove();

src/main/java/io/luna/net/msg/in/WalkingMessageReader.java

@@ -80,6 +80,7 @@ public boolean validate(Player player, WalkingEvent event) {
 
     @Override
     public void handle(Player player, WalkingEvent event) {
-        player.getOverlays().closeWindows();
+        // Only interrupt actions for non-interaction clicks.
+        player.getOverlays().closeWindows(event.getOrigin() != WalkingOrigin.INTERACTION);
     }
 }

src/main/kotlin/api/api/event/Matcher.kt

@@ -21,10 +21,10 @@ import kotlin.reflect.KClass
 
 /**
  * A matcher that routes events of type [E] by deriving a lookup key of type [K].
- * 
+ *
  * Matchers provide an optimized alternative to scanning every listener in an event pipeline. Each incoming event is
  * transformed into a key via [key], and that key is then used to find the matching listeners directly.
- * 
+ *
  * Matchers may also produce [InteractionActionListener] instances for interaction-driven events so listener execution
  * can be deferred until movement and reach requirements are satisfied.
  *
@@ -45,7 +45,6 @@ abstract class Matcher<E : Event, K : Any>(private val eventType: KClass<E>) {
          * @return The matcher for [E].
          * @throws NoSuchElementException If no matcher exists for [E].
          */
-        @Suppress("UNCHECKED_CAST")
         inline fun <reified E : Event, K : Any> get(): Matcher<E, K> {
             return get(E::class)
         }
@@ -59,8 +58,7 @@ abstract class Matcher<E : Event, K : Any>(private val eventType: KClass<E>) {
          */
         @Suppress("UNCHECKED_CAST")
         fun <E : Event, K : Any> get(eventType: KClass<E>): Matcher<E, K> {
-            val matcher = ALL[eventType]
-            return when (matcher) {
+            return when (val matcher = ALL[eventType]) {
                 null -> throw NoSuchElementException("Matcher for event type $eventType was not found.")
                 else -> matcher as Matcher<E, K>
             }
@@ -127,7 +125,7 @@ abstract class Matcher<E : Event, K : Any>(private val eventType: KClass<E>) {
 
     /**
      * Registers an optimized listener for [key].
-     * 
+     *
      * The listener will only be considered for events whose computed key matches [key].
      *
      * @param key The matcher key.
@@ -151,19 +149,19 @@ abstract class Matcher<E : Event, K : Any>(private val eventType: KClass<E>) {
 
     /**
      * Registers this matcher with the backing event pipeline for [eventType].
-     * 
+     *
      * The pipeline receives an [EventMatcher] that delegates matching, existence checks, and interaction listener
      * creation back to this matcher.
      */
     private fun addListener() {
         val type = eventType.java
         val pipeline = pipelines.get(type)
-        pipeline.matcher = EventMatcher(this::match, this::has, this::interactions)
+        pipeline.setMatcher(EventMatcher(this::match, this::has, this::interactions))
     }
 
     /**
      * Attempts to match [msg] against listeners registered under its computed key.
-     * 
+     *
      * If one or more listeners are found, they are executed in registration order.
      *
      * @param msg The event to match.
@@ -182,8 +180,8 @@ abstract class Matcher<E : Event, K : Any>(private val eventType: KClass<E>) {
 
     /**
      * Creates interaction listeners for [msg] using the listeners registered under its computed key.
-     * 
-     * Each matched listener is wrapped as an [InteractionActionListener] so it can be executed later by the 
+     *
+     * Each matched listener is wrapped as an [InteractionActionListener] so it can be executed later by the
      * interaction system once the player has satisfied the required reach policy.
      *
      * @param plr The player attempting the interaction.

src/main/kotlin/engine/engine/obj/ladders.kts

@@ -0,0 +1,78 @@
+package engine.obj
+
+import api.predef.*
+import io.luna.game.action.impl.ClimbAction
+import io.luna.game.event.impl.ObjectClickEvent
+import io.luna.game.event.impl.ServerStateChangedEvent.ServerLaunchEvent
+import io.luna.game.model.Direction
+import io.luna.game.model.def.GameObjectDefinition
+import io.luna.game.model.mob.Player
+import io.luna.game.model.`object`.GameObject
+
+/**
+ * Supported ladder interaction action names.
+ */
+val LADDER_ACTIONS = listOf("Climb", "Climb-up", "Climb-down")
+
+/**
+ * Starts a ladder climb for [plr].
+ *
+ * @param plr The climbing player.
+ * @param ladder The ladder being used.
+ * @param offset The height offset to apply. Positive climbs up, negative climbs down.
+ */
+fun climb(plr: Player, ladder: GameObject, offset: Int) {
+    val plrPos = plr.position
+    val dir = Direction.between(plrPos, ladder.position)
+    when (Integer.signum(offset)) {
+        1 -> plr.submitAction(ClimbAction(plr, plrPos.translate(0, 0, 1), dir, "You climb up the ladder."))
+        -1 -> plr.submitAction(ClimbAction(plr, plrPos.translate(0, 0, -1), dir, "You climb down the ladder."))
+    }
+}
+
+/**
+ * Returns the object click handler for a ladder action name.
+ *
+ * @param name The ladder action name.
+ * @return The matching object click handler.
+ * @throws IllegalArgumentException If [name] is not a supported ladder action.
+ */
+fun handleAction(name: String): EventAction<ObjectClickEvent> =
+    when (name) {
+        "Climb-up" -> fun(event: ObjectClickEvent) { climb(event.plr, event.gameObject, 1) }
+        "Climb-down" -> fun(event: ObjectClickEvent) { climb(event.plr, event.gameObject, -1) }
+        "Climb" ->
+            fun(event: ObjectClickEvent) {
+                val plr = event.plr
+                plr.newDialogue().options("Climb up", { climb(plr, event.gameObject, 1) },
+                                          "Climb down", { climb(plr, event.gameObject, -1) },
+                                          "Nevermind", { plr.overlays.closeWindows() }).open()
+            }
+
+        else -> throw IllegalArgumentException("Argument '$name' must be either 'Climb', 'Climb-up', or 'Climb-down'.")
+    }
+
+/**
+ * Registers a ladder interaction for the given object action slot.
+ *
+ * @param id The object id.
+ * @param index The action slot index.
+ * @param name The action name in that slot.
+ */
+fun handleIndex(id: Int, index: Int, name: String) {
+    if (LADDER_ACTIONS.contains(name)) {
+        when (index) {
+            0 -> object1(id, handleAction(name))
+            1 -> object2(id, handleAction(name))
+            2 -> object3(id, handleAction(name))
+        }
+    }
+}
+
+on(ServerLaunchEvent::class) {
+    for (def in GameObjectDefinition.ALL) {
+        if (def.name.equals("Ladder")) {
+            def.actions.forEachIndexed { index, name -> handleIndex(def.id, index, name) }
+        }
+    }
+}