Add skill extension properties

Author: Major-

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

@@ -0,0 +1,81 @@
+package org.apollo.game.plugin.api
+
+import org.apollo.game.model.entity.Player
+import org.apollo.game.model.entity.Skill
+import org.apollo.game.model.entity.SkillSet
+
+val Player.attack: SkillProxy get() = SkillProxy(skillSet, Skill.ATTACK)
+val Player.defence: SkillProxy get() = SkillProxy(skillSet, Skill.DEFENCE)
+val Player.strength: SkillProxy get() = SkillProxy(skillSet, Skill.STRENGTH)
+val Player.hitpoints: SkillProxy get() = SkillProxy(skillSet, Skill.HITPOINTS)
+val Player.ranged: SkillProxy get() = SkillProxy(skillSet, Skill.RANGED)
+val Player.prayer: SkillProxy get() = SkillProxy(skillSet, Skill.PRAYER)
+val Player.magic: SkillProxy get() = SkillProxy(skillSet, Skill.MAGIC)
+val Player.cooking: SkillProxy get() = SkillProxy(skillSet, Skill.COOKING)
+val Player.woodcutting: SkillProxy get() = SkillProxy(skillSet, Skill.WOODCUTTING)
+val Player.fletching: SkillProxy get() = SkillProxy(skillSet, Skill.FLETCHING)
+val Player.fishing: SkillProxy get() = SkillProxy(skillSet, Skill.FISHING)
+val Player.firemaking: SkillProxy get() = SkillProxy(skillSet, Skill.FIREMAKING)
+val Player.crafting: SkillProxy get() = SkillProxy(skillSet, Skill.CRAFTING)
+val Player.smithing: SkillProxy get() = SkillProxy(skillSet, Skill.SMITHING)
+val Player.mining: SkillProxy get() = SkillProxy(skillSet, Skill.MINING)
+val Player.herblore: SkillProxy get() = SkillProxy(skillSet, Skill.HERBLORE)
+val Player.agility: SkillProxy get() = SkillProxy(skillSet, Skill.AGILITY)
+val Player.thieving: SkillProxy get() = SkillProxy(skillSet, Skill.THIEVING)
+val Player.slayer: SkillProxy get() = SkillProxy(skillSet, Skill.SLAYER)
+val Player.farming: SkillProxy get() = SkillProxy(skillSet, Skill.FARMING)
+val Player.runecraft: SkillProxy get() = SkillProxy(skillSet, Skill.RUNECRAFT)
+
+/**
+ * A proxy class to allow
+ */
+class SkillProxy(val skills: SkillSet, val skill: Int) {
+
+    /**
+     * The maximum level of this skill.
+     */
+    val maximum = skills.getMaximumLevel(skill)
+
+    /**
+     * The current level of this skill.
+     */
+    val current = skills.getCurrentLevel(skill)
+
+    val experience = ExperienceProxy()
+
+    /**
+     * A proxy class to make [experience] (effectively) write-only.
+     */
+    inner class ExperienceProxy {
+
+        operator fun plusAssign(amount: Int) = skills.addExperience(skill, amount.toDouble())
+
+        operator fun plusAssign(amount: Double) = skills.addExperience(skill, amount)
+
+    }
+
+    /**
+     * Boosts the current level of this skill by [amount], if possible (i.e. if `current + amount <= maximum + amount`).
+     */
+    fun boost(amount: Int) {
+        val new = Math.min(current + amount, maximum + amount)
+        skills.setCurrentLevel(skill, new)
+    }
+
+    /**
+     * Drains the current level of this skill by [amount], if possible (i.e. if `current - amount >= 0`).
+     */
+    fun drain(amount: Int) {
+        val new = Math.max(current - amount, 0)
+        skills.setCurrentLevel(skill, new)
+    }
+
+    /**
+     * Restores the current level of this skill by [amount], if possible (i.e. if `current + amount < maximum`).
+     */
+    fun restore(amount: Int) {
+        val new = Math.max(current + amount, maximum)
+        skills.setCurrentLevel(skill, new)
+    }
+
+}

game/plugin/api/src/player.kt

@@ -1,14 +1,13 @@
+
 import Fishing_plugin.FishingAction
 import org.apollo.game.action.ActionBlock
 import org.apollo.game.action.AsyncDistancedAction
 import org.apollo.game.message.impl.NpcActionMessage
 import org.apollo.game.model.Position
 import org.apollo.game.model.entity.Player
