Merge pull request #58 from Exanthiax/master

Modernizes XP Requirements and Level Effects

Author: WillFP

build.gradle.kts

@@ -40,7 +40,7 @@ allprojects {
     }
 
     dependencies {
-        compileOnly("com.willfp:eco:6.55.0")
+        compileOnly("com.willfp:eco:6.56.0")
         compileOnly("org.jetbrains:annotations:23.0.0")
         compileOnly("org.jetbrains.kotlin:kotlin-stdlib:2.1.0")
     }

eco-core/core-plugin/src/main/kotlin/com/willfp/ecopets/api/EcoPetsAPI.kt

@@ -102,7 +102,7 @@ interface EcoPetsAPI {
     fun getPetXPRequired(
         player: OfflinePlayer,
         pet: Pet
-    ): Int
+    ): Double
 
     /**
      * Get experience to the next level.

eco-core/core-plugin/src/main/kotlin/com/willfp/ecopets/pets/Pet.kt

@@ -16,33 +16,39 @@ import com.willfp.eco.core.recipe.Recipes
 import com.willfp.eco.core.recipe.parts.EmptyTestableItem
 import com.willfp.eco.core.registry.Registrable
 import com.willfp.eco.util.NumberUtils
+import com.willfp.eco.util.NumberUtils.evaluateExpression
+import com.willfp.eco.core.placeholder.context.placeholderContext
 import com.willfp.eco.util.formatEco
 import com.willfp.eco.util.toNiceString
 import com.willfp.ecopets.EcoPetsPlugin
 import com.willfp.ecopets.api.event.PlayerPetExpGainEvent
 import com.willfp.ecopets.api.event.PlayerPetLevelUpEvent
 import com.willfp.ecopets.pets.entity.PetEntity
+import com.willfp.ecopets.util.LevelInjectable
 import com.willfp.libreforge.ViolationContext
 import com.willfp.libreforge.conditions.ConditionList
 import com.willfp.libreforge.conditions.Conditions
 import com.willfp.libreforge.counters.Counters
 import com.willfp.libreforge.effects.EffectList
 import com.willfp.libreforge.effects.Effects
+import com.willfp.libreforge.effects.executors.impl.NormalExecutorFactory
 import org.bukkit.Bukkit
 import org.bukkit.OfflinePlayer
+import org.bukkit.configuration.InvalidConfigurationException
 import org.bukkit.entity.Player
 import org.bukkit.inventory.ItemStack
 import org.bukkit.persistence.PersistentDataType
 import java.util.Objects
-import java.util.concurrent.TimeUnit
 import kotlin.math.abs
 
 class Pet(
     val id: String,
     val config: Config,
     private val plugin: EcoPetsPlugin
 ) : Registrable {
+
     val name = config.getFormattedString("name")
+
     val description = config.getFormattedString("description")
 
     val levelKey: PersistentDataKey<Int> = PersistentDataKey(
@@ -52,9 +58,7 @@ class Pet(
     )
 
     val xpKey: PersistentDataKey<Double> = PersistentDataKey(
-        EcoPetsPlugin.instance.namespacedKeyFactory.create("${id}_xp"),
-        PersistentDataKeyType.DOUBLE,
-        0.0
+        EcoPetsPlugin.instance.namespacedKeyFactory.create("${id}_xp"), PersistentDataKeyType.DOUBLE, 0.0
     )
 
     private val spawnEggBacker: ItemStack? = run {
@@ -115,25 +119,27 @@ class Pet(
 
     val entityTexture = config.getString("entity-texture")
 
-    private val levelXpRequirements = listOf(0) + config.getInts("level-xp-requirements")
+    private val xpFormula = config.getStringOrNull("xp-formula")
+
+    private val levelXpRequirements = config.getDoublesOrNull("level-xp-requirements")
 
-    val maxLevel = levelXpRequirements.size
+    val maxLevel = config.getIntOrNull("max-level") ?: levelXpRequirements?.size ?: Int.MAX_VALUE
 
     val levelGUI = PetLevelGUI(plugin, this)
 
     private val baseItem: ItemStack = Items.lookup(config.getString("icon")).item
 
     private val effects: EffectList
+
     private val conditions: ConditionList
 
-    private val levels = Caffeine.newBuilder()
-        .build<Int, PetLevel>()
-    private val effectsDescription = Caffeine.newBuilder()
-        .build<Int, List<String>>()
-    private val rewardsDescription = Caffeine.newBuilder()
-        .build<Int, List<String>>()
-    private val levelUpMessages = Caffeine.newBuilder()
-        .build<Int, List<String>>()
+    private val levels = Caffeine.newBuilder().build<Int, PetLevel>()
+
+    private val effectsDescription = Caffeine.newBuilder().build<Int, List<String>>()
+
+    private val rewardsDescription = Caffeine.newBuilder().build<Int, List<String>>()
+
+    private val levelUpMessages = Caffeine.newBuilder().build<Int, List<String>>()
 
     private val levelCommands = mutableMapOf<Int, MutableList<String>>()
 
@@ -150,13 +156,14 @@ class Pet(
         }
 
     private val petXpGains = config.getSubsections("xp-gain-methods").mapNotNull {
-        Counters.compile(
-            it,
-            ViolationContext(plugin, "Pet $id XP Gain methods")
-        )
+        Counters.compile(it, ViolationContext(plugin, "Pet $id"))
     }
 
     init {
+        if (xpFormula == null && levelXpRequirements == null) {
+            throw InvalidConfigurationException("Pet $id has no requirements or xp formula")
+        }
+
         config.injectPlaceholders(
             PlayerStaticPlaceholder(
                 "level"
@@ -175,24 +182,7 @@ class Pet(
             ViolationContext(plugin, "Pet $id")
         )
 
-        for (string in config.getStrings("level-commands")) {
-            val split = string.split(":")
-
-            if (split.size == 1) {
-                for (level in 1..maxLevel) {
-                    val commands = levelCommands[level] ?: mutableListOf()
-                    commands.add(string)
-                    levelCommands[level] = commands
-                }
-            } else {
-                val level = split[0].toInt()
-
-                val command = string.removePrefix("$level:")
-                val commands = levelCommands[level] ?: mutableListOf()
-                commands.add(command)
-                levelCommands[level] = commands
-            }
-        }
+        manageLevelCommands(config)
 
         PlayerPlaceholder(
             plugin,
@@ -237,6 +227,37 @@ class Pet(
         }.register()
     }
 
+    @Deprecated("Use level-up-effects instead")
+    private fun manageLevelCommands(config: Config) {
+        if (config.getStrings("level-commands").isNotEmpty()) {
+            plugin.logger.warning("$id pet: The `level-commands` key is deprecated and will be removed in future versions. Switch to `level-up-effects` instead. Refer to the wiki for more info.")
+        }
+        for (string in config.getStrings("level-commands")) {
+            val split = string.split(":")
+
+            if (split.size == 1) {
+                for (level in 1..maxLevel) {
+                    val commands = levelCommands[level] ?: mutableListOf()
+                    commands.add(string)
+                    levelCommands[level] = commands
+                }
+            } else {
+                val level = split[0].toInt()
+
+                val command = string.removePrefix("$level:")
+                val commands = levelCommands[level] ?: mutableListOf()
+                commands.add(command)
+                levelCommands[level] = commands
+            }
+        }
+    }
+
+    val levelUpEffects = Effects.compileChain(
+        config.getSubsections("level-up-effects"),
+        NormalExecutorFactory.create(),
+        ViolationContext(plugin, "Job $id level-up-effects")
+    )
+
     fun makePetEntity(): PetEntity {
         return PetEntity.create(this)
     }
@@ -313,14 +334,7 @@ class Pet(
             .map {
                 it.replace("%percentage_progress%", (player.getPetProgress(this) * 100).toNiceString())
                     .replace("%current_xp%", player.getPetXP(this).toNiceString())
-                    .replace("%required_xp%", this.getExpForLevel(player.getPetLevel(this) + 1).let { req ->
-                        if (req == Int.MAX_VALUE) {
-                            plugin.langYml.getFormattedString("infinity")
-                        } else {
-                            req.toNiceString()
-                        }
-                    }
-                    )
+                    .replace("%required_xp%", this.getFormattedExpForLevel(player.getPetLevel(this) + 1))
                     .replace("%description%", this.description)
                     .replace("%pet%", this.name)
                     .replace("%level%", (forceLevel ?: player.getPetLevel(this)).toString())
@@ -395,14 +409,36 @@ class Pet(
             .build()
     }
 
-    fun getExpForLevel(level: Int): Int {
-        if (level < 1 || level > maxLevel) {
-            return Int.MAX_VALUE
+    /**
+     * Get the XP required to reach the next level, if currently at [level].
+     */
+    fun getExpForLevel(level: Int): Double {
+        if (xpFormula != null) {
+            return evaluateExpression(
+                xpFormula,
+                placeholderContext(
+                    injectable = LevelInjectable(level)
+                )
+            )
         }
 
-        return levelXpRequirements[level - 1]
+        if (levelXpRequirements != null) {
+            return levelXpRequirements.getOrNull(level) ?: Double.POSITIVE_INFINITY
+        }
+
+        return Double.POSITIVE_INFINITY
     }
 
