Examples with EntityType org.bukkit.entity.EntityType used on opensource projects

Example 66 with EntityType

use of org.bukkit.entity.EntityType in project MagicPlugin by elBukkit.

the class MagicCommandExecutor method onMagicList.

protected boolean onMagicList(CommandSender sender, String subCommand, String[] args) {
    String usage = "Usage: magic list <wands|map|automata|tasks|schematics|entities|blocks>";
    String listCommand = "";
    if (args.length > 1) {
        listCommand = args[1];
        if (!api.hasPermission(sender, "Magic.commands.magic." + subCommand + "." + listCommand)) {
            sendNoPermission(sender);
            return false;
        }
    } else {
        sender.sendMessage(ChatColor.GRAY + "For more specific information, add 'tasks', 'wands', 'maps', 'schematics', 'entities', 'blocks' or 'automata' parameter.");
        MageController apiController = api.getController();
        if (apiController != null && apiController instanceof MagicController) {
            MagicController controller = (MagicController) apiController;
            long timeout = controller.getPhysicsTimeout();
            if (timeout > 0) {
                long seconds = (timeout - System.currentTimeMillis()) / 1000;
                sender.sendMessage(ChatColor.GREEN + "Physics handler active for another " + ChatColor.DARK_GREEN + seconds + ChatColor.GREEN + " seconds");
            } else {
                sender.sendMessage(ChatColor.GRAY + "Physics handler inactive");
            }
        }
        Collection<Mage> mages = controller.getMages();
        sender.sendMessage(ChatColor.AQUA + "Modified blocks (" + ChatColor.LIGHT_PURPLE + UndoList.getRegistry().getModified().size() + ChatColor.AQUA + ")");
        sender.sendMessage(ChatColor.AQUA + "Watching blocks (" + ChatColor.LIGHT_PURPLE + UndoList.getRegistry().getWatching().size() + ChatColor.AQUA + ")");
        sender.sendMessage(ChatColor.AQUA + "Registered breaking (" + ChatColor.LIGHT_PURPLE + UndoList.getRegistry().getBreaking().size() + ChatColor.AQUA + ")");
        sender.sendMessage(ChatColor.AQUA + "Registered breakable (" + ChatColor.LIGHT_PURPLE + UndoList.getRegistry().getBreakable().size() + ChatColor.AQUA + ")");
        sender.sendMessage(ChatColor.AQUA + "Registered reflective (" + ChatColor.LIGHT_PURPLE + UndoList.getRegistry().getReflective().size() + ChatColor.AQUA + ")");
        sender.sendMessage(ChatColor.LIGHT_PURPLE + "Active mages: " + ChatColor.LIGHT_PURPLE + mages.size());
        Collection<com.elmakers.mine.bukkit.api.block.UndoList> pendingUndo = api.getPendingUndo();
        sender.sendMessage(ChatColor.AQUA + "Pending undo (" + ChatColor.LIGHT_PURPLE + pendingUndo.size() + ChatColor.AQUA + "): ");
        long now = System.currentTimeMillis();
        for (com.elmakers.mine.bukkit.api.block.UndoList undo : pendingUndo) {
            long remainingTime = (undo.getScheduledTime() - now) / 1000;
            sender.sendMessage(ChatColor.AQUA + undo.getName() + ChatColor.GRAY + " will undo in " + ChatColor.WHITE + "" + remainingTime + "" + ChatColor.GRAY + " seconds");
        }
        Collection<Mage> pending = api.getMagesWithPendingBatches();
        sender.sendMessage(ChatColor.AQUA + "Pending casts (" + ChatColor.LIGHT_PURPLE + pending.size() + ChatColor.AQUA + "): ");
        for (Mage mage : pending) {
            int totalSize = 0;
            int totalRemaining = 0;
            Collection<Batch> pendingBatches = mage.getPendingBatches();
            String names = "";
            if (pendingBatches.size() > 0) {
                for (Batch batch : pendingBatches) {
                    names = names + batch.getName() + " ";
                    totalSize += batch.size();
                    totalRemaining += batch.remaining();
                }
            }
            sender.sendMessage(ChatColor.AQUA + mage.getName() + ChatColor.GRAY + " has " + ChatColor.WHITE + "" + pendingBatches.size() + "" + ChatColor.GRAY + " pending (" + ChatColor.WHITE + "" + totalRemaining + "/" + totalSize + "" + ChatColor.GRAY + ") (" + names + ")");
        }
        return true;
    }
    if (listCommand.equalsIgnoreCase("schematics")) {
        List<String> schematics = new ArrayList<>();
        try {
            Plugin plugin = (Plugin) api;
            MagicController controller = (MagicController) api.getController();
            // Find built-in schematics
            CodeSource src = MagicAPI.class.getProtectionDomain().getCodeSource();
            if (src != null) {
                URL jar = src.getLocation();
                try (InputStream is = jar.openStream();
                    ZipInputStream zip = new ZipInputStream(is)) {
                    while (true) {
                        ZipEntry e = zip.getNextEntry();
                        if (e == null)
                            break;
                        String name = e.getName();
                        if (name.startsWith("schematics/")) {
                            schematics.add(name.replace("schematics/", ""));
                        }
                    }
                }
            }
            // Check extra path first
            File configFolder = plugin.getDataFolder();
            File magicSchematicFolder = new File(configFolder, "schematics");
            if (magicSchematicFolder.exists()) {
                for (File nextFile : magicSchematicFolder.listFiles()) {
                    schematics.add(nextFile.getName());
                }
            }
            String extraSchematicFilePath = controller.getExtraSchematicFilePath();
            if (extraSchematicFilePath != null && extraSchematicFilePath.length() > 0) {
                File schematicFolder = new File(configFolder, "../" + extraSchematicFilePath);
                if (schematicFolder.exists() && !schematicFolder.equals(magicSchematicFolder)) {
                    for (File nextFile : schematicFolder.listFiles()) {
                        schematics.add(nextFile.getName());
                    }
                }
            }
        } catch (Exception ex) {
            sender.sendMessage("Error loading schematics: " + ex.getMessage());
            ex.printStackTrace();
            ;
        }
        sender.sendMessage(ChatColor.DARK_AQUA + "Found " + ChatColor.LIGHT_PURPLE + schematics.size() + ChatColor.DARK_AQUA + " schematics");
        Collections.sort(schematics);
        for (String schematic : schematics) {
            if (schematic.indexOf(".schematic") > 0) {
                sender.sendMessage(ChatColor.AQUA + schematic.replace(".schematic", ""));
            }
        }
        return true;
    }
    if (listCommand.equalsIgnoreCase("tasks")) {
        List<BukkitTask> tasks = Bukkit.getScheduler().getPendingTasks();
        HashMap<String, Integer> pluginCounts = new HashMap<>();
        HashMap<String, HashMap<String, Integer>> taskCounts = new HashMap<>();
        for (BukkitTask task : tasks) {
            String pluginName = task.getOwner().getName();
            HashMap<String, Integer> pluginTaskCounts = taskCounts.get(pluginName);
            if (pluginTaskCounts == null) {
                pluginTaskCounts = new HashMap<>();
                taskCounts.put(pluginName, pluginTaskCounts);
            }
            String className = "(Unknown)";
            Runnable taskRunnable = CompatibilityUtils.getTaskRunnable(task);
            if (taskRunnable != null) {
                Class<? extends Runnable> taskClass = taskRunnable.getClass();
                className = taskClass.getName();
            }
            Integer count = pluginTaskCounts.get(className);
            if (count == null)
                count = 0;
            count++;
            pluginTaskCounts.put(className, count);
            Integer totalCount = pluginCounts.get(pluginName);
            if (totalCount == null)
                totalCount = 0;
            totalCount++;
            pluginCounts.put(pluginName, totalCount);
        }
        sender.sendMessage(ChatColor.LIGHT_PURPLE + "Active tasks: " + tasks.size());
        for (Entry<String, HashMap<String, Integer>> pluginEntry : taskCounts.entrySet()) {
            String pluginName = pluginEntry.getKey();
            sender.sendMessage(" " + ChatColor.DARK_PURPLE + pluginName + ": " + ChatColor.LIGHT_PURPLE + pluginCounts.get(pluginName));
            for (Entry<String, Integer> taskEntry : pluginEntry.getValue().entrySet()) {
                sender.sendMessage("  " + ChatColor.DARK_PURPLE + taskEntry.getKey() + ": " + ChatColor.LIGHT_PURPLE + taskEntry.getValue());
            }
        }
        return true;
    }
    if (listCommand.equalsIgnoreCase("wands")) {
        String owner = "";
        if (args.length > 2) {
            owner = args[2];
        }
        Collection<LostWand> lostWands = api.getLostWands();
        int shown = 0;
        for (LostWand lostWand : lostWands) {
            Location location = lostWand.getLocation();
            if (location == null)
                continue;
            if (owner.length() > 0 && !owner.equalsIgnoreCase(lostWand.getOwner())) {
                continue;
            }
            shown++;
            sender.sendMessage(ChatColor.AQUA + lostWand.getName() + ChatColor.WHITE + " (" + lostWand.getOwner() + ") @ " + ChatColor.BLUE + location.getWorld().getName() + " " + location.getBlockX() + " " + location.getBlockY() + " " + location.getBlockZ());
        }
        sender.sendMessage(shown + " lost wands found" + (owner.length() > 0 ? " for " + owner : ""));
        return true;
    }
    if (listCommand.equalsIgnoreCase("automata")) {
        Collection<Mage> automata = api.getAutomata();
        for (Mage automaton : automata) {
            Location location = automaton.getLocation();
            String worldName = location.getWorld().getName();
            boolean isOnline = false;
            World world = Bukkit.getWorld(worldName);
            if (worldName != null) {
                isOnline = world.isChunkLoaded(location.getBlockX() >> 4, location.getBlockZ() >> 4);
            }
            ChatColor nameColor = isOnline ? ChatColor.AQUA : ChatColor.GRAY;
            sender.sendMessage(nameColor + automaton.getName() + ChatColor.WHITE + " @ " + ChatColor.BLUE + worldName + " " + location.getBlockX() + " " + location.getBlockY() + " " + location.getBlockZ());
        }
        sender.sendMessage(automata.size() + " automata active");
        return true;
    }
    if (listCommand.equalsIgnoreCase("maps")) {
        String keyword = "";
        for (int i = 2; i < args.length; i++) {
            if (i != 2)
                keyword = keyword + " ";
            keyword = keyword + args[i];
        }
        onMapList(sender, keyword);
        return true;
    }
    if (listCommand.equalsIgnoreCase("blocks")) {
        for (BlockData blockData : UndoList.getRegistry().getModified().values()) {
            BlockVector blockLocation = blockData.getLocation();
            Block block = blockData.getBlock();
            sender.sendMessage(ChatColor.BLUE + "Block at " + ChatColor.GRAY + blockLocation.getBlockX() + ChatColor.DARK_GRAY + "," + ChatColor.GRAY + blockLocation.getBlockY() + ChatColor.DARK_GRAY + "," + ChatColor.GRAY + blockLocation.getBlockZ() + ChatColor.BLUE + " stored as " + ChatColor.AQUA + blockData.getMaterial() + ChatColor.BLUE + " is currently " + ChatColor.AQUA + block.getType() + ChatColor.BLUE + " from " + ChatColor.GOLD + blockData.getUndoList().getName());
        }
        return true;
    }
    if (listCommand.equalsIgnoreCase("mages")) {
        for (Mage mage : api.getController().getMages()) {
            Entity mageEntity = mage.getEntity();
            Location location = mage.getLocation();
            ChatColor mageColor = ChatColor.YELLOW;
            if (mage instanceof com.elmakers.mine.bukkit.magic.Mage && ((com.elmakers.mine.bukkit.magic.Mage) mage).isForget()) {
                mageColor = ChatColor.RED;
            } else if (mage.isAutomaton()) {
                mageColor = ChatColor.GOLD;
            }
            String mageType = mageEntity == null ? "Non-Entity" : mageEntity.getType().name();
            String message = ChatColor.AQUA + "Mage " + mageColor + mage.getId() + ChatColor.GRAY + " (" + mage.getName() + ")" + ChatColor.AQUA + " of type " + ChatColor.DARK_AQUA + mageType + ChatColor.AQUA;
            if (location != null) {
                String worldName = location.getWorld() != null ? location.getWorld().getName() : "(Unknown world)";
                message = message + " is at " + ChatColor.BLUE + worldName + " " + ChatColor.DARK_PURPLE + " " + location.getBlockX() + " " + location.getBlockY() + " " + location.getBlockZ();
            }
            sender.sendMessage(message);
        }
        return true;
    }
    if (listCommand.equalsIgnoreCase("entities")) {
        World world = Bukkit.getWorlds().get(0);
        NumberFormat formatter = new DecimalFormat("#0.0");
        List<EntityType> types = Arrays.asList(EntityType.values());
        Collections.sort(types, new Comparator<EntityType>() {

            @Override
            public int compare(EntityType o1, EntityType o2) {
                return o1.name().compareTo(o2.name());
            }
        });
        Collection<? extends Player> players = Bukkit.getServer().getOnlinePlayers();
        for (Player player : players) {
            showEntityInfo(sender, player, EntityType.PLAYER.name() + ChatColor.GRAY + " (" + player.getName() + " [" + (player.isSneaking() ? "sneaking" : "standing") + "])", formatter);
            break;
        }
        final Class<?> worldClass = NMSUtils.getBukkitClass("net.minecraft.server.World");
        for (EntityType entityType : types) {
            if (entityType.isSpawnable()) {
                Entity testEntity = null;
                String errorMessage = null;
                String entityName = "Entity" + entityType.getEntityClass().getSimpleName();
                // Still better than actually adding all of these entities to the world!
                if (entityName.equals("EntityGiant")) {
                    entityName = "EntityGiantZombie";
                } else if (entityName.equals("EntityLeashHitch")) {
                    entityName = "EntityLeash";
                } else if (entityName.equals("EntityStorageMinecart")) {
                    entityName = "EntityMinecartChest";
                } else if (entityName.equals("EntitySpawnerMinecart")) {
                    entityName = "EntityMinecartMobSpawner";
                } else if (entityName.equals("EntityCommandMinecart")) {
                    entityName = "EntityMinecartCommandBlock";
                } else if (entityName.equals("EntityPoweredMinecart")) {
                    entityName = "EntityMinecartFurnace";
                } else if (entityName.equals("EntityExplosiveMinecart")) {
                    entityName = "EntityMinecartTNT";
                } else if (entityName.contains("Minecart")) {
                    entityName = entityType.getEntityClass().getSimpleName();
                    entityName = entityName.replace("Minecart", "");
                    entityName = "EntityMinecart" + entityName;
                }
                try {
                    Class<?> entityClass = NMSUtils.getBukkitClass("net.minecraft.server." + entityName);
                    if (entityClass != null) {
                        Constructor<? extends Object> constructor = entityClass.getConstructor(worldClass);
                        Object nmsWorld = NMSUtils.getHandle(world);
                        Object nmsEntity = constructor.newInstance(nmsWorld);
                        testEntity = NMSUtils.getBukkitEntity(nmsEntity);
                        if (testEntity == null) {
                            errorMessage = "Failed to get Bukkit entity for class " + entityName;
                        }
                    } else {
                        errorMessage = "Could not load class " + entityName;
                    }
                } catch (Exception ex) {
                    testEntity = null;
                    errorMessage = ex.getClass().getSimpleName() + " [" + entityName + "]";
                    String message = ex.getMessage();
                    if (message != null && !message.isEmpty()) {
                        errorMessage += ": " + message;
                    }
                }
                if (testEntity == null) {
                    sender.sendMessage(ChatColor.BLACK + entityType.name() + ": " + ChatColor.RED + "Spawning error " + ChatColor.DARK_RED + "(" + errorMessage + ")");
                    continue;
                }
                String label = entityType.name();
                Ageable ageable = (testEntity instanceof Ageable) ? (Ageable) testEntity : null;
                Zombie zombie = (testEntity instanceof Zombie) ? (Zombie) testEntity : null;
                Skeleton skeleton = (testEntity instanceof Skeleton) ? (Skeleton) testEntity : null;
                Slime slime = (testEntity instanceof Slime) ? (Slime) testEntity : null;
                if (ageable != null) {
                    label = label + ChatColor.GRAY + " (Adult)";
                    ageable.setAdult();
                } else if (zombie != null) {
                    label = label + ChatColor.GRAY + " (Adult)";
                    zombie.setBaby(false);
                } else if (skeleton != null) {
                    label = label + ChatColor.GRAY + " (NORMAL)";
                    skeleton.setSkeletonType(Skeleton.SkeletonType.NORMAL);
                } else if (slime != null) {
                    label = label + ChatColor.GRAY + " (Size 1)";
                    slime.setSize(1);
                }
                showEntityInfo(sender, testEntity, label, formatter);
                if (ageable != null) {
                    label = entityType.name() + ChatColor.GRAY + " (Baby)";
                    ageable.setBaby();
                    showEntityInfo(sender, testEntity, label, formatter);
                } else if (zombie != null) {
                    label = entityType.name() + ChatColor.GRAY + " (Baby)";
                    zombie.setBaby(true);
                    showEntityInfo(sender, testEntity, label, formatter);
                } else if (skeleton != null) {
                    label = entityType.name() + ChatColor.GRAY + " (WITHER)";
                    skeleton.setSkeletonType(Skeleton.SkeletonType.WITHER);
                    showEntityInfo(sender, testEntity, label, formatter);
                } else if (slime != null) {
                    label = entityType.name() + ChatColor.GRAY + " (Size 2)";
                    slime.setSize(2);
                    showEntityInfo(sender, testEntity, label, formatter);
                    label = entityType.name() + ChatColor.GRAY + " (Size 4)";
                    slime.setSize(4);
                    showEntityInfo(sender, testEntity, label, formatter);
                    label = entityType.name() + ChatColor.GRAY + " (Size 8)";
                    slime.setSize(8);
                    showEntityInfo(sender, testEntity, label, formatter);
                    label = entityType.name() + ChatColor.GRAY + " (Size 16)";
                    slime.setSize(16);
                    showEntityInfo(sender, testEntity, label, formatter);
                }
            }
        }
        return true;
    }
    sender.sendMessage(usage);
    return true;
}

