Item.java

package com.osroyale.game.world.items;
 
import com.google.common.collect.Iterables;
import com.osroyale.game.world.entity.combat.attack.FightType;
import com.osroyale.game.world.entity.combat.ranged.RangedWeaponDefinition;
import com.osroyale.game.world.entity.combat.weapon.WeaponInterface;
import com.osroyale.game.world.items.containers.equipment.EquipmentType;
import com.osroyale.game.world.items.containers.pricechecker.PriceType;
import com.osroyale.util.Utility;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.OptionalInt;

 
* The container class that represents an item that can be interacted with.
 *
 * @author lare96 <http://github.com/lare96>
 */
public class Item implements Cloneable {

    private int id;

    private int amount;

    public Item(int id, int amount) {
        if (amount < 0) amount = 0;
        this.id = id;
        this.amount = amount;
    }

    public Item(int id, int minAmt, int maxAmt) {
        if (minAmt < 0 || maxAmt < 0) amount = 0;
        this.id = id;
        this.amount = Utility.random(minAmt, maxAmt, true);
    }
 
    public Item(int id, long amount) {
        int amount2;
        if (amount < 0) {
            amount2 = 0;
        } else if (amount > Integer.MAX_VALUE) {
            amount2 = Integer.MAX_VALUE;
        } else {
            amount2 = (int) amount;
        }
        this.id = id;
        this.amount = amount2;
    }
 
