Skill.java

package com.osroyale.game.world.entity.skill;
 
import com.osroyale.content.event.EventDispatcher;
import com.osroyale.content.event.InteractionEvent;
import com.osroyale.content.event.InteractionEvent.InteractionType;
import com.osroyale.content.event.InteractionEventListener;
import com.osroyale.content.event.impl.*;
import com.osroyale.game.world.entity.mob.player.Player;
import com.osroyale.util.Stopwatch;
 
import java.util.function.Function;

 
public class Skill implements InteractionEventListener {

    public static final int ATTACK = 0;

    public static final int DEFENCE = 1;

    public static final int STRENGTH = 2;

    public static final int HITPOINTS = 3;

    public static final int RANGED = 4;

    public static final int PRAYER = 5;

    public static final int MAGIC = 6;

    public static final int COOKING = 7;

    public static final int WOODCUTTING = 8;

    public static final int FLETCHING = 9;

    public static final int FISHING = 10;

    public static final int FIREMAKING = 11;

    public static final int CRAFTING = 12;

    public static final int SMITHING = 13;

    public static final int MINING = 14;

    public static final int HERBLORE = 15;

    public static final int AGILITY = 16;

    public static final int THIEVING = 17;

    public static final int SLAYER = 18;

    public static final int FARMING = 19;

    public static final int RUNECRAFTING = 20;

    public static final int CONSTRUCTION = 21;

    public static final int HUNTER = 22;

    public static final int SKILL_COUNT = 23;

    public static final int TOTAL_SKILL_LEVEL = 99 * SKILL_COUNT;

    private static final String[] SKILL_NAMES = new String[]{
        /* 00 */ "Attack",
        /* 01 */ "Defence",
        /* 02 */ "Strength",
        /* 03 */ "Hitpoints",
        /* 04 */ "Ranged",
        /* 05 */ "Prayer",
        /* 06 */ "Magic",
        /* 07 */ "Cooking",
        /* 08 */ "Woodcutting",
        /* 09 */ "Fletching",
        /* 10 */ "Fishing",
        /* 11 */ "Firemaking",
        /* 12 */ "Crafting",
        /* 13 */ "Smithing",
        /* 14 */ "Mining",
        /* 15 */ "Herblore",
        /* 16 */ "Agility",
        /* 17 */ "Thieving",
        /* 18 */ "Slayer",
        /* 19 */ "Farming",
        /* 20 */ "Runecrafting",
        /* 21 */ "Construction",
        /* 22 */ "Hunter",
    };

    private static final int[] EXP_FOR_LEVEL = {
            0, 83, 174, 276, 388, 512, 650, 801, 969, 1154, 1358, 1584, 1833, 2107,
            2411, 2746, 3115, 3523, 3973, 4470, 5018, 5624, 6291, 7028, 7842, 8740,
            9730, 10824, 12031, 13363, 14833, 16456, 18247, 20224, 22406, 24815, 27473,
            30408, 33648, 37224, 41171, 45529, 50339, 55649, 61512, 67983, 75127, 83014,
            91721, 101333, 111945, 123660, 136594, 150872, 166636, 184040, 203254, 224466,
            247886, 273742, 302288, 333804, 368599, 407015, 449428, 496254, 547953, 605032,
            668051, 737627, 814445, 899257, 992895, 1096278, 1210421, 1336443, 1475581,
            1629200, 1798808, 1986068, 2192818, 2421087, 2673114, 2951373, 3258594, 3597792,
            3972294, 4385776, 4842295, 5346332, 5902831, 6517253, 7195629, 7944614, 8771558,
            9684577, 10692629, 11805606, 13034431
    };

