imports/architectury-api
1
0
Fork 0
mirror of https://github.com/architectury/architectury-api.git synced 2026-03-28 03:56:59 -05:00
Code Issues Packages Projects Releases Wiki Activity

Event Priorities

Browse Source 
Signed-off-by: shedaniel <daniel@shedaniel.me>
This commit is contained in:
shedaniel
2023-09-22 23:51:01 +08:00
parent 5422b8c615
commit bb56e81121
9 changed files with 632 additions and 347 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
common/src/main/java/dev/architectury/event/Event.java
View File

@@ -22,8 +22,12 @@ package dev.architectury.event;
public interface Event<T> {
T invoker();
T invoker(EventPriority priority);
void register(T listener);
void register(EventPriority priority, T listener);
void unregister(T listener);
boolean isRegistered(T listener);

157
common/src/main/java/dev/architectury/event/EventFactory.java
View File

@@ -28,9 +28,7 @@ import org.jetbrains.annotations.ApiStatus;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
@@ -196,15 +194,106 @@ public final class EventFactory {
private static class EventImpl<T> implements Event<T> {
private final Function<List<T>, T> function;
private T invoker = null;
private ArrayList<T> listeners;
private final Map<EventPriority, IndividualInvoker<T>> invokers;
private List<T> listeners;
private final Invoker<T> overallInvoker;
private final T emptyInvoker;
public EventImpl(Function<List<T>, T> function) {
this.function = function;
this.invokers = new EnumMap<>(EventPriority.class);
this.invokers.put(EventPriority.NORMAL, new IndividualInvoker<>(this.function));
this.overallInvoker = new Invoker<>(this.function, this.listeners);
this.buildListeners();
this.emptyInvoker = this.function.apply(Collections.emptyList());
}
private void buildListeners() {
if (this.invokers.size() == 1) {
this.listeners = this.invokers.values().iterator().next().listeners;
} else {
this.listeners = new ArrayList<>();
for (var invoker : this.invokers.values()) {
this.listeners.addAll(invoker.listeners);
}
}
this.overallInvoker.listeners = this.listeners;
this.overallInvoker.invoker = null;
}
@Override
public T invoker() {
return this.overallInvoker.invoker();
}
@Override
public T invoker(EventPriority priority) {
IndividualInvoker<T> invoker = this.invokers.get(priority);
if (invoker != null) {
return invoker.invoker();
} else {
return emptyInvoker;
}
}
@Override
public void register(T listener) {
this.register(EventPriority.NORMAL, listener);
}
@Override
public void register(EventPriority priority, T listener) {
this.getOrCreatePriority(priority).register(listener);
this.buildListeners();
}
@Override
public void unregister(T listener) {
for (var invoker : this.invokers.values()) {
invoker.unregister(listener);
}
this.buildListeners();
}
@Override
public boolean isRegistered(T listener) {
return overallInvoker.listeners.contains(listener);
}
private IndividualInvoker<T> getOrCreatePriority(EventPriority priority) {
IndividualInvoker<T> invoker = this.invokers.get(priority);
if (invoker == null) {
invoker = new IndividualInvoker<>(this.function);
this.invokers.put(priority, invoker);
}
return invoker;
}
@Override
public void clearListeners() {
this.invokers.put(EventPriority.NORMAL, new IndividualInvoker<>(this.function));
this.buildListeners();
}
}
private static class Invoker<T> {
protected final Function<List<T>, T> function;
protected T invoker = null;
protected List<T> listeners;
public Invoker(Function<List<T>, T> function) {
this.function = function;
this.listeners = new ArrayList<>();
}
@Override
public Invoker(Function<List<T>, T> function, List<T> listeners) {
this.function = function;
this.listeners = listeners;
}
public T invoker() {
if (invoker == null) {
update();
@@ -212,31 +301,6 @@ public final class EventFactory {
return invoker;
}
@Override
public void register(T listener) {
listeners.add(listener);
invoker = null;
}
@Override
public void unregister(T listener) {
listeners.remove(listener);
listeners.trimToSize();
invoker = null;
}
@Override
public boolean isRegistered(T listener) {
return listeners.contains(listener);
}
@Override
public void clearListeners() {
listeners.clear();
listeners.trimToSize();
invoker = null;
}
public void update() {
if (listeners.size() == 1) {
invoker = listeners.get(0);
@@ -245,4 +309,35 @@ public final class EventFactory {
}
}
}
private static class IndividualInvoker<T> extends Invoker<T> {
public IndividualInvoker(Function<List<T>, T> function) {
super(function);
}
public IndividualInvoker(Function<List<T>, T> function, ArrayList<T> listeners) {
super(function, listeners);
}
public void register(T listener) {
listeners.add(listener);
invoker = null;
}
public void unregister(T listener) {
listeners.remove(listener);
if (listeners instanceof ArrayList<T> arrayList) {
arrayList.trimToSize();
}
invoker = null;
}
public void clearListeners() {
listeners.clear();
if (listeners instanceof ArrayList<T> arrayList) {
arrayList.trimToSize();
}
invoker = null;
}
}
}

30
common/src/main/java/dev/architectury/event/EventPriority.java Normal file
View File

@@ -0,0 +1,30 @@
/*
* This file is part of architectury.
* Copyright (C) 2020, 2021, 2022 architectury
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package dev.architectury.event;
public enum EventPriority {
HIGHEST,
HIGH,
NORMAL,
LOW,
LOWEST;
public static final EventPriority[] VALUES = values();
}

72
fabric/src/main/java/dev/architectury/event/fabric/EventHandlerImpl.java
View File

@@ -19,6 +19,7 @@
package dev.architectury.event.fabric;
import dev.architectury.event.EventPriority;
import dev.architectury.event.events.client.ClientGuiEvent;
import dev.architectury.event.events.client.ClientLifecycleEvent;
import dev.architectury.event.events.client.ClientTickEvent;
@@ -42,57 +43,74 @@ import net.fabricmc.fabric.api.event.player.UseItemCallback;
import net.fabricmc.fabric.api.loot.v2.LootTableEvents;
import net.fabricmc.fabric.api.message.v1.ServerMessageDecoratorEvent;
import net.fabricmc.fabric.api.message.v1.ServerMessageEvents;
import net.minecraft.resources.ResourceLocation;
import java.util.concurrent.CompletableFuture;
import java.util.function.Function;
public class EventHandlerImpl {
public static final ResourceLocation HIGHEST = new ResourceLocation("architectury", "highest");
public static final ResourceLocation HIGH = new ResourceLocation("architectury", "high");
public static final ResourceLocation LOW = new ResourceLocation("architectury", "low");
public static final ResourceLocation LOWEST = new ResourceLocation("architectury", "lowest");
public static final ResourceLocation[] PHASES = new ResourceLocation[]{HIGHEST, HIGH, net.fabricmc.fabric.api.event.Event.DEFAULT_PHASE, LOW, LOWEST};
@Environment(EnvType.CLIENT)
public static void registerClient() {
ClientLifecycleEvents.CLIENT_STARTED.register(instance -> ClientLifecycleEvent.CLIENT_STARTED.invoker().stateChanged(instance));
ClientLifecycleEvents.CLIENT_STOPPING.register(instance -> ClientLifecycleEvent.CLIENT_STOPPING.invoker().stateChanged(instance));
registerWithPriority(ClientLifecycleEvents.CLIENT_STARTED, priority -> instance -> ClientLifecycleEvent.CLIENT_STARTED.invoker(priority).stateChanged(instance));
registerWithPriority(ClientLifecycleEvents.CLIENT_STOPPING, priority -> instance -> ClientLifecycleEvent.CLIENT_STOPPING.invoker(priority).stateChanged(instance));
ClientTickEvents.START_CLIENT_TICK.register(instance -> ClientTickEvent.CLIENT_PRE.invoker().tick(instance));
ClientTickEvents.END_CLIENT_TICK.register(instance -> ClientTickEvent.CLIENT_POST.invoker().tick(instance));
ClientTickEvents.START_WORLD_TICK.register(instance -> ClientTickEvent.CLIENT_LEVEL_PRE.invoker().tick(instance));
ClientTickEvents.END_WORLD_TICK.register(instance -> ClientTickEvent.CLIENT_LEVEL_POST.invoker().tick(instance));
registerWithPriority(ClientTickEvents.START_CLIENT_TICK, priority -> instance -> ClientTickEvent.CLIENT_PRE.invoker(priority).tick(instance));
registerWithPriority(ClientTickEvents.END_CLIENT_TICK, priority -> instance -> ClientTickEvent.CLIENT_POST.invoker(priority).tick(instance));
registerWithPriority(ClientTickEvents.START_WORLD_TICK, priority -> instance -> ClientTickEvent.CLIENT_LEVEL_PRE.invoker(priority).tick(instance));
registerWithPriority(ClientTickEvents.END_WORLD_TICK, priority -> instance -> ClientTickEvent.CLIENT_LEVEL_POST.invoker(priority).tick(instance));
ItemTooltipCallback.EVENT.register((itemStack, tooltipFlag, list) -> ClientTooltipEvent.ITEM.invoker().append(itemStack, list, tooltipFlag));
HudRenderCallback.EVENT.register((graphics, tickDelta) -> ClientGuiEvent.RENDER_HUD.invoker().renderHud(graphics, tickDelta));
registerWithPriority(ItemTooltipCallback.EVENT, priority -> (itemStack, tooltipFlag, list) -> ClientTooltipEvent.ITEM.invoker(priority).append(itemStack, list, tooltipFlag));
registerWithPriority(HudRenderCallback.EVENT, priority -> (graphics, tickDelta) -> ClientGuiEvent.RENDER_HUD.invoker(priority).renderHud(graphics, tickDelta));
}
public static void registerCommon() {
ServerLifecycleEvents.SERVER_STARTING.register(instance -> LifecycleEvent.SERVER_BEFORE_START.invoker().stateChanged(instance));
ServerLifecycleEvents.SERVER_STARTED.register(instance -> LifecycleEvent.SERVER_STARTED.invoker().stateChanged(instance));
ServerLifecycleEvents.SERVER_STOPPING.register(instance -> LifecycleEvent.SERVER_STOPPING.invoker().stateChanged(instance));
ServerLifecycleEvents.SERVER_STOPPED.register(instance -> LifecycleEvent.SERVER_STOPPED.invoker().stateChanged(instance));
registerWithPriority(ServerLifecycleEvents.SERVER_STARTING, priority -> instance -> LifecycleEvent.SERVER_BEFORE_START.invoker(priority).stateChanged(instance));
registerWithPriority(ServerLifecycleEvents.SERVER_STARTED, priority -> instance -> LifecycleEvent.SERVER_STARTED.invoker(priority).stateChanged(instance));
registerWithPriority(ServerLifecycleEvents.SERVER_STOPPING, priority -> instance -> LifecycleEvent.SERVER_STOPPING.invoker(priority).stateChanged(instance));
registerWithPriority(ServerLifecycleEvents.SERVER_STOPPED, priority -> instance -> LifecycleEvent.SERVER_STOPPED.invoker(priority).stateChanged(instance));
ServerTickEvents.START_SERVER_TICK.register(instance -> TickEvent.SERVER_PRE.invoker().tick(instance));
ServerTickEvents.END_SERVER_TICK.register(instance -> TickEvent.SERVER_POST.invoker().tick(instance));
ServerTickEvents.START_WORLD_TICK.register(instance -> TickEvent.SERVER_LEVEL_PRE.invoker().tick(instance));
ServerTickEvents.END_WORLD_TICK.register(instance -> TickEvent.SERVER_LEVEL_POST.invoker().tick(instance));
registerWithPriority(ServerTickEvents.START_SERVER_TICK, priority -> instance -> TickEvent.SERVER_PRE.invoker(priority).tick(instance));
registerWithPriority(ServerTickEvents.END_SERVER_TICK, priority -> instance -> TickEvent.SERVER_POST.invoker(priority).tick(instance));
registerWithPriority(ServerTickEvents.START_WORLD_TICK, priority -> instance -> TickEvent.SERVER_LEVEL_PRE.invoker(priority).tick(instance));
registerWithPriority(ServerTickEvents.END_WORLD_TICK, priority -> instance -> TickEvent.SERVER_LEVEL_POST.invoker(priority).tick(instance));
ServerWorldEvents.LOAD.register((server, world) -> LifecycleEvent.SERVER_LEVEL_LOAD.invoker().act(world));
ServerWorldEvents.UNLOAD.register((server, world) -> LifecycleEvent.SERVER_LEVEL_UNLOAD.invoker().act(world));
registerWithPriority(ServerWorldEvents.LOAD, priority -> (server, world) -> LifecycleEvent.SERVER_LEVEL_LOAD.invoker(priority).act(world));
registerWithPriority(ServerWorldEvents.UNLOAD, priority -> (server, world) -> LifecycleEvent.SERVER_LEVEL_UNLOAD.invoker(priority).act(world));
CommandRegistrationCallback.EVENT.register((dispatcher, registry, selection) -> CommandRegistrationEvent.EVENT.invoker().register(dispatcher, registry, selection));
registerWithPriority(CommandRegistrationCallback.EVENT, priority -> (dispatcher, registry, selection) -> CommandRegistrationEvent.EVENT.invoker(priority).register(dispatcher, registry, selection));
UseItemCallback.EVENT.register((player, world, hand) -> InteractionEvent.RIGHT_CLICK_ITEM.invoker().click(player, hand).asMinecraft());
UseBlockCallback.EVENT.register((player, world, hand, hitResult) -> InteractionEvent.RIGHT_CLICK_BLOCK.invoker().click(player, hand, hitResult.getBlockPos(), hitResult.getDirection()).asMinecraft());
AttackBlockCallback.EVENT.register((player, world, hand, pos, face) -> InteractionEvent.LEFT_CLICK_BLOCK.invoker().click(player, hand, pos, face).asMinecraft());
AttackEntityCallback.EVENT.register((player, world, hand, entity, hitResult) -> PlayerEvent.ATTACK_ENTITY.invoker().attack(player, world, entity, hand, hitResult).asMinecraft());
registerWithPriority(UseItemCallback.EVENT, priority -> (player, world, hand) -> InteractionEvent.RIGHT_CLICK_ITEM.invoker(priority).click(player, hand).asMinecraft());
registerWithPriority(UseBlockCallback.EVENT, priority -> (player, world, hand, hitResult) -> InteractionEvent.RIGHT_CLICK_BLOCK.invoker(priority).click(player, hand, hitResult.getBlockPos(), hitResult.getDirection()).asMinecraft());
registerWithPriority(AttackBlockCallback.EVENT, priority -> (player, world, hand, pos, face) -> InteractionEvent.LEFT_CLICK_BLOCK.invoker(priority).click(player, hand, pos, face).asMinecraft());
registerWithPriority(AttackEntityCallback.EVENT, priority -> (player, world, hand, entity, hitResult) -> PlayerEvent.ATTACK_ENTITY.invoker(priority).attack(player, world, entity, hand, hitResult).asMinecraft());
LootTableEvents.MODIFY.register((resourceManager, lootManager, id, tableBuilder, source) -> LootEvent.MODIFY_LOOT_TABLE.invoker().modifyLootTable(lootManager, id, new LootTableModificationContextImpl(tableBuilder), source.isBuiltin()));
registerWithPriority(LootTableEvents.MODIFY, priority -> (resourceManager, lootManager, id, tableBuilder, source) -> LootEvent.MODIFY_LOOT_TABLE.invoker(priority).modifyLootTable(lootManager, id, new LootTableModificationContextImpl(tableBuilder), source.isBuiltin()));
ServerMessageDecoratorEvent.EVENT.register(ServerMessageDecoratorEvent.CONTENT_PHASE, (player, component) -> {
ChatEvent.ChatComponent chatComponent = new ChatComponentImpl(component);
ChatEvent.DECORATE.invoker().decorate(player, chatComponent);
return chatComponent.get();
});
ServerMessageEvents.ALLOW_CHAT_MESSAGE.register((message, sender, params) -> {
return !ChatEvent.RECEIVED.invoker().received(sender, message.decoratedContent()).isFalse();
registerWithPriority(ServerMessageEvents.ALLOW_CHAT_MESSAGE, priority -> (message, sender, params) -> {
return !ChatEvent.RECEIVED.invoker(priority).received(sender, message.decoratedContent()).isFalse();
});
}
private static <T> void registerWithPriority(net.fabricmc.fabric.api.event.Event<T> fabricEvent, Function<EventPriority, T> listener) {
fabricEvent.addPhaseOrdering(HIGH, net.fabricmc.fabric.api.event.Event.DEFAULT_PHASE);
fabricEvent.addPhaseOrdering(HIGHEST, HIGH);
fabricEvent.addPhaseOrdering(net.fabricmc.fabric.api.event.Event.DEFAULT_PHASE, LOW);
fabricEvent.addPhaseOrdering(LOW, LOWEST);
for (EventPriority priority : EventPriority.VALUES) {
fabricEvent.register(PHASES[priority.ordinal()], listener.apply(priority));
}
}
@Environment(EnvType.SERVER)
public static void registerServer() {

12
forge/src/main/java/dev/architectury/event/forge/EventHandlerImpl.java
View File

@@ -28,17 +28,13 @@ import net.minecraftforge.common.MinecraftForge;
public class EventHandlerImpl {
@OnlyIn(Dist.CLIENT)
public static void registerClient() {
MinecraftForge.EVENT_BUS.register(EventHandlerImplClient.class);
EventBuses.onRegistered(ArchitecturyForge.MOD_ID, bus -> {
bus.register(EventHandlerImplClient.ModBasedEventHandler.class);
});
EventHandlerImplClient.init();
EventBuses.onRegistered(ArchitecturyForge.MOD_ID, EventHandlerImplClient.ModBasedEventHandler::init);
}
public static void registerCommon() {
MinecraftForge.EVENT_BUS.register(EventHandlerImplCommon.class);
EventBuses.onRegistered(ArchitecturyForge.MOD_ID, bus -> {
bus.register(EventHandlerImplCommon.ModBasedEventHandler.class);
});
EventHandlerImplCommon.init();
EventBuses.onRegistered(ArchitecturyForge.MOD_ID, EventHandlerImplCommon.ModBasedEventHandler::init);
}
@OnlyIn(Dist.DEDICATED_SERVER)

292
forge/src/main/java/dev/architectury/event/forge/EventHandlerImplClient.java
View File

@@ -20,6 +20,7 @@
package dev.architectury.event.forge;
import dev.architectury.event.CompoundEventResult;
import dev.architectury.event.EventPriority;
import dev.architectury.event.EventResult;
import dev.architectury.event.events.client.ClientChatEvent;
import dev.architectury.event.events.client.*;
@@ -35,79 +36,116 @@ import net.minecraft.network.chat.Component;
import net.minecraftforge.api.distmarker.Dist;
import net.minecraftforge.api.distmarker.OnlyIn;
import net.minecraftforge.client.event.*;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.entity.player.ItemTooltipEvent;
import net.minecraftforge.event.entity.player.PlayerInteractEvent;
import net.minecraftforge.event.level.LevelEvent;
import net.minecraftforge.eventbus.api.EventPriority;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import net.minecraftforge.eventbus.api.Event;
import net.minecraftforge.eventbus.api.IEventBus;
import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
import java.util.function.BiConsumer;
@OnlyIn(Dist.CLIENT)
public class EventHandlerImplClient {
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(ItemTooltipEvent event) {
ClientTooltipEvent.ITEM.invoker().append(event.getItemStack(), event.getToolTip(), event.getFlags());
public static void init() {
for (EventPriority priority : EventPriority.VALUES) {
registerWithPriority(priority, ItemTooltipEvent.class, EventHandlerImplClient::event);
registerWithPriority(priority, net.minecraftforge.event.TickEvent.ClientTickEvent.class, EventHandlerImplClient::event);
registerWithPriority(priority, RenderGuiEvent.Post.class, EventHandlerImplClient::eventRenderGameOverlayEvent);
registerWithPriority(priority, ClientPlayerNetworkEvent.LoggingIn.class, EventHandlerImplClient::event);
registerWithPriority(priority, ClientPlayerNetworkEvent.LoggingOut.class, EventHandlerImplClient::event);
registerWithPriority(priority, ClientPlayerNetworkEvent.Clone.class, EventHandlerImplClient::event);
registerWithPriority(priority, ScreenEvent.Init.Pre.class, EventHandlerImplClient::eventInitScreenEvent);
registerWithPriority(priority, ScreenEvent.Init.Post.class, EventHandlerImplClient::eventInitScreenEvent);
registerWithPriority(priority, CustomizeGuiOverlayEvent.DebugText.class, EventHandlerImplClient::eventRenderGameOverlayEvent);
registerWithPriority(priority, net.minecraftforge.client.event.ClientChatEvent.class, EventHandlerImplClient::event);
registerWithPriority(priority, ClientChatReceivedEvent.class, EventHandlerImplClient::event);
registerWithPriority(priority, LevelEvent.Load.class, EventHandlerImplClient::eventWorldEvent);
registerWithPriority(priority, ScreenEvent.Opening.class, EventHandlerImplClient::event);
registerWithPriority(priority, ScreenEvent.Render.Pre.class, EventHandlerImplClient::eventDrawScreenEvent);
registerWithPriority(priority, ScreenEvent.Render.Post.class, EventHandlerImplClient::eventDrawScreenEvent);
registerWithPriority(priority, ContainerScreenEvent.Render.Background.class, EventHandlerImplClient::eventContainerScreenEvent);
registerWithPriority(priority, ContainerScreenEvent.Render.Foreground.class, EventHandlerImplClient::eventContainerScreenEvent);
registerWithPriority(priority, PlayerInteractEvent.RightClickEmpty.class, EventHandlerImplClient::eventPlayerInteractEvent);
registerWithPriority(priority, PlayerInteractEvent.LeftClickEmpty.class, EventHandlerImplClient::eventPlayerInteractEvent);
registerWithPriority(priority, RecipesUpdatedEvent.class, EventHandlerImplClient::event);
registerWithPriority(priority, RenderTooltipEvent.Pre.class, EventHandlerImplClient::eventRenderTooltipEvent);
registerWithPriority(priority, RenderTooltipEvent.Color.class, EventHandlerImplClient::eventRenderTooltipEvent);
registerWithPriority(priority, ScreenEvent.MouseScrolled.Pre.class, EventHandlerImplClient::eventMouseScrollEvent);
registerWithPriority(priority, ScreenEvent.MouseScrolled.Post.class, EventHandlerImplClient::eventMouseScrollEvent);
registerWithPriority(priority, ScreenEvent.MouseButtonPressed.Pre.class, EventHandlerImplClient::eventMouseClickedEvent);
registerWithPriority(priority, ScreenEvent.MouseButtonPressed.Post.class, EventHandlerImplClient::eventMouseClickedEvent);
registerWithPriority(priority, ScreenEvent.MouseDragged.Pre.class, EventHandlerImplClient::eventMouseDragEvent);
registerWithPriority(priority, ScreenEvent.MouseDragged.Post.class, EventHandlerImplClient::eventMouseDragEvent);
registerWithPriority(priority, ScreenEvent.MouseButtonReleased.Pre.class, EventHandlerImplClient::eventMouseReleasedEvent);
registerWithPriority(priority, ScreenEvent.MouseButtonReleased.Post.class, EventHandlerImplClient::eventMouseReleasedEvent);
registerWithPriority(priority, ScreenEvent.CharacterTyped.Pre.class, EventHandlerImplClient::eventKeyboardCharTypedEvent);
registerWithPriority(priority, ScreenEvent.CharacterTyped.Post.class, EventHandlerImplClient::eventKeyboardCharTypedEvent);
registerWithPriority(priority, ScreenEvent.KeyPressed.Pre.class, EventHandlerImplClient::eventKeyboardKeyPressedEvent);
registerWithPriority(priority, ScreenEvent.KeyPressed.Post.class, EventHandlerImplClient::eventKeyboardKeyPressedEvent);
registerWithPriority(priority, ScreenEvent.KeyReleased.Pre.class, EventHandlerImplClient::eventKeyboardKeyReleasedEvent);
registerWithPriority(priority, ScreenEvent.KeyReleased.Post.class, EventHandlerImplClient::eventKeyboardKeyReleasedEvent);
registerWithPriority(priority, InputEvent.MouseScrollingEvent.class, EventHandlerImplClient::eventInputEvent);
registerWithPriority(priority, InputEvent.MouseButton.Pre.class, EventHandlerImplClient::eventInputEvent);
registerWithPriority(priority, InputEvent.MouseButton.Post.class, EventHandlerImplClient::eventInputEvent);
registerWithPriority(priority, InputEvent.Key.class, EventHandlerImplClient::eventInputEvent);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(net.minecraftforge.event.TickEvent.ClientTickEvent event) {
public static void event(ItemTooltipEvent event, EventPriority priority) {
ClientTooltipEvent.ITEM.invoker(priority).append(event.getItemStack(), event.getToolTip(), event.getFlags());
}
public static void event(net.minecraftforge.event.TickEvent.ClientTickEvent event, EventPriority priority) {
if (event.phase == net.minecraftforge.event.TickEvent.Phase.START)
ClientTickEvent.CLIENT_PRE.invoker().tick(Minecraft.getInstance());
ClientTickEvent.CLIENT_PRE.invoker(priority).tick(Minecraft.getInstance());
else if (event.phase == net.minecraftforge.event.TickEvent.Phase.END)
ClientTickEvent.CLIENT_POST.invoker().tick(Minecraft.getInstance());
ClientTickEvent.CLIENT_POST.invoker(priority).tick(Minecraft.getInstance());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventRenderGameOverlayEvent(RenderGuiEvent.Post event) {
ClientGuiEvent.RENDER_HUD.invoker().renderHud(event.getGuiGraphics(), event.getPartialTick());
public static void eventRenderGameOverlayEvent(RenderGuiEvent.Post event, EventPriority priority) {
ClientGuiEvent.RENDER_HUD.invoker(priority).renderHud(event.getGuiGraphics(), event.getPartialTick());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(ClientPlayerNetworkEvent.LoggingIn event) {
ClientPlayerEvent.CLIENT_PLAYER_JOIN.invoker().join(event.getPlayer());
public static void event(ClientPlayerNetworkEvent.LoggingIn event, EventPriority priority) {
ClientPlayerEvent.CLIENT_PLAYER_JOIN.invoker(priority).join(event.getPlayer());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(ClientPlayerNetworkEvent.LoggingOut event) {
ClientPlayerEvent.CLIENT_PLAYER_QUIT.invoker().quit(event.getPlayer());
public static void event(ClientPlayerNetworkEvent.LoggingOut event, EventPriority priority) {
ClientPlayerEvent.CLIENT_PLAYER_QUIT.invoker(priority).quit(event.getPlayer());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(ClientPlayerNetworkEvent.Clone event) {
ClientPlayerEvent.CLIENT_PLAYER_RESPAWN.invoker().respawn(event.getOldPlayer(), event.getNewPlayer());
public static void event(ClientPlayerNetworkEvent.Clone event, EventPriority priority) {
ClientPlayerEvent.CLIENT_PLAYER_RESPAWN.invoker(priority).respawn(event.getOldPlayer(), event.getNewPlayer());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventInitScreenEvent(ScreenEvent.Init.Pre event) {
if (ClientGuiEvent.INIT_PRE.invoker().init(event.getScreen(), new ScreenAccessImpl(event.getScreen())).isFalse()) {
public static void eventInitScreenEvent(ScreenEvent.Init.Pre event, EventPriority priority) {
if (ClientGuiEvent.INIT_PRE.invoker(priority).init(event.getScreen(), new ScreenAccessImpl(event.getScreen())).isFalse()) {
event.setCanceled(true);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventInitScreenEvent(ScreenEvent.Init.Post event) {
ClientGuiEvent.INIT_POST.invoker().init(event.getScreen(), new ScreenAccessImpl(event.getScreen()));
public static void eventInitScreenEvent(ScreenEvent.Init.Post event, EventPriority priority) {
ClientGuiEvent.INIT_POST.invoker(priority).init(event.getScreen(), new ScreenAccessImpl(event.getScreen()));
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventRenderGameOverlayEvent(CustomizeGuiOverlayEvent.DebugText event) {
public static void eventRenderGameOverlayEvent(CustomizeGuiOverlayEvent.DebugText event, EventPriority priority) {
if (Minecraft.getInstance().options.renderDebug) {
ClientGuiEvent.DEBUG_TEXT_LEFT.invoker().gatherText(event.getLeft());
ClientGuiEvent.DEBUG_TEXT_RIGHT.invoker().gatherText(event.getRight());
ClientGuiEvent.DEBUG_TEXT_LEFT.invoker(priority).gatherText(event.getLeft());
ClientGuiEvent.DEBUG_TEXT_RIGHT.invoker(priority).gatherText(event.getRight());
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(net.minecraftforge.client.event.ClientChatEvent event) {
EventResult process = ClientChatEvent.SEND.invoker().send(event.getMessage(), null);
public static void event(net.minecraftforge.client.event.ClientChatEvent event, EventPriority priority) {
EventResult process = ClientChatEvent.SEND.invoker(priority).send(event.getMessage(), null);
if (process.isFalse()) {
event.setCanceled(true);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(ClientChatReceivedEvent event) {
CompoundEventResult<Component> process = ClientChatEvent.RECEIVED.invoker().process(event.getBoundChatType(), event.getMessage());
public static void event(ClientChatReceivedEvent event, EventPriority priority) {
CompoundEventResult<Component> process = ClientChatEvent.RECEIVED.invoker(priority).process(event.getBoundChatType(), event.getMessage());
if (process.isPresent()) {
if (process.isFalse())
event.setCanceled(true);
@@ -116,17 +154,15 @@ public class EventHandlerImplClient {
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventWorldEvent(LevelEvent.Load event) {
public static void eventWorldEvent(LevelEvent.Load event, EventPriority priority) {
if (event.getLevel().isClientSide()) {
ClientLevel world = (ClientLevel) event.getLevel();
ClientLifecycleEvent.CLIENT_LEVEL_LOAD.invoker().act(world);
ClientLifecycleEvent.CLIENT_LEVEL_LOAD.invoker(priority).act(world);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(ScreenEvent.Opening event) {
CompoundEventResult<Screen> result = ClientGuiEvent.SET_SCREEN.invoker().modifyScreen(event.getScreen());
public static void event(ScreenEvent.Opening event, EventPriority priority) {
CompoundEventResult<Screen> result = ClientGuiEvent.SET_SCREEN.invoker(priority).modifyScreen(event.getScreen());
if (result.isPresent()) {
if (result.isFalse())
event.setCanceled(true);
@@ -135,59 +171,51 @@ public class EventHandlerImplClient {
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventDrawScreenEvent(ScreenEvent.Render.Pre event) {
if (ClientGuiEvent.RENDER_PRE.invoker().render(event.getScreen(), event.getGuiGraphics(), event.getMouseX(), event.getMouseY(), event.getPartialTick()).isFalse()) {
public static void eventDrawScreenEvent(ScreenEvent.Render.Pre event, EventPriority priority) {
if (ClientGuiEvent.RENDER_PRE.invoker(priority).render(event.getScreen(), event.getGuiGraphics(), event.getMouseX(), event.getMouseY(), event.getPartialTick()).isFalse()) {
event.setCanceled(true);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventDrawScreenEvent(ScreenEvent.Render.Post event) {
ClientGuiEvent.RENDER_POST.invoker().render(event.getScreen(), event.getGuiGraphics(), event.getMouseX(), event.getMouseY(), event.getPartialTick());
public static void eventDrawScreenEvent(ScreenEvent.Render.Post event, EventPriority priority) {
ClientGuiEvent.RENDER_POST.invoker(priority).render(event.getScreen(), event.getGuiGraphics(), event.getMouseX(), event.getMouseY(), event.getPartialTick());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventContainerScreenEvent(ContainerScreenEvent.Render.Background event) {
ClientGuiEvent.RENDER_CONTAINER_BACKGROUND.invoker().render(event.getContainerScreen(), event.getGuiGraphics(), event.getMouseX(), event.getMouseY(), Minecraft.getInstance().getDeltaFrameTime());
public static void eventContainerScreenEvent(ContainerScreenEvent.Render.Background event, EventPriority priority) {
ClientGuiEvent.RENDER_CONTAINER_BACKGROUND.invoker(priority).render(event.getContainerScreen(), event.getGuiGraphics(), event.getMouseX(), event.getMouseY(), Minecraft.getInstance().getDeltaFrameTime());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventContainerScreenEvent(ContainerScreenEvent.Render.Foreground event) {
ClientGuiEvent.RENDER_CONTAINER_FOREGROUND.invoker().render(event.getContainerScreen(), event.getGuiGraphics(), event.getMouseX(), event.getMouseY(), Minecraft.getInstance().getDeltaFrameTime());
public static void eventContainerScreenEvent(ContainerScreenEvent.Render.Foreground event, EventPriority priority) {
ClientGuiEvent.RENDER_CONTAINER_FOREGROUND.invoker(priority).render(event.getContainerScreen(), event.getGuiGraphics(), event.getMouseX(), event.getMouseY(), Minecraft.getInstance().getDeltaFrameTime());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventPlayerInteractEvent(PlayerInteractEvent.RightClickEmpty event) {
InteractionEvent.CLIENT_RIGHT_CLICK_AIR.invoker().click(event.getEntity(), event.getHand());
public static void eventPlayerInteractEvent(PlayerInteractEvent.RightClickEmpty event, EventPriority priority) {
InteractionEvent.CLIENT_RIGHT_CLICK_AIR.invoker(priority).click(event.getEntity(), event.getHand());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventPlayerInteractEvent(PlayerInteractEvent.LeftClickEmpty event) {
InteractionEvent.CLIENT_LEFT_CLICK_AIR.invoker().click(event.getEntity(), event.getHand());
public static void eventPlayerInteractEvent(PlayerInteractEvent.LeftClickEmpty event, EventPriority priority) {
InteractionEvent.CLIENT_LEFT_CLICK_AIR.invoker(priority).click(event.getEntity(), event.getHand());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(RecipesUpdatedEvent event) {
ClientRecipeUpdateEvent.EVENT.invoker().update(event.getRecipeManager());
public static void event(RecipesUpdatedEvent event, EventPriority priority) {
ClientRecipeUpdateEvent.EVENT.invoker(priority).update(event.getRecipeManager());
}
private static final ThreadLocal<TooltipEventPositionContextImpl> tooltipPositionContext = ThreadLocal.withInitial(TooltipEventPositionContextImpl::new);
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventRenderTooltipEvent(RenderTooltipEvent.Pre event) {
public static void eventRenderTooltipEvent(RenderTooltipEvent.Pre event, EventPriority priority) {
GuiGraphics graphics = event.getGraphics();
ClientTooltipEvent.additionalContexts().setItem(event.getItemStack());
try {
if (ClientTooltipEvent.RENDER_PRE.invoker().renderTooltip(graphics, event.getComponents(), event.getX(), event.getY()).isFalse()) {
if (ClientTooltipEvent.RENDER_PRE.invoker(priority).renderTooltip(graphics, event.getComponents(), event.getX(), event.getY()).isFalse()) {
event.setCanceled(true);
return;
}
TooltipEventPositionContextImpl positionContext = tooltipPositionContext.get();
positionContext.reset(event.getX(), event.getY());
ClientTooltipEvent.RENDER_MODIFY_POSITION.invoker().renderTooltip(graphics, positionContext);
ClientTooltipEvent.RENDER_MODIFY_POSITION.invoker(priority).renderTooltip(graphics, positionContext);
event.setX(positionContext.getTooltipX());
event.setY(positionContext.getTooltipY());
} finally {
@@ -195,8 +223,7 @@ public class EventHandlerImplClient {
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventRenderTooltipEvent(RenderTooltipEvent.Color event) {
public static void eventRenderTooltipEvent(RenderTooltipEvent.Color event, EventPriority priority) {
GuiGraphics graphics = event.getGraphics();
ClientTooltipEvent.additionalContexts().setItem(event.getItemStack());
@@ -206,7 +233,7 @@ public class EventHandlerImplClient {
colorContext.setBackgroundColor(event.getBackgroundStart());
colorContext.setOutlineGradientTopColor(event.getBorderStart());
colorContext.setOutlineGradientBottomColor(event.getBorderEnd());
ClientTooltipEvent.RENDER_MODIFY_COLOR.invoker().renderTooltip(graphics, event.getX(), event.getY(), colorContext);
ClientTooltipEvent.RENDER_MODIFY_COLOR.invoker(priority).renderTooltip(graphics, event.getX(), event.getY(), colorContext);
event.setBackground(colorContext.getBackgroundColor());
event.setBorderEnd(colorContext.getOutlineGradientBottomColor());
event.setBorderStart(colorContext.getOutlineGradientTopColor());
@@ -215,129 +242,126 @@ public class EventHandlerImplClient {
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventMouseScrollEvent(ScreenEvent.MouseScrolled.Pre event) {
if (ClientScreenInputEvent.MOUSE_SCROLLED_PRE.invoker().mouseScrolled(Minecraft.getInstance(), event.getScreen(), event.getMouseX(), event.getMouseY(), event.getScrollDelta()).isFalse()) {
public static void eventMouseScrollEvent(ScreenEvent.MouseScrolled.Pre event, EventPriority priority) {
if (ClientScreenInputEvent.MOUSE_SCROLLED_PRE.invoker(priority).mouseScrolled(Minecraft.getInstance(), event.getScreen(), event.getMouseX(), event.getMouseY(), event.getScrollDelta()).isFalse()) {
event.setCanceled(true);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventMouseScrollEvent(ScreenEvent.MouseScrolled.Post event) {
ClientScreenInputEvent.MOUSE_SCROLLED_POST.invoker().mouseScrolled(Minecraft.getInstance(), event.getScreen(), event.getMouseX(), event.getMouseY(), event.getScrollDelta());
public static void eventMouseScrollEvent(ScreenEvent.MouseScrolled.Post event, EventPriority priority) {
ClientScreenInputEvent.MOUSE_SCROLLED_POST.invoker(priority).mouseScrolled(Minecraft.getInstance(), event.getScreen(), event.getMouseX(), event.getMouseY(), event.getScrollDelta());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventMouseClickedEvent(ScreenEvent.MouseButtonPressed.Pre event) {
if (ClientScreenInputEvent.MOUSE_CLICKED_PRE.invoker().mouseClicked(Minecraft.getInstance(), event.getScreen(), event.getMouseX(), event.getMouseY(), event.getButton()).isFalse()) {
public static void eventMouseClickedEvent(ScreenEvent.MouseButtonPressed.Pre event, EventPriority priority) {
if (ClientScreenInputEvent.MOUSE_CLICKED_PRE.invoker(priority).mouseClicked(Minecraft.getInstance(), event.getScreen(), event.getMouseX(), event.getMouseY(), event.getButton()).isFalse()) {
event.setCanceled(true);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventMouseClickedEvent(ScreenEvent.MouseButtonPressed.Post event) {
ClientScreenInputEvent.MOUSE_CLICKED_POST.invoker().mouseClicked(Minecraft.getInstance(), event.getScreen(), event.getMouseX(), event.getMouseY(), event.getButton());
public static void eventMouseClickedEvent(ScreenEvent.MouseButtonPressed.Post event, EventPriority priority) {
ClientScreenInputEvent.MOUSE_CLICKED_POST.invoker(priority).mouseClicked(Minecraft.getInstance(), event.getScreen(), event.getMouseX(), event.getMouseY(), event.getButton());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventMouseDragEvent(ScreenEvent.MouseDragged.Pre event) {
if (ClientScreenInputEvent.MOUSE_DRAGGED_PRE.invoker().mouseDragged(Minecraft.getInstance(), event.getScreen(), event.getMouseX(), event.getMouseY(), event.getMouseButton(), event.getDragX(), event.getDragY()).isFalse()) {
public static void eventMouseDragEvent(ScreenEvent.MouseDragged.Pre event, EventPriority priority) {
if (ClientScreenInputEvent.MOUSE_DRAGGED_PRE.invoker(priority).mouseDragged(Minecraft.getInstance(), event.getScreen(), event.getMouseX(), event.getMouseY(), event.getMouseButton(), event.getDragX(), event.getDragY()).isFalse()) {
event.setCanceled(true);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventMouseDragEvent(ScreenEvent.MouseDragged.Post event) {
ClientScreenInputEvent.MOUSE_DRAGGED_POST.invoker().mouseDragged(Minecraft.getInstance(), event.getScreen(), event.getMouseX(), event.getMouseY(), event.getMouseButton(), event.getDragX(), event.getDragY());
public static void eventMouseDragEvent(ScreenEvent.MouseDragged.Post event, EventPriority priority) {
ClientScreenInputEvent.MOUSE_DRAGGED_POST.invoker(priority).mouseDragged(Minecraft.getInstance(), event.getScreen(), event.getMouseX(), event.getMouseY(), event.getMouseButton(), event.getDragX(), event.getDragY());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventMouseReleasedEvent(ScreenEvent.MouseButtonReleased.Pre event) {
if (ClientScreenInputEvent.MOUSE_RELEASED_PRE.invoker().mouseReleased(Minecraft.getInstance(), event.getScreen(), event.getMouseX(), event.getMouseY(), event.getButton()).isFalse()) {
public static void eventMouseReleasedEvent(ScreenEvent.MouseButtonReleased.Pre event, EventPriority priority) {
if (ClientScreenInputEvent.MOUSE_RELEASED_PRE.invoker(priority).mouseReleased(Minecraft.getInstance(), event.getScreen(), event.getMouseX(), event.getMouseY(), event.getButton()).isFalse()) {
event.setCanceled(true);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventMouseReleasedEvent(ScreenEvent.MouseButtonReleased.Post event) {
ClientScreenInputEvent.MOUSE_RELEASED_PRE.invoker().mouseReleased(Minecraft.getInstance(), event.getScreen(), event.getMouseX(), event.getMouseY(), event.getButton());
public static void eventMouseReleasedEvent(ScreenEvent.MouseButtonReleased.Post event, EventPriority priority) {
ClientScreenInputEvent.MOUSE_RELEASED_PRE.invoker(priority).mouseReleased(Minecraft.getInstance(), event.getScreen(), event.getMouseX(), event.getMouseY(), event.getButton());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventKeyboardCharTypedEvent(ScreenEvent.CharacterTyped.Pre event) {
if (ClientScreenInputEvent.CHAR_TYPED_PRE.invoker().charTyped(Minecraft.getInstance(), event.getScreen(), event.getCodePoint(), event.getModifiers()).isFalse()) {
public static void eventKeyboardCharTypedEvent(ScreenEvent.CharacterTyped.Pre event, EventPriority priority) {
if (ClientScreenInputEvent.CHAR_TYPED_PRE.invoker(priority).charTyped(Minecraft.getInstance(), event.getScreen(), event.getCodePoint(), event.getModifiers()).isFalse()) {
event.setCanceled(true);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventKeyboardCharTypedEvent(ScreenEvent.CharacterTyped.Post event) {
ClientScreenInputEvent.CHAR_TYPED_POST.invoker().charTyped(Minecraft.getInstance(), event.getScreen(), event.getCodePoint(), event.getModifiers());
public static void eventKeyboardCharTypedEvent(ScreenEvent.CharacterTyped.Post event, EventPriority priority) {
ClientScreenInputEvent.CHAR_TYPED_POST.invoker(priority).charTyped(Minecraft.getInstance(), event.getScreen(), event.getCodePoint(), event.getModifiers());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventKeyboardKeyPressedEvent(ScreenEvent.KeyPressed.Pre event) {
if (ClientScreenInputEvent.KEY_PRESSED_PRE.invoker().keyPressed(Minecraft.getInstance(), event.getScreen(), event.getKeyCode(), event.getScanCode(), event.getModifiers()).isFalse()) {
public static void eventKeyboardKeyPressedEvent(ScreenEvent.KeyPressed.Pre event, EventPriority priority) {
if (ClientScreenInputEvent.KEY_PRESSED_PRE.invoker(priority).keyPressed(Minecraft.getInstance(), event.getScreen(), event.getKeyCode(), event.getScanCode(), event.getModifiers()).isFalse()) {
event.setCanceled(true);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventKeyboardKeyPressedEvent(ScreenEvent.KeyPressed.Post event) {
ClientScreenInputEvent.KEY_PRESSED_POST.invoker().keyPressed(Minecraft.getInstance(), event.getScreen(), event.getKeyCode(), event.getScanCode(), event.getModifiers());
public static void eventKeyboardKeyPressedEvent(ScreenEvent.KeyPressed.Post event, EventPriority priority) {
ClientScreenInputEvent.KEY_PRESSED_POST.invoker(priority).keyPressed(Minecraft.getInstance(), event.getScreen(), event.getKeyCode(), event.getScanCode(), event.getModifiers());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventKeyboardKeyReleasedEvent(ScreenEvent.KeyReleased.Pre event) {
if (ClientScreenInputEvent.KEY_RELEASED_PRE.invoker().keyReleased(Minecraft.getInstance(), event.getScreen(), event.getKeyCode(), event.getScanCode(), event.getModifiers()).isFalse()) {
public static void eventKeyboardKeyReleasedEvent(ScreenEvent.KeyReleased.Pre event, EventPriority priority) {
if (ClientScreenInputEvent.KEY_RELEASED_PRE.invoker(priority).keyReleased(Minecraft.getInstance(), event.getScreen(), event.getKeyCode(), event.getScanCode(), event.getModifiers()).isFalse()) {
event.setCanceled(true);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventKeyboardKeyReleasedEvent(ScreenEvent.KeyReleased.Post event) {
ClientScreenInputEvent.KEY_RELEASED_POST.invoker().keyReleased(Minecraft.getInstance(), event.getScreen(), event.getKeyCode(), event.getScanCode(), event.getModifiers());
public static void eventKeyboardKeyReleasedEvent(ScreenEvent.KeyReleased.Post event, EventPriority priority) {
ClientScreenInputEvent.KEY_RELEASED_POST.invoker(priority).keyReleased(Minecraft.getInstance(), event.getScreen(), event.getKeyCode(), event.getScanCode(), event.getModifiers());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventInputEvent(InputEvent.MouseScrollingEvent event) {
if (ClientRawInputEvent.MOUSE_SCROLLED.invoker().mouseScrolled(Minecraft.getInstance(), event.getScrollDelta()).isFalse()) {
public static void eventInputEvent(InputEvent.MouseScrollingEvent event, EventPriority priority) {
if (ClientRawInputEvent.MOUSE_SCROLLED.invoker(priority).mouseScrolled(Minecraft.getInstance(), event.getScrollDelta()).isFalse()) {
event.setCanceled(true);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventInputEvent(InputEvent.MouseButton.Pre event) {
if (ClientRawInputEvent.MOUSE_CLICKED_PRE.invoker().mouseClicked(Minecraft.getInstance(), event.getButton(), event.getAction(), event.getModifiers()).isFalse()) {
public static void eventInputEvent(InputEvent.MouseButton.Pre event, EventPriority priority) {
if (ClientRawInputEvent.MOUSE_CLICKED_PRE.invoker(priority).mouseClicked(Minecraft.getInstance(), event.getButton(), event.getAction(), event.getModifiers()).isFalse()) {
event.setCanceled(true);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventInputEvent(InputEvent.MouseButton.Post event) {
ClientRawInputEvent.MOUSE_CLICKED_POST.invoker().mouseClicked(Minecraft.getInstance(), event.getButton(), event.getAction(), event.getModifiers());
public static void eventInputEvent(InputEvent.MouseButton.Post event, EventPriority priority) {
ClientRawInputEvent.MOUSE_CLICKED_POST.invoker(priority).mouseClicked(Minecraft.getInstance(), event.getButton(), event.getAction(), event.getModifiers());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventInputEvent(InputEvent.Key event) {
ClientRawInputEvent.KEY_PRESSED.invoker().keyPressed(Minecraft.getInstance(), event.getKey(), event.getScanCode(), event.getAction(), event.getModifiers());
public static void eventInputEvent(InputEvent.Key event, EventPriority priority) {
ClientRawInputEvent.KEY_PRESSED.invoker(priority).keyPressed(Minecraft.getInstance(), event.getKey(), event.getScanCode(), event.getAction(), event.getModifiers());
}
private static <T extends Event> void registerWithPriority(EventPriority priority, Class<T> type, BiConsumer<T, EventPriority> callback) {
net.minecraftforge.eventbus.api.EventPriority forgePriority = net.minecraftforge.eventbus.api.EventPriority.valueOf(priority.name());
MinecraftForge.EVENT_BUS.addListener(forgePriority, false, type, event -> callback.accept(event, priority));
}
@OnlyIn(Dist.CLIENT)
public static class ModBasedEventHandler {
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventTextureStitchEvent(TextureStitchEvent.Post event) {
// ClientTextureStitchEvent.POST.invoker().stitch(event.getAtlas());
public static void init(IEventBus bus) {
for (EventPriority priority : EventPriority.VALUES) {
registerWithPriority(bus, priority, TextureStitchEvent.Post.class, ModBasedEventHandler::eventTextureStitchEvent);
registerWithPriority(bus, priority, FMLClientSetupEvent.class, ModBasedEventHandler::event);
registerWithPriority(bus, priority, RegisterShadersEvent.class, ModBasedEventHandler::event);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(FMLClientSetupEvent event) {
ClientLifecycleEvent.CLIENT_SETUP.invoker().stateChanged(Minecraft.getInstance());
public static void eventTextureStitchEvent(TextureStitchEvent.Post event, EventPriority priority) {
// ClientTextureStitchEvent.POST.invoker(priority).stitch(event.getAtlas());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(RegisterShadersEvent event) {
ClientReloadShadersEvent.EVENT.invoker().reload(event.getResourceProvider(), event::registerShader);
public static void event(FMLClientSetupEvent event, EventPriority priority) {
ClientLifecycleEvent.CLIENT_SETUP.invoker(priority).stateChanged(Minecraft.getInstance());
}
public static void event(RegisterShadersEvent event, EventPriority priority) {
ClientReloadShadersEvent.EVENT.invoker(priority).reload(event.getResourceProvider(), event::registerShader);
}
private static <T extends Event> void registerWithPriority(IEventBus bus, EventPriority priority, Class<T> type, BiConsumer<T, EventPriority> callback) {
net.minecraftforge.eventbus.api.EventPriority forgePriority = net.minecraftforge.eventbus.api.EventPriority.valueOf(priority.name());
bus.addListener(forgePriority, false, type, event -> callback.accept(event, priority));
}
}
}

316
forge/src/main/java/dev/architectury/event/forge/EventHandlerImplCommon.java
View File

@@ -20,6 +20,7 @@
package dev.architectury.event.forge;
import dev.architectury.event.CompoundEventResult;
import dev.architectury.event.EventPriority;
import dev.architectury.event.EventResult;
import dev.architectury.event.events.common.PlayerEvent;
import dev.architectury.event.events.common.*;
@@ -31,6 +32,7 @@ import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.LevelAccessor;
import net.minecraft.world.level.storage.loot.LootDataManager;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.CommandEvent;
import net.minecraftforge.event.LootTableLoadEvent;
import net.minecraftforge.event.RegisterCommandsEvent;
@@ -56,95 +58,134 @@ import net.minecraftforge.event.level.ExplosionEvent.Start;
import net.minecraftforge.event.level.LevelEvent;
import net.minecraftforge.event.server.*;
import net.minecraftforge.eventbus.api.Event;
import net.minecraftforge.eventbus.api.EventPriority;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import net.minecraftforge.eventbus.api.IEventBus;
import net.minecraftforge.fml.LogicalSide;
import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
import net.minecraftforge.server.ServerLifecycleHooks;
import java.lang.ref.WeakReference;
import java.util.function.BiConsumer;
public class EventHandlerImplCommon {
public static WeakReference<LootDataManager> lootDataManagerRef = null;
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(ServerTickEvent event) {
if (event.phase == Phase.START)
TickEvent.SERVER_PRE.invoker().tick(ServerLifecycleHooks.getCurrentServer());
else if (event.phase == Phase.END)
TickEvent.SERVER_POST.invoker().tick(ServerLifecycleHooks.getCurrentServer());
public static void init() {
for (EventPriority priority : EventPriority.VALUES) {
registerWithPriority(priority, ServerTickEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, LevelTickEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, ServerStartingEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, ServerStartedEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, ServerStoppingEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, ServerStoppedEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, RegisterCommandsEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, PlayerLoggedInEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, PlayerLoggedOutEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, PlayerRespawnEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, CommandEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, PlayerTickEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, LevelEvent.Load.class, EventHandlerImplCommon::eventWorldEvent);
registerWithPriority(priority, LevelEvent.Unload.class, EventHandlerImplCommon::eventWorldEvent);
registerWithPriority(priority, LevelEvent.Save.class, EventHandlerImplCommon::eventWorldEvent);
registerWithPriority(priority, LivingDeathEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, AdvancementEvent.AdvancementEarnEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, Clone.class, EventHandlerImplCommon::eventPlayerEvent);
registerWithPriority(priority, Start.class, EventHandlerImplCommon::eventExplosionEvent);
registerWithPriority(priority, Detonate.class, EventHandlerImplCommon::eventExplosionEvent);
registerWithPriority(priority, LivingAttackEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, EntityJoinLevelEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, FarmlandTrampleEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, FillBucketEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, MobSpawnEvent.FinalizeSpawn.class, EventHandlerImplCommon::eventLivingSpawnEvent);
registerWithPriority(priority, AnimalTameEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, ItemCraftedEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, ItemSmeltedEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, EntityItemPickupEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, ItemPickupEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, ItemTossEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, PlayerContainerEvent.Open.class, EventHandlerImplCommon::eventPlayerContainerEvent);
registerWithPriority(priority, PlayerContainerEvent.Close.class, EventHandlerImplCommon::eventPlayerContainerEvent);
registerWithPriority(priority, PlayerInteractEvent.RightClickItem.class, EventHandlerImplCommon::eventPlayerInteractEvent);
registerWithPriority(priority, PlayerInteractEvent.RightClickBlock.class, EventHandlerImplCommon::eventPlayerInteractEvent);
registerWithPriority(priority, PlayerInteractEvent.EntityInteract.class, EventHandlerImplCommon::eventPlayerInteractEvent);
registerWithPriority(priority, PlayerInteractEvent.LeftClickBlock.class, EventHandlerImplCommon::eventPlayerInteractEvent);
registerWithPriority(priority, BreakEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, EntityPlaceEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, ServerAboutToStartEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, PlayerChangedDimensionEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, ChunkDataEvent.Save.class, EventHandlerImplCommon::eventChunkDataEvent);
registerWithPriority(priority, ChunkDataEvent.Load.class, EventHandlerImplCommon::eventChunkDataEvent);
registerWithPriority(priority, LootTableLoadEvent.class, EventHandlerImplCommon::event);
registerWithPriority(priority, AttackEntityEvent.class, EventHandlerImplCommon::event);
}
registerWithPriority(EventPriority.HIGHEST, ServerChatEvent.class, (serverChatEvent, priority) -> event(serverChatEvent));
registerWithPriority(EventPriority.LOWEST, ServerChatEvent.class, (serverChatEvent, priority) -> eventAfter(serverChatEvent));
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(LevelTickEvent event) {
public static void event(ServerTickEvent event, EventPriority priority) {
if (event.phase == Phase.START)
TickEvent.SERVER_PRE.invoker(priority).tick(ServerLifecycleHooks.getCurrentServer());
else if (event.phase == Phase.END)
TickEvent.SERVER_POST.invoker(priority).tick(ServerLifecycleHooks.getCurrentServer());
}
public static void event(LevelTickEvent event, EventPriority priority) {
if (event.side == LogicalSide.SERVER) {
if (event.phase == Phase.START)
TickEvent.SERVER_LEVEL_PRE.invoker().tick((ServerLevel) event.level);
TickEvent.SERVER_LEVEL_PRE.invoker(priority).tick((ServerLevel) event.level);
else if (event.phase == Phase.END)
TickEvent.SERVER_LEVEL_POST.invoker().tick((ServerLevel) event.level);
TickEvent.SERVER_LEVEL_POST.invoker(priority).tick((ServerLevel) event.level);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(ServerStartingEvent event) {
LifecycleEvent.SERVER_STARTING.invoker().stateChanged(event.getServer());
public static void event(ServerStartingEvent event, EventPriority priority) {
LifecycleEvent.SERVER_STARTING.invoker(priority).stateChanged(event.getServer());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(ServerStartedEvent event) {
LifecycleEvent.SERVER_STARTED.invoker().stateChanged(event.getServer());
public static void event(ServerStartedEvent event, EventPriority priority) {
LifecycleEvent.SERVER_STARTED.invoker(priority).stateChanged(event.getServer());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(ServerStoppingEvent event) {
LifecycleEvent.SERVER_STOPPING.invoker().stateChanged(event.getServer());
public static void event(ServerStoppingEvent event, EventPriority priority) {
LifecycleEvent.SERVER_STOPPING.invoker(priority).stateChanged(event.getServer());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(ServerStoppedEvent event) {
LifecycleEvent.SERVER_STOPPED.invoker().stateChanged(event.getServer());
public static void event(ServerStoppedEvent event, EventPriority priority) {
LifecycleEvent.SERVER_STOPPED.invoker(priority).stateChanged(event.getServer());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(RegisterCommandsEvent event) {
CommandRegistrationEvent.EVENT.invoker().register(event.getDispatcher(), event.getBuildContext(), event.getCommandSelection());
public static void event(RegisterCommandsEvent event, EventPriority priority) {
CommandRegistrationEvent.EVENT.invoker(priority).register(event.getDispatcher(), event.getBuildContext(), event.getCommandSelection());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(PlayerLoggedInEvent event) {
PlayerEvent.PLAYER_JOIN.invoker().join((ServerPlayer) event.getEntity());
public static void event(PlayerLoggedInEvent event, EventPriority priority) {
PlayerEvent.PLAYER_JOIN.invoker(priority).join((ServerPlayer) event.getEntity());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(PlayerLoggedOutEvent event) {
PlayerEvent.PLAYER_QUIT.invoker().quit((ServerPlayer) event.getEntity());
public static void event(PlayerLoggedOutEvent event, EventPriority priority) {
PlayerEvent.PLAYER_QUIT.invoker(priority).quit((ServerPlayer) event.getEntity());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(PlayerRespawnEvent event) {
PlayerEvent.PLAYER_RESPAWN.invoker().respawn((ServerPlayer) event.getEntity(), event.isEndConquered());
public static void event(PlayerRespawnEvent event, EventPriority priority) {
PlayerEvent.PLAYER_RESPAWN.invoker(priority).respawn((ServerPlayer) event.getEntity(), event.isEndConquered());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(CommandEvent event) {
public static void event(CommandEvent event, EventPriority priority) {
CommandPerformEvent performEvent = new CommandPerformEvent(event.getParseResults(), event.getException());
if (CommandPerformEvent.EVENT.invoker().act(performEvent).isFalse()) {
if (CommandPerformEvent.EVENT.invoker(priority).act(performEvent).isFalse()) {
event.setCanceled(true);
}
event.setParseResults(performEvent.getResults());
event.setException(performEvent.getThrowable());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(PlayerTickEvent event) {
public static void event(PlayerTickEvent event, EventPriority priority) {
if (event.phase == Phase.START) {
TickEvent.PLAYER_PRE.invoker().tick(event.player);
TickEvent.PLAYER_PRE.invoker(priority).tick(event.player);
} else if (event.phase == Phase.END) {
TickEvent.PLAYER_POST.invoker().tick(event.player);
TickEvent.PLAYER_POST.invoker(priority).tick(event.player);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(ServerChatEvent event) {
class ChatComponentImpl implements ChatEvent.ChatComponent {
@Override
@@ -160,95 +201,82 @@ public class EventHandlerImplCommon {
ChatEvent.DECORATE.invoker().decorate(event.getPlayer(), new ChatComponentImpl());
}
@SubscribeEvent(priority = EventPriority.LOWEST)
public static void eventAfter(ServerChatEvent event) {
EventResult process = ChatEvent.RECEIVED.invoker().received(event.getPlayer(), event.getMessage());
if (process.isFalse())
event.setCanceled(true);
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventWorldEvent(LevelEvent.Load event) {
public static void eventWorldEvent(LevelEvent.Load event, EventPriority priority) {
if (event.getLevel() instanceof ServerLevel) {
ServerLevel world = (ServerLevel) event.getLevel();
LifecycleEvent.SERVER_LEVEL_LOAD.invoker().act(world);
LifecycleEvent.SERVER_LEVEL_LOAD.invoker(priority).act(world);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventWorldEvent(LevelEvent.Unload event) {
public static void eventWorldEvent(LevelEvent.Unload event, EventPriority priority) {
if (event.getLevel() instanceof ServerLevel) {
ServerLevel world = (ServerLevel) event.getLevel();
LifecycleEvent.SERVER_LEVEL_UNLOAD.invoker().act(world);
LifecycleEvent.SERVER_LEVEL_UNLOAD.invoker(priority).act(world);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventWorldEvent(LevelEvent.Save event) {
public static void eventWorldEvent(LevelEvent.Save event, EventPriority priority) {
if (event.getLevel() instanceof ServerLevel) {
ServerLevel world = (ServerLevel) event.getLevel();
LifecycleEvent.SERVER_LEVEL_SAVE.invoker().act(world);
LifecycleEvent.SERVER_LEVEL_SAVE.invoker(priority).act(world);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(LivingDeathEvent event) {
if (EntityEvent.LIVING_DEATH.invoker().die(event.getEntity(), event.getSource()).isFalse()) {
public static void event(LivingDeathEvent event, EventPriority priority) {
if (EntityEvent.LIVING_DEATH.invoker(priority).die(event.getEntity(), event.getSource()).isFalse()) {
event.setCanceled(true);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(AdvancementEvent.AdvancementEarnEvent event) {
public static void event(AdvancementEvent.AdvancementEarnEvent event, EventPriority priority) {
if (event.getEntity() instanceof ServerPlayer) {
PlayerEvent.PLAYER_ADVANCEMENT.invoker().award((ServerPlayer) event.getEntity(), event.getAdvancement());
PlayerEvent.PLAYER_ADVANCEMENT.invoker(priority).award((ServerPlayer) event.getEntity(), event.getAdvancement());
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventPlayerEvent(Clone event) {
public static void eventPlayerEvent(Clone event, EventPriority priority) {
if (event.getOriginal() instanceof ServerPlayer && event.getEntity() instanceof ServerPlayer) {
PlayerEvent.PLAYER_CLONE.invoker().clone((ServerPlayer) event.getOriginal(), (ServerPlayer) event.getEntity(), !event.isWasDeath());
PlayerEvent.PLAYER_CLONE.invoker(priority).clone((ServerPlayer) event.getOriginal(), (ServerPlayer) event.getEntity(), !event.isWasDeath());
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventExplosionEvent(Start event) {
if (ExplosionEvent.PRE.invoker().explode(event.getLevel(), event.getExplosion()).isFalse()) {
public static void eventExplosionEvent(Start event, EventPriority priority) {
if (ExplosionEvent.PRE.invoker(priority).explode(event.getLevel(), event.getExplosion()).isFalse()) {
event.setCanceled(true);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventExplosionEvent(Detonate event) {
ExplosionEvent.DETONATE.invoker().explode(event.getLevel(), event.getExplosion(), event.getAffectedEntities());
public static void eventExplosionEvent(Detonate event, EventPriority priority) {
ExplosionEvent.DETONATE.invoker(priority).explode(event.getLevel(), event.getExplosion(), event.getAffectedEntities());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(LivingAttackEvent event) {
if (EntityEvent.LIVING_HURT.invoker().hurt(event.getEntity(), event.getSource(), event.getAmount()).isFalse()) {
public static void event(LivingAttackEvent event, EventPriority priority) {
if (EntityEvent.LIVING_HURT.invoker(priority).hurt(event.getEntity(), event.getSource(), event.getAmount()).isFalse()) {
event.setCanceled(true);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(EntityJoinLevelEvent event) {
if (EntityEvent.ADD.invoker().add(event.getEntity(), event.getLevel()).isFalse()) {
public static void event(EntityJoinLevelEvent event, EventPriority priority) {
if (EntityEvent.ADD.invoker(priority).add(event.getEntity(), event.getLevel()).isFalse()) {
event.setCanceled(true);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(FarmlandTrampleEvent event) {
if (event.getLevel() instanceof Level && InteractionEvent.FARMLAND_TRAMPLE.invoker().trample((Level) event.getLevel(), event.getPos(), event.getState(), event.getFallDistance(), event.getEntity()).value() != null) {
public static void event(FarmlandTrampleEvent event, EventPriority priority) {
if (event.getLevel() instanceof Level && InteractionEvent.FARMLAND_TRAMPLE.invoker(priority).trample((Level) event.getLevel(), event.getPos(), event.getState(), event.getFallDistance(), event.getEntity()).value() != null) {
event.setCanceled(true);
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(FillBucketEvent event) {
public static void event(FillBucketEvent event, EventPriority priority) {
ItemStack oldItem = event.getEmptyBucket();
CompoundEventResult<ItemStack> result = PlayerEvent.FILL_BUCKET.invoker().fill(event.getEntity(), event.getLevel(), oldItem, event.getTarget());
CompoundEventResult<ItemStack> result = PlayerEvent.FILL_BUCKET.invoker(priority).fill(event.getEntity(), event.getLevel(), oldItem, event.getTarget());
if (result.interruptsFurtherEvaluation()) {
event.setCanceled(true);
event.setFilledBucket(result.object());
@@ -265,9 +293,8 @@ public class EventHandlerImplCommon {
// EntityEvent.ENTER_SECTION.invoker().enterChunk(event.getEntity(), event.getNewChunkX(), event.getNewChunkZ(), event.getOldChunkX(), event.getOldChunkZ());
// }
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventLivingSpawnEvent(MobSpawnEvent.FinalizeSpawn event) {
EventResult result = EntityEvent.LIVING_CHECK_SPAWN.invoker().canSpawn(event.getEntity(), event.getLevel(), event.getX(), event.getY(), event.getZ(), event.getSpawnType(), event.getSpawner());
public static void eventLivingSpawnEvent(MobSpawnEvent.FinalizeSpawn event, EventPriority priority) {
EventResult result = EntityEvent.LIVING_CHECK_SPAWN.invoker(priority).canSpawn(event.getEntity(), event.getLevel(), event.getX(), event.getY(), event.getZ(), event.getSpawnType(), event.getSpawner());
if (result.interruptsFurtherEvaluation()) {
if (!result.isEmpty()) {
event.setSpawnCancelled(result.value());
@@ -275,27 +302,23 @@ public class EventHandlerImplCommon {
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(AnimalTameEvent event) {
EventResult result = EntityEvent.ANIMAL_TAME.invoker().tame(event.getAnimal(), event.getTamer());
public static void event(AnimalTameEvent event, EventPriority priority) {
EventResult result = EntityEvent.ANIMAL_TAME.invoker(priority).tame(event.getAnimal(), event.getTamer());
event.setCanceled(result.isFalse());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(ItemCraftedEvent event) {
PlayerEvent.CRAFT_ITEM.invoker().craft(event.getEntity(), event.getCrafting(), event.getInventory());
public static void event(ItemCraftedEvent event, EventPriority priority) {
PlayerEvent.CRAFT_ITEM.invoker(priority).craft(event.getEntity(), event.getCrafting(), event.getInventory());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(ItemSmeltedEvent event) {
PlayerEvent.SMELT_ITEM.invoker().smelt(event.getEntity(), event.getSmelting());
public static void event(ItemSmeltedEvent event, EventPriority priority) {
PlayerEvent.SMELT_ITEM.invoker(priority).smelt(event.getEntity(), event.getSmelting());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(EntityItemPickupEvent event) {
public static void event(EntityItemPickupEvent event, EventPriority priority) {
// note: this event is weird, cancel is equivalent to denying the pickup,
// and setting the result to ALLOW will pick it up without adding it to the player's inventory
var result = PlayerEvent.PICKUP_ITEM_PRE.invoker().canPickup(event.getEntity(), event.getItem(), event.getItem().getItem());
var result = PlayerEvent.PICKUP_ITEM_PRE.invoker(priority).canPickup(event.getEntity(), event.getItem(), event.getItem().getItem());
if (result.isFalse()) {
event.setCanceled(true);
} else if (result.isTrue()) {
@@ -303,38 +326,32 @@ public class EventHandlerImplCommon {
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(ItemPickupEvent event) {
PlayerEvent.PICKUP_ITEM_POST.invoker().pickup(event.getEntity(), event.getOriginalEntity(), event.getStack());
public static void event(ItemPickupEvent event, EventPriority priority) {
PlayerEvent.PICKUP_ITEM_POST.invoker(priority).pickup(event.getEntity(), event.getOriginalEntity(), event.getStack());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(ItemTossEvent event) {
PlayerEvent.DROP_ITEM.invoker().drop(event.getPlayer(), event.getEntity());
public static void event(ItemTossEvent event, EventPriority priority) {
PlayerEvent.DROP_ITEM.invoker(priority).drop(event.getPlayer(), event.getEntity());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventPlayerContainerEvent(PlayerContainerEvent.Open event) {
PlayerEvent.OPEN_MENU.invoker().open(event.getEntity(), event.getContainer());
public static void eventPlayerContainerEvent(PlayerContainerEvent.Open event, EventPriority priority) {
PlayerEvent.OPEN_MENU.invoker(priority).open(event.getEntity(), event.getContainer());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventPlayerContainerEvent(PlayerContainerEvent.Close event) {
PlayerEvent.CLOSE_MENU.invoker().close(event.getEntity(), event.getContainer());
public static void eventPlayerContainerEvent(PlayerContainerEvent.Close event, EventPriority priority) {
PlayerEvent.CLOSE_MENU.invoker(priority).close(event.getEntity(), event.getContainer());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventPlayerInteractEvent(PlayerInteractEvent.RightClickItem event) {
CompoundEventResult<ItemStack> result = InteractionEvent.RIGHT_CLICK_ITEM.invoker().click(event.getEntity(), event.getHand());
public static void eventPlayerInteractEvent(PlayerInteractEvent.RightClickItem event, EventPriority priority) {
CompoundEventResult<ItemStack> result = InteractionEvent.RIGHT_CLICK_ITEM.invoker(priority).click(event.getEntity(), event.getHand());
if (result.isPresent()) {
event.setCanceled(true);
event.setCancellationResult(result.result().asMinecraft());
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventPlayerInteractEvent(PlayerInteractEvent.RightClickBlock event) {
EventResult result = InteractionEvent.RIGHT_CLICK_BLOCK.invoker().click(event.getEntity(), event.getHand(), event.getPos(), event.getFace());
public static void eventPlayerInteractEvent(PlayerInteractEvent.RightClickBlock event, EventPriority priority) {
EventResult result = InteractionEvent.RIGHT_CLICK_BLOCK.invoker(priority).click(event.getEntity(), event.getHand(), event.getPos(), event.getFace());
if (result.isPresent()) {
event.setCanceled(true);
event.setCancellationResult(result.asMinecraft());
@@ -343,18 +360,16 @@ public class EventHandlerImplCommon {
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventPlayerInteractEvent(PlayerInteractEvent.EntityInteract event) {
EventResult result = InteractionEvent.INTERACT_ENTITY.invoker().interact(event.getEntity(), event.getTarget(), event.getHand());
public static void eventPlayerInteractEvent(PlayerInteractEvent.EntityInteract event, EventPriority priority) {
EventResult result = InteractionEvent.INTERACT_ENTITY.invoker(priority).interact(event.getEntity(), event.getTarget(), event.getHand());
if (result.isPresent()) {
event.setCanceled(true);
event.setCancellationResult(result.asMinecraft());
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventPlayerInteractEvent(PlayerInteractEvent.LeftClickBlock event) {
EventResult result = InteractionEvent.LEFT_CLICK_BLOCK.invoker().click(event.getEntity(), event.getHand(), event.getPos(), event.getFace());
public static void eventPlayerInteractEvent(PlayerInteractEvent.LeftClickBlock event, EventPriority priority) {
EventResult result = InteractionEvent.LEFT_CLICK_BLOCK.invoker(priority).click(event.getEntity(), event.getHand(), event.getPos(), event.getFace());
if (result.isPresent()) {
event.setCanceled(true);
event.setCancellationResult(result.asMinecraft());
@@ -363,10 +378,9 @@ public class EventHandlerImplCommon {
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(BreakEvent event) {
public static void event(BreakEvent event, EventPriority priority) {
if (event.getPlayer() instanceof ServerPlayer && event.getLevel() instanceof Level) {
EventResult result = BlockEvent.BREAK.invoker().breakBlock((Level) event.getLevel(), event.getPos(), event.getState(), (ServerPlayer) event.getPlayer(), new IntValue() {
EventResult result = BlockEvent.BREAK.invoker(priority).breakBlock((Level) event.getLevel(), event.getPos(), event.getState(), (ServerPlayer) event.getPlayer(), new IntValue() {
@Override
public int getAsInt() {
return event.getExpToDrop();
@@ -383,57 +397,55 @@ public class EventHandlerImplCommon {
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(EntityPlaceEvent event) {
public static void event(EntityPlaceEvent event, EventPriority priority) {
if (event.getLevel() instanceof Level) {
EventResult result = BlockEvent.PLACE.invoker().placeBlock((Level) event.getLevel(), event.getPos(), event.getState(), event.getEntity());
EventResult result = BlockEvent.PLACE.invoker(priority).placeBlock((Level) event.getLevel(), event.getPos(), event.getState(), event.getEntity());
if (result.isFalse()) {
event.setCanceled(true);
}
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(ServerAboutToStartEvent event) {
LifecycleEvent.SERVER_BEFORE_START.invoker().stateChanged(event.getServer());
public static void event(ServerAboutToStartEvent event, EventPriority priority) {
LifecycleEvent.SERVER_BEFORE_START.invoker(priority).stateChanged(event.getServer());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(PlayerChangedDimensionEvent event) {
public static void event(PlayerChangedDimensionEvent event, EventPriority priority) {
if (event.getEntity() instanceof ServerPlayer) {
PlayerEvent.CHANGE_DIMENSION.invoker().change((ServerPlayer) event.getEntity(), event.getFrom(), event.getTo());
PlayerEvent.CHANGE_DIMENSION.invoker(priority).change((ServerPlayer) event.getEntity(), event.getFrom(), event.getTo());
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventChunkDataEvent(ChunkDataEvent.Save event) {
public static void eventChunkDataEvent(ChunkDataEvent.Save event, EventPriority priority) {
if (event.getLevel() instanceof ServerLevel) {
ChunkEvent.SAVE_DATA.invoker().save(event.getChunk(), (ServerLevel) event.getLevel(), event.getData());
ChunkEvent.SAVE_DATA.invoker(priority).save(event.getChunk(), (ServerLevel) event.getLevel(), event.getData());
}
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void eventChunkDataEvent(ChunkDataEvent.Load event) {
public static void eventChunkDataEvent(ChunkDataEvent.Load event, EventPriority priority) {
LevelAccessor level = event.getChunk().getWorldForge();
if (!(level instanceof ServerLevel) && event instanceof LevelEventAttachment) {
level = ((LevelEventAttachment) event).architectury$getAttachedLevel();
}
ChunkEvent.LOAD_DATA.invoker().load(event.getChunk(), level instanceof ServerLevel ? (ServerLevel) level : null, event.getData());
ChunkEvent.LOAD_DATA.invoker(priority).load(event.getChunk(), level instanceof ServerLevel ? (ServerLevel) level : null, event.getData());
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(LootTableLoadEvent event) {
LootEvent.MODIFY_LOOT_TABLE.invoker().modifyLootTable(lootDataManagerRef == null ? null : lootDataManagerRef.get(), event.getName(), new LootTableModificationContextImpl(event.getTable()), true);
public static void event(LootTableLoadEvent event, EventPriority priority) {
LootEvent.MODIFY_LOOT_TABLE.invoker(priority).modifyLootTable(lootDataManagerRef == null ? null : lootDataManagerRef.get(), event.getName(), new LootTableModificationContextImpl(event.getTable()), true);
}
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(AttackEntityEvent event) {
EventResult result = PlayerEvent.ATTACK_ENTITY.invoker().attack(event.getEntity(), event.getEntity().level(), event.getTarget(), event.getEntity().getUsedItemHand(), null);
public static void event(AttackEntityEvent event, EventPriority priority) {
EventResult result = PlayerEvent.ATTACK_ENTITY.invoker(priority).attack(event.getEntity(), event.getEntity().level(), event.getTarget(), event.getEntity().getUsedItemHand(), null);
if (result.isFalse()) {
event.setCanceled(true);
}
}
private static <T extends Event> void registerWithPriority(EventPriority priority, Class<T> type, BiConsumer<T, EventPriority> callback) {
net.minecraftforge.eventbus.api.EventPriority forgePriority = net.minecraftforge.eventbus.api.EventPriority.valueOf(priority.name());
MinecraftForge.EVENT_BUS.addListener(forgePriority, false, type, event -> callback.accept(event, priority));
}
public interface LevelEventAttachment {
LevelAccessor architectury$getAttachedLevel();
@@ -441,9 +453,19 @@ public class EventHandlerImplCommon {
}
public static class ModBasedEventHandler {
@SubscribeEvent(priority = EventPriority.HIGH)
public static void event(FMLCommonSetupEvent event) {
LifecycleEvent.SETUP.invoker().run();
public static void init(IEventBus bus) {
for (EventPriority priority : EventPriority.VALUES) {
registerWithPriority(bus, priority, FMLCommonSetupEvent.class, ModBasedEventHandler::event);
}
}
public static void event(FMLCommonSetupEvent event, EventPriority priority) {
LifecycleEvent.SETUP.invoker(priority).run();
}
private static <T extends Event> void registerWithPriority(IEventBus bus, EventPriority priority, Class<T> type, BiConsumer<T, EventPriority> callback) {
net.minecraftforge.eventbus.api.EventPriority forgePriority = net.minecraftforge.eventbus.api.EventPriority.valueOf(priority.name());
bus.addListener(forgePriority, false, type, event -> callback.accept(event, priority));
}
}
}

2
testmod-common/src/main/java/dev/architectury/test/TestMod.java
View File

@@ -26,6 +26,7 @@ import dev.architectury.test.debug.MessageSink;
import dev.architectury.test.debug.client.ClientOverlayMessageSink;
import dev.architectury.test.entity.TestEntity;
import dev.architectury.test.events.DebugEvents;
import dev.architectury.test.events.TestEvents;
import dev.architectury.test.gamerule.TestGameRules;
import dev.architectury.test.item.TestBlockInteractions;
import dev.architectury.test.loot.TestLoot;
@@ -49,6 +50,7 @@ public class TestMod {
public static final String MOD_ID = "architectury_test";
public static void initialize() {
TestEvents.test();
DebugEvents.initialize();
TestRegistries.initialize();
TestGameRules.init();

94
testmod-common/src/main/java/dev/architectury/test/events/TestEvents.java Normal file
View File

@@ -0,0 +1,94 @@
/*
* This file is part of architectury.
* Copyright (C) 2020, 2021, 2022 architectury
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package dev.architectury.test.events;
import com.google.common.base.Preconditions;
import dev.architectury.event.Event;
import dev.architectury.event.EventFactory;
import dev.architectury.event.EventPriority;
import dev.architectury.event.EventResult;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;
public class TestEvents {
public static void test() {
testPriority();
testOrder();
}
public static void testPriority() {
Event<Supplier<EventResult>> event = EventFactory.createEventResult();
event.register(EventPriority.HIGH, () -> {
throw new RuntimeException("This should not be ran!");
});
event.register(EventPriority.HIGHEST, () -> EventResult.interruptDefault());
Preconditions.checkArgument(event.invoker().get() == EventResult.interruptDefault());
}
public static void testOrder() {
Event<Runnable> event = EventFactory.createLoop();
Runnable runnable;
List<Integer> list = new ArrayList<>();
event.register(EventPriority.HIGH, () -> list.add(2));
event.register(() -> list.add(4));
event.register(EventPriority.LOW, () -> list.add(6));
event.register(EventPriority.HIGH, () -> list.add(3));
event.register(EventPriority.LOWEST, runnable = () -> list.add(8));
event.register(EventPriority.HIGHEST, () -> list.add(0));
event.register(() -> list.add(5));
event.register(EventPriority.LOW, () -> list.add(7));
event.register(EventPriority.LOWEST, () -> list.add(9));
event.register(EventPriority.HIGHEST, () -> list.add(1));
// Test if the order is correct, when we invoke all priorities at once
event.invoker().run();
Preconditions.checkArgument(list.equals(list.stream().sorted().toList()));
Preconditions.checkArgument(list.size() == 10);
list.clear();
// Test if the order is correct, when we invoke each priority individually
for (EventPriority value : EventPriority.VALUES) {
event.invoker(value).run();
}
Preconditions.checkArgument(list.equals(list.stream().sorted().toList()));
Preconditions.checkArgument(list.size() == 10);
// Test if unregistering works
Preconditions.checkArgument(event.isRegistered(runnable));
event.unregister(runnable);
Preconditions.checkArgument(!event.isRegistered(runnable));
// Now test if the order is correct, when we invoke all priorities at once
list.clear();
event.invoker().run();
Preconditions.checkArgument(list.equals(list.stream().sorted().toList()));
Preconditions.checkArgument(list.size() == 9);
// Test if the order is correct, when we invoke each priority individually
list.clear();
for (EventPriority value : EventPriority.VALUES) {
event.invoker(value).run();
}
Preconditions.checkArgument(list.equals(list.stream().sorted().toList()));
Preconditions.checkArgument(list.size() == 9);
}
}