Example 67 with EntityType

use of org.bukkit.entity.EntityType in project MagicPlugin by elBukkit.

the class CheckEntityAction method prepare.

@Override
public void prepare(CastContext context, ConfigurationSection parameters) {
    super.prepare(context, parameters);
    allowCaster = parameters.getBoolean("allow_caster", true);
    onlyCaster = parameters.getBoolean("only_caster", false);
    if (parameters.contains("allowed_entities")) {
        List<String> keys = ConfigurationUtils.getStringList(parameters, "allowed_entities");
        allowedTypes = new HashSet<>();
        for (String key : keys) {
            try {
                EntityType entityType = EntityType.valueOf(key.toUpperCase());
                allowedTypes.add(entityType);
            } catch (Exception ex) {
                context.getLogger().warning("Invalid entity type in CheckEntity configuration: " + key);
            }
        }
    }
    if (parameters.contains("denied_entities")) {
        List<String> keys = ConfigurationUtils.getStringList(parameters, "denied_entities");
        deniedTypes = new HashSet<>();
        for (String key : keys) {
            try {
                EntityType entityType = EntityType.valueOf(key.toUpperCase());
                deniedTypes.add(entityType);
            } catch (Exception ex) {
                context.getLogger().warning("Invalid entity type in CheckEntity configuration: " + key);
            }
        }
    }
}

