ExchangeSession.java

package com.osroyale.game.world.entity.mob.player.exchange;
 
import com.google.common.collect.ImmutableSet;
import com.osroyale.content.activity.ActivityType;
import com.osroyale.content.gambling.GambleStage;
import com.osroyale.game.task.impl.DuelNotificationTask;
import com.osroyale.game.task.impl.SessionRemovalNotificationTask;
import com.osroyale.game.world.World;
import com.osroyale.game.world.entity.mob.player.Player;
import com.osroyale.game.world.entity.mob.player.PlayerRight;
import com.osroyale.game.world.items.Item;
import com.osroyale.game.world.items.containers.ItemContainer;
import com.osroyale.game.world.items.containers.inventory.Inventory;
import com.osroyale.game.world.position.Position;
 
import java.util.*;
import java.util.function.Consumer;

 
public abstract class ExchangeSession {

    public static final Set<ExchangeSession> SESSIONS = new HashSet<>();

    public final Player player;

    public final Player other;

    public final ExchangeSessionType type;

    public final Map<Player, ItemContainer> item_containers = new HashMap<>();

    private Object attachment;

    public ExchangeSession(Player player, Player other, ExchangeSessionType type) {
        this.player = player;
        this.other = other;
        this.type = type;
        forEach(p -> item_containers.put(p, new ItemContainer(28, ItemContainer.StackPolicy.STANDARD)));
    }

    public boolean canOffer = true;

    public boolean finalized;

    public abstract boolean onRequest();

    public abstract void accept(Player player, String COMPONENT);

    public abstract boolean canAddItem(Player player, Item item, int slot);

    public abstract boolean canRemoveItem(Player player, Item item, int slot);

    public abstract boolean onButtonClick(Player player, int button);

    public abstract void updateMainComponents(String component);

    public abstract void updateOfferComponents();

    public abstract void onReset();

    public boolean request() {
        if (inAnySession()) {
            player.exchangeSession.reset();
            return false;
        }
      /*  if (PlayerRight.isAdministrator(player) && !PlayerRight.isOwner(player) || !PlayerRight.isDeveloper(player)) {
            player.message("You can not exchange as an administrator.");
            return false;
        }
        if (PlayerRight.isAdministrator(other) && !PlayerRight.isOwner(other) || !PlayerRight.isDeveloper(other)) {
            player.message("You can not exchange an administrator.");
            return false;
        }*/
 
        if (getSession(other).isPresent() && getSession(other).get().inAnySession()) {
            player.message("This player is currently is a " + type.name + " with another player.");
            return false;
        }
        if (Objects.equals(player, other)) {
            player.message("You cannot " + type.name + " with yourself.");
            return false;
        }
 
        if(player.getGambling().getStage().equals(GambleStage.PLACING_BET) || player.getGambling().getStage().equals(GambleStage.IN_PROGRESS)) {
            return false;
        }
 
        if(other.getGambling().getStage().equals(GambleStage.PLACING_BET) || other.getGambling().getStage().equals(GambleStage.IN_PROGRESS)) {
            return false;
        }
 
        if (PlayerRight.isIronman(player) && !PlayerRight.isOwner(other)) {
            player.message("You can not " + type.name + " as you are an iron man.");
            return false;
        }
        if (PlayerRight.isIronman(other) && !PlayerRight.isOwner(player)) {
            player.message(other.getName() + " can not be " + type.name + "d as they are an iron man.");
            return false;
        }
        if (player.exchangeSession.requested_players.contains(other)) {
            player.message("You have already sent a request to this player.");
            return false;
        }
        if (player.locking.locked()) {
            player.message("You cannot send a " + type.name + " request right now.");
            return false;
        }
        if (other.locking.locked()) {
            player.message(other.getName() + " is currently busy.");
            return false;
        }
        if (player.playerAssistant.busy()) {
            player.message("Please finish what you are doing before you do that.");
            return false;
        }
        if (other.playerAssistant.busy()) {
            player.message(other.getName() + " is currently busy.");
            return false;
        }
        if (player.inActivity(ActivityType.DUEL_ARENA)) {
            player.message("You can not do that whilst in a duel!");
            return false;
        }
        if (other.inActivity(ActivityType.DUEL_ARENA)) {
            other.message("You can not do that whilst in a duel!");
            return false;
        }
        if (!onRequest()) {
            return false;
        }
        if(this.type == ExchangeSessionType.DUEL && !other.getPosition().inLocation(new Position(3311, 3201), new Position(3394, 3287), true)) {
            player.exchangeSession.reset();
            return false;
        }
        return SESSIONS.add(this);
    }

    public final boolean add(Player player, int slot, int amount) {
        Item invItem = player.inventory.get(slot);
        if (invItem == null) {
            return false;
        }
        if (!Item.valid(invItem) || !player.inventory.contains(invItem.getId())) {
            return false;
        }
        if (!canOffer) {
            return false;
        }
        if (!inSession(player, type)) {
            return false;
        }
        if (!canAddItem(player, invItem, slot)) {
            return false;
        }
        if (!invItem.isTradeable() && !PlayerRight.isOwner(player)) {
            player.message("You can't offer this item.");
            return false;
        }
        Item item = new Item(invItem.getId(), amount);
        int count = player.inventory.computeAmountForId(item.getId());
        if (item.getAmount() > count) {
            item.setAmount(count);
        }
        if (item_containers.get(player).add(item)) {
            player.inventory.remove(item);
            updateOfferComponents();
            return true;
        }
        return false;
    }

