Upstream/Minestom
1
0
Fork 0
mirror of https://github.com/Minestom/Minestom.git synced 2024-06-26 06:24:54 +02:00
Code Issues Projects Releases Wiki Activity

Remove EventNode#map

Browse Source
This commit is contained in:
TheMode 2021-06-04 21:12:27 +02:00
parent 2872a25325
commit 25f1183a1b
5 changed files with 13 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/main/java/net/minestom/server/entity/Entity.java
View File

@ -156,8 +156,8 @@ public class Entity implements Viewable, Tickable, EventHandler<EntityEvent>, Da
Entity.ENTITY_BY_ID.put(id, this);
Entity.ENTITY_BY_UUID.put(uuid, this);
this.eventNode = EventNode.type("entity-" + uuid, EventFilter.ENTITY);
MinecraftServer.getGlobalEventHandler().map(this, eventNode);
this.eventNode = EventNode.value("entity-" + uuid, EventFilter.ENTITY, this::equals);
MinecraftServer.getGlobalEventHandler().addChild(eventNode);
}
public Entity(@NotNull EntityType entityType) {

56
src/main/java/net/minestom/server/event/EventNode.java
View File

@ -64,24 +64,7 @@ public class EventNode<T extends Event> {
return new EventNode<>(name, filter, predicate != null ? (e, o) -> predicate.test(e, (V) o) : null);
}
private static final Map<Class<? extends Event>, EventFilter<Event, ?>> REDIRECTION_MAP = new ConcurrentHashMap<>();
private static final Map<Class<? extends Event>, List<EventFilter<Event, ?>>> REDIRECTION_CACHE = new ConcurrentHashMap<>();
private static void registerMapping(EventFilter<? extends Event, ?> filter) {
final var type = filter.getEventType();
REDIRECTION_MAP.put(type, (EventFilter<Event, ?>) filter);
}
static {
registerMapping(EventFilter.ENTITY);
registerMapping(EventFilter.PLAYER);
registerMapping(EventFilter.ITEM);
registerMapping(EventFilter.INSTANCE);
registerMapping(EventFilter.INVENTORY);
}
private final Map<Class<? extends T>, List<EventListener<T>>> listenerMap = new ConcurrentHashMap<>();
private final Map<Object, EventNode<T>> redirectionMap = new ConcurrentHashMap<>();
private final Set<EventNode<T>> children = new CopyOnWriteArraySet<>();
protected final String name;
@ -127,19 +110,6 @@ public class EventNode<T extends Event> {
// Cancelled by superclass
return;
}
// Process redirection
if (!redirectionMap.isEmpty()) {
// Loop through register redirection
getRedirectionCache(event).forEach(redirectionFilter -> {
final Object handler = redirectionFilter.getHandler(event);
if (handler != null) {
final var node = redirectionMap.get(handler);
if (node != null) {
node.call(event);
}
}
});
}
// Process listener list
final var listeners = listenerMap.get(eventClass);
if (listeners != null && !listeners.isEmpty()) {
@ -243,16 +213,6 @@ public class EventNode<T extends Event> {
return this;
}
public <E extends T> EventNode<T> map(@NotNull Object value, @NotNull EventNode<E> node) {
this.redirectionMap.put(value, (EventNode<T>) node);
return this;
}
public EventNode<T> unmap(@NotNull Object value) {
this.redirectionMap.remove(value);
return this;
}
public @NotNull String getName() {
return name;
}
@ -288,20 +248,4 @@ public class EventNode<T extends Event> {
throw new IllegalStateException("Something wrong happened, listener count: " + result);
}
}
private static List<EventFilter<Event, ?>> getRedirectionCache(Event event) {
return REDIRECTION_CACHE.computeIfAbsent(event.getClass(),
aClass -> findFilters(event));
}
private static List<EventFilter<Event, ?>> findFilters(Event event) {
final var eventClass = event.getClass();
List<EventFilter<Event, ?>> filters = new ArrayList<>();
REDIRECTION_MAP.forEach((aClass, f) -> {
if (aClass.isAssignableFrom(eventClass)) {
filters.add(f);
}
});
return filters;
}
}

5
src/main/java/net/minestom/server/event/handler/EventHandler.java
View File

@ -7,11 +7,16 @@ import org.jetbrains.annotations.NotNull;
/**
* Represents an element which can have {@link Event} listeners assigned to it.
* <p>
* Use {@link EventNode} directly.
*/
@Deprecated
public interface EventHandler<T extends Event> {
@Deprecated
@NotNull EventNode<T> getEventNode();
@Deprecated
default <V extends T> boolean addEventCallback(@NotNull Class<V> eventClass, @NotNull EventCallback<V> eventCallback) {
var node = getEventNode();
node.addListener(eventClass, eventCallback::run);

4
src/main/java/net/minestom/server/instance/Instance.java
View File

@ -120,8 +120,8 @@ public abstract class Instance implements BlockModifier, Tickable, EventHandler<
this.worldBorder = new WorldBorder(this);
this.eventNode = EventNode.type("instance-" + uniqueId, EventFilter.INSTANCE);
MinecraftServer.getGlobalEventHandler().map(this, eventNode);
this.eventNode = EventNode.value("instance-" + uniqueId, EventFilter.INSTANCE, this::equals);
MinecraftServer.getGlobalEventHandler().addChild(eventNode);
}
/**

4
src/test/java/demo/PlayerInit.java
View File

@ -133,6 +133,10 @@ public class PlayerInit {
packetController.setCancel(false);
});
connectionManager.addPlayerInitialization(player -> {
player.addEventCallback(PlayerTickEvent.class, event -> {});
});
// EVENT REGISTERING
var globalNode = MinecraftServer.getGlobalEventHandler();