Example 68 with EntityType

use of org.bukkit.entity.EntityType in project MagicPlugin by elBukkit.

the class ExplosionController method loadProperties.

public void loadProperties(ConfigurationSection properties) {
    maxTNTPerChunk = properties.getInt("max_tnt_per_chunk", 0);
    autoRollbackDuration = properties.getInt("auto_rollback_duration", 10000);
    autoRollbackSpeed = properties.getDouble("auto_rollback_speed", 2);
    rollbackExplosions.clear();
    Collection<String> typeNames = properties.getStringList("auto_rollback_explosions");
    if (typeNames != null) {
        for (String typeName : typeNames) {
            try {
                EntityType entityType = EntityType.valueOf(typeName.toUpperCase());
                rollbackExplosions.add(entityType);
            } catch (Exception ex) {
                controller.getLogger().warning("Failed to parse entity type: " + typeName + " in auto_rollback_explosions");
            }
        }
    }
}

Example 69 with EntityType

use of org.bukkit.entity.EntityType in project MagicPlugin by elBukkit.

the class TargetingSpell method processParameters.

@Override
public void processParameters(ConfigurationSection parameters) {
    super.processParameters(parameters);
    targeting.processParameters(parameters);
    processTemplateParameters(parameters);
    allowMaxRange = parameters.getBoolean("allow_max_range", false);
    checkProtection = parameters.getBoolean("check_protection", false);
    damageResistanceProtection = parameters.getInt("damage_resistance_protection", 0);
    targetBreakables = parameters.getDouble("target_breakables", 1);
    reverseTargeting = parameters.getBoolean("reverse_targeting", false);
    instantBlockEffects = parameters.getBoolean("instant_block_effects", false);
    MaterialSetManager materials = controller.getMaterialSetManager();
    targetThroughMaterials = MaterialSets.empty();
    targetThroughMaterials = materials.getMaterialSet("transparent", targetThroughMaterials);
    targetThroughMaterials = materials.fromConfig(parameters.getString("transparent"), targetThroughMaterials);
    targetableMaterials = MaterialSets.wildcard();
    targetableMaterials = materials.fromConfig(parameters.getString("targetable"), targetableMaterials);
    reflectiveMaterials = MaterialSets.empty();
    reflectiveMaterials = materials.fromConfig(parameters.getString("reflective"), reflectiveMaterials);
    if (parameters.getBoolean("reflective_override", true)) {
        String reflectiveKey = controller.getReflectiveMaterials(mage, mage.getLocation());
        if (reflectiveKey != null) {
            reflectiveMaterials = MaterialSets.union(materials.fromConfigEmpty(reflectiveKey), reflectiveMaterials);
        }
    }
    targetNPCs = parameters.getBoolean("target_npc", false);
    targetArmorStands = parameters.getBoolean("target_armor_stand", false);
    targetInvisible = parameters.getBoolean("target_invisible", true);
    targetVanished = parameters.getBoolean("target_vanished", false);
    targetUnknown = parameters.getBoolean("target_unknown", true);
    targetTamed = parameters.getBoolean("target_tamed", true);
    if (parameters.contains("target_type")) {
        String entityTypeName = parameters.getString("target_type");
        try {
            targetEntityType = Class.forName("org.bukkit.entity." + entityTypeName);
        } catch (Throwable ex) {
            controller.getLogger().warning("Unknown entity type in target_type of " + getKey() + ": " + entityTypeName);
            targetEntityType = null;
        }
    } else if (parameters.contains("target_types")) {
        targetEntityType = null;
        targetEntityTypes = new HashSet<>();
        Collection<String> typeKeys = ConfigurationUtils.getStringList(parameters, "target_types");
        for (String typeKey : typeKeys) {
            try {
                EntityType entityType = EntityType.valueOf(typeKey.toUpperCase());
                targetEntityTypes.add(entityType);
            } catch (Throwable ex) {
                controller.getLogger().warning("Unknown entity type in target_types of " + getKey() + ": " + typeKey);
            }
        }
    } else {
        targetEntityType = null;
        targetEntityTypes = null;
    }
    if (parameters.contains("ignore_types")) {
        ignoreEntityTypes = new HashSet<>();
        Collection<String> typeKeys = ConfigurationUtils.getStringList(parameters, "ignore_types");
        for (String typeKey : typeKeys) {
            try {
                EntityType entityType = EntityType.valueOf(typeKey.toUpperCase());
                ignoreEntityTypes.add(entityType);
            } catch (Throwable ex) {
                controller.getLogger().warning("Unknown entity type in ignore_types of " + getKey() + ": " + typeKey);
            }
        }
    } else {
        ignoreEntityTypes = null;
    }
    targetDisplayName = parameters.getString("target_name", null);
    targetContents = ConfigurationUtils.getMaterial(parameters, "target_contents", null);
    originAtTarget = parameters.getBoolean("origin_at_target", false);
    Location defaultLocation = getLocation();
    targetLocation = ConfigurationUtils.overrideLocation(parameters, "t", defaultLocation, controller.canCreateWorlds());
    // For two-click construction spells
    defaultLocation = targetLocation == null ? defaultLocation : targetLocation;
    targetLocation2 = ConfigurationUtils.overrideLocation(parameters, "t2", defaultLocation, controller.canCreateWorlds());
    if (parameters.contains("entity") && mage != null) {
        Entity mageEntity = mage.getEntity();
        if (mageEntity != null) {
            Entity entity = CompatibilityUtils.getEntity(mageEntity.getWorld(), UUID.fromString(parameters.getString("entity")));
            if (entity != null) {
                targetLocation = entity.getLocation();
                targetEntity = entity;
            }
        }
    } else if (parameters.contains("player")) {
        Player player = DeprecatedUtils.getPlayer(parameters.getString("player"));
        if (player != null) {
            targetLocation = player.getLocation();
            targetEntity = player;
        }
    } else {
        targetEntity = null;
    }
    // Special hack that should work well in most casts.
    boolean targetUnderwater = parameters.getBoolean("target_underwater", true);
    if (targetUnderwater && isUnderwater()) {
        targetThroughMaterials = MaterialSets.union(targetThroughMaterials, Material.WATER, Material.STATIONARY_WATER);
    }
}

