Examples with StackedEntity dev.rosewood.rosestacker.stack.StackedEntity used on opensource projects

Example 16 with StackedEntity

use of dev.rosewood.rosestacker.stack.StackedEntity in project RoseStacker by Rosewood-Development.

the class InteractListener method onInteractEntity.

@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
public void onInteractEntity(PlayerInteractEntityEvent event) {
    if (!(event.getRightClicked() instanceof LivingEntity))
        return;
    StackManager stackManager = this.rosePlugin.getManager(StackManager.class);
    if (stackManager.isWorldDisabled(event.getPlayer().getWorld()))
        return;
    if (!stackManager.isEntityStackingEnabled())
        return;
    LivingEntity entity = (LivingEntity) event.getRightClicked();
    StackedEntity stackedEntity = stackManager.getStackedEntity(entity);
    if (stackedEntity == null)
        return;
    Player player = event.getPlayer();
    ItemStack itemStack = event.getHand() == EquipmentSlot.HAND ? player.getInventory().getItemInMainHand() : player.getInventory().getItemInOffHand();
    if (itemStack.getType() == Material.NAME_TAG) {
        Bukkit.getScheduler().runTask(this.rosePlugin, stackedEntity::updateDisplay);
        return;
    } else if (itemStack.getType() == Material.WATER_BUCKET) {
        switch(entity.getType()) {
            case COD:
            case SALMON:
            case PUFFERFISH:
            case TROPICAL_FISH:
            case AXOLOTL:
                break;
            default:
                return;
        }
        if (stackedEntity.getStackSize() != 1)
            Bukkit.getScheduler().runTask(this.rosePlugin, stackedEntity::decreaseStackSize);
        return;
    }
    if (this.spawnEntities(entity, entity.getLocation(), itemStack)) {
        ItemUtils.takeOneItem(event.getPlayer(), event.getHand());
        event.setCancelled(true);
    }
}

Example 17 with StackedEntity

use of dev.rosewood.rosestacker.stack.StackedEntity in project RoseStacker by Rosewood-Development.

the class StackToolListener method onLeftClickEntity.

/**
 * Handles Shift Left Clicks for StackedEntities
 *
 * @param event The EntityDamageByEntityEvent
 */
@EventHandler(priority = EventPriority.LOWEST)
public void onLeftClickEntity(EntityDamageByEntityEvent event) {
    if (!(event.getDamager() instanceof Player))
        return;
    Player player = (Player) event.getDamager();
    ItemStack tool = player.getInventory().getItemInMainHand();
    if (!ItemUtils.isStackingTool(tool))
        return;
    event.setCancelled(true);
    if (!(event.getEntity() instanceof LivingEntity))
        return;
    if (!player.hasPermission("rosestacker.stacktool")) {
        this.localeManager.sendMessage(player, "command-stacktool-no-permission");
        return;
    }
    LivingEntity entity = (LivingEntity) event.getEntity();
    StackedEntity stackedEntity = this.stackManager.getStackedEntity(entity);
    if (stackedEntity == null) {
        this.localeManager.sendMessage(player, "command-stacktool-invalid-entity");
        return;
    }
    if (!player.isSneaking()) {
        SelectedEntities selected = this.selectedEntities.get(player.getUniqueId());
        if (selected == null) {
            selected = new SelectedEntities();
            this.selectedEntities.put(player.getUniqueId(), selected);
        }
        if (selected.getEntity1() == stackedEntity) {
            selected.unselect();
            this.localeManager.sendMessage(player, "command-stacktool-unselect-1", StringPlaceholders.single("type", stackedEntity.getStackSettings().getDisplayName()));
            return;
        }
        selected.select(stackedEntity);
        if (!selected.hasSelected()) {
            this.localeManager.sendMessage(player, "command-stacktool-select-1", StringPlaceholders.single("type", stackedEntity.getStackSettings().getDisplayName()));
        } else {
            this.localeManager.sendMessage(player, "command-stacktool-select-2", StringPlaceholders.single("type", stackedEntity.getStackSettings().getDisplayName()));
            StackedEntity entity1 = selected.getEntity1();
            StackedEntity entity2 = selected.getEntity2();
            selected.unselect();
            EntityStackComparisonResult result = stackedEntity.getStackSettings().canStackWith(entity1, entity2, false, true);
            if (result == EntityStackComparisonResult.CAN_STACK) {
                this.localeManager.sendMessage(player, "command-stacktool-can-stack");
            } else {
                this.localeManager.sendMessage(player, "command-stacktool-can-not-stack", StringPlaceholders.single("reason", result.name()));
            }
        }
    } else {
        String trueStr = this.localeManager.getLocaleMessage("command-stacktool-info-true");
        String falseStr = this.localeManager.getLocaleMessage("command-stacktool-info-false");
        this.localeManager.sendMessage(player, "command-stacktool-info");
        this.localeManager.sendSimpleMessage(player, "command-stacktool-info-uuid", StringPlaceholders.single("uuid", entity.getUniqueId().toString()));
        this.localeManager.sendSimpleMessage(player, "command-stacktool-info-entity-id", StringPlaceholders.single("id", entity.getEntityId()));
        this.localeManager.sendSimpleMessage(player, "command-stacktool-info-entity-type", StringPlaceholders.single("type", entity.getType().name()));
        this.localeManager.sendSimpleMessage(player, "command-stacktool-info-stack-size", StringPlaceholders.single("amount", stackedEntity.getStackSize()));
        if (entity.getCustomName() != null)
            this.localeManager.sendSimpleMessage(player, "command-stacktool-info-custom-name", StringPlaceholders.single("name", entity.getCustomName()));
        this.localeManager.sendSimpleMessage(player, "command-stacktool-info-entity-stackable", StringPlaceholders.single("value", PersistentDataUtils.isUnstackable(entity) ? falseStr : trueStr));
        this.localeManager.sendSimpleMessage(player, "command-stacktool-info-entity-from-spawner", StringPlaceholders.single("value", PersistentDataUtils.isSpawnedFromSpawner(entity) ? trueStr : falseStr));
        this.localeManager.sendSimpleMessage(player, "command-stacktool-info-entity-has-ai", StringPlaceholders.single("value", !PersistentDataUtils.isAiDisabled(entity) && entity.hasAI() ? trueStr : falseStr));
        this.localeManager.sendSimpleMessage(player, "command-stacktool-info-location", StringPlaceholders.builder("x", entity.getLocation().getBlockX()).addPlaceholder("y", entity.getLocation().getBlockY()).addPlaceholder("z", entity.getLocation().getBlockZ()).addPlaceholder("world", entity.getWorld().getName()).build());
        this.localeManager.sendSimpleMessage(player, "command-stacktool-info-chunk", StringPlaceholders.builder("x", entity.getLocation().getChunk().getX()).addPlaceholder("z", entity.getLocation().getChunk().getZ()).build());
    }
}

