LizardmanShamanConsumableManager.kt

package scripts.kotlin.api.framework.routine.api.lizardman.shaman

import org.tribot.script.sdk.MyPlayer
import org.tribot.script.sdk.Skill
import org.tribot.script.sdk.query.Query
import org.tribot.script.sdk.util.TribotRandom
import scripts.kotlin.api.antiban.DistributionParameters
import scripts.kotlin.api.antiban.PlayerBehaviorProfile
import scripts.kotlin.api.framework.routine.api.Consumable
import scripts.kotlin.api.framework.routine.api.Logger
import scripts.kotlin.api.framework.routine.api.interfaces.TribotConsumableManager

class LizardmanShamanConsumableManager(
    override val consumables: Array<Consumable> = Consumable.values(),
    override val logger: Logger = Logger("Shaman Consumable Manager")
) : TribotConsumableManager {

    private val staminaProfile = PlayerBehaviorProfile(
        variable1Parameters = DistributionParameters(40.0, 10.0),
        variable2Parameters = DistributionParameters(5.0, 1.0)
    )
    private var drinkStaminaAtPercent = getNewDrinkStaminaAtPercent()
    private fun getNewDrinkStaminaAtPercent(): Double {
        return TribotRandom.normal(staminaProfile.variable1, staminaProfile.variable2)
    }
    private fun setNewDrinkStaminaAtPercent() {
        drinkStaminaAtPercent = getNewDrinkStaminaAtPercent()
    }

    private val rangingProfile = PlayerBehaviorProfile(
        variable1Parameters = DistributionParameters(10.0, 2.5),
        variable2Parameters = DistributionParameters(2.0, 0.5)
    )
    private var drinkRangingAtPercent = getNewDrinkRangingAtPercent()
    private fun getNewDrinkRangingAtPercent(): Double {
        return TribotRandom.normal(rangingProfile.variable1, rangingProfile.variable2)
    }
    private fun setNewDrinkRangingAtPercent() {
        drinkRangingAtPercent = getNewDrinkRangingAtPercent()
    }

    private val divineRangingProfile = PlayerBehaviorProfile(
        variable1Parameters = DistributionParameters(90.0, 8.0),
        variable2Parameters = DistributionParameters(3.0, 1.0)
    )
    private var drinkDivineRangingAtPercent = getNewDrinkDivineRangingAtPercent()
    private fun getNewDrinkDivineRangingAtPercent(): Double {
        return TribotRandom.normal(divineRangingProfile.variable1, divineRangingProfile.variable2).coerceIn(0.0, 100.0)
    }
    private fun setNewDrinkDivineRangingAtPercent() {
        drinkDivineRangingAtPercent = getNewDrinkDivineRangingAtPercent()
    }
    private var lastDivineRangingDrinkTime: Long = -1

    override fun consume(consumable: Consumable): Boolean {
        return when (consumable) {
            Consumable.STAMINA -> {
                if (MyPlayer.getRunEnergy() < drinkStaminaAtPercent && drink(consumable)) {
                    setNewDrinkStaminaAtPercent()
                    return true
                }
                return false
            }

            Consumable.ANTIPOISON,
            Consumable.SUPERANTIPOISON -> {
                MyPlayer.isPoisoned() && drink(consumable)
            }

            Consumable.ANTIDOTE_PLUS_PLUS,
            Consumable.ANTIVENOM,
            Consumable.ANTIVENOM_PLUS -> {
                (MyPlayer.isPoisoned() || MyPlayer.isVenomed()) && drink(consumable)
            }

            Consumable.RANGING -> {
                val baseRangedLevel = Skill.RANGED.actualLevel
                val currentRangedLevel = Skill.RANGED.currentLevel
                val maxBoostFromPotion = (baseRangedLevel * 0.1 + 4).toInt()
                val threshold = baseRangedLevel + maxBoostFromPotion * drinkRangingAtPercent / 100

                if (currentRangedLevel < threshold && drink(consumable)) {
                    setNewDrinkRangingAtPercent()
                    return true
                }
                return false
            }

            Consumable.DIVINE_RANGING -> {
                // Requires 10hp
                if (MyPlayer.getCurrentHealth() < 11) {
                    return false
                }

                val elapsedTime = System.currentTimeMillis() - lastDivineRangingDrinkTime
                val maxEffectTime = 300000  // 5 minutes in milliseconds
                val dynamicThreshold = maxEffectTime * (drinkDivineRangingAtPercent / 100)

                // If the effect duration minus the elapsed time is less than or equal to the dynamic threshold, repot
                if (lastDivineRangingDrinkTime == -1L || maxEffectTime - elapsedTime <= dynamicThreshold) {
                    if (drink(consumable)) {
                        lastDivineRangingDrinkTime = System.currentTimeMillis()
                        setNewDrinkDivineRangingAtPercent()  // Update the random value after each consumption
                        return true
                    }
                }
                return false
            }

            // Players only consume a prayer potion when the potential restore is,
            // less than or equal to the missing prayer points, preventing wastage.
            // Bonus items influence the restoration amount.
            // Efficiency is maximized by using the potion only when necessary.
            Consumable.PRAYER -> {
                val basePrayerLevel = Skill.PRAYER.actualLevel  // This represents the maximum prayer points.
                val currentPrayerPoints = Skill.PRAYER.currentLevel  // This represents the current prayer points.

                val hasBonus = Query.inventory()
                    .nameContains("prayer cape", "holy wrench")
                    .isNoted
                    .isAny
                        ||
                        Query.equipment()
                            .nameContains("prayer cape", "ring of the gods")
                            .isAny

                val restoreAmount = if (hasBonus) {
                    (7 + 0.27 * basePrayerLevel).toInt()
                }
                else {
                    (7 + 0.25 * basePrayerLevel).toInt()
                }

                val missingPrayerPoints = basePrayerLevel - currentPrayerPoints
                return missingPrayerPoints >= restoreAmount && drink(consumable)
            }

            else -> false
        }
    }
}