Added Entity lookup system, TestableEntity, CustomEntity
This commit is contained in:
Auxilor
@@ -0,0 +1,84 @@
|
||||
package com.willfp.eco.core.entities;
|
||||
|
||||
import org.apache.commons.lang3.Validate;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.NamespacedKey;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
import java.util.function.Function;
|
||||
import java.util.function.Predicate;
|
||||
|
||||
/**
|
||||
* A custom entity has 3 components.
|
||||
*
|
||||
* <ul>
|
||||
* <li>The key to identify it</li>
|
||||
* <li>The test to check if any entity is this custom entity</li>
|
||||
* <li>The supplier to spawn the custom {@link org.bukkit.entity.Entity}</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class CustomEntity implements TestableEntity {
|
||||
/**
|
||||
* The key.
|
||||
*/
|
||||
private final NamespacedKey key;
|
||||
|
||||
/**
|
||||
* The test for Entities to pass.
|
||||
*/
|
||||
private final Predicate<@NotNull Entity> test;
|
||||
|
||||
/**
|
||||
* The provider to spawn the entity.
|
||||
*/
|
||||
private final Function<Location, Entity> provider;
|
||||
|
||||
/**
|
||||
* Create a new custom entity.
|
||||
*
|
||||
* @param key The entity key.
|
||||
* @param test The test.
|
||||
* @param provider The provider to spawn the entity.
|
||||
*/
|
||||
public CustomEntity(@NotNull final NamespacedKey key,
|
||||
@NotNull final Predicate<@NotNull Entity> test,
|
||||
@NotNull final Function<Location, Entity> provider) {
|
||||
this.key = key;
|
||||
this.test = test;
|
||||
this.provider = provider;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean matches(@Nullable final Entity entity) {
|
||||
if (entity == null) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return test.test(entity);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Entity spawn(@NotNull final Location location) {
|
||||
Validate.notNull(location.getWorld());
|
||||
|
||||
return provider.apply(location);
|
||||
}
|
||||
|
||||
/**
|
||||
* Register the entity.
|
||||
*/
|
||||
public void register() {
|
||||
Entities.registerCustomEntity(this.getKey(), this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the key.
|
||||
*
|
||||
* @return The key.
|
||||
*/
|
||||
public NamespacedKey getKey() {
|
||||
return this.key;
|
||||
}
|
||||
}
|
||||
241
eco-api/src/main/java/com/willfp/eco/core/entities/Entities.java
Normal file
241
eco-api/src/main/java/com/willfp/eco/core/entities/Entities.java
Normal file
@@ -0,0 +1,241 @@
|
||||
package com.willfp.eco.core.entities;
|
||||
|
||||
import com.willfp.eco.core.entities.args.EntityArgParseResult;
|
||||
import com.willfp.eco.core.entities.args.EntityArgParser;
|
||||
import com.willfp.eco.core.entities.impl.ModifiedTestableEntity;
|
||||
import com.willfp.eco.core.entities.impl.SimpleTestableEntity;
|
||||
import com.willfp.eco.util.NamespacedKeyUtils;
|
||||
import com.willfp.eco.util.StringUtils;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.NamespacedKey;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.EntityType;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.function.Function;
|
||||
|
||||
/**
|
||||
* Class to manage all custom and vanilla entities.
|
||||
*/
|
||||
public final class Entities {
|
||||
/**
|
||||
* All entities.
|
||||
*/
|
||||
private static final Map<NamespacedKey, TestableEntity> REGISTRY = new ConcurrentHashMap<>();
|
||||
|
||||
/**
|
||||
* All entity parsers.
|
||||
*/
|
||||
private static final List<EntityArgParser> ARG_PARSERS = new ArrayList<>();
|
||||
|
||||
/**
|
||||
* Register a new custom item.
|
||||
*
|
||||
* @param key The key of the item.
|
||||
* @param item The item.
|
||||
*/
|
||||
public static void registerCustomEntity(@NotNull final NamespacedKey key,
|
||||
@NotNull final TestableEntity item) {
|
||||
REGISTRY.put(key, item);
|
||||
}
|
||||
|
||||
/**
|
||||
* Register a new arg parser.
|
||||
*
|
||||
* @param parser The parser.
|
||||
*/
|
||||
public static void registerArgParser(@NotNull final EntityArgParser parser) {
|
||||
ARG_PARSERS.add(parser);
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove an entity.
|
||||
*
|
||||
* @param key The key of the entity.
|
||||
*/
|
||||
public static void removeCustomEntity(@NotNull final NamespacedKey key) {
|
||||
REGISTRY.remove(key);
|
||||
}
|
||||
|
||||
/**
|
||||
* This is the backbone of the entire eco entity system.
|
||||
* <p>
|
||||
* You can look up a TestableEntity for any type or custom entity,
|
||||
* and it will return it with any modifiers passed as parameters.
|
||||
* <p>
|
||||
* If you want to get an Entity instance from this, then just call
|
||||
* {@link TestableEntity#spawn(Location)}.
|
||||
* <p>
|
||||
* The advantages of the testable entity system are that there is the inbuilt
|
||||
* {@link TestableEntity#matches(Entity)} - this allows to check if any entity
|
||||
* is that testable entity; which may sound negligible, but actually it allows for
|
||||
* much more power and flexibility. For example, you can have an entity with an
|
||||
* extra metadata tag, extra lore lines, different display name - and it
|
||||
* will still work as long as the test passes.
|
||||
* <p>
|
||||
* Unlike {@link com.willfp.eco.core.items.Items#lookup(String)}, this can return
|
||||
* null as there is no empty entity equivalent.
|
||||
*
|
||||
* @param key The lookup string.
|
||||
* @return The testable entity, or null if not found.
|
||||
*/
|
||||
@Nullable
|
||||
public static TestableEntity lookup(@NotNull final String key) {
|
||||
if (key.contains("?")) {
|
||||
String[] options = key.split("\\?");
|
||||
for (String option : options) {
|
||||
TestableEntity lookup = lookup(option);
|
||||
if (lookup != null) {
|
||||
return lookup;
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
String[] args = StringUtils.parseTokens(key);
|
||||
|
||||
if (args.length == 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
TestableEntity entity;
|
||||
|
||||
String[] split = args[0].toLowerCase().split(":");
|
||||
|
||||
if (split.length == 1) {
|
||||
EntityType type;
|
||||
try {
|
||||
type = EntityType.valueOf(args[0].toUpperCase());
|
||||
} catch (IllegalArgumentException e) {
|
||||
return null;
|
||||
}
|
||||
entity = new SimpleTestableEntity(type);
|
||||
} else {
|
||||
String namespace = split[0];
|
||||
String keyID = split[1];
|
||||
NamespacedKey namespacedKey = NamespacedKeyUtils.create(namespace, keyID);
|
||||
|
||||
TestableEntity part = REGISTRY.get(namespacedKey);
|
||||
|
||||
if (part == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
entity = part;
|
||||
}
|
||||
|
||||
|
||||
String[] modifierArgs = Arrays.copyOfRange(args, 1, args.length);
|
||||
|
||||
List<EntityArgParseResult> parseResults = new ArrayList<>();
|
||||
|
||||
for (EntityArgParser argParser : ARG_PARSERS) {
|
||||
EntityArgParseResult result = argParser.parseArguments(modifierArgs);
|
||||
if (result != null) {
|
||||
parseResults.add(result);
|
||||
}
|
||||
}
|
||||
|
||||
Function<Location, Entity> spawner = entity::spawn;
|
||||
|
||||
if (!parseResults.isEmpty()) {
|
||||
entity = new ModifiedTestableEntity(
|
||||
entity,
|
||||
test -> {
|
||||
for (EntityArgParseResult parseResult : parseResults) {
|
||||
if (!parseResult.test().test(test)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
},
|
||||
location -> {
|
||||
Entity spawned = spawner.apply(location);
|
||||
|
||||
for (EntityArgParseResult parseResult : parseResults) {
|
||||
parseResult.modifier().accept(spawned);
|
||||
}
|
||||
|
||||
return spawned;
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
return entity;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get a Testable Entity from an ItemStack.
|
||||
* <p>
|
||||
* Will search for registered entity first. If there are no matches in the registry,
|
||||
* then it will return a {@link com.willfp.eco.core.entities.impl.SimpleTestableEntity} matching the entity type.
|
||||
* <p>
|
||||
* If the entity is not custom and has unknown type, this will return null.
|
||||
*
|
||||
* @param entity The Entity.
|
||||
* @return The found Testable Entity.
|
||||
*/
|
||||
@Nullable
|
||||
public static TestableEntity getEntity(@Nullable final Entity entity) {
|
||||
if (entity == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
TestableEntity customEntity = getEntity(entity);
|
||||
|
||||
if (customEntity != null) {
|
||||
return customEntity;
|
||||
}
|
||||
|
||||
for (TestableEntity known : REGISTRY.values()) {
|
||||
if (known.matches(entity)) {
|
||||
return known;
|
||||
}
|
||||
}
|
||||
|
||||
if (entity.getType() == EntityType.UNKNOWN) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return new SimpleTestableEntity(entity.getType());
|
||||
}
|
||||
|
||||
/**
|
||||
* Get if entity is a custom entity.
|
||||
*
|
||||
* @param entity The entity to check.
|
||||
* @return If is custom.
|
||||
*/
|
||||
public static boolean isCustomEntity(@NotNull final Entity entity) {
|
||||
for (TestableEntity testable : REGISTRY.values()) {
|
||||
if (testable.matches(entity)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all registered custom items.
|
||||
*
|
||||
* @return A set of all items.
|
||||
*/
|
||||
public static Set<TestableEntity> getCustomEntities() {
|
||||
return new HashSet<>(REGISTRY.values());
|
||||
}
|
||||
|
||||
private Entities() {
|
||||
throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
package com.willfp.eco.core.entities;
|
||||
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
/**
|
||||
* An item with a test to see if any item is that item.
|
||||
*/
|
||||
public interface TestableEntity {
|
||||
/**
|
||||
* If an Entity matches the test.
|
||||
*
|
||||
* @param entity The entity to test.
|
||||
* @return If the entity matches.
|
||||
*/
|
||||
boolean matches(@Nullable Entity entity);
|
||||
|
||||
/**
|
||||
* Spawn the entity.
|
||||
*
|
||||
* @param location The location.
|
||||
* @return The entity.
|
||||
*/
|
||||
Entity spawn(@NotNull Location location);
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
package com.willfp.eco.core.entities.args;
|
||||
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
|
||||
import java.util.function.Consumer;
|
||||
import java.util.function.Predicate;
|
||||
|
||||
/**
|
||||
* @param test The test for the entity.
|
||||
* @param modifier The modifier to apply to the entity.
|
||||
* @see EntityArgParser
|
||||
*/
|
||||
public record EntityArgParseResult(@NotNull Predicate<Entity> test,
|
||||
@NotNull Consumer<Entity> modifier) {
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
package com.willfp.eco.core.entities.args;
|
||||
|
||||
import com.willfp.eco.core.entities.TestableEntity;
|
||||
import org.bukkit.Location;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
/**
|
||||
* An argument parser should generate the predicate as well
|
||||
* as modify the Entity for {@link TestableEntity#spawn(Location)}.
|
||||
*/
|
||||
public interface EntityArgParser {
|
||||
/**
|
||||
* Parse the arguments.
|
||||
*
|
||||
* @param args The arguments.
|
||||
* @return The predicate test to apply to the modified entity.
|
||||
*/
|
||||
@Nullable EntityArgParseResult parseArguments(@NotNull String[] args);
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
package com.willfp.eco.core.entities.impl;
|
||||
|
||||
import com.willfp.eco.core.entities.TestableEntity;
|
||||
import org.apache.commons.lang3.Validate;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
import java.util.function.Function;
|
||||
import java.util.function.Predicate;
|
||||
|
||||
/**
|
||||
* Existing testable entity with an extra filter.
|
||||
*
|
||||
* @see com.willfp.eco.core.entities.CustomEntity
|
||||
*/
|
||||
public class ModifiedTestableEntity implements TestableEntity {
|
||||
/**
|
||||
* The item.
|
||||
*/
|
||||
private final TestableEntity handle;
|
||||
|
||||
/**
|
||||
* The amount.
|
||||
*/
|
||||
private final Predicate<Entity> test;
|
||||
|
||||
/**
|
||||
* The provider to spawn the entity.
|
||||
*/
|
||||
private final Function<Location, Entity> provider;
|
||||
|
||||
/**
|
||||
* Create a new modified testable entity.
|
||||
*
|
||||
* @param entity The base entity.
|
||||
* @param test The test.
|
||||
* @param provider The provider to spawn the entity.
|
||||
*/
|
||||
public ModifiedTestableEntity(@NotNull final TestableEntity entity,
|
||||
@NotNull final Predicate<@NotNull Entity> test,
|
||||
@NotNull final Function<Location, Entity> provider) {
|
||||
this.handle = entity;
|
||||
this.test = test;
|
||||
this.provider = provider;
|
||||
}
|
||||
|
||||
/**
|
||||
* If the entity matches the test.
|
||||
*
|
||||
* @param entity The entity to test.
|
||||
* @return If the entity matches the test.
|
||||
*/
|
||||
@Override
|
||||
public boolean matches(@Nullable final Entity entity) {
|
||||
return entity != null && handle.matches(entity) && test.test(entity);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Entity spawn(@NotNull final Location location) {
|
||||
Validate.notNull(location.getWorld());
|
||||
|
||||
return provider.apply(location);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the handle.
|
||||
*
|
||||
* @return The handle.
|
||||
*/
|
||||
public TestableEntity getHandle() {
|
||||
return this.handle;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
package com.willfp.eco.core.entities.impl;
|
||||
|
||||
import com.willfp.eco.core.entities.TestableEntity;
|
||||
import org.apache.commons.lang3.Validate;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.EntityType;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
/**
|
||||
* Default vanilla entities.
|
||||
*/
|
||||
public class SimpleTestableEntity implements TestableEntity {
|
||||
/**
|
||||
* The entity type.
|
||||
*/
|
||||
private final EntityType type;
|
||||
|
||||
/**
|
||||
* Create a new simple testable entity.
|
||||
*
|
||||
* @param type The entity type.
|
||||
*/
|
||||
public SimpleTestableEntity(@NotNull final EntityType type) {
|
||||
this.type = type;
|
||||
|
||||
Validate.notNull(type.getEntityClass(), "Entity cannot be of unknown type!");
|
||||
}
|
||||
|
||||
/**
|
||||
* If the entity matches the type.
|
||||
*
|
||||
* @param entity The entity to test.
|
||||
* @return If the entity is of the specified type.
|
||||
*/
|
||||
@Override
|
||||
public boolean matches(@Nullable final Entity entity) {
|
||||
return entity != null && entity.getType() == type;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Entity spawn(@NotNull final Location location) {
|
||||
Validate.notNull(location.getWorld());
|
||||
|
||||
assert type.getEntityClass() != null;
|
||||
|
||||
return location.getWorld().spawn(location, type.getEntityClass());
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the type.
|
||||
*
|
||||
* @return The type.
|
||||
*/
|
||||
public EntityType getType() {
|
||||
return this.type;
|
||||
}
|
||||
}
|
||||
@@ -8,6 +8,7 @@ import com.willfp.eco.core.recipe.parts.ModifiedTestableItem;
|
||||
import com.willfp.eco.core.recipe.parts.TestableStack;
|
||||
import com.willfp.eco.util.NamespacedKeyUtils;
|
||||
import com.willfp.eco.util.NumberUtils;
|
||||
import com.willfp.eco.util.StringUtils;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.NamespacedKey;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
@@ -118,7 +119,7 @@ public final class Items {
|
||||
return new EmptyTestableItem();
|
||||
}
|
||||
|
||||
String[] args = parseLookupString(key);
|
||||
String[] args = StringUtils.parseTokens(key);
|
||||
|
||||
if (args.length == 0) {
|
||||
return new EmptyTestableItem();
|
||||
@@ -237,54 +238,6 @@ public final class Items {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse lookup string into arguments.
|
||||
* <p>
|
||||
* Handles quoted strings for names.
|
||||
*
|
||||
* @param lookup The lookup string.
|
||||
* @return An array of arguments to be processed.
|
||||
* @author Shawn (https://stackoverflow.com/questions/70606170/split-a-list-on-spaces-and-group-quoted-characters/70606653#70606653)
|
||||
*/
|
||||
@NotNull
|
||||
public static String[] parseLookupString(@NotNull final String lookup) {
|
||||
char[] chars = lookup.toCharArray();
|
||||
List<String> arguments = new ArrayList<>();
|
||||
StringBuilder argumentBuilder = new StringBuilder();
|
||||
for (int i = 0; i < chars.length; i++) {
|
||||
if (chars[i] == ' ') {
|
||||
/*
|
||||
Take the current value of the argument builder, append it to the
|
||||
list of found arguments, and then clear it for the next argument.
|
||||
*/
|
||||
arguments.add(argumentBuilder.toString());
|
||||
argumentBuilder.setLength(0);
|
||||
} else if (chars[i] == '"') {
|
||||
/*
|
||||
Work until the next unescaped quote to handle quotes with
|
||||
spaces in them - assumes the input string is well-formatted
|
||||
*/
|
||||
for (i++; chars[i] != '"'; i++) {
|
||||
/*
|
||||
If the found quote is escaped, ignore it in the parsing
|
||||
*/
|
||||
if (chars[i] == '\\') {
|
||||
i++;
|
||||
}
|
||||
argumentBuilder.append(chars[i]);
|
||||
}
|
||||
} else {
|
||||
/*
|
||||
If it's a regular character, just append it to the current argument.
|
||||
*/
|
||||
argumentBuilder.append(chars[i]);
|
||||
}
|
||||
}
|
||||
arguments.add(argumentBuilder.toString()); // Adds the last argument to the arguments.
|
||||
return arguments.toArray(new String[0]);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get a Testable Item from an ItemStack.
|
||||
* <p>
|
||||
|
||||
@@ -477,6 +477,53 @@ public final class StringUtils {
|
||||
return LEGACY_COMPONENT_SERIALIZER.serialize(component);
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse string into tokens.
|
||||
* <p>
|
||||
* Handles quoted strings for names.
|
||||
*
|
||||
* @param lookup The lookup string.
|
||||
* @return An array of tokens to be processed.
|
||||
* @author Shawn (https://stackoverflow.com/questions/70606170/split-a-list-on-spaces-and-group-quoted-characters/70606653#70606653)
|
||||
*/
|
||||
@NotNull
|
||||
public static String[] parseTokens(@NotNull final String lookup) {
|
||||
char[] chars = lookup.toCharArray();
|
||||
List<String> tokens = new ArrayList<>();
|
||||
StringBuilder tokenBuilder = new StringBuilder();
|
||||
for (int i = 0; i < chars.length; i++) {
|
||||
if (chars[i] == ' ') {
|
||||
/*
|
||||
Take the current value of the argument builder, append it to the
|
||||
list of found tokens, and then clear it for the next argument.
|
||||
*/
|
||||
tokens.add(tokenBuilder.toString());
|
||||
tokenBuilder.setLength(0);
|
||||
} else if (chars[i] == '"') {
|
||||
/*
|
||||
Work until the next unescaped quote to handle quotes with
|
||||
spaces in them - assumes the input string is well-formatted
|
||||
*/
|
||||
for (i++; chars[i] != '"'; i++) {
|
||||
/*
|
||||
If the found quote is escaped, ignore it in the parsing
|
||||
*/
|
||||
if (chars[i] == '\\') {
|
||||
i++;
|
||||
}
|
||||
tokenBuilder.append(chars[i]);
|
||||
}
|
||||
} else {
|
||||
/*
|
||||
If it's a regular character, just append it to the current argument.
|
||||
*/
|
||||
tokenBuilder.append(chars[i]);
|
||||
}
|
||||
}
|
||||
tokens.add(tokenBuilder.toString()); // Adds the last argument to the tokens.
|
||||
return tokens.toArray(new String[0]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Options for formatting.
|
||||
*/
|
||||
|
||||
Reference in New Issue
Block a user