    public static final int[][] INTERFACE_DATA = {
            {4004, 4005},
            {4008, 4009},
            {4006, 4007},
            {4016, 4017},
            {4010, 4011},
            {4012, 4013},
            {4014, 4015},
            {4034, 4035},
            {4038, 4039},
            {4026, 4027},
            {4032, 4033},
            {4036, 4037},
            {4024, 4025},
            {4030, 4031},
            {4028, 4029},
            {4020, 4021},
            {4018, 4019},
            {4022, 4023},
            {12166, 12167},
            {13926, 13927},
            {4152, 4153},
            {24134, 24135},
            {-1, -1},
            {-1, -1},
            {-1, -1}};
 
    public transient final Stopwatch stopwatch = Stopwatch.start();

    private final int skill;

    private int level;

    private int maxLevel;

    private double experience;
 
    private boolean doingSkill = false;

    public Skill(int skill, int level, double experience) {
        this.skill = skill;
        this.level = level;
        this.maxLevel = getLevelForExperience(experience);
        this.experience = experience;
    }

    public int getSkill() {
        return skill;
    }

    public int getLevel() {
        return level;
    }

    public int getMaxLevel() {
        return maxLevel;
    }

    public double getExperience() {
        return experience;
    }

    public int getRoundedExperience() {
        return (int) experience;
    }

    public void setLevel(int level) {
        this.level = level;
    }

    public void setMaxLevel(int maxLevel) {
        this.maxLevel = maxLevel;
    }

    public void setExperience(double experience) {
        this.experience = experience;
    }

    public boolean reqLevel(int level) {
        return this.level >= level;
    }

    public void modifyLevel(Function<Integer, Integer> function) {
        modifyLevel(function, 0, maxLevel);
    }

    public void modifyLevel(Function<Integer, Integer> function, int lowerBounds, int upperBounds) {
        level = function.apply(level);
 
        if (level < 0) {
            level = 0;
        } else {
            if (level < lowerBounds) {
                level = lowerBounds;
            }
 
            if (level > upperBounds) {
                level = upperBounds;
            }
        }
    }

    public void addLevel(int amount) {
        modifyLevel(level -> level + amount);
    }

    public void removeLevel(int amount) {
        modifyLevel(level -> level - amount);
    }

    public void multiplyLevel(double amount) {
        modifyLevel(level -> (int) (level * amount));
    }

    public void divideLevel(double amount) {
        modifyLevel(level -> amount == 0 ? -level : (int) (level / amount));
    }

    public double modifyExperience(Function<Double, Double> function) {
        return modifyExperience(function, 0, 200_000_000);
    }

    public double modifyExperience(Function<Double, Double> function, int lowerBounds, int upperBounds) {
        experience = function.apply(experience);
 
        if (experience < 0) {
            experience = 0;
        } else {
            if (experience < lowerBounds) {
                experience = lowerBounds;
            }
 
            if (experience > upperBounds) {
                experience = upperBounds;
            }
        }
 
        return experience;
    }

    public double addExperience(double amount) {
        return modifyExperience(experience -> experience + amount);
    }

    public void removeExperience(double amount) {
        modifyExperience(experience -> experience - amount);
    }

    public void multiplyExperience(double amount) {
        modifyExperience(experience -> experience * amount);
    }

    public void divideExperience(double amount) {
        modifyExperience(experience -> amount == 0 ? -experience : (experience / amount));
    }

    private static byte binarySearch(double experience, int min, int max) {
        int mid = (min + max) / 2;
        double value = EXP_FOR_LEVEL[mid];
 
        if (value > experience) {
            return binarySearch(experience, min, mid - 1);
        } else if (value == (int) experience || EXP_FOR_LEVEL[mid + 1] > experience) {
            return (byte) (mid + 1);
        }
 
        return binarySearch(experience, mid + 1, max);
    }

    public static final byte getLevelForExperience(double experience) {
        if ((int) experience >= EXP_FOR_LEVEL[98]) {
            return 99;
        }
        return binarySearch(experience, 0, 98);
    }