    public final boolean remove(Player player, int slot, int amount) {
        Item containerItem = this.item_containers.get(player).get(slot);
        if (player == null || containerItem == null) {
            return false;
        }
        if (!Item.valid(containerItem) || !this.item_containers.get(player).contains(containerItem.getId())) {
            return false;
        }
        if (!canOffer) {
            return false;
        }
        if (!inSession(player, type)) {
            return false;
        }
        if (!canRemoveItem(player, containerItem, slot)) {
            return false;
        }
        Item item = new Item(containerItem.getId(), amount == -1 ? this.item_containers.get(player).computeAmountForId(containerItem.getId()) : amount);
        int count = item_containers.get(player).computeAmountForId(item.getId());
        if (item.getAmount() > count) {
            item.setAmount(count);
        }
        if (item_containers.get(player).remove(item)) {
            player.inventory.add(item);
            item_containers.get(player).shift();
 
            if (this.player.equals(player)) {
                World.schedule(this.type == ExchangeSessionType.DUEL ? new DuelNotificationTask(other) : new SessionRemovalNotificationTask(other));
            } else if (player.equals(other)) {
                World.schedule(this.type == ExchangeSessionType.DUEL ? new DuelNotificationTask(this.player) : new SessionRemovalNotificationTask(this.player));
            }
 
            updateOfferComponents();
            return true;
        }
        return false;
    }

    public void setAttachment(Object attachment) {
        this.attachment = attachment;
    }

    public Object getAttachment() {
        return attachment;
    }

    public boolean hasAttachment() {
        return Objects.nonNull(attachment);
    }

    public static boolean inSession(Player player, Player other, ExchangeSessionType type) {
        return SESSIONS.stream().anyMatch(session -> allMatch(session, player.getName(), other.getName()) && session.type.equals(type));
    }

    public static boolean inSession(Player player, ExchangeSessionType type) {
        return getSession(player, type).isPresent();
    }

    public boolean inAnySession() {
        return getSession(player).isPresent();
    }

    public void depositeAll(Player player) {
        Inventory inventory = player.inventory;
        if (inventory.isEmpty()) {
            player.message("There is nothing in your inventory to deposit!");
            return;
        }
 
        List<Item> transfer = new ArrayList<>();
        for (Item item : inventory.getItems()) {
            if (item == null || !item.isTradeable()) {
                continue;
            }
 
            transfer.add(item);
        }
 
        this.item_containers.get(player).addAll(transfer);
        inventory.removeAll(transfer);
 
        inventory.refresh();
        updateOfferComponents();
    }

    protected void withdrawAll(Player player) {
        ItemContainer container = this.item_containers.get(player);
 
        if (container.isEmpty()) {
            player.message("There is nothing in this container to withdraw!");
            return;
        }
        player.inventory.addAll(container);
        container.clear();
        updateOfferComponents();
    }

    protected void finalize(ExchangeCompletionType type) {
        final Optional<ExchangeSession> session = getSession(player);
 
        if (!session.isPresent() || session.get().finalized) {
            return;
        }
 
        session.get().finalized = true;
 
        switch (type) {
            case RESTORE:
                session.get().forEach(player -> {
                    ItemContainer items = item_containers.get(player);
                    items.forEach(player.inventory::add);
                    items.clear();
                });
                break;
            case DISPOSE:
                session.get().forEach(s -> item_containers.get(s).clear());
                break;
            case HALT:
                //nothing happens when halted, the session only gets finalized.
                break;
        }
        SESSIONS.remove(this);
        onReset();
    }

    public static Optional<ExchangeSession> getSession(Player player) {
        return SESSIONS.stream().filter(s -> anyMatch(s, player.getName())).findAny();
    }

    public static Optional<ExchangeSession> getSession(Player player, ExchangeSessionType type) {
        return SESSIONS.stream().filter(s -> s.type.equals(type) && anyMatch(s, player.getName())).findAny();
    }

    public static Optional<ExchangeSession> getSession(Player player, Player other) {
        return SESSIONS.stream().filter(s -> allMatch(s, player.getName(), other.getName())).findAny();
    }

    public static Optional<ExchangeSession> getSession(Player player, Player other, ExchangeSessionType type) {
        return SESSIONS.stream().filter(s -> allMatch(s, player.getName(), other.getName()) && s.type.equals(type)).findAny();
    }

    public void forEach(Consumer<Player> action) {
        ImmutableSet.of(player, other).forEach(action);
    }

    public Player getOther(Player p) {
        return p.getName().equals(player.getName()) ? this.other : this.player;
    }
 
    private static boolean anyMatch(ExchangeSession session, String name) {
        return Arrays.stream(new String[]{session.player.getName(), session.other.getName()}).anyMatch(n -> n.equals(name));
    }
 
    private static boolean allMatch(ExchangeSession session, String name, String otherName) {
        return Arrays.stream(new String[]{session.player.getName(), session.other.getName()}).anyMatch(n -> n.equals(name) || n.equals(otherName));
    }
}