Deduplicate drop database, fix some bugs, rewrite RationalTable, use Double over Rational for more precision

Author: lare96

data/game/def/npcs/drops.json

@@ -75,12 +75,6 @@ public GroundItem(LunaContext context, int id, int amount, Position position, Ch
         super(context, position, EntityType.ITEM, view);
         checkArgument(ItemDefinition.isIdValid(id), "Invalid item identifier.");
         checkArgument(amount > 0, "Amount must be above 0.");
-
-        // Non-stackable ground items must be represented one-by-one.
-        ItemDefinition def = ItemDefinition.ALL.retrieve(id);
-        checkArgument(def.isStackable() || amount == 1,
-                "Non-stackable ground items [" + def.getName() + "] have a maximum amount of 1.");
-
         this.id = id;
         this.amount = amount;
     }

src/main/java/io/luna/game/model/item/GroundItem.java

@@ -28,11 +28,7 @@ public final class RandomUtils {
      * @return {@code true} if the roll succeeds, {@code false} otherwise.
      */
     public static boolean roll(Rational rational) {
-        if (rational.getNumerator() <= 0) {
-            return false;
-        } else if (rational.getNumerator() >= rational.getDenominator()) {
-            return true;
-        } else return ThreadLocalRandom.current().nextLong(0, rational.getDenominator()) < rational.getNumerator();
+        return roll(rational.doubleValue());
     }
 
     /**
@@ -76,7 +72,7 @@ public static double nextDouble() {
      * @param value The percent chance to succeed (0–100).
      * @return {@code true} if successful, {@code false} otherwise.
      */
-    public static boolean rollPercent(int value) {
+    public static boolean roll(int value) {
         value = Math.max(0, Math.min(value, 100));
         return ThreadLocalRandom.current().nextInt(100) < value;
     }
@@ -87,7 +83,7 @@ public static boolean rollPercent(int value) {
      * @param value The chance to succeed (0.0–1.0).
      * @return {@code true} if successful, {@code false} otherwise.
      */
-    public static boolean rollPercent(double value) {
+    public static boolean roll(double value) {
         value = Math.max(0.0, Math.min(value, 1.0));
         return ThreadLocalRandom.current().nextDouble() <= value;
     }

src/main/java/io/luna/util/RandomUtils.java

@@ -319,7 +319,6 @@ public long getDenominator() {
      * Compares this rational to another for ordering.
      * <p>
      * The comparison is performed using the double-precision value of each number.
-     * </p>
      *
      * @param other The other rational to compare against.
      * @return A negative value if less, zero if equal, or positive if greater.

src/main/java/io/luna/util/Rational.java

@@ -26,7 +26,7 @@ object Suspendable {
     /**
      * Maybes runs [action] based on [prob]. Returns `true` if the action ran.
      */
-    suspend fun maybe(prob: Rational, action: suspend () -> Unit): Boolean {
+    suspend fun maybe(prob: Double, action: suspend () -> Unit): Boolean {
         if (RandomUtils.roll(prob)) {
             action()
             return true

src/main/kotlin/api/api/bot/Suspendable.kt

@@ -5,7 +5,6 @@ import io.luna.game.model.Entity
 import io.luna.game.model.item.Item
 import io.luna.game.model.mob.Mob
 import io.luna.util.RandomUtils
-import io.luna.util.Rational
 
 /**
  * Represents a drop table with a fixed chance to roll for item drops. This is the base class for all drop table types
@@ -19,7 +18,7 @@ import io.luna.util.Rational
  *
  * @author lare96
  */
-abstract class DropTable(private val chance: Rational = ALWAYS) : Iterable<DropTableItem> {
+abstract class DropTable(private val chance: Double = ALWAYS) : Iterable<DropTableItem> {
 
     /**
      * Rolls on the drop table based on the provided context [mob] (killer) and [source] (victim).
@@ -30,7 +29,7 @@ abstract class DropTable(private val chance: Rational = ALWAYS) : Iterable<DropT
         val allItems = mutableListOf<Item>()
         if (RandomUtils.roll(chance) && canRollOnTable(mob, source)) {
             val items = computeTable(mob, source).filterNot {
-                val alwaysDrop = it.chance == ALWAYS
+                val alwaysDrop = it.chance >= 1.0
                 if (alwaysDrop) {
                     val alwaysItem = it.toItem()
                     if (alwaysItem != null) {
@@ -60,7 +59,7 @@ abstract class DropTable(private val chance: Rational = ALWAYS) : Iterable<DropT
                 if (RandomUtils.roll(item.chance)) item.toItem() else null
             }
 
-            else -> RationalTable(items.map { it.chance to it }).roll()?.toItem()
+            else -> ProbabilityTable(items.map { it.chance to it }).roll()?.toItem()
         }
     }
 

src/main/kotlin/api/api/drops/DropTable.kt

@@ -69,7 +69,7 @@ object DropTableHandler {
      * @param action The block defining the drop table items.
      * @return A simple drop table instance.
      */
-    fun createSimple(chance: Rational = Rational.ALWAYS, action: DropTableItemReceiver.() -> Unit): SimpleDropTable {
+    fun createSimple(chance: Double = ALWAYS, action: DropTableItemReceiver.() -> Unit): SimpleDropTable {
         return create(action).table { SimpleDropTable(table, chance) }
     }
 
@@ -81,7 +81,7 @@ object DropTableHandler {
      * @return A simple drop table with one item.
      */
     fun createSingleton(
-        chance: Rational = Rational.ALWAYS,
+        chance: Double = ALWAYS,
         action: DropTableItemReceiver.() -> DropTableItemChanceReceiver,
     ): SimpleDropTable {
         return createSimple { action(this).chance(chance) }

src/main/kotlin/api/api/drops/DropTableHandler.kt

@@ -13,7 +13,7 @@ import io.luna.util.Rational
  * @property chance The probability of dropping this item.
  * @author lare96
  */
-class DropTableItem(val id: Int, val amount: IntRange, val chance: Rational) {
+class DropTableItem(val id: Int, val amount: IntRange, val chance: Double) {
 
     companion object {
 
@@ -38,13 +38,13 @@ class DropTableItem(val id: Int, val amount: IntRange, val chance: Rational) {
     }
 
 
-    constructor(name: String, amount: IntRange, chance: Rational, noted: Boolean = false) :
+    constructor(name: String, amount: IntRange, chance: Double, noted: Boolean = false) :
             this(computeId(name, noted), amount, chance)
 
-    constructor(name: String, amount: Int, chance: Rational, noted: Boolean = false) :
+    constructor(name: String, amount: Int, chance: Double, noted: Boolean = false) :
             this(computeId(name, noted), amount..amount, chance)
 
-    constructor(id: Int, amount: Int, chance: Rational) :
+    constructor(id: Int, amount: Int, chance: Double) :
             this(id, amount..amount, chance)
 
     override fun toString(): String {

src/main/kotlin/api/api/drops/DropTableItem.kt

@@ -93,7 +93,7 @@ object GenericDropTables {
      * @param chance Chance to roll on this table.
      * @param rowBonus Enables RoW effects programmatically.
      */
-    fun gemDropTable(chance: Rational = ALWAYS, rowBonus: Boolean = false): DropTable {
+    fun gemDropTable(chance: Double = ALWAYS, rowBonus: Boolean = false): DropTable {
         return DropTableHandler.create {
             nothing(1 of 2)
             "Uncut sapphire" x 1 chance (1 of 4)
@@ -136,7 +136,7 @@ object GenericDropTables {
      * @param chance Chance to roll on this table.
      * @param rowBonus Enables RoW effects programmatically.
      */
-    fun rareDropTable(chance: Rational = ALWAYS, rowBonus: Boolean = false): DropTable {
+    fun rareDropTable(chance: Double = ALWAYS, rowBonus: Boolean = false): DropTable {
         return DropTableHandler.create {
             "Nature rune" x 40..70 chance (1 of 42)
             "Adamant javelin" x 10..20 chance (1 of 64)
@@ -181,7 +181,7 @@ object GenericDropTables {
      * @param chance Chance to roll on this table.
      * @param rowBonus Enables RoW effects programmatically.
      */
-    fun megaRareDropTable(chance: Rational = ALWAYS, rowBonus: Boolean = false): DropTable {
+    fun megaRareDropTable(chance: Double = ALWAYS, rowBonus: Boolean = false): DropTable {
         return DropTableHandler.create {
             nothing(22 of 25)
             "Rune spear" x 1..5 chance (1 of 16)
@@ -208,7 +208,7 @@ object GenericDropTables {
      * @param combatLevelFactor If true, seed tier is scaled by the mob's combat level.
      * @param chance Chance to roll on this table.
      */
-    fun generalSeedDropTable(combatLevelFactor: Boolean = true, chance: Rational = ALWAYS): DropTable {
+    fun generalSeedDropTable(combatLevelFactor: Boolean = true, chance: Double = ALWAYS): DropTable {
         return DropTableHandler.create {}.table {
             object : DropTable(chance) {
                 override fun computeTable(mob: Mob?, source: Entity?): DropTableItemList {
@@ -247,7 +247,7 @@ object GenericDropTables {
      *
      * @param chance Chance to roll on this table.
      */
-    fun rareSeedDropTable(chance: Rational = ALWAYS): SimpleDropTable {
+    fun rareSeedDropTable(chance: Double = ALWAYS): SimpleDropTable {
         return DropTableHandler.createSimple(chance) {
             "Toadflax seed" x 1 chance (1 of 5)
             "Irit seed" x 1 chance (1 of 7)
@@ -269,7 +269,7 @@ object GenericDropTables {
      *
      * @param chance Chance to roll on this table.
      */
-    fun treeHerbSeedDropTable(chance: Rational): SimpleDropTable {
+    fun treeHerbSeedDropTable(chance: Double): SimpleDropTable {
         return DropTableHandler.createSimple(chance) {
             "Ranarr seed" x 1 chance (1 of 8)
             "Snapdragon seed" x 1 chance (1 of 8)
@@ -292,7 +292,7 @@ object GenericDropTables {
      *
      * @param chance Chance to roll on this table.
      */
-    fun uncommonSeedDropTable(chance: Rational = ALWAYS): DropTable {
+    fun uncommonSeedDropTable(chance: Double = ALWAYS): DropTable {
         return DropTableHandler.createSimple(chance) {
             items += generalSeedDropList3
             items += generalSeedDropList4
@@ -307,7 +307,7 @@ object GenericDropTables {
      *
      * @param chance Chance to roll on this table.
      */
-    fun usefulHerbDropTable(chance: Rational = ALWAYS): DropTable {
+    fun usefulHerbDropTable(chance: Double = ALWAYS): DropTable {
         return DropTableHandler.createSimple(chance) {
             noted {
                 "Grimy avantoe" x 1..3 chance (1 of 3)
@@ -323,7 +323,7 @@ object GenericDropTables {
      *
      * @param chance Chance to roll on this table.
      */
-    fun herbDropTable(chance: Rational = ALWAYS): DropTable {
+    fun herbDropTable(chance: Double = ALWAYS): DropTable {
         return DropTableHandler.createSimple(chance) {
             "Grimy guam leaf" x 1 chance (1 of 4)
             "Grimy marrentill" x 1 chance (1 of 5)

src/main/kotlin/api/api/drops/GenericDropTables.kt

@@ -0,0 +1,62 @@
+package api.drops
+
+import api.predef.*
+
+/**
+ * A table that selects one outcome from a list of probability entries.
+ *
+ * Each entry consists of a probability value and its associated result.
+ *
+ * When the total chance is less than or equal to `1.0`, the table behaves as an absolute probability table.
+ * Any unclaimed probability space results in no selection being made.
+ *
+ * When the total chance exceeds `1.0`, the table falls back to relative-weight selection. In that mode, entry
+ * values are treated as weights rather than absolute probabilities.
+ *
+ * @param entries The probability entries to roll against.
+ *
+ * @author lare96
+ */
+class ProbabilityTable<T>(private val entries: List<Pair<Double, T>>) {
+
+    /**
+     * Rolls this table and returns the selected value, if any.
+     *
+     * If the combined chance of all entries is less than or equal to `1.0`, this performs an absolute
+     * probability roll over the range `[0.0, 1.0]`. If the roll lands outside all entry ranges, this returns
+     * `null`.
+     *
+     * If the combined chance exceeds `1.0`, this performs a relative-weight roll over the range
+     * `[0.0, totalChance]` instead. This preserves selection behavior for oversized tables, but the entry values
+     * are no longer interpreted as absolute probabilities.
+     *
+     * @return The selected value, or `null` if no value is selected.
+     */
+    fun roll(): T? {
+        if (entries.isEmpty()) {
+            // No table to roll on.
+            return null
+        }
+
+        val totalChance = entries.sumOf { it.first }
+        if (totalChance > 1.0) {
+            logger.warn(
+                "Absolute selection is invalid when total chance exceeds 1.0. Falling back to relative mode instead."
+            )
+        }
+
+        val roll = if (totalChance > 1.0) rand().nextDouble(totalChance) else rand().nextDouble()
+        var current = 0.0
+
+        for ((chance, value) in entries) {
+            // Advance the cumulative boundary until the rolled point is reached.
+            current += chance
+            if (roll < current) {
+                return value
+            }
+        }
+
+        // The roll landed in unclaimed probability space.
+        return null
+    }
+}