PrayerBook.java

package com.osroyale.game.world.entity.mob.prayer;
 
import java.util.*;
import java.util.function.Consumer;

 
public class PrayerBook {

    private final Set<Prayer> active = EnumSet.noneOf(Prayer.class);

    private transient Consumer<Prayer> sendActivated;

    private transient Consumer<Prayer> sendDeactivated;

    private transient Consumer<Prayer> sendOverhead;

    private transient Consumer<Prayer> sendNoOverhead;

    public transient int drainCounter;

    public boolean isActive(Prayer... prayers) {
        for (Prayer prayer : prayers)
            if (!active.contains(prayer)) return false;
        return true;
    }
 
    public boolean hasOverhead() {
        for (Prayer prayer : Prayer.OVERHEAD) {
            if (isActive(prayer)) {
                return true;
            }
        }
        return false;
    }
 
    public void deactivateOverhead() {
        for (Prayer prayer : Prayer.OVERHEAD) {
            if (isActive(prayer)) {
                deactivate(prayer);
            }
        }
    }

    public boolean anyActive(Prayer... prayers) {
        for (Prayer prayer : prayers)
            if (active.contains(prayer)) return true;
        return false;
    }

    public boolean noneActive(Prayer... prayers) {
        for (Prayer prayer : prayers)
            if (active.contains(prayer)) return false;
        return true;
    }

    private void onlyOrNone(Prayer... prayers) {
        if (isActive(prayers)) reset();
        else only(prayers);
    }

    public void only(Prayer... prayers) {
        List<Prayer> list = Arrays.asList(prayers);
        Set<Prayer> activate = new HashSet<>(list);
        Set<Prayer> deactivate = new HashSet<>(active);
        deactivate.removeAll(activate);
        mutate(activate, deactivate);
    }

    private void activate(Prayer... prayers) {
        for (Prayer prayer : prayers) {
            if (!active.add(prayer) || sendActivated == null) continue;
            sendActivated.accept(prayer);
            if (sendOverhead != null && prayer.is(Prayer.Type.OVERHEAD)) {
                sendOverhead.accept(prayer);
            }
        }
    }

    public void deactivate(Prayer... prayers) {
        for (Prayer prayer : prayers) {
            if (!active.remove(prayer) || sendDeactivated == null) continue;
            sendDeactivated.accept(prayer);
            if (sendNoOverhead != null && prayer.is(Prayer.Type.OVERHEAD)) {
                sendNoOverhead.accept(prayer);
            }
        }
    }

    public void toggle(Prayer... prayers) {
        Set<Prayer> activate = new HashSet<>();
        Set<Prayer> deactivate = new HashSet<>();
        for (Prayer prayer : prayers) {
            if (deactivate.contains(prayer)) continue;
            if (!active.contains(prayer)) {
                deactivate.addAll(prayer.toDeactivate());
                activate.add(prayer);
            } else deactivate.add(prayer);
        }
        deactivate.removeAll(activate);
        mutate(activate, deactivate);
    }

    public void setAs(PrayerBook book) {
        onlyOrNone(book.toArray());
    }

    private void mutate(Set<Prayer> activate, Set<Prayer> deactivate) {
        deactivate(deactivate.toArray(new Prayer[deactivate.size()]));
        activate(activate.toArray(new Prayer[activate.size()]));
    }

    public int drainAmount(int bonus) {
        if (active.isEmpty())
            return 0;
 
        int effect = 0, amount = 0;
        int resistance = 60 + 2 * bonus;
 
        for (Prayer prayer : active) {
            effect += prayer.getDrainRate();
        }
 
        drainCounter += effect;
 
        if (drainCounter > resistance) {
            amount = drainCounter / resistance;
            drainCounter -= amount * resistance;
        }
 
        return amount;
    }
 
    public void resetProtection() {
        if (isActive(Prayer.PROTECT_FROM_MAGIC))
            deactivate(Prayer.PROTECT_FROM_MAGIC);
        if (isActive(Prayer.PROTECT_FROM_MELEE))
            deactivate(Prayer.PROTECT_FROM_MELEE);
        if (isActive(Prayer.PROTECT_FROM_RANGE))
            deactivate(Prayer.PROTECT_FROM_RANGE);
    }

    public void reset() {
        deactivate(active.toArray(new Prayer[active.size()]));
    }
 
    public boolean isActive() {
        return !active.isEmpty();
    }
 
    public Set<Prayer> getEnabled() {
        return active;
    }

    public Prayer[] toArray() {
        if (active.isEmpty()) return new Prayer[0];
        return active.toArray(new Prayer[active.size()]);
    }

    public void setOnChange(Consumer<Prayer> sendActivated, Consumer<Prayer> sendDeactivated, Consumer<Prayer> sendOverhead, Consumer<Prayer> sendNoOverhead) {
        this.sendActivated = sendActivated;
        this.sendDeactivated = sendDeactivated;
        this.sendOverhead = sendOverhead;
        this.sendNoOverhead = sendNoOverhead;
    }
 
    @Override
    public String toString() {
        return "PrayerBook[active=" + active.toString() + "]";
    }
 
}