think.rpgitems.power.impl.Attachments Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of rpgitems Show documentation
The legacy RPGItems continues. (fork)
There is a newer version: 3.12.2
package think.rpgitems.power.impl;

import cat.nyaa.nyaacore.Pair;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.Event;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.entity.EntityShootBowEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.EquipmentSlot;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.PlayerInventory;
import think.rpgitems.item.ItemManager;
import think.rpgitems.item.RPGItem;
import think.rpgitems.power.*;
import think.rpgitems.power.trigger.BaseTriggers;

import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

@Meta(defaultTrigger = "RIGHT_CLICK", withSelectors = true, generalInterface = PowerPlain.class, implClass = Attachments.Impl.class)
public class Attachments extends BasePower {

    @Property
    public List allowedSlots;

    @Property
    public List allowedInvSlots;

    @Property
    public int limit;

    @Property
    public Set allowedItems;

    @Property
    public boolean requireHurtByEntity = true;

    public List getAllowedInvSlots() {
        return allowedInvSlots;
    }

    public Set getAllowedItems() {
        return allowedItems;
    }

    public List getAllowedSlots() {
        return allowedSlots;
    }

    public int getLimit() {
        return limit;
    }

    @Override
    public String getName() {
        return "attachments";
    }

    @Override
    public String displayText() {
        return null;
    }

    /**
     * Whether to require hurt by entity for HURT trigger
     */
    public boolean isRequireHurtByEntity() {
        return requireHurtByEntity;
    }

    public class Impl implements PowerTick, PowerRightClick, PowerLeftClick, PowerOffhandClick, PowerPlain, PowerHit, PowerSneaking, PowerHurt, PowerHitTaken, PowerBowShoot {

        @Override
        public PowerResult tick(Player player, ItemStack stack) {
            return fire(player, stack);
        }

        @Override
        public PowerResult fire(Player player, ItemStack stack) {
            return fire(player, stack, null);
        }

        public PowerResult fire(Player player, ItemStack stack, Event event) {
            Set allow = (getAllowedItems() == null || getAllowedItems().isEmpty()) ? null : getAllowedItems().stream().flatMap(s -> {
                try {
                    int uid = Integer.parseInt(s);
                    Set items = ItemManager.getItems(uid);
                    return items.stream();
                } catch (NumberFormatException e) {
                    Set items = ItemManager.getItems(s);
                    return items.stream();
                }
            }).collect(Collectors.toSet());
            int num = 0;
            ItemStack itemStack = null;
            PlayerInventory inventory = player.getInventory();
            if (getAllowedSlots() != null) {
                for (EquipmentSlot allowedSlot : getAllowedSlots()) {
                    itemStack = switch (allowedSlot) {
                        case HAND -> inventory.getItemInMainHand();
                        case OFF_HAND -> inventory.getItemInOffHand();
                        case FEET -> inventory.getBoots();
                        case LEGS -> inventory.getLeggings();
                        case CHEST -> inventory.getChestplate();
                        case HEAD -> inventory.getHelmet();
                    };
                    if (attach(player, stack, event, itemStack, allow)) {
                        num += 1;
                    }
                    if (num >= getLimit()) return PowerResult.ok();
                }
            }
            if (getAllowedInvSlots() == null || getAllowedInvSlots().isEmpty()) {
                for (ItemStack envSlot : inventory.getContents()) {
                    if (attach(player, stack, event, envSlot, allow)) {
                        num += 1;
                    }
                    if (num >= getLimit()) return PowerResult.ok();
                }
            } else {
                for (int envSlot : getAllowedInvSlots()) {
                    if (envSlot < 0) break;
                    itemStack = inventory.getItem(envSlot);
                    if (attach(player, stack, event, itemStack, allow)) {
                        num += 1;
                    }
                    if (num >= getLimit()) return PowerResult.ok();
                }
            }

            if (num == 0) {
                return PowerResult.fail();
            } else {
                return PowerResult.ok();
            }
        }

        public boolean attach(Player player, ItemStack stack, Event event, ItemStack itemStack, Set allow) {
            if (itemStack == null) return false;
            if (itemStack.equals(stack)) return false;
            Optional optItem = ItemManager.toRPGItem(itemStack);
            if (optItem.isEmpty()) return false;
            RPGItem item = optItem.get();
            if (allow != null && !allow.contains(item)) return false;
            item.power(player, itemStack, event, BaseTriggers.ATTACHMENT, Pair.of(stack, event));
            return true;
        }

        @Override
        public PowerResult sneaking(Player player, ItemStack stack) {
            return fire(player, stack);
        }

        @Override
        public PowerResult takeHit(Player target, ItemStack stack, double damage, EntityDamageEvent event) {
            if (!isRequireHurtByEntity() || event instanceof EntityDamageByEntityEvent) {
                return fire(target, stack, event).with(damage);
            }
            return PowerResult.noop();
        }

        @Override
        public PowerResult hurt(Player target, ItemStack stack, EntityDamageEvent event) {
            if (!isRequireHurtByEntity() || event instanceof EntityDamageByEntityEvent) {
                return fire(target, stack, event);
            }
            return PowerResult.noop();
        }

        @Override
        public PowerResult hit(Player player, ItemStack stack, LivingEntity entity, double damage, EntityDamageByEntityEvent event) {
            return fire(player, stack, event).with(damage);
        }

        @Override
        public PowerResult leftClick(Player player, ItemStack stack, PlayerInteractEvent event) {
            return fire(player, stack, event);
        }

        @Override
        public PowerResult offhandClick(Player player, ItemStack stack, PlayerInteractEvent event) {
            return fire(player, stack, event);
        }

        @Override
        public PowerResult rightClick(Player player, ItemStack stack, PlayerInteractEvent event) {
            return fire(player, stack, event);
        }

        @Override
        public PowerResult bowShoot(Player player, ItemStack stack, EntityShootBowEvent event) {
            return fire(player, stack).with(event.getForce());
        }

        @Override
        public Power getPower() {
            return Attachments.this;
        }
    }
}