Example 18 with StackedEntity

use of dev.rosewood.rosestacker.stack.StackedEntity in project RoseStacker by Rosewood-Development.

the class WildStackerEntityConversionHandler method handleConversion.

@Override
public Set<Stack<?>> handleConversion(Set<ConversionData> conversionData) {
    Set<LivingEntity> entities = conversionData.stream().map(ConversionData::getEntity).filter(Objects::nonNull).collect(Collectors.toSet());
    Set<Stack<?>> stacks = new HashSet<>();
    for (LivingEntity entity : entities) {
        PersistentDataContainer dataContainer = entity.getPersistentDataContainer();
        if (dataContainer.has(PersistentDataUtils.CONVERTED_KEY, PersistentDataType.INTEGER))
            continue;
        int stackSize = dataContainer.getOrDefault(STACK_KEY, PersistentDataType.INTEGER, -1);
        if (stackSize == -1)
            continue;
        dataContainer.set(PersistentDataUtils.CONVERTED_KEY, PersistentDataType.INTEGER, 1);
        StackedEntity stackedEntity = new StackedEntity(entity, this.createEntityStackNBT(entity.getType(), stackSize, entity.getLocation()));
        this.stackManager.addEntityStack(stackedEntity);
        stacks.add(stackedEntity);
    }
    return stacks;
}

Example 19 with StackedEntity

use of dev.rosewood.rosestacker.stack.StackedEntity in project RoseStacker by Rosewood-Development.

the class MobSpawningMethod method spawn.