Example 70 with EntityType

use of org.bukkit.entity.EntityType in project MagicPlugin by elBukkit.

the class AlterSpell method alterEntity.

protected SpellResult alterEntity(Entity entity) {
    EntityType entityType = entity.getType();
    switch(entityType) {
        case PAINTING:
            registerModified(entity);
            Painting painting = (Painting) entity;
            Art[] artValues = Art.values();
            Art oldArt = painting.getArt();
            Art newArt = oldArt;
            int ordinal = (oldArt.ordinal() + 1);
            for (int i = 0; i < artValues.length; i++) {
                newArt = artValues[ordinal++ % artValues.length];
                painting.setArt(newArt);
                newArt = painting.getArt();
                if (oldArt != newArt) {
                    break;
                }
            }
            if (oldArt == newArt) {
                return SpellResult.FAIL;
            }
            mage.sendDebugMessage("Altering art from " + oldArt + " to " + newArt);
            break;
        case ITEM_FRAME:
            ItemFrame itemFrame = (ItemFrame) entity;
            ItemStack frameItem = itemFrame.getItem();
            if (frameItem == null || frameItem.getType() != Material.MAP) {
                return SpellResult.NO_TARGET;
            }
            short data = frameItem.getDurability();
            data++;
            MapView mapView = DeprecatedUtils.getMap(data);
            if (mapView == null) {
                data = 0;
                mapView = DeprecatedUtils.getMap(data);
                if (mapView == null) {
                    return SpellResult.NO_TARGET;
                }
            }
            registerModified(entity);
            frameItem.setDurability(data);
            itemFrame.setItem(frameItem);
            break;
        case HORSE:
            registerModified(entity);
            Horse horse = (Horse) entity;
            Color color = horse.getColor();
            Color[] colorValues = Color.values();
            color = colorValues[(color.ordinal() + 1) % colorValues.length];
            Style horseStyle = horse.getStyle();
            Style[] styleValues = Style.values();
            horseStyle = styleValues[(horseStyle.ordinal() + 1) % styleValues.length];
            horse.setStyle(horseStyle);
            horse.setColor(color);
            break;
        case OCELOT:
            registerModified(entity);
            Ocelot ocelot = (Ocelot) entity;
            Type catType = ocelot.getCatType();
            Type[] typeValues = Type.values();
            catType = typeValues[(catType.ordinal() + 1) % typeValues.length];
            ocelot.setCatType(catType);
            break;
        case VILLAGER:
            registerModified(entity);
            Villager villager = (Villager) entity;
            Profession profession = villager.getProfession();
            Profession[] professionValues = Profession.values();
            profession = professionValues[(profession.ordinal() + 1) % professionValues.length];
            villager.setProfession(profession);
            break;
        case WOLF:
            registerModified(entity);
            Wolf wolf = (Wolf) entity;
            DyeColor wolfColor = wolf.getCollarColor();
            DyeColor[] wolfColorValues = DyeColor.values();
            wolfColor = wolfColorValues[(wolfColor.ordinal() + 1) % wolfColorValues.length];
            wolf.setCollarColor(wolfColor);
            break;
        case SHEEP:
            registerModified(entity);
            Sheep sheep = (Sheep) entity;
            DyeColor dyeColor = sheep.getColor();
            DyeColor[] dyeColorValues = DyeColor.values();
            dyeColor = dyeColorValues[(dyeColor.ordinal() + 1) % dyeColorValues.length];
            sheep.setColor(dyeColor);
            break;
        case SKELETON:
            registerModified(entity);
            Skeleton skeleton = (Skeleton) entity;
            SkeletonType skeletonType = skeleton.getSkeletonType();
            SkeletonType[] skeletonTypeValues = SkeletonType.values();
            skeletonType = skeletonTypeValues[(skeletonType.ordinal() + 1) % skeletonTypeValues.length];
            skeleton.setSkeletonType(skeletonType);
            break;
        default:
            return SpellResult.NO_TARGET;
    }
    ;
    registerForUndo();
    return SpellResult.CAST;
}