[RFC] Port of Ruby combat framework to Kotlin

.gitignore

@@ -1,5 +1,6 @@
 .*
 
+!.idea/
 !.gitignore
 !.rubocop.yml
 !.editorconfig

buildSrc/src/main/groovy/org/apollo/build/plugin/ApolloPluginExtension.groovy

@@ -2,9 +2,7 @@ package org.apollo.build.plugin
 
 import org.apollo.build.plugin.tasks.ApolloScriptCompileTask
 import org.gradle.api.Project
-import org.gradle.api.Task
 import org.gradle.api.file.FileTree
-import org.gradle.api.tasks.testing.Test
 
 class ApolloPluginExtension {
     final Project project
@@ -79,7 +77,7 @@ class ApolloPluginExtension {
             main {
                 kotlin {
                     srcDir this.srcDir
-                    exclude '*.kts'
+                    exclude '**/*.kts'
                 }
             }
 
@@ -98,7 +96,7 @@ class ApolloPluginExtension {
         def buildTask = project.tasks['classes']
 
         FileTree scripts = project.fileTree(srcDir).matching {
-            include '*.kts'
+            include '**/*.kts'
         }
 
         project.tasks.create('compileScripts', ApolloScriptCompileTask) {

game/plugin/api/src/org/apollo/game/plugins/api/attributes.kt

@@ -0,0 +1,45 @@
+import org.apollo.game.model.entity.Mob
+import org.apollo.game.model.entity.attr.*
+import kotlin.reflect.KClass
+import kotlin.reflect.KProperty
+
+object MobAttributeDelegators {
+    inline fun <reified T : Any> attribute(name: String, defaultValue: T): MobAttributeDelegate<T> {
+        return MobAttributeDelegate<T>(name, T::class, defaultValue, false)
+    }
+
+    inline fun <reified T : Any> persistentAttribute(name: String, defaultValue: T): MobAttributeDelegate<T> {
+        return MobAttributeDelegate<T>(name, T::class, defaultValue, true)
+    }
+
+}
+
+class MobAttributeDelegate<T : Any>(val name: String, val type: KClass<T>, val defaultValue: T, persistent: Boolean = true) {
+    init {
+        val attrType = when {
+            type == Int::class || type == Long::class -> AttributeType.LONG
+            type == Boolean::class -> AttributeType.BOOLEAN
+            type == Double::class -> AttributeType.DOUBLE
+            type == String::class -> AttributeType.STRING
+            else -> throw IllegalArgumentException("Can only store primitive attributes, not: ${type.qualifiedName}")
+        }
+
+        val definition = AttributeDefinition(defaultValue, if (persistent) AttributePersistence.PERSISTENT else AttributePersistence.TRANSIENT, attrType)
+        AttributeMap.define(name, definition)
+    }
+
+    operator fun getValue(thisRef: Mob, property: KProperty<*>): T {
+        return thisRef.attributes[name]?.value as T? ?: defaultValue
+    }
+
+    operator fun setValue(thisRef: Mob, property: KProperty<*>, value: T) {
+        val attr = when {
+            type == Double::class || type == Int::class || type == Long::class -> NumericalAttribute(value as Number)
+            type == Boolean::class -> BooleanAttribute(value as Boolean)
+            type == String::class -> StringAttribute(value as String, false)
+            else -> throw IllegalArgumentException("Can only store primitive attributes, not: ${type.qualifiedName}")
+        }
+
+        thisRef.setAttribute(name, attr)
+    }
+}

game/plugin/api/src/org/apollo/game/plugins/api/player.kt

@@ -0,0 +1,28 @@
+package org.apollo.game.plugins.api
+
+import org.apollo.game.model.entity.Mob
+import org.apollo.game.model.entity.Skill
+import org.apollo.game.model.entity.SkillSet
+
+val Mob.skills: SkillSet get() = skillSet
+val SkillSet.attack: Skill get() = getSkill(Skill.ATTACK)
+val SkillSet.defence: Skill get() = getSkill(Skill.DEFENCE)
+val SkillSet.strength: Skill get() = getSkill(Skill.STRENGTH)
+val SkillSet.hitpoints: Skill get() = getSkill(Skill.HITPOINTS)
+val SkillSet.ranged: Skill get() = getSkill(Skill.RANGED)
+val SkillSet.prayer: Skill get() = getSkill(Skill.PRAYER)
+val SkillSet.magic: Skill get() = getSkill(Skill.MAGIC)
+val SkillSet.cooking: Skill get() = getSkill(Skill.COOKING)
+val SkillSet.woodcutting: Skill get() = getSkill(Skill.WOODCUTTING)
+val SkillSet.fletching: Skill get() = getSkill(Skill.FLETCHING)
+val SkillSet.fishing: Skill get() = getSkill(Skill.FISHING)
+val SkillSet.firemaking: Skill get() = getSkill(Skill.FIREMAKING)
+val SkillSet.crafting: Skill get() = getSkill(Skill.CRAFTING)
+val SkillSet.smithing: Skill get() = getSkill(Skill.SMITHING)
+val SkillSet.mining: Skill get() = getSkill(Skill.MINING)
+val SkillSet.herblore: Skill get() = getSkill(Skill.HERBLORE)
+val SkillSet.agility: Skill get() = getSkill(Skill.AGILITY)
+val SkillSet.thieving: Skill get() = getSkill(Skill.THIEVING)
+val SkillSet.slayer: Skill get() = getSkill(Skill.SLAYER)
+val SkillSet.farming: Skill get() = getSkill(Skill.FARMING)
+val SkillSet.runecraft: Skill get() = getSkill(Skill.RUNECRAFT)

game/plugin/api/src/util.kt

@@ -1,9 +1,21 @@
-package org.apollo.game.plugin.api
-
-import java.util.Random
+import java.lang.ref.WeakReference
+import java.util.*
+import kotlin.reflect.KProperty
 
 val RAND = Random()
 
 fun rand(bounds: Int): Int {
     return RAND.nextInt(bounds)
-}
+}
+
+class WeakRefHolder<T>(private var _value: WeakReference<T?> = WeakReference(null)) {
+    operator fun getValue(thisRef: Any?, property: KProperty<*>): T? {
+        return _value.get()
+    }
+
+    operator fun setValue(
+        thisRef: Any?, property: KProperty<*>, value: T?
+    ) {
+        _value = WeakReference(value)
+    }
+}

game/plugin/entity/combat/build.gradle

@@ -0,0 +1,11 @@
+plugin {
+    name = "combat"
+    description = "Extensible framework for combat."
+    authors = [
+        "Gary Tierney <[email protected]>"
+    ]
+    dependencies = [
+        "util:lookup",
+        "api"
+    ]
+}

game/plugin/entity/combat/src/combat.plugin.kts

@@ -0,0 +1,37 @@
+import org.apollo.game.message.impl.NpcActionMessage
+import org.apollo.game.model.event.impl.LogoutEvent
+
+/**
+
+on :message, :npc_action do |player, message|
+target = $world.npc_repository.get message.index
+
+# unless target.attacking
+#   target_combat_state        = get_combat_state target
+#   target_combat_state.target = player
+#
+#   target.start_action CombatAction.new(target)
+# end
+
+player_combat_state = player.get_combat_state
+player_combat_state.target = target
+
+player.send HintIconMessage.for_npc(target.index)
+player.walking_queue.clear
+player.start_action CombatAction.new(player)
+end
+ */
+
+start {
+
+}
+
+on_player_event { LogoutEvent::class }
+    .then {
+        CombatStateManager.remove(it)
+    }
+
+on { NpcActionMessage::class }
+    .then {
+        CombatAction.start(this, it, it.world.npcRepository[index])
+    }

game/plugin/entity/combat/src/equipment/ammo/arrows.kt

@@ -0,0 +1,71 @@
+object Arrows : AmmoType({
+    fired from "shortbows" and "longbows"
+
+    projectile {
+        startHeight = 41
+        endHeight = 37
+        delay = 41
+        lifetime = 60
+        pitch = 15
+    }
+
+    "bronze" {
+        requires level 1
+        30% dropChance
+
+        graphics {
+            projectile = 10
+            attack = 19
+        }
+    }
+
+    "iron" {
+        requires level 1
+        35% dropChance
+
+        graphics {
+            projectile = 9
+            attack = 18
+        }
+    }
+
+    "steel" {
+        requires level 5
+        40% dropChance
+
+        graphics {
+            projectile = 11
+            attack = 20
+        }
+    }
+
+    "mithril" {
+        requires level 20
+        45% dropChance
+
+        graphics {
+            projectile = 12
+            attack = 21
+        }
+    }
+
+    "adamant" {
+        requires level 30
+        50% dropChance
+
+        graphics {
+            projectile = 13
+            attack = 22
+        }
+    }
+
+    "rune" {
+        requires level 40
+        60% dropChance
+
+        graphics {
+            projectile = 15
+            attack = 24
+        }
+    }
+})

game/plugin/entity/combat/src/equipment/weapons/melee/scimitars.plugin.kts

@@ -0,0 +1,65 @@
+
+
+Scimitar("Iron Scimitar") {
+    attackBonuses {
+        stab = 2
+        slash = 10
+    }
+
+    meleeStrength = 9
+}
+
+Scimitar("Steel Scimitar") {
+    attackBonuses {
+        stab = 3
+        slash = 15
+    }
+
+    meleeStrength = 14
+}
+
+// @todo - regexp support
+//Scimitar("/(black|white) Scimitar/") {
+//    attackBonuses {
+//        stab = 4
+//        slash = 19
+//    }
+//
+//    meleeStrength = 14
+//}
+
+Scimitar("Mithril Scimitar") {
+    attackBonuses {
+        stab = 5
+        slash = 21
+    }
+
+    meleeStrength = 20
+}
+
+Scimitar("Adamant Scimitar") {
+    attackBonuses {
+        stab = 6
+        slash = 29
+    }
+
+    meleeStrength = 28
+}
+
+Scimitar("Rune Scimitar") {
+    attackBonuses {
+        stab = 7
+        slash = 45
+    }
+
+    meleeStrength = 44
+}
+
+Scimitar("Dragon Scimitar") {
+    attackBonuses {
+        stab = 8
+        slash = 67
+    }
+
+    meleeStrength = 66
+}

game/plugin/entity/combat/src/equipment/weapons/melee_classes.kt

@@ -0,0 +1,21 @@
+import AttackStyle.*
+import org.apollo.game.model.Animation
+
+object Scimitar : MeleeWeaponClass({
+    widgetId = 2423
+    defaults {
+        attackSpeed = 4
+        attackAnimation = Animation(390)
+        attackType = AttackType.Slash
+    }
+
+    Accurate { button = 2 }
+    Aggressive { button = 3 }
+    AltAggressive {
+        button = 4
+        attackType = AttackType.Stab
+        attackAnimation = Animation(391)
+    }
+
+    Defensive { button = 5 }
+})

game/plugin/entity/combat/src/equipment/weapons/ranged/bows.plugin.kts

@@ -0,0 +1,3 @@
+Bow("Shortbow") {
+
+}

game/plugin/entity/combat/src/equipment/weapons/ranged_classes.kt

@@ -0,0 +1,28 @@
+import AttackStyle.*
+import AttackType.Ranged
+import org.apollo.game.model.Animation
+
+object Bow : RangedWeaponClass(Arrows, {
+    widgetId = 1764
+
+    defaults {
+        attackType = Ranged
+        attackAnimation = Animation(426)
+        attackSpeed = 4
+        attackRange = 7
+    }
+
+    Accurate {
+        button = 1772
+    }
+
+    Rapid {
+        button = 1770
+        attackSpeed = 3
+
+    }
+
+    LongRanged {
+        button = 1771
+    }
+})