-import org.apollo.game.model.entity.Skill
+import org.apollo.game.plugin.api.fishing
 import org.apollo.game.plugin.skills.fishing.FishingSpot
 import org.apollo.game.plugin.skills.fishing.FishingTool
-import org.apollo.game.plugins.api.fishing
-import org.apollo.game.plugins.api.skills
 import java.util.Objects
 import java.util.Random
 
@@ -62,7 +61,7 @@ class FishingAction(player: Player, position: Position, val option: FishingSpot.
             mob.playAnimation(tool.animation)
             wait(FISHING_DELAY)
 
-            val level = mob.skills.fishing.currentLevel
+            val level = mob.fishing.current
             val fish = option.sample(level)
 
             if (successfulCatch(level, fish.level)) {
@@ -72,7 +71,7 @@ class FishingAction(player: Player, position: Position, val option: FishingSpot.
 
                 mob.inventory.add(fish.id)
                 mob.sendMessage("You catch a ${fish.formattedName}.")
-                mob.skills.addExperience(Skill.FISHING, fish.experience)
+                mob.fishing.experience += fish.experience
 
                 if (mob.inventory.freeSlots() == 0) {
                     mob.inventory.forceCapacityExceeded()
@@ -91,7 +90,7 @@ class FishingAction(player: Player, position: Position, val option: FishingSpot.
      * Verifies that the player can gather fish from the [FishingSpot] they clicked.
      */
     private fun verify(): Boolean {
-        if (mob.skills.fishing.currentLevel < option.level) {
+        if (mob.fishing.current < option.level) {
             mob.sendMessage("You need a fishing level of ${option.level} to fish at this spot.")
             return false
         } else if (!hasTool(mob, tool)) {
@@ -113,7 +112,6 @@ class FishingAction(player: Player, position: Position, val option: FishingSpot.
         if (javaClass != other?.javaClass) return false
 
         other as FishingAction
-
         return option == other.option && position == other.position && mob == other.mob
     }
 

game/plugin/skills/fishing/src/fishing.plugin.kts

@@ -5,52 +5,47 @@ import org.apollo.game.message.impl.ObjectActionMessage
 import org.apollo.game.model.Position
 import org.apollo.game.model.World
 import org.apollo.game.model.entity.Player
-import org.apollo.game.model.entity.Skill
 import org.apollo.game.model.entity.obj.GameObject
+import org.apollo.game.plugin.api.mining
 import org.apollo.game.plugin.skills.mining.Ore
 import org.apollo.game.plugin.skills.mining.PICKAXES
 import org.apollo.game.plugin.skills.mining.Pickaxe
 import org.apollo.game.plugin.skills.mining.lookupOreRock
-import org.apollo.game.plugins.api.Definitions
-import org.apollo.game.plugins.api.mining
-import org.apollo.game.plugins.api.skills
 import org.apollo.net.message.Message
-import java.util.*
+import java.util.Optional
 
 class MiningTarget(val objectId: Int, val position: Position, val ore: Ore) {
+
     fun getObject(world: World): Optional<GameObject> {
         val region = world.regionRepository.fromPosition(position)
-        val obj = region.findObject(position, objectId)
-
-        return obj
+        return region.findObject(position, objectId)
     }
 
     fun isSuccessful(mob: Player): Boolean {
         val offset = if (ore.chanceOffset) 1 else 0
-        val percent = (ore.chance * mob.skills.mining.currentLevel + offset) * 100
+        val percent = (ore.chance * mob.mining.current + offset) * 100
 
-        return rand(100) < percent;
+        return rand(100) < percent
     }
+
 }
 
-class MiningAction(player: Player, val tool: Pickaxe, val target: MiningTarget) : AsyncDistancedAction<Player>(
-        PULSES,
-        true,
-        player,
-        target.position,
-        ORE_SIZE
-) {
+class MiningAction(
+    player: Player,
+    private val tool: Pickaxe,
+    private val target: MiningTarget
+) : AsyncDistancedAction<Player>(PULSES, true, player, target.position, ORE_SIZE) {
 
     companion object {
         private val PULSES = 0
-        private val ORE_SIZE = 1;
+        private val ORE_SIZE = 1
 
         fun pickaxeFor(player: Player): Pickaxe? {
             return PICKAXES
-                    .filter { it.level <= player.skills.mining.currentLevel }
-                    .filter { player.equipment.contains(it.id) || player.inventory.contains(it.id) }
-                    .sortedByDescending { it.level }
-                    .firstOrNull()
+                .filter { it.level <= player.mining.current }
+                .filter { player.equipment.contains(it.id) || player.inventory.contains(it.id) }
+                .sortedByDescending { it.level }
+                .firstOrNull()
         }
 
         /**
@@ -69,10 +64,10 @@ class MiningAction(player: Player, val tool: Pickaxe, val target: MiningTarget)
         }
     }
 
-    override fun action() : ActionBlock = {
+    override fun action(): ActionBlock = {
         mob.turnTo(position)
 
-        val level = mob.skills.mining.currentLevel
+        val level = mob.mining.current
         if (level < target.ore.level) {
             mob.sendMessage("You do not have the required level to mine this rock.")
             stop()
@@ -98,33 +93,40 @@ class MiningAction(player: Player, val tool: Pickaxe, val target: MiningTarget)
                 val oreName = Definitions.item(target.ore.id)?.name?.toLowerCase()
                 mob.sendMessage("You manage to mine some $oreName")
 
-                mob.skills.addExperience(Skill.MINING, target.ore.exp)
+                mob.mining.experience += target.ore.exp
                 mob.world.expireObject(obj.get(), target.ore.objects[target.objectId]!!, target.ore.respawn)
                 stop()
             }
         }
     }
 }
 
-class ExpiredProspectingAction : DistancedAction<Player> {
-
-    constructor(mob: Player, position: Position) : super(PROSPECT_PULSES, true, mob, position, ORE_SIZE)
+class ExpiredProspectingAction(
+    mob: Player,
+    position: Position
+) : DistancedAction<Player>(PROSPECT_PULSES, true, mob, position, ORE_SIZE) {
 
     companion object {
         private val PROSPECT_PULSES = 0
-        private val ORE_SIZE = 1;
+        private val ORE_SIZE = 1
     }
 
     override fun executeAction() {
         mob.sendMessage("There is currently no ore available in this rock.")
-        stop();
+        stop()
     }
+
 }
 
-class ProspectingAction(val m: Player, val p: Position, val ore: Ore) : AsyncDistancedAction<Player>(PROSPECT_PULSES, true, m, p, ORE_SIZE) {
+class ProspectingAction(
+    player: Player,
+    position: Position,
+    private val ore: Ore
+) : AsyncDistancedAction<Player>(PROSPECT_PULSES, true, player, position, ORE_SIZE) {
+
     companion object {
         private val PROSPECT_PULSES = 3
-        private val ORE_SIZE = 1;
+        private val ORE_SIZE = 1
 
         /**
          * Starts a [MiningAction] for the specified [Player], terminating the [Message] that triggered it.
@@ -135,9 +137,10 @@ class ProspectingAction(val m: Player, val p: Position, val ore: Ore) : AsyncDis
 
             message.terminate()
         }
+
     }
 
-    override fun action() : ActionBlock = {
+    override fun action(): ActionBlock = {
         mob.sendMessage("You examine the rock for ores...")
         mob.turnTo(position)
 
@@ -148,22 +151,23 @@ class ProspectingAction(val m: Player, val p: Position, val ore: Ore) : AsyncDis
 
         stop()
     }
+
 }
 
 on { ObjectActionMessage::class }
-        .where { option == 1 }
-        .then {
-            val ore = lookupOreRock(id)
-            if (ore != null) {
-                MiningAction.start(this, it, ore)
-            }
+    .where { option == 1 }
+    .then {
+        val ore = lookupOreRock(id)
+        if (ore != null) {
+            MiningAction.start(this, it, ore)
         }
+    }
 
 on { ObjectActionMessage::class }
-        .where { option == 2 }
-        .then {
-            var ore = lookupOreRock(id)
-            if (ore != null) {
-                ProspectingAction.start(this, it, ore)
-            }
+    .where { option == 2 }
+    .then {
+        val ore = lookupOreRock(id)
+        if (ore != null) { // TODO send expired action if rock is expired
+            ProspectingAction.start(this, it, ore)
         }
+    }