    public Item clone() {
        try {
            return (Item) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return this;
    }

    public Item unnoted() {
        return new Item(getDefinition().getUnnotedId(), amount);
    }

    public Item noted() {
        return new Item(getDefinition().getNotedId(), amount);
    }

    public int getValue(PriceType type) {
        ItemDefinition def = getDefinition();
        if (def == null) {
            return 0;
        }
 
        switch (type) {
            case VALUE:
                return def.getValue();
            case HIGH_ALCH_VALUE:
                return def.getHighAlch();
            case LOW_ALCH_VALUE:
                return def.getLowAlch();
        }
 
        return 0;
    }
 
    public int getSellValue() {
        return (int) Math.floor(getValue() / 2);
    }

    public int getValue() {
        ItemDefinition def = getDefinition();
        if (def == null) {
            return 0;
        }
        return def.getValue();
    }

    public Item createWithId(int newId) {
        if (id == newId) {
            return this;
        }
        return new Item(newId, amount);
    }

    public Item createWithAmount(int newAmount) {
        if (amount == newAmount) {
            return this;
        }
        return new Item(id, newAmount);
    }

    public Item createAndIncrement(int addAmount) {
        if (addAmount < 0) { // Same effect as decrementing.
            return createAndDecrement(Math.abs(addAmount));
        }
 
        int newAmount = amount + addAmount;
 
        if (newAmount < amount) { // An overflow.
            newAmount = Integer.MAX_VALUE;
        }
 
        Item item = clone();
        item.setAmount(newAmount);
        return item;
    }

    public Item createAndDecrement(int removeAmount) {
        if (removeAmount < 0) { // Same effect as incrementing.
            return createAndIncrement(-removeAmount);
        }
 
        int newAmount = amount - removeAmount;
 
        // Value too low, or an overflow.
        if (newAmount < 1 || newAmount > amount) {
            newAmount = 1;
        }
 
        Item clone = clone();
        clone.setAmount(newAmount);
        return clone;
    }

    public Item(int id) {
        this(id, 1);
    }

    public static final int[] convert(Item... ids) {
        List<Integer> values = new ArrayList<>();
        for (Item identifier : ids) {
            values.add(identifier.getId());
        }
        return values.stream().mapToInt(Integer::intValue).toArray();
    }

    public static final Item[] convert(int... id) {
        List<Item> items = new ArrayList<>();
        for (int identifier : id) {
            items.add(new Item(identifier));
        }
        return Iterables.toArray(items, Item.class);
    }

    public static boolean valid(Item item) {
        return item != null && item.id > 0 && item.id < ItemDefinition.DEFINITIONS.length && item.getDefinition() != null;
    }

    public Item copy() {
        return new Item(id, amount);
    }

    public final void incrementAmount() {
        incrementAmountBy(1);
    }

    public final void decrementAmount() {
        decrementAmountBy(1);
    }

    public final void incrementAmountBy(int amount) {
        this.amount += amount;
    }

    public final void decrementAmountBy(int amount) {
        if ((this.amount - amount) < 1) {
            this.amount = 0;
        } else {
            this.amount -= amount;
        }
    }

    public ItemDefinition getDefinition() {
        return ItemDefinition.get(id);
    }

    public final int getId() {
        return id;
    }

    public final void setId(int id) {
        this.id = id;
    }

    public final int getAmount() {
        return amount;
    }

    public final void setAmount(int amount) {
        if (amount < 0) amount = 0;
        this.amount = amount;
    }
 
    public String getName() {
        return getDefinition().getName();
    }
 
    public String getDestroyMessage() {
        return getDefinition().getDestroyMessage();
    }
 
    public boolean isStackable() {
        return getDefinition().isStackable();
    }
 
    public boolean isNoteable() {
        return getDefinition().isNoteable();
    }
 
    public boolean isNoted() {
        return getDefinition().isNoted();
    }
 
    public boolean isEquipable() {
        return getDefinition().getEquipmentType() != EquipmentType.NOT_WIELDABLE || getDefinition().isEquipable();
    }
 
    public boolean isTwoHanded() {
        return getDefinition().isTwoHanded();
    }
 
    public boolean isTradeable() {
        return getDefinition().isTradeable();
    }
 
    public boolean isDestroyable() {
        return getDefinition().isDestroyable();
    }
 
    public int getStandAnimation() {
        return getDefinition().getStandAnimation();
    }
 
    public int getWalkAnimation() {
        return getDefinition().getWalkAnimation();
    }
 
    public int getRunAnimation() {
        return getDefinition().getRunAnimation();
    }
 
 
    public OptionalInt getAttackAnimation(FightType type) {
        return getDefinition().getAttackAnimation(type);
    }
 
    public OptionalInt getBlockAnimation() {
        return getDefinition().getBlockAnimation();
    }
 
    public int getNotedId() {
        return getDefinition().getNotedId();
    }
 
    public int getUnnotedId() {
        return getDefinition().getUnnotedId();
    }
 
    public int getStreetValue() {
        return getDefinition().getStreetValue();
    }
 
    public int getBaseValue() {
        return getDefinition().getBaseValue();
    }
 
    public int getHighAlch() {
        return getDefinition().getHighAlch();
    }
 
    public int getLowAlch() {
        return getDefinition().getLowAlch();
    }
 
    public double getWeight() {
        return getDefinition().getWeight();
    }
 
    public EquipmentType getEquipmentType() {
        return getDefinition().getEquipmentType();
    }
 
    public Optional<RangedWeaponDefinition> getRangedDefinition() {
        return getDefinition().getRangedDefinition();
    }
 
    public int[] getRequirements() {
        return getDefinition().getRequirements();
    }
 
    public int[] getBonuses() {
        return getDefinition().getBonuses();
    }
 
    public int getBonus(int index) {
        return getDefinition().getBonuses()[index];
    }
 
    public boolean equalIds(Item other) {
        return other != null && id == other.id;
    }
 
    public boolean matchesId(int id) {
        return this.id == id;
    }
 
    @Override
    public final String toString() {
        return String.format("item[id=%d amount=%d]", id, amount);
    }
 
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Item) {
            Item other = (Item) obj;
            return other.id == id && other.amount == amount;
        }
        return false;
    }
 
    @Override
    public int hashCode() {
        return amount << 16 | id & 0xFFFF;
    }
 
    public WeaponInterface getWeaponInterface() {
        return getDefinition().getWeaponInterface();
    }
}