From 490a2e3fdd124562ed09f048beec5178555a36a4 Mon Sep 17 00:00:00 2001 From: shedaniel Date: Fri, 21 Feb 2020 22:12:48 +0800 Subject: 4.0.4 Signed-off-by: shedaniel --- .../me/shedaniel/rei/RoughlyEnoughItemsCore.java | 85 +++++++++++++--------- .../me/shedaniel/rei/api/BaseBoundsHandler.java | 5 ++ .../java/me/shedaniel/rei/api/DisplayHelper.java | 40 +++++++++- .../java/me/shedaniel/rei/api/OverlayDecider.java | 25 +++++++ .../me/shedaniel/rei/impl/DisplayHelperImpl.java | 25 ++++--- .../me/shedaniel/rei/impl/RecipeHelperImpl.java | 20 ++++- .../me/shedaniel/rei/plugin/DefaultPlugin.java | 30 ++++++-- .../me/shedaniel/rei/utils/CollectionUtils.java | 9 +++ 8 files changed, 184 insertions(+), 55 deletions(-) create mode 100644 src/main/java/me/shedaniel/rei/api/OverlayDecider.java (limited to 'src/main/java/me/shedaniel') diff --git a/src/main/java/me/shedaniel/rei/RoughlyEnoughItemsCore.java b/src/main/java/me/shedaniel/rei/RoughlyEnoughItemsCore.java index 4a6126cad..0d19edfdb 100644 --- a/src/main/java/me/shedaniel/rei/RoughlyEnoughItemsCore.java +++ b/src/main/java/me/shedaniel/rei/RoughlyEnoughItemsCore.java @@ -52,7 +52,6 @@ import java.util.Optional; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; -import java.util.concurrent.atomic.AtomicLong; @ApiStatus.Internal public class RoughlyEnoughItemsCore implements ClientModInitializer { @@ -131,13 +130,13 @@ public class RoughlyEnoughItemsCore implements ClientModInitializer { } @ApiStatus.Internal - public static void syncRecipes(AtomicLong lastSync) { + public static void syncRecipes(long[] lastSync) { if (lastSync != null) { - if (lastSync.get() > 0 && System.currentTimeMillis() - lastSync.get() <= 5000) { + if (lastSync[0] > 0 && System.currentTimeMillis() - lastSync[0] <= 5000) { RoughlyEnoughItemsCore.LOGGER.warn("[REI] Suppressing Sync Recipes!"); return; } - lastSync.set(System.currentTimeMillis()); + lastSync[0] = System.currentTimeMillis(); } RecipeManager recipeManager = MinecraftClient.getInstance().getNetworkHandler().getRecipeManager(); if (ConfigObject.getInstance().doesRegisterRecipesInAnotherThread()) { @@ -230,9 +229,20 @@ public class RoughlyEnoughItemsCore implements ClientModInitializer { } } + private boolean shouldReturn(Class screen) { + for (OverlayDecider decider : DisplayHelper.getInstance().getAllOverlayDeciders()) { + if (!decider.isHandingScreen(screen)) + continue; + ActionResult result = decider.shouldScreenBeOverlayed(screen); + if (result != ActionResult.PASS) + return result == ActionResult.FAIL || ScreenHelper.getLastContainerScreenHooks() == null; + } + return true; + } + private void registerClothEvents() { final Identifier recipeButtonTex = new Identifier("textures/gui/recipe_button.png"); - AtomicLong lastSync = new AtomicLong(-1); + long[] lastSync = {-1}; ClothClientHooks.SYNC_RECIPES.register((minecraftClient, recipeManager, synchronizeRecipesS2CPacket) -> syncRecipes(lastSync)); ClothClientHooks.SCREEN_ADD_BUTTON.register((minecraftClient, screen, abstractButtonWidget) -> { if (ConfigObject.getInstance().doesDisableRecipeBook() && screen instanceof ContainerScreen && abstractButtonWidget instanceof TexturedButtonWidget) @@ -241,29 +251,32 @@ public class RoughlyEnoughItemsCore implements ClientModInitializer { return ActionResult.PASS; }); ClothClientHooks.SCREEN_INIT_POST.register((minecraftClient, screen, screenHooks) -> { - if (screen instanceof ContainerScreen) { - if (screen instanceof InventoryScreen && minecraftClient.interactionManager.hasCreativeInventory()) - return; + if (screen instanceof InventoryScreen && minecraftClient.interactionManager.hasCreativeInventory()) + return; + if (shouldReturn(screen.getClass())) + return; + if (screen instanceof ContainerScreen) ScreenHelper.setLastContainerScreen((ContainerScreen) screen); - boolean alreadyAdded = false; - for (Element element : Lists.newArrayList(screenHooks.cloth_getInputListeners())) - if (ContainerScreenOverlay.class.isAssignableFrom(element.getClass())) - if (alreadyAdded) - screenHooks.cloth_getInputListeners().remove(element); - else - alreadyAdded = true; - if (!alreadyAdded) - screenHooks.cloth_getInputListeners().add(ScreenHelper.getLastOverlay(true, false)); - } + boolean alreadyAdded = false; + for (Element element : Lists.newArrayList(screenHooks.cloth_getInputListeners())) + if (ContainerScreenOverlay.class.isAssignableFrom(element.getClass())) + if (alreadyAdded) + screenHooks.cloth_getInputListeners().remove(element); + else + alreadyAdded = true; + if (!alreadyAdded) + screenHooks.cloth_getInputListeners().add(ScreenHelper.getLastOverlay(true, false)); }); ClothClientHooks.SCREEN_RENDER_POST.register((minecraftClient, screen, i, i1, v) -> { - if (screen instanceof ContainerScreen) - ScreenHelper.getLastOverlay().render(i, i1, v); + if (shouldReturn(screen.getClass())) + return; + ScreenHelper.getLastOverlay().render(i, i1, v); }); ClothClientHooks.SCREEN_MOUSE_DRAGGED.register((minecraftClient, screen, v, v1, i, v2, v3) -> { - if (screen instanceof ContainerScreen) - if (ScreenHelper.isOverlayVisible() && ScreenHelper.getLastOverlay().mouseDragged(v, v1, i, v2, v3)) - return ActionResult.SUCCESS; + if (shouldReturn(screen.getClass())) + return ActionResult.PASS; + if (ScreenHelper.isOverlayVisible() && ScreenHelper.getLastOverlay().mouseDragged(v, v1, i, v2, v3)) + return ActionResult.SUCCESS; return ActionResult.PASS; }); ClothClientHooks.SCREEN_MOUSE_CLICKED.register((minecraftClient, screen, v, v1, i) -> { @@ -277,29 +290,33 @@ public class RoughlyEnoughItemsCore implements ClientModInitializer { return ActionResult.PASS; }); ClothClientHooks.SCREEN_MOUSE_SCROLLED.register((minecraftClient, screen, v, v1, v2) -> { - if (screen instanceof ContainerScreen) - if (ScreenHelper.isOverlayVisible() && ScreenHelper.getLastOverlay().mouseScrolled(v, v1, v2)) - return ActionResult.SUCCESS; + if (shouldReturn(screen.getClass())) + return ActionResult.PASS; + if (ScreenHelper.isOverlayVisible() && ScreenHelper.getLastOverlay().mouseScrolled(v, v1, v2)) + return ActionResult.SUCCESS; return ActionResult.PASS; }); ClothClientHooks.SCREEN_CHAR_TYPED.register((minecraftClient, screen, character, keyCode) -> { - if (screen instanceof ContainerScreen) - if (ScreenHelper.getLastOverlay().charTyped(character, keyCode)) - return ActionResult.SUCCESS; + if (shouldReturn(screen.getClass())) + return ActionResult.PASS; + if (ScreenHelper.getLastOverlay().charTyped(character, keyCode)) + return ActionResult.SUCCESS; return ActionResult.PASS; }); ClothClientHooks.SCREEN_LATE_RENDER.register((minecraftClient, screen, i, i1, v) -> { if (!ScreenHelper.isOverlayVisible()) return; - if (screen instanceof ContainerScreen) - ScreenHelper.getLastOverlay().lateRender(i, i1, v); + if (shouldReturn(screen.getClass())) + return; + ScreenHelper.getLastOverlay().lateRender(i, i1, v); }); ClothClientHooks.SCREEN_KEY_PRESSED.register((minecraftClient, screen, i, i1, i2) -> { if (screen.getFocused() != null && screen.getFocused() instanceof TextFieldWidget || (screen.getFocused() instanceof RecipeBookWidget && ((RecipeBookGuiHooks) screen.getFocused()).rei_getSearchField() != null && ((RecipeBookGuiHooks) screen.getFocused()).rei_getSearchField().isFocused())) return ActionResult.PASS; - if (screen instanceof ContainerScreen) - if (ScreenHelper.getLastOverlay().keyPressed(i, i1, i2)) - return ActionResult.SUCCESS; + if (shouldReturn(screen.getClass())) + return ActionResult.PASS; + if (ScreenHelper.getLastOverlay().keyPressed(i, i1, i2)) + return ActionResult.SUCCESS; if (screen instanceof ContainerScreen && ConfigObject.getInstance().doesDisableRecipeBook() && ConfigObject.getInstance().doesFixTabCloseContainer()) if (i == 258 && minecraftClient.options.keyInventory.matchesKey(i, i1)) { minecraftClient.player.closeContainer(); diff --git a/src/main/java/me/shedaniel/rei/api/BaseBoundsHandler.java b/src/main/java/me/shedaniel/rei/api/BaseBoundsHandler.java index 1bd251725..7efc6d19a 100644 --- a/src/main/java/me/shedaniel/rei/api/BaseBoundsHandler.java +++ b/src/main/java/me/shedaniel/rei/api/BaseBoundsHandler.java @@ -12,6 +12,11 @@ import java.util.List; import java.util.function.Supplier; public interface BaseBoundsHandler extends DisplayHelper.DisplayBoundsHandler { + + static BaseBoundsHandler getInstance() { + return DisplayHelper.getInstance().getBaseBoundsHandler(); + } + /** * Gets the exclusion zones by the screen class * diff --git a/src/main/java/me/shedaniel/rei/api/DisplayHelper.java b/src/main/java/me/shedaniel/rei/api/DisplayHelper.java index 2e1a174b1..a641eb372 100644 --- a/src/main/java/me/shedaniel/rei/api/DisplayHelper.java +++ b/src/main/java/me/shedaniel/rei/api/DisplayHelper.java @@ -8,7 +8,9 @@ package me.shedaniel.rei.api; import me.shedaniel.math.api.Rectangle; import me.shedaniel.rei.RoughlyEnoughItemsCore; import me.shedaniel.rei.gui.config.SearchFieldLocation; +import me.shedaniel.rei.utils.CollectionUtils; import net.minecraft.util.ActionResult; +import org.jetbrains.annotations.ApiStatus; import java.util.List; import java.util.function.Supplier; @@ -34,8 +36,20 @@ public interface DisplayHelper { * Gets all registered bounds handlers * * @return the list of registered bounds handlers + * @deprecated see {@link #getAllOverlayDeciders()} */ - List> getAllBoundsHandlers(); + @Deprecated + @ApiStatus.ScheduledForRemoval + default List> getAllBoundsHandlers() { + return (List) CollectionUtils.castAndMap(getAllOverlayDeciders(), DisplayBoundsHandler.class); + } + + /** + * Gets all registered overlay deciders + * + * @return the list of registered overlay deciders + */ + List getAllOverlayDeciders(); /** * Gets all responsible bounds handlers @@ -50,17 +64,31 @@ public interface DisplayHelper { * Registers a bounds handler * * @param handler the handler to register + * @deprecated see {@link #registerHandler(OverlayDecider)} + */ + @Deprecated + @ApiStatus.ScheduledForRemoval + default void registerBoundsHandler(DisplayBoundsHandler handler) { + registerHandler(handler); + } + + /** + * Registers a bounds decider + * + * @param decider the decider to register */ - void registerBoundsHandler(DisplayBoundsHandler handler); + void registerHandler(OverlayDecider decider); /** * Gets the base bounds handler api for exclusion zones * * @return the base bounds handler + * @see BaseBoundsHandler#getInstance() */ + @ApiStatus.Internal BaseBoundsHandler getBaseBoundsHandler(); - interface DisplayBoundsHandler { + interface DisplayBoundsHandler extends OverlayDecider { /** * Gets the base supported class for the bounds handler * @@ -68,6 +96,11 @@ public interface DisplayHelper { */ Class getBaseSupportedClass(); + @Override + default boolean isHandingScreen(Class screen) { + return getBaseSupportedClass().isAssignableFrom(screen); + } + /** * Gets the left bounds of the overlay * @@ -140,6 +173,7 @@ public interface DisplayHelper { * * @return the priority in float */ + @Override default float getPriority() { return 0f; } diff --git a/src/main/java/me/shedaniel/rei/api/OverlayDecider.java b/src/main/java/me/shedaniel/rei/api/OverlayDecider.java new file mode 100644 index 000000000..4f6120e2a --- /dev/null +++ b/src/main/java/me/shedaniel/rei/api/OverlayDecider.java @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2018, 2019, 2020 shedaniel + * Licensed under the MIT License (the "License"). + */ + +package me.shedaniel.rei.api; + +import net.minecraft.util.ActionResult; + +public interface OverlayDecider { + boolean isHandingScreen(Class screen); + + default ActionResult shouldScreenBeOverlayed(Class screen) { + return ActionResult.PASS; + } + + /** + * Gets the priority of the handler, the higher it is, the earlier it is called. + * + * @return the priority in float + */ + default float getPriority() { + return 0f; + } +} diff --git a/src/main/java/me/shedaniel/rei/impl/DisplayHelperImpl.java b/src/main/java/me/shedaniel/rei/impl/DisplayHelperImpl.java index 77fa4fe80..fd73aa6bd 100644 --- a/src/main/java/me/shedaniel/rei/impl/DisplayHelperImpl.java +++ b/src/main/java/me/shedaniel/rei/impl/DisplayHelperImpl.java @@ -10,8 +10,11 @@ import com.google.common.collect.Maps; import me.shedaniel.math.api.Rectangle; import me.shedaniel.rei.api.BaseBoundsHandler; import me.shedaniel.rei.api.DisplayHelper; +import me.shedaniel.rei.api.OverlayDecider; +import me.shedaniel.rei.utils.CollectionUtils; import org.jetbrains.annotations.ApiStatus; +import java.util.Collections; import java.util.Comparator; import java.util.List; import java.util.Map; @@ -20,7 +23,7 @@ import java.util.stream.Collectors; @ApiStatus.Internal public class DisplayHelperImpl implements DisplayHelper { - private static final Comparator> BOUNDS_HANDLER_COMPARATOR; + private static final Comparator BOUNDS_HANDLER_COMPARATOR; private static final DisplayBoundsHandler EMPTY = new DisplayBoundsHandler() { @Override public Class getBaseSupportedClass() { @@ -44,29 +47,30 @@ public class DisplayHelperImpl implements DisplayHelper { }; static { - Comparator> comparator = Comparator.comparingDouble(DisplayBoundsHandler::getPriority); + Comparator comparator = Comparator.comparingDouble(OverlayDecider::getPriority); BOUNDS_HANDLER_COMPARATOR = comparator.reversed(); } - private List> screenDisplayBoundsHandlers = Lists.newArrayList(); + private List screenDisplayBoundsHandlers = Lists.newArrayList(); private Map, DisplayBoundsHandler> handlerCache = Maps.newHashMap(); private Map, List>> handlerSortedCache = Maps.newHashMap(); private BaseBoundsHandler baseBoundsHandler; private Class tempScreen; + @SuppressWarnings("rawtypes") @Override public List> getSortedBoundsHandlers(Class screenClass) { List> possibleCached = handlerSortedCache.get(screenClass); if (possibleCached != null) return possibleCached; tempScreen = screenClass; - handlerSortedCache.put(screenClass, screenDisplayBoundsHandlers.stream().filter(this::filterResponsible).sorted(BOUNDS_HANDLER_COMPARATOR).collect(Collectors.toList())); + handlerSortedCache.put(screenClass, (List) CollectionUtils.castAndMap(CollectionUtils.filter(screenDisplayBoundsHandlers, this::filterResponsible), DisplayBoundsHandler.class)); return handlerSortedCache.get(screenClass); } @Override - public List> getAllBoundsHandlers() { - return screenDisplayBoundsHandlers; + public List getAllOverlayDeciders() { + return Collections.unmodifiableList(screenDisplayBoundsHandlers); } @Override @@ -79,13 +83,14 @@ public class DisplayHelperImpl implements DisplayHelper { return handlerCache.get(screenClass); } - private boolean filterResponsible(DisplayBoundsHandler handler) { - return handler.getBaseSupportedClass().isAssignableFrom(tempScreen); + private boolean filterResponsible(OverlayDecider handler) { + return handler.isHandingScreen(tempScreen); } @Override - public void registerBoundsHandler(DisplayBoundsHandler handler) { - screenDisplayBoundsHandlers.add(handler); + public void registerHandler(OverlayDecider decider) { + screenDisplayBoundsHandlers.add(decider); + screenDisplayBoundsHandlers.sort(BOUNDS_HANDLER_COMPARATOR); } @Override diff --git a/src/main/java/me/shedaniel/rei/impl/RecipeHelperImpl.java b/src/main/java/me/shedaniel/rei/impl/RecipeHelperImpl.java index d559c1157..a1074b836 100644 --- a/src/main/java/me/shedaniel/rei/impl/RecipeHelperImpl.java +++ b/src/main/java/me/shedaniel/rei/impl/RecipeHelperImpl.java @@ -264,7 +264,7 @@ public class RecipeHelperImpl implements RecipeHelper { ((DisplayHelperImpl) DisplayHelper.getInstance()).resetData(); ((DisplayHelperImpl) DisplayHelper.getInstance()).resetCache(); BaseBoundsHandler baseBoundsHandler = new BaseBoundsHandlerImpl(); - DisplayHelper.getInstance().registerBoundsHandler(baseBoundsHandler); + DisplayHelper.getInstance().registerHandler(baseBoundsHandler); ((DisplayHelperImpl) DisplayHelper.getInstance()).setBaseBoundsHandler(baseBoundsHandler); List plugins = RoughlyEnoughItemsCore.getPlugins(); plugins.sort(Comparator.comparingInt(REIPluginEntry::getPriority).reversed()); @@ -328,6 +328,22 @@ public class RecipeHelperImpl implements RecipeHelper { return -1f; } }); + DisplayHelper.getInstance().registerHandler(new OverlayDecider() { + @Override + public boolean isHandingScreen(Class screen) { + return true; + } + + @Override + public ActionResult shouldScreenBeOverlayed(Class screen) { + return ContainerScreen.class.isAssignableFrom(screen) ? ActionResult.SUCCESS : ActionResult.PASS; + } + + @Override + public float getPriority() { + return -10; + } + }); // Clear Cache ((DisplayHelperImpl) DisplayHelper.getInstance()).resetCache(); @@ -344,7 +360,7 @@ public class RecipeHelperImpl implements RecipeHelper { displayVisibilityHandlers.sort(VISIBILITY_HANDLER_COMPARATOR); long usedTime = System.currentTimeMillis() - startTime; - RoughlyEnoughItemsCore.LOGGER.info("[REI] Registered %d stack entries, %d recipes displays, %d exclusion zones suppliers, %d bounds handler, %d visibility handlers and %d categories (%s) in %d ms.", EntryRegistry.getInstance().getStacksList().size(), recipeCount[0], DisplayHelper.getInstance().getBaseBoundsHandler().supplierSize(), DisplayHelper.getInstance().getAllBoundsHandlers().size(), getDisplayVisibilityHandlers().size(), categories.size(), categories.keySet().stream().map(RecipeCategory::getCategoryName).collect(Collectors.joining(", ")), usedTime); + RoughlyEnoughItemsCore.LOGGER.info("[REI] Registered %d stack entries, %d recipes displays, %d exclusion zones suppliers, %d overlay decider, %d visibility handlers and %d categories (%s) in %d ms.", EntryRegistry.getInstance().getStacksList().size(), recipeCount[0], BaseBoundsHandler.getInstance().supplierSize(), DisplayHelper.getInstance().getAllOverlayDeciders().size(), getDisplayVisibilityHandlers().size(), categories.size(), categories.keySet().stream().map(RecipeCategory::getCategoryName).collect(Collectors.joining(", ")), usedTime); } @Override diff --git a/src/main/java/me/shedaniel/rei/plugin/DefaultPlugin.java b/src/main/java/me/shedaniel/rei/plugin/DefaultPlugin.java index 111e391e4..027b6bcf6 100644 --- a/src/main/java/me/shedaniel/rei/plugin/DefaultPlugin.java +++ b/src/main/java/me/shedaniel/rei/plugin/DefaultPlugin.java @@ -57,6 +57,7 @@ import net.minecraft.item.*; import net.minecraft.potion.PotionUtil; import net.minecraft.recipe.*; import net.minecraft.tag.BlockTags; +import net.minecraft.util.ActionResult; import net.minecraft.util.Identifier; import net.minecraft.util.math.MathHelper; import net.minecraft.util.registry.Registry; @@ -267,15 +268,32 @@ public class DefaultPlugin implements REIPluginV0 { if (!ConfigObject.getInstance().isLoadingDefaultPlugin()) { return; } - displayHelper.getBaseBoundsHandler().registerExclusionZones(AbstractInventoryScreen.class, new DefaultPotionEffectExclusionZones()); - displayHelper.getBaseBoundsHandler().registerExclusionZones(RecipeBookProvider.class, new DefaultRecipeBookExclusionZones()); - displayHelper.getBaseBoundsHandler().registerExclusionZones(RecipeViewingScreen.class, () -> { + BaseBoundsHandler baseBoundsHandler = BaseBoundsHandler.getInstance(); + baseBoundsHandler.registerExclusionZones(AbstractInventoryScreen.class, new DefaultPotionEffectExclusionZones()); + baseBoundsHandler.registerExclusionZones(RecipeBookProvider.class, new DefaultRecipeBookExclusionZones()); + baseBoundsHandler.registerExclusionZones(RecipeViewingScreen.class, () -> { CategoryBaseWidget widget = ((RecipeViewingScreen) MinecraftClient.getInstance().currentScreen).getWorkingStationsBaseWidget(); if (widget == null) return Collections.emptyList(); return Collections.singletonList(widget.getBounds().clone()); }); - displayHelper.registerBoundsHandler(new DisplayHelper.DisplayBoundsHandler>() { + displayHelper.registerHandler(new OverlayDecider() { + @Override + public boolean isHandingScreen(Class screen) { + return InventoryScreen.class.isAssignableFrom(screen); + } + + @Override + public ActionResult shouldScreenBeOverlayed(Class screen) { + return isHandingScreen(screen) ? ActionResult.FAIL : ActionResult.PASS; + } + + @Override + public float getPriority() { + return 10f; + } + }); + displayHelper.registerHandler(new DisplayHelper.DisplayBoundsHandler>() { @Override public Class getBaseSupportedClass() { return ContainerScreen.class; @@ -297,7 +315,7 @@ public class DefaultPlugin implements REIPluginV0 { return -1.0f; } }); - displayHelper.registerBoundsHandler(new DisplayHelper.DisplayBoundsHandler() { + displayHelper.registerHandler(new DisplayHelper.DisplayBoundsHandler() { @Override public Class getBaseSupportedClass() { return RecipeViewingScreen.class; @@ -319,7 +337,7 @@ public class DefaultPlugin implements REIPluginV0 { return -1.0f; } }); - displayHelper.registerBoundsHandler(new DisplayHelper.DisplayBoundsHandler() { + displayHelper.registerHandler(new DisplayHelper.DisplayBoundsHandler() { @Override public Class getBaseSupportedClass() { return VillagerRecipeViewingScreen.class; diff --git a/src/main/java/me/shedaniel/rei/utils/CollectionUtils.java b/src/main/java/me/shedaniel/rei/utils/CollectionUtils.java index 95d730f64..d364708de 100644 --- a/src/main/java/me/shedaniel/rei/utils/CollectionUtils.java +++ b/src/main/java/me/shedaniel/rei/utils/CollectionUtils.java @@ -32,6 +32,15 @@ public class CollectionUtils { return null; } + public static List castAndMap(List list, Class castClass) { + List l = new ArrayList<>(); + for (T t : list) { + if (castClass.isAssignableFrom(t.getClass())) + l.add((R) t); + } + return l; + } + public static T findFirstOrNull(List list, Predicate predicate) { for (T t : list) { if (predicate.test(t)) -- cgit