Fixed infinite lunar cast range

Server/src/main/content/global/skill/magic/SpellListener.kt

@@ -26,12 +26,12 @@ abstract class SpellListener(val bookName: String) : Listener {
         @JvmField
         val GROUND_ITEM = -6
     }
-    fun onCast(spellID: Int,type: Int,method: (player: Player, node: Node?) -> Unit){
+    fun onCast(spellID: Int, type: Int, range: Int = 10, method: (player: Player, node: Node?) -> Unit){
-        SpellListeners.add(spellID,type,bookName,method)
+        SpellListeners.add(spellID, type, bookName, range, method)
     }
 
-    fun onCast(spellID: Int, type: Int, vararg ids: Int, method: (player: Player, node: Node?) -> Unit){
+    fun onCast(spellID: Int, type: Int, vararg ids: Int, range: Int = 10, method: (player: Player, node: Node?) -> Unit){
-        SpellListeners.add(spellID,type,ids,bookName,method)
+        SpellListeners.add(spellID, type, ids, bookName, range, method)
     }
 
     fun requires(player: Player, magicLevel: Int = 0, runes: Array<Item> = arrayOf<Item>(), specialEquipment: IntArray = intArrayOf()) {

Server/src/main/content/global/skill/magic/SpellListeners.kt

@@ -1,45 +1,81 @@
 package content.global.skill.magic
 
 import core.game.event.SpellCastEvent
-import core.api.log
+import core.api.*
 import core.game.node.Node
 import core.game.node.entity.player.Player
 import core.game.node.entity.player.link.SpellBookManager
 import core.tools.Log
 import core.tools.SystemLogger
+import core.game.interaction.*
+import core.game.world.map.path.Pathfinder
 
 object SpellListeners {
     val castMap = HashMap<String,(Player, Node?) -> Unit>()
+    val spellRanges = HashMap<String, Int>()
 
-    fun add(spellID: Int, type: Int, book: String, method: (Player,Node?) -> Unit){
+    fun add(spellID: Int, type: Int, book: String, distance: Int, method: (Player,Node?) -> Unit){
         castMap["$book:$spellID:$type"] = method
+        spellRanges["$book:$spellID:$type"] = distance
     }
 
-    fun add(spellID: Int, type: Int, ids: IntArray, book: String, method: (Player, Node?) -> Unit){
+    fun add(spellID: Int, type: Int, ids: IntArray, book: String, distance: Int, method: (Player, Node?) -> Unit){
         for(id in ids) {
             castMap["$book:$spellID:$type:$id"] = method
+            spellRanges["$book:$spellID:$type:$id"] = distance
         }
     }
 
-    fun get(spellID: Int, type: Int, book: String): ((Player,Node?) -> Unit)?{
+    fun get(spellID: Int, type: Int, book: String): Pair<Int, ((Player,Node?) -> Unit)?> {
         log(this::class.java, Log.FINE, "Getting $book:$spellID:$type")
-        return castMap["$book:$spellID:$type"]
+        return Pair (spellRanges["$book:$spellID:$type"] ?: 10, castMap["$book:$spellID:$type"])
     }
 
-    fun get(spellID: Int, type: Int, id: Int, book: String): ((Player,Node?) -> Unit)?{
+    fun get(spellID: Int, type: Int, id: Int, book: String): Pair<Int, ((Player,Node?) -> Unit)?> {
         log(this::class.java, Log.FINE, "Getting $book:$spellID:$type:$id")
-        return castMap["$book:$spellID:$type:$id"]
+        return Pair (spellRanges["$book:$spellID:$type:$id"] ?: 10, castMap["$book:$spellID:$type:$id"])
     }
 
     @JvmStatic
     fun run(button: Int, type: Int, book: String, player: Player, node: Node? = null){
-        val method = get(button,type,node?.id ?: 0,book) ?: get(button,type,book) ?: return
+        var (range, method) = get (button, type, node?.id ?: 0, book)
-        try {
+        if (method == null) {
-            method.invoke(player, node)
+            var next = get (button, type, book)
-            player.dispatch(SpellCastEvent(SpellBookManager.SpellBook.valueOf(book.uppercase()), button, node))
+            range = next.first
-        } catch (e: IllegalStateException){
+            method = next.second ?: return
-            player.removeAttribute("spell:runes")
+        }
-            return
+
+        if (type in intArrayOf (SpellListener.NPC, SpellListener.OBJECT, SpellListener.PLAYER, SpellListener.GROUND_ITEM)) {
+            player.pulseManager.run (object : MovementPulse (player, node, Pathfinder.SMART) {
+                override fun pulse() : Boolean {
+                    try {
+                        method?.invoke (player, node)
+                    } catch (e: IllegalStateException) {
+                        player.removeAttribute ("spell:runes")
+                        return true
+                    }
+                    return true
+                }
+
+                override fun update () : Boolean {
+                    if (player.location.withinMaxnormDistance (node!!.centerLocation, range) && hasLineOfSight (player, node!!)) {
+                        player.faceLocation (node.getFaceLocation(player.location))
+                        player.walkingQueue.reset()
+                        pulse()
+                        stop()
+                        return true
+                    }
+                    return super.update()
+                }
+            })
+        } else {
+            try {
+                method?.invoke(player, node)
+                player.dispatch(SpellCastEvent(SpellBookManager.SpellBook.valueOf(book.uppercase()), button, node))
+            } catch (e: IllegalStateException){
+                player.removeAttribute("spell:runes")
+                return
+            }
         }
     }
 }

Server/src/main/core/api/ContentAPI.kt

@@ -75,6 +75,7 @@ import core.net.packet.context.MusicContext
 import core.net.packet.out.MusicPacket
 import core.game.system.timer.*
 import core.game.system.timer.impl.*
+import core.game.node.entity.combat.CombatSwingHandler
 import java.util.regex.*
 import java.io.*
 import kotlin.math.*
@@ -2713,7 +2714,7 @@ fun apRange(entity: Entity, apRange: Int) {
 }
 
 fun hasLineOfSight(entity: Entity, target: Node) : Boolean {
-    return ProjectilePathfinder.find(entity, target).isSuccessful
+    return CombatSwingHandler.isProjectileClipped (entity, target, false)
 }
 
 fun animationFinished(entity: Entity) : Boolean {