@Override
public void spawn(StackedSpawner stackedSpawner) {
    StackedSpawnerTile spawnerTile = stackedSpawner.getSpawnerTile();
    SpawnerStackSettings stackSettings = stackedSpawner.getStackSettings();
    // Mob spawning logic
    List<ConditionTag> spawnRequirements = new ArrayList<>(stackSettings.getSpawnRequirements());
    // Check general spawner conditions
    List<ConditionTag> perSpawnConditions = spawnRequirements.stream().filter(ConditionTag::isRequiredPerSpawn).collect(Collectors.toList());
    spawnRequirements.removeAll(perSpawnConditions);
    Set<ConditionTag> invalidSpawnConditions = spawnRequirements.stream().filter(x -> !x.check(stackedSpawner, stackedSpawner.getBlock())).collect(Collectors.toSet());
    if (Setting.SPAWNER_SPAWN_ONLY_PLAYER_PLACED.getBoolean() && !stackedSpawner.isPlacedByPlayer())
        invalidSpawnConditions.add(NotPlayerPlacedConditionTag.INSTANCE);
    boolean passedSpawnerChecks = invalidSpawnConditions.isEmpty();
    // Will be removed when they pass
    invalidSpawnConditions.addAll(perSpawnConditions);
    // Spawn the mobs
    int spawnAmount;
    if (Setting.SPAWNER_SPAWN_COUNT_STACK_SIZE_RANDOMIZED.getBoolean()) {
        if (stackSettings.getSpawnCountStackSizeMultiplier() != -1) {
            int spawnerSpawnCount = Math.max(spawnerTile.getSpawnCount(), 0);
            spawnAmount = StackerUtils.randomInRange(stackedSpawner.getStackSize(), spawnerSpawnCount);
        } else {
            spawnAmount = this.random.nextInt(spawnerTile.getSpawnCount()) + 1;
        }
    } else {
        spawnAmount = spawnerTile.getSpawnCount();
    }
    EntityCacheManager entityCacheManager = RoseStacker.getInstance().getManager(EntityCacheManager.class);
    StackManager stackManager = RoseStacker.getInstance().getManager(StackManager.class);
    Bukkit.getScheduler().runTaskAsynchronously(RoseStacker.getInstance(), () -> {
        Set<Location> spawnLocations = new HashSet<>();
        int spawnRange = spawnerTile.getSpawnRange();
        for (int i = 0; i < spawnAmount; i++) {
            int attempts = 0;
            while (attempts < Setting.SPAWNER_MAX_FAILED_SPAWN_ATTEMPTS.getInt()) {
                int xOffset = this.random.nextInt(spawnRange * 2 + 1) - spawnRange;
                int yOffset = !Setting.SPAWNER_USE_VERTICAL_SPAWN_RANGE.getBoolean() ? this.random.nextInt(3) - 1 : this.random.nextInt(spawnRange * 2 + 1) - spawnRange;
                int zOffset = this.random.nextInt(spawnRange * 2 + 1) - spawnRange;
                Location spawnLocation = stackedSpawner.getLocation().clone().add(xOffset + 0.5, yOffset, zOffset + 0.5);
                Block target = stackedSpawner.getLocation().clone().add(xOffset, yOffset, zOffset).getBlock();
                boolean invalid = false;
                for (ConditionTag conditionTag : perSpawnConditions) {
                    if (!conditionTag.check(stackedSpawner, target)) {
                        invalid = true;
                    } else {
                        invalidSpawnConditions.remove(conditionTag);
                    }
                }
                if (invalid) {
                    attempts++;
                    continue;
                }
                if (!passedSpawnerChecks)
                    break;
                spawnLocations.add(spawnLocation);
                break;
            }
        }
        EntityType entityType = stackedSpawner.getSpawnerTile().getSpawnedType();
        Predicate<Entity> predicate = entity -> entity.getType() == entityType;
        Collection<Entity> nearbyEntities = entityCacheManager.getNearbyEntities(stackedSpawner.getLocation(), stackSettings.getSpawnRange(), predicate);
        List<StackedEntity> nearbyStackedEntities = new ArrayList<>();
        for (Entity entity : nearbyEntities) {
            StackedEntity stackedEntity = stackManager.getStackedEntity((LivingEntity) entity);
            if (stackedEntity != null)
                nearbyStackedEntities.add(stackedEntity);
        }
        int successfulSpawns = this.spawnEntitiesIntoNearbyStacks(stackedSpawner, spawnAmount, spawnLocations, nearbyStackedEntities, stackManager);
        stackedSpawner.getLastInvalidConditions().clear();
        if (successfulSpawns <= 0) {
            if (invalidSpawnConditions.isEmpty()) {
                stackedSpawner.getLastInvalidConditions().add(NoneConditionTag.class);
            } else {
                List<Class<? extends ConditionTag>> invalidSpawnConditionClasses = new ArrayList<>();
                for (ConditionTag conditionTag : invalidSpawnConditions) invalidSpawnConditionClasses.add(conditionTag.getClass());
                stackedSpawner.getLastInvalidConditions().addAll(invalidSpawnConditionClasses);
            }
            // Spawn particles indicating the spawn did not occur
            stackedSpawner.getWorld().spawnParticle(Particle.SMOKE_NORMAL, stackedSpawner.getLocation().clone().add(0.5, 0.5, 0.5), 50, 0.5, 0.5, 0.5, 0);
        } else {
            // Spawn particles indicating the spawn occurred
            stackedSpawner.getWorld().spawnParticle(Particle.FLAME, stackedSpawner.getLocation().clone().add(0.5, 0.5, 0.5), 50, 0.5, 0.5, 0.5, 0);
            Bukkit.getScheduler().runTask(RoseStacker.getInstance(), () -> {
                if (stackedSpawner.getBlock().getType() == Material.SPAWNER)
                    PersistentDataUtils.increaseSpawnCount(spawnerTile, successfulSpawns);
            });
        }
    });
}