+    fun getFormattedExpForLevel(level: Int): String {
+        val required = getExpForLevel(level)
+        return if (required.isInfinite()) {
+            plugin.langYml.getFormattedString("infinity")
+        } else {
+            required.toNiceString()
+        }
+    }
+
+    @Deprecated("Use level-up-effects instead")
     fun executeLevelCommands(player: Player, level: Int) {
         val commands = levelCommands[level] ?: emptyList()
 
@@ -492,45 +528,8 @@ fun OfflinePlayer.getPetXP(pet: Pet): Double =
 fun OfflinePlayer.setPetXP(pet: Pet, xp: Double) =
     this.profile.write(pet.xpKey, xp)
 
-fun OfflinePlayer.getPetXPRequired(pet: Pet): Int =
-    pet.getExpForLevel(this.getPetLevel(pet) + 1)
-
-private val expMultiplierCache = Caffeine.newBuilder()
-    .expireAfterWrite(10, TimeUnit.SECONDS)
-    .build<Player, Double> {
-        it.cacheSkillExperienceMultiplier()
-    }
-
-val Player.petExperienceMultiplier: Double
-    get() = expMultiplierCache.get(this)!!
-
-private fun Player.cacheSkillExperienceMultiplier(): Double {
-    if (this.hasPermission("ecopets.xpmultiplier.quadruple")) {
-        return 4.0
-    }
-
-    if (this.hasPermission("ecopets.xpmultiplier.triple")) {
-        return 3.0
-    }
-
-    if (this.hasPermission("ecopets.xpmultiplier.double")) {
-        return 2.0
-    }
-
-    if (this.hasPermission("ecopets.xpmultiplier.50percent")) {
-        return 1.5
-    }
-
-    val prefix = "ecopets.xpmultiplier."
-    for (permissionAttachmentInfo in this.effectivePermissions) {
-        val permission = permissionAttachmentInfo.permission
-        if (permission.startsWith(prefix)) {
-            return ((permission.substring(permission.lastIndexOf(".") + 1).toDoubleOrNull() ?: 100.0) / 100) + 1
-        }
-    }
-
-    return 1.0
-}
+fun OfflinePlayer.getPetXPRequired(pet: Pet) =
+    this.profile.read(pet.xpKey)
 
 fun Player.givePetExperience(pet: Pet, experience: Double, noMultiply: Boolean = false) {
     val exp = abs(if (noMultiply) experience else experience * this.petExperienceMultiplier)

eco-core/core-plugin/src/main/kotlin/com/willfp/ecopets/pets/PetLevelListener.kt

@@ -2,6 +2,7 @@ package com.willfp.ecopets.pets
 
 import com.willfp.ecopets.EcoPetsPlugin
 import com.willfp.ecopets.api.event.PlayerPetLevelUpEvent
+import com.willfp.libreforge.toDispatcher
 import org.bukkit.Sound
 import org.bukkit.event.EventHandler
 import org.bukkit.event.EventPriority
@@ -16,6 +17,7 @@ class PetLevelListener(
         val player = event.player
         val level = event.level
 
+        pet.levelUpEffects?.trigger(player.toDispatcher())
         pet.executeLevelCommands(player, level)
 
         if (this.plugin.configYml.getBool("level-up.sound.enabled")) {

eco-core/core-plugin/src/main/kotlin/com/willfp/ecopets/pets/PetXPAccumulator.kt

@@ -1,7 +1,9 @@
 package com.willfp.ecopets.pets
 
+import com.github.benmanes.caffeine.cache.Caffeine
 import com.willfp.libreforge.counters.Accumulator
 import org.bukkit.entity.Player
+import java.util.concurrent.TimeUnit
 
 class PetXPAccumulator(
     private val pet: Pet
@@ -14,3 +16,40 @@ class PetXPAccumulator(
         player.givePetExperience(pet, count)
     }
 }
+
+private val expMultiplierCache = Caffeine.newBuilder()
+    .expireAfterWrite(10, TimeUnit.SECONDS)
+    .build<Player, Double> {
+        it.cachePetExperienceMultiplier()
+    }
+
+val Player.petExperienceMultiplier: Double
+    get() = expMultiplierCache.get(this)!!
+
+private fun Player.cachePetExperienceMultiplier(): Double {
+    if (this.hasPermission("ecopets.xpmultiplier.quadruple")) {
+        return 4.0
+    }
+
+    if (this.hasPermission("ecopets.xpmultiplier.triple")) {
+        return 3.0
+    }
+
+    if (this.hasPermission("ecopets.xpmultiplier.double")) {
+        return 2.0
+    }
+
+    if (this.hasPermission("ecopets.xpmultiplier.50percent")) {
+        return 1.5
+    }
+
+    val prefix = "ecopets.xpmultiplier."
+    for (permissionAttachmentInfo in this.effectivePermissions) {
+        val permission = permissionAttachmentInfo.permission
+        if (permission.startsWith(prefix)) {
+            return ((permission.substring(permission.lastIndexOf(".") + 1).toDoubleOrNull() ?: 100.0) / 100) + 1
+        }
+    }
+
+    return 1.0
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/ecopets/util/LevelInjectable.kt

@@ -0,0 +1,27 @@
+package com.willfp.ecopets.util
+
+import com.willfp.eco.core.placeholder.InjectablePlaceholder
+import com.willfp.eco.core.placeholder.PlaceholderInjectable
+import com.willfp.eco.core.placeholder.StaticPlaceholder
+
+class LevelInjectable(
+    level: Int
+) : PlaceholderInjectable {
+    private val placeholders = listOf(
+        StaticPlaceholder(
+            "level"
+        ) { level.toString() }
+    )
+
+    override fun getPlaceholderInjections(): List<InjectablePlaceholder> {
+        return placeholders
+    }
+
+    override fun addInjectablePlaceholder(p0: Iterable<InjectablePlaceholder>) {
+        return
+    }
+
+    override fun clearInjectedPlaceholders() {
+        return
+    }
+}