    public static final int getExperienceForLevel(int level) {
        if (level >= 99) {
            return EXP_FOR_LEVEL[98];
        }
        if (level < 1) {
            return 0;
        }
        return EXP_FOR_LEVEL[level - 1];
    }

    public static String getName(int skill) {
        return SKILL_NAMES[skill];
    }

    public static Function<Integer, Integer> add(int amount) {
        return level -> level + amount;
    }

    public static Function<Integer, Integer> subtract(int amount) {
        return level -> level - amount;
    }

    public static Function<Integer, Integer> multiply(double amount) {
        return level -> (int) (level * amount);
    }

    public static Function<Integer, Integer> divide(double amount) {
        return level -> amount == 0 ? 0 : (int) (level / amount);
    }
 
    public void setDoingSkill(boolean doingSkill) {
        this.doingSkill = doingSkill;
    }
 
    public boolean isDoingSkill() {
        return doingSkill;
    }
 
    protected double modifier() {
        return 0;
    }
 
    protected boolean clickItem(Player player, ItemInteractionEvent event) {
        return false;
    }
 
    protected boolean clickNpc(Player player, NpcInteractionEvent event) {
        return false;
    }
 
    protected boolean clickObject(Player player, ObjectInteractionEvent event) {
        return false;
    }
 
    protected boolean clickButton(Player player, ClickButtonInteractionEvent event) {
        return false;
    }
 
    protected boolean useItem(Player player, ItemOnItemInteractionEvent event) {
        return false;
    }
 
    protected boolean useItem(Player player, ItemOnObjectInteractionEvent event) {
        return false;
    }
 
    protected boolean itemContainerAction(Player player, ItemContainerInteractionEvent event) {
        return false;
    }
 
    @Override
    public String toString() {
        return String.format("Skill[name=%s, id=%s, level=%s, max=%s, experience=%s]", getName(skill), skill, level, maxLevel, experience);
    }
 
    @Override
    public boolean onEvent(Player player, InteractionEvent interactionEvent) {
        final EventDispatcher dispatcher = new EventDispatcher(interactionEvent);
        dispatcher.dispatch(InteractionType.CLICK_BUTTON, e -> clickButton(player, (ClickButtonInteractionEvent) e));
        dispatcher.dispatch(InteractionType.ITEM_ON_ITEM, e -> useItem(player, (ItemOnItemInteractionEvent) e));
        dispatcher.dispatch(InteractionType.ITEM_ON_OBJECT, e -> useItem(player, (ItemOnObjectInteractionEvent) e));
 
        dispatcher.dispatch(InteractionType.FIRST_ITEM_CLICK, e -> clickItem(player, (FirstItemClickInteractionEvent) e));
        dispatcher.dispatch(InteractionType.SECOND_ITEM_CLICK, e -> clickItem(player, (SecondItemClickInteractionEvent) e));
        dispatcher.dispatch(InteractionType.THIRD_ITEM_CLICK, e -> clickItem(player, (ThirdItemClickInteractionEvent) e));
 
        dispatcher.dispatch(InteractionType.FIRST_CLICK_NPC, e -> clickNpc(player, (FirstNpcClick) e));
        dispatcher.dispatch(InteractionType.SECOND_CLICK_NPC, e -> clickNpc(player, (SecondNpcClick) e));
        dispatcher.dispatch(InteractionType.FIRST_CLICK_OBJECT, e -> clickObject(player, (FirstObjectClick) e));
        dispatcher.dispatch(InteractionType.SECOND_CLICK_OBJECT, e -> clickObject(player, (SecondObjectClick) e));
        dispatcher.dispatch(InteractionType.THIRD_CLICK_OBJECT, e -> clickObject(player, (ThirdObjectClick) e));
        dispatcher.dispatch(InteractionType.ITEM_CONTAINER_INTERACTION_EVENT, e -> itemContainerAction(player, (ItemContainerInteractionEvent) e));
        return interactionEvent.isHandled();
    }
}