private static void generateEntityStatistics() { for (EntityType entityType : EntityType.values()) { Class<? extends Entity> entityClass = entityType.getEntityClass(); if (entityClass == null) { continue; } if (Monster.class.isAssignableFrom(entityClass)) { set(ENTITY_KILLED_BY, entityType, "entityKilledBy." + entityClass.getSimpleName()); } if (Creature.class.isAssignableFrom(entityClass)) { set(KILL_ENTITY, entityType, "killEntity." + entityClass.getSimpleName()); } } } }
@Override public List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException { Preconditions.checkNotNull(sender, "Sender cannot be null"); Preconditions.checkNotNull(args, "Arguments cannot be null"); Preconditions.checkNotNull(alias, "Alias cannot be null"); if (args.length == 1) { String arg = args[0]; ArrayList<String> completion = new ArrayList<>(); for (EntityType type : EntityType.values()) { if (checkSummon(null, type.getName()) && type.getName().toLowerCase() .startsWith(arg)) { completion.add(type.getName()); } } EntityRegistry.getRegisteredCustomEntities().forEach((d) -> { if (d.getId().toLowerCase().startsWith(arg)) { completion.add(d.getId().toLowerCase()); } }); return completion; } else { return Collections.emptyList(); } } }
private List<EntityType> getTypes() { if (arguments.containsKey("type")) { SelectorValue value = arguments.get("type"); if (!value.isInverted()) { EntityType type = EntityType.fromName(value.getValue()); if (type == null) { try { type = EntityType.valueOf(value.getValue().toUpperCase()); } catch (IllegalArgumentException ex) { return Collections.emptyList(); } } return Arrays.asList(type); } else { return Arrays.stream(EntityType.values()).filter(mode -> { if (mode.getName() == null) { return !mode.name().equalsIgnoreCase(value.getValue()); } return !mode.getName().equalsIgnoreCase(value.getValue()); }).collect(Collectors.toList()); } } if (selector == SelectorType.ALL_ENTITIES) { return Arrays.asList(EntityType.values()); } else { return Arrays.asList(EntityType.PLAYER); } }
/** * Gets the lower-cased name of a given Entity Class * * @param entityClass to get the name of * @return Entity name */ public static String getName(Class<? extends Entity> entityClass) { if (entityClass == null) { return ""; } for (EntityType type : EntityType.values()) { Class<?> typeEntityClass = type.getEntityClass(); if (typeEntityClass != null && typeEntityClass.isAssignableFrom(entityClass)) { return getName(type); } } return entityClass.getSimpleName().toLowerCase(Locale.ENGLISH); }
/** * Get a list of creature names. * * @param requireSpawnable Whether to only show entries that are spawnable * @return */ public static String getCreatureNameList(boolean requireSpawnable) { StringBuilder str = new StringBuilder(); for (EntityType type : EntityType.values()) { Class<?> entityClass = type.getEntityClass(); if (entityClass == null) { continue; } if (!LivingEntity.class.isAssignableFrom(entityClass)) { continue; } if (!requireSpawnable || type.isSpawnable()) { if (str.length() > 0) { str.append(", "); } str.append(type.getName()); } } return str.toString(); } }
@SuppressWarnings("deprecation") private static EntityType matchEntityType(String toMatch) { EntityType type; try { type = EntityType.valueOf(toMatch); } catch (IllegalArgumentException ex) { type = EntityType.fromName(toMatch); } if (type != null) return type; return matchEnum(EntityType.values(), toMatch); }
EntityType[] entityTypes = EntityType.values(); for (EntityType entityType : entityTypes) { examples.add(entityType.name().toLowerCase());
@Override public void getParameterOptions(Spell spell, String parameterKey, Collection<String> examples) { if (parameterKey.equals("type")) { for (EntityType type : EntityType.values()) { examples.add(type.name().toLowerCase());
@Override public Collection<String> onTabComplete(CommandSender sender, String commandName, String[] args) { List<String> options = new ArrayList<>(); if (!sender.hasPermission("Magic.commands.mmob")) return options; if (args.length == 1) { options.add("spawn"); options.add("list"); options.add("clear"); } else if (args.length == 2 && (args[0].equalsIgnoreCase("spawn") || args[0].equalsIgnoreCase("clear"))) { options.addAll(api.getController().getMobKeys()); for (EntityType entityType : EntityType.values()) { if (entityType.isAlive() && entityType.isSpawnable()) { options.add(entityType.name().toLowerCase()); } } } else if (args.length == 3 && args[0].equalsIgnoreCase("clear")) { List<World> worlds = api.getPlugin().getServer().getWorlds(); for (World world : worlds) { options.add(world.getName()); } } return options; } }
case "spawn.mobs": options.addAll(api.getController().getMobKeys()); for (EntityType entityType : EntityType.values()) { if (entityType.isAlive() && entityType.isSpawnable()) { options.add(entityType.name().toLowerCase());
public BukkitCommandCompletions(BukkitCommandManager manager) { super(manager); registerAsyncCompletion("mobs", c -> { final Stream<String> normal = Stream.of(EntityType.values()) .map(entityType -> ACFUtil.simplifyString(entityType.getName())); return normal.collect(Collectors.toList());
for (EntityType type : EntityType.values()) { Class<?> clazz = type.getEntityClass(); if (clazz == null) continue;
public static void build() { NULL = new BukkitMCEntityType(EntityType.UNKNOWN, MCVanillaEntityType.UNKNOWN); for(MCVanillaEntityType v : MCVanillaEntityType.values()) { if(v.existsInCurrent()) { EntityType type; try { type = getBukkitType(v); } catch (IllegalArgumentException | NoSuchFieldError ex) { CHLog.GetLogger().w(CHLog.Tags.RUNTIME, "Could not find a Bukkit EntityType for " + v.name(), Target.UNKNOWN); continue; } BukkitMCEntityType wrapper = new BukkitMCEntityType(type, v); wrapper.setWrapperClass(); VANILLA_MAP.put(v, wrapper); MAP.put(v.name(), wrapper); BUKKIT_MAP.put(type, wrapper); } } for(EntityType b : EntityType.values()) { if(!BUKKIT_MAP.containsKey(b)) { MAP.put(b.name(), new BukkitMCEntityType(b, MCVanillaEntityType.UNKNOWN)); BUKKIT_MAP.put(b, new BukkitMCEntityType(b, MCVanillaEntityType.UNKNOWN)); } } }
EntityType type = null; for (EntityType entityType : EntityType.values()) { if (entityType.getTypeId() == stack.getDurability()) { type = entityType;
init(true); List<String> names = section.getStringList(listName); EntityType[] entities = EntityType.values(); for (String name : names) { EntityType entity = null;
@Override protected void loadKeys() { if (config.getConfigurationSection("Treasures") != null) { backup(); return; } loadTreasures("Fishing"); loadTreasures("Excavation"); loadTreasures("Hylian_Luck"); loadEnchantments(); for (EntityType entity : EntityType.values()) { if (entity.isAlive()) { loadTreasures("Shake." + entity.toString()); } } }
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
/** * Tests if we have an entry for every Bukkit entry. */ @Test public void testBukkitTypesExistInMobNames() { for (EntityType type : EntityType.values()) { if (type.isAlive() && type.isSpawnable() && type != EntityType.ARMOR_STAND) { // Throws IllegalArgumentException if no entry exists MobNames.valueOf(type.toString()); } } }
for (EntityType loop : EntityType.values())