+ * We just create a terminal which is used to forward all the key presses and mouse clicks but we don't render it. + */ +public class KeyboardScreen extends Screen implements MenuAccess { + + protected final KeyboardContainer keyboardContainer; + protected final InputHandler input; + private final Terminal terminalData; + private WidgetTerminal terminal; + private MouseState mouseState = MouseState.RELEASED; + private boolean captureMouse; + private boolean regrabingMouse; + private final byte[] lastPosLock = new byte[0]; + private double lastX = 0; + private double lastY = 0; + private double lastScroll = 0; + + public KeyboardScreen(KeyboardContainer keyboardContainer, Inventory inv, Component titleIn) { + super(titleIn); + this.keyboardContainer = keyboardContainer; + this.input = new ClientInputHandler(keyboardContainer); + this.terminalData = new Terminal(0, 0, false); + } + + @Override + public KeyboardContainer getMenu() { + return this.keyboardContainer; + } + + @Override + public void render(@NotNull PoseStack poseStack, int x, int y, float partialTicks) { + super.render(poseStack, x, y, partialTicks); + + Minecraft minecraft = Minecraft.getInstance(); + float scale = 2f; + int screenWidth = minecraft.getWindow().getGuiScaledWidth(); + // Make the text a bit smaller on small screens + if (screenWidth <= 1080) + scale = 1f; + + poseStack.scale(scale, scale, 1); + Component text = Component.translatable("text.advancedperipherals.keyboard.close"); + float textX = (screenWidth / 2f - minecraft.font.width(text) * scale / 2f) / scale; + minecraft.font.drawShadow(poseStack, text, textX, 1, 0xFFFFFF); + } + + @Override + protected void init() { + if (this.isCapturingMouse()) { + this.grabMouse(); + } else { + this.grabMouseWithControl(); + } + this.passEvents = true; + KeyMapping.releaseAll(); + + super.init(); + this.minecraft.keyboardHandler.setSendRepeatsToGui(true); + + this.terminal = addWidget(new WidgetTerminal(terminalData, new ClientInputHandler(this.keyboardContainer), 0, 0)); + this.terminal.visible = false; + this.terminal.active = false; + setFocused(this.terminal); + } + + @Override + public final void removed() { + if (this.regrabingMouse) { + return; + } + super.removed(); + if (this.minecraft.player != null) { + this.keyboardContainer.removed(this.minecraft.player); + } + this.minecraft.keyboardHandler.setSendRepeatsToGui(false); + } + + @Override + public void onClose() { + // Don't allow closing using standard keys like E. Closing using ESCAPE is still possible due to the keyPressed method + } + + @Override + public boolean isPauseScreen() { + return false; + } + + @Override + public void mouseMoved(double x, double y) { + if (this.mouseState != MouseState.CAPTURE) { + return; + } + ClientWorker.put("mouse_move", () -> { + synchronized (this.lastPosLock) { + double dx = x - this.lastX; + double dy = y - this.lastY; + APNetworking.sendToServer(new KeyboardMouseMovePacket(dx, dy)); + this.lastX = x; + this.lastY = y; + } + }); + } + + @Override + public boolean mouseClicked(double x, double y, int button) { + if (this.mouseState != MouseState.CAPTURE) { + return false; + } + APNetworking.sendToServer(new KeyboardMouseClickPacket(button, false)); + return true; + } + + @Override + public boolean mouseReleased(double x, double y, int button) { + if (this.mouseState != MouseState.CAPTURE) { + return false; + } + APNetworking.sendToServer(new KeyboardMouseClickPacket(button, true)); + return true; + } + + @Override + public boolean mouseScrolled(double x, double y, double direction) { + this.lastScroll += direction; + int scrolled = (int) this.lastScroll; + if (scrolled == 0) { + return true; + } + if (this.mouseState == MouseState.CAPTURE) { + ClientWorker.put("mouse_scroll", () -> { + if (this.mouseState != MouseState.CAPTURE) { + return; + } + this.lastScroll -= scrolled; + APNetworking.sendToServer(new KeyboardMouseScrollPacket(scrolled)); + }); + } else { + this.lastScroll -= scrolled; + minecraft.player.getInventory().swapPaint(scrolled); + } + return true; + } + + @Override + public final boolean keyPressed(int key, int scancode, int modifiers) { + if (key == GLFW.GLFW_KEY_ESCAPE) { + if (this.minecraft.player != null) { + this.minecraft.player.closeContainer(); + } else { + super.onClose(); + } + return true; + } + // Forward the tab key to the terminal, rather than moving between controls. + if (key == GLFW.GLFW_KEY_TAB && getFocused() != null && getFocused() == terminal) { + return getFocused().keyPressed(key, scancode, modifiers); + } + + return super.keyPressed(key, scancode, modifiers); + } + + public boolean isCapturingMouse() { + return this.captureMouse; + } + + public void setCaptureMouse(boolean enable) { + this.captureMouse = enable; + if (enable) { + this.grabMouse(); + } else { + this.grabMouseWithControl(); + } + } + + private void grabMouseWithControl() { + if (this.mouseState == MouseState.NORMAL) { + return; + } + this.releaseMouse(); + this.regrabingMouse = true; + this.minecraft.mouseHandler.grabMouse(); + this.regrabingMouse = false; + this.minecraft.screen = this; + this.mouseState = MouseState.NORMAL; + } + + private void grabMouse() { + if (this.minecraft.mouseHandler.isMouseGrabbed()) { + this.minecraft.mouseHandler.releaseMouse(); + } + Window window = this.minecraft.getWindow(); + synchronized (this.lastPosLock) { + this.lastX = window.getScreenWidth() / 2; + this.lastY = window.getScreenHeight() / 2; + InputConstants.grabOrReleaseMouse(window.getWindow(), InputConstants.CURSOR_DISABLED, this.lastX, this.lastY); + } + this.mouseState = MouseState.CAPTURE; + } + + private void releaseMouse() { + if (this.mouseState == MouseState.RELEASED) { + return; + } + if (this.minecraft.mouseHandler.isMouseGrabbed()) { + this.minecraft.mouseHandler.releaseMouse(); + return; + } + Window window = this.minecraft.getWindow(); + synchronized (this.lastPosLock) { + this.lastX = window.getScreenWidth() / 2; + this.lastY = window.getScreenHeight() / 2; + InputConstants.grabOrReleaseMouse(window.getWindow(), InputConstants.CURSOR_NORMAL, this.lastX, this.lastY); + } + this.mouseState = MouseState.RELEASED; + } + + private enum MouseState { + RELEASED, NORMAL, CAPTURE + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/client/screens/SaddleTurtleOverlay.java b/src/main/java/de/srendi/advancedperipherals/client/screens/SaddleTurtleOverlay.java new file mode 100644 index 000000000..60bb4cccf --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/client/screens/SaddleTurtleOverlay.java @@ -0,0 +1,156 @@ +package de.srendi.advancedperipherals.client.screens; + +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.vertex.PoseStack; +import de.srendi.advancedperipherals.common.entity.TurtleSeatEntity; +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.Font; +import net.minecraft.client.gui.GuiComponent; +import net.minecraft.client.player.LocalPlayer; +import net.minecraft.network.chat.Component; +import net.minecraft.network.chat.FormattedText; +import net.minecraft.util.FormattedCharSequence; +import net.minecraftforge.client.gui.overlay.ForgeGui; +import net.minecraftforge.client.gui.overlay.IGuiOverlay; + +public class SaddleTurtleOverlay extends GuiComponent implements IGuiOverlay { + public static final String ID = "saddle_turtle_overlay"; + + private static final long ACTIVE_TIMEOUT = 5000; + + private ForgeGui gui; + private int screenWidth = 0; + private int screenHeight = 0; + + private int fuelLevel = 0; + private int fuelLimit = 0; + private int barColor = 0; + private long lastActived = 0; + + public SaddleTurtleOverlay() {} + + protected Font getFont() { + return this.gui.getMinecraft().font; + } + + protected int textWidth(String text) { + return getFont().width(text); + } + + protected int textWidth(FormattedText text) { + return getFont().width(text); + } + + protected int textWidth(FormattedCharSequence text) { + return getFont().width(text); + } + + public boolean isPlayerControllingTurtle() { + LocalPlayer player = Minecraft.getInstance().player; + return player != null && player.getVehicle() instanceof TurtleSeatEntity; + } + + public boolean isPlayerMountedOnTurtle() { + LocalPlayer player = Minecraft.getInstance().player; + return player != null && player.getRootVehicle() instanceof TurtleSeatEntity; + } + + public boolean shouldRenderFuelBar() { + if (this.lastActived == 0) { + return false; + } + if (!this.isPlayerMountedOnTurtle()) { + this.hide(); + return false; + } + return this.lastActived + ACTIVE_TIMEOUT > System.currentTimeMillis(); + } + + public void hide() { + this.fuelLevel = 0; + this.fuelLimit = 0; + this.barColor = 0; + this.lastActived = 0; + } + + public void keepAlive() { + this.lastActived = System.currentTimeMillis(); + } + + public void setFuelLevel(int level) { + if (level < 0) { + level = 0; + } + if (this.fuelLevel != level) { + this.fuelLevel = level; + this.keepAlive(); + } + } + + public void setFuelLimit(int limit) { + if (this.fuelLimit != limit) { + this.fuelLimit = limit; + this.keepAlive(); + } + } + + public void setBarColor(int color) { + if (this.barColor != color) { + this.barColor = color; + this.keepAlive(); + } + } + + private void renderFuelBar(PoseStack stack) { + // TODO: use a better looking bar here, and/or find someway to change the bar's color + RenderSystem.setShaderTexture(0, GuiComponent.GUI_ICONS_LOCATION); + int fontColor = 0x80ff20; + + int width = 182; + int left = this.screenWidth / 2 - 91; + int top = this.screenHeight - 32 + 3; + this.blit(stack, left, top, 0, 64, width, 5); + if (fuelLevel > 0 && fuelLimit > 0) { + int progWidth = fuelLevel * width / fuelLimit; + this.blit(stack, left, top, 0, 69, progWidth, 5); + } + + String text = fuelLimit > 0 ? String.format("%d / %d", fuelLevel, fuelLimit) : "Infinity"; + int x = (this.screenWidth - getFont().width(text)) / 2; + int y = this.screenHeight - 31; + getFont().draw(stack, text, (float)(x + 1), (float) y, 0); + getFont().draw(stack, text, (float)(x - 1), (float) y, 0); + getFont().draw(stack, text, (float) x, (float)(y + 1), 0); + getFont().draw(stack, text, (float) x, (float)(y - 1), 0); + getFont().draw(stack, text, (float) x, (float) y, fontColor); + } + + private void renderDismountHint(PoseStack stack) { + Minecraft minecraft = Minecraft.getInstance(); + Component name = Component.translatable("block.computercraft.turtle_normal.upgraded", Component.translatable("turtle.advancedperipherals.saddle_turtle")); + // TODO: get and render turtle's label if exists + Component text = Component.translatable("text.advancedperipherals.saddle_turtle.dismount_hint", + name, minecraft.options.keyShift.getTranslatedKeyMessage(), minecraft.options.keyInventory.getTranslatedKeyMessage()); + float top = 10; + float x = (float)(this.screenWidth / 2 - textWidth(text) / 2); + getFont().drawShadow(stack, text, x, top, 0xffffff); + } + + @Override + public void render(ForgeGui gui, PoseStack poseStack, float partialTick, int screenWidth, int screenHeight) { + if (!this.isPlayerMountedOnTurtle()) { + return; + } + + this.gui = gui; + this.screenWidth = screenWidth; + this.screenHeight = screenHeight; + + if (this.shouldRenderFuelBar()) { + this.renderFuelBar(poseStack); + } + if (this.isPlayerControllingTurtle()) { + this.renderDismountHint(poseStack); + } + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/client/screens/SmartGlassesScreen.java b/src/main/java/de/srendi/advancedperipherals/client/screens/SmartGlassesScreen.java new file mode 100644 index 000000000..c81884b59 --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/client/screens/SmartGlassesScreen.java @@ -0,0 +1,78 @@ +package de.srendi.advancedperipherals.client.screens; + +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.vertex.PoseStack; +import dan200.computercraft.client.gui.ComputerScreenBase; +import dan200.computercraft.client.gui.widgets.ComputerSidebar; +import dan200.computercraft.client.gui.widgets.WidgetTerminal; +import dan200.computercraft.shared.turtle.inventory.ContainerTurtle; +import de.srendi.advancedperipherals.AdvancedPeripherals; +import de.srendi.advancedperipherals.client.widgets.SmartGlassesSettingsSwitch; +import de.srendi.advancedperipherals.common.container.SmartGlassesContainer; +import de.srendi.advancedperipherals.common.smartglasses.SlotType; +import net.minecraft.network.chat.Component; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.util.FormattedCharSequence; +import net.minecraft.world.entity.player.Inventory; +import org.jetbrains.annotations.NotNull; + +public class SmartGlassesScreen extends ComputerScreenBase { + + private static final ResourceLocation BACKGROUND = new ResourceLocation(AdvancedPeripherals.MOD_ID, "textures/gui/smart_glasses_gui.png"); + public static final ResourceLocation SIDEBAR = new ResourceLocation(AdvancedPeripherals.MOD_ID, "textures/gui/corners_glasses.png"); + + private static final int TEX_WIDTH = 254; + private static final int TEX_HEIGHT = 217; + private SlotType currentType = SlotType.defaultType(); + + public SmartGlassesScreen(SmartGlassesContainer container, Inventory player, Component title) { + super(container, player, title, ContainerTurtle.BORDER); + + imageWidth = TEX_WIDTH + ComputerSidebar.WIDTH; + imageHeight = TEX_HEIGHT; + } + + @Override + protected void init() { + super.init(); + addRenderableWidget(new SmartGlassesSettingsSwitch(254, 147, SlotType.PERIPHERALS, this)); + addRenderableWidget(new SmartGlassesSettingsSwitch(254, 170, SlotType.MODULES, this)); + } + + @Override + protected WidgetTerminal createTerminal() { + return new WidgetTerminal(terminalData, input, leftPos + ContainerTurtle.BORDER + ComputerSidebar.WIDTH, topPos + ContainerTurtle.BORDER); + } + + @Override + protected void renderBg(@NotNull PoseStack transform, float partialTicks, int mouseX, int mouseY) { + RenderSystem.setShaderTexture(0, BACKGROUND); + blit(transform, leftPos + ComputerSidebar.WIDTH, topPos, 0, 0, TEX_WIDTH, TEX_HEIGHT); + + if (currentType == SlotType.PERIPHERALS) + blit(transform, leftPos + ComputerSidebar.WIDTH + 222, topPos + 183, 186, 183, 18, 18); + + RenderSystem.setShaderTexture(0, SIDEBAR); + ComputerSidebar.renderBackground(transform, leftPos, topPos + sidebarYOffset); + } + + @Override + protected void renderTooltip(@NotNull PoseStack poseStack, int x, int y) { + super.renderTooltip(poseStack, x, y); + renderables.forEach(renderable -> { + if (renderable instanceof SmartGlassesSettingsSwitch smartGlassesSettingsSwitch) { + smartGlassesSettingsSwitch.renderTooltip(poseStack, x, y); + } + }); + } + + @Override + protected void renderLabels(@NotNull PoseStack poseStack, int x, int y) { + FormattedCharSequence formattedcharsequence = currentType.getName().getVisualOrderText(); + this.font.draw(poseStack, formattedcharsequence, (212 + ComputerSidebar.WIDTH - (float) this.font.width(formattedcharsequence) / 2), 133, 4210752); + } + + public void setCurrentType(SlotType currentType) { + this.currentType = currentType; + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/common/container/base/BaseItemScreen.java b/src/main/java/de/srendi/advancedperipherals/client/screens/base/BaseItemScreen.java similarity index 73% rename from src/main/java/de/srendi/advancedperipherals/common/container/base/BaseItemScreen.java rename to src/main/java/de/srendi/advancedperipherals/client/screens/base/BaseItemScreen.java index 527878f10..a7e7e9476 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/container/base/BaseItemScreen.java +++ b/src/main/java/de/srendi/advancedperipherals/client/screens/base/BaseItemScreen.java @@ -1,16 +1,18 @@ -package de.srendi.advancedperipherals.common.container.base; +package de.srendi.advancedperipherals.client.screens.base; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.PoseStack; +import de.srendi.advancedperipherals.common.container.base.BaseItemContainer; import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen; import net.minecraft.client.renderer.GameRenderer; import net.minecraft.network.chat.Component; import net.minecraft.resources.ResourceLocation; import net.minecraft.world.entity.player.Inventory; +import org.jetbrains.annotations.NotNull; public abstract class BaseItemScreen extends AbstractContainerScreen { - public BaseItemScreen(T screenContainer, Inventory inv, Component titleIn) { + protected BaseItemScreen(T screenContainer, Inventory inv, Component titleIn) { super(screenContainer, inv, titleIn); imageWidth = getSizeX(); @@ -18,14 +20,14 @@ public BaseItemScreen(T screenContainer, Inventory inv, Component titleIn) { } @Override - public void render(PoseStack matrixStack, int x, int y, float partialTicks) { + public void render(@NotNull PoseStack matrixStack, int x, int y, float partialTicks) { renderBackground(matrixStack); super.render(matrixStack, x, y, partialTicks); renderTooltip(matrixStack, x, y); } @Override - protected void renderBg(PoseStack matrixStack, float partialTicks, int x, int y) { + protected void renderBg(@NotNull PoseStack matrixStack, float partialTicks, int x, int y) { RenderSystem.setShader(GameRenderer::getPositionTexShader); RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1.0F); RenderSystem.setShaderTexture(0, getTexture()); diff --git a/src/main/java/de/srendi/advancedperipherals/common/container/base/BaseScreen.java b/src/main/java/de/srendi/advancedperipherals/client/screens/base/BaseScreen.java similarity index 86% rename from src/main/java/de/srendi/advancedperipherals/common/container/base/BaseScreen.java rename to src/main/java/de/srendi/advancedperipherals/client/screens/base/BaseScreen.java index f9311435e..9390fa902 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/container/base/BaseScreen.java +++ b/src/main/java/de/srendi/advancedperipherals/client/screens/base/BaseScreen.java @@ -1,7 +1,8 @@ -package de.srendi.advancedperipherals.common.container.base; +package de.srendi.advancedperipherals.client.screens.base; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.PoseStack; +import de.srendi.advancedperipherals.common.container.base.BaseContainer; import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen; import net.minecraft.client.renderer.GameRenderer; import net.minecraft.network.chat.Component; @@ -11,7 +12,7 @@ public abstract class BaseScreen extends AbstractContainerScreen { - public BaseScreen(T screenContainer, Inventory inv, Component titleIn) { + protected BaseScreen(T screenContainer, Inventory inv, Component titleIn) { super(screenContainer, inv, titleIn); imageWidth = getSizeX(); imageHeight = getSizeY(); diff --git a/src/main/java/de/srendi/advancedperipherals/client/smartglasses/OverlayModuleLevelRenderer.java b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/OverlayModuleLevelRenderer.java new file mode 100644 index 000000000..1a8aa23c2 --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/OverlayModuleLevelRenderer.java @@ -0,0 +1,115 @@ +package de.srendi.advancedperipherals.client.smartglasses; + +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.vertex.BufferBuilder; +import com.mojang.blaze3d.vertex.BufferUploader; +import com.mojang.blaze3d.vertex.DefaultVertexFormat; +import com.mojang.blaze3d.vertex.PoseStack; +import com.mojang.blaze3d.vertex.Tesselator; +import com.mojang.blaze3d.vertex.VertexConsumer; +import de.srendi.advancedperipherals.AdvancedPeripherals; +import de.srendi.advancedperipherals.client.RenderUtil; +import de.srendi.advancedperipherals.client.smartglasses.objects.threedim.IThreeDObjectRenderer; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.three_dim.ThreeDimensionalObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.RenderableObject; +import de.srendi.advancedperipherals.common.util.EnumColor; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.GameRenderer; +import net.minecraft.client.renderer.RenderType; +import net.minecraft.core.BlockPos; +import net.minecraft.core.Direction; +import net.minecraft.world.inventory.InventoryMenu; +import net.minecraft.world.phys.Vec3; +import net.minecraftforge.api.distmarker.Dist; +import net.minecraftforge.client.event.RenderLevelStageEvent; +import net.minecraftforge.eventbus.api.SubscribeEvent; +import net.minecraftforge.fml.common.Mod; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@Mod.EventBusSubscriber(value = Dist.CLIENT, bus = Mod.EventBusSubscriber.Bus.FORGE, modid = AdvancedPeripherals.MOD_ID) +public class OverlayModuleLevelRenderer { + + @SubscribeEvent + public static void renderLevelState(RenderLevelStageEvent event) { + PoseStack posestack = event.getPoseStack(); + Vec3 view = Minecraft.getInstance().getEntityRenderDispatcher().camera.getPosition(); + + BufferBuilder bufferbuilder = Tesselator.getInstance().getBuilder(); + if (event.getStage() == RenderLevelStageEvent.Stage.AFTER_TRANSLUCENT_BLOCKS) { + Map, List> batches = new HashMap<>(); + + for (RenderableObject object : OverlayObjectHolder.getObjects()) { + if (!object.isEnabled() || !(object.getRenderObject() instanceof IThreeDObjectRenderer)) + continue; + + ThreeDimensionalObject threeDimObject = (ThreeDimensionalObject) object; + + Class objectClass = threeDimObject.getClass(); + + if (batches.containsKey(objectClass)) { + batches.get(objectClass).add(threeDimObject); + continue; + } + + List newBatchArray = new ArrayList<>(); + newBatchArray.add(threeDimObject); + batches.put(objectClass, newBatchArray); + } + + for (List batch : batches.values()) { + ((IThreeDObjectRenderer) batch.get(0).getRenderObject()).renderBatch(batch, event, posestack, view, bufferbuilder); + } + + //TODO Everything below here is just for debugging and testing. Will be removed before we push to production + BlockPos blockPos = new BlockPos(2, 100, 0); + + float[] colors = EnumColor.DARK_PURPLE.getRgb(); + + RenderSystem.setShader(GameRenderer::getPositionColorShader); + bufferbuilder.begin(RenderType.translucent().mode(), DefaultVertexFormat.POSITION_COLOR_NORMAL); + posestack.pushPose(); + + posestack.translate(-view.x + blockPos.getX(), -view.y + blockPos.getY(), -view.z + blockPos.getZ()); + + RenderUtil.drawPlane(posestack, bufferbuilder, colors[0], colors[1], colors[2], 0.8f, Direction.UP, 0f, 0.5f, 0f, 0.5f, 0f, 1f); + + BufferUploader.drawWithShader(bufferbuilder.end()); + posestack.popPose(); + + VertexConsumer boxVertexConsumer = Minecraft.getInstance().renderBuffers().bufferSource().getBuffer(RenderType.entityCutout(InventoryMenu.BLOCK_ATLAS)); + //RenderSystem.setShader(GameRenderer::getPositionColorLightmapShader); + + //bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR_LIGHTMAP); + posestack.pushPose(); + colors = EnumColor.WHITE.getRgb(); + + blockPos = new BlockPos(0, 100, 0); + posestack.translate(-view.x + blockPos.getX(), -view.y + blockPos.getY(), -view.z + blockPos.getZ()); + + RenderUtil.drawSphere(posestack, boxVertexConsumer, 2f, 0f, 0f, 0f, 270f, 0f, 0f, colors[0], colors[1], colors[2], 0.4f, 16, 128); + + //BufferUploader.drawWithShader(bufferbuilder.end()); + posestack.popPose(); + + boxVertexConsumer = Minecraft.getInstance().renderBuffers().bufferSource().getBuffer(RenderType.entityCutout(InventoryMenu.BLOCK_ATLAS)); + + //bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR_NORMAL); + posestack.pushPose(); + + colors = EnumColor.WHITE.getRgb(); + blockPos = new BlockPos(6, 100, 0); + posestack.translate(-view.x + blockPos.getX(), -view.y + blockPos.getY(), -view.z + blockPos.getZ()); + + RenderUtil.drawTorus(posestack, boxVertexConsumer, 1f, 0.4f, 0f, 0f, 0f, 0f, 0f, 0f, colors[0], colors[1], colors[2], 1f, 48, 48); + + //BufferUploader.drawWithShader(bufferbuilder.end()); + posestack.popPose(); + + } + } + +} diff --git a/src/main/java/de/srendi/advancedperipherals/client/smartglasses/OverlayModuleOverlay.java b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/OverlayModuleOverlay.java new file mode 100644 index 000000000..6ef3fab90 --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/OverlayModuleOverlay.java @@ -0,0 +1,56 @@ +package de.srendi.advancedperipherals.client.smartglasses; + +import com.mojang.blaze3d.vertex.PoseStack; +import de.srendi.advancedperipherals.client.smartglasses.objects.twodim.ITwoDObjectRenderer; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.RenderableObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.two_dim.RectangleObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.two_dim.TextObject; +import net.minecraftforge.client.gui.overlay.ForgeGui; +import net.minecraftforge.client.gui.overlay.IGuiOverlay; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.TreeMap; + +public class OverlayModuleOverlay implements IGuiOverlay { + public static final String ID = "overlay_module_overlay"; + + @Override + public void render(ForgeGui gui, PoseStack poseStack, float partialTick, int screenWidth, int screenHeight) { + poseStack.pushPose(); + + Map, List>> prioritizedBatches = new TreeMap<>(); + + for (RenderableObject object : OverlayObjectHolder.getObjects()) { + if (!object.isEnabled() || !(object.getRenderObject() instanceof ITwoDObjectRenderer)) { + continue; + } + + // We need to sort the objects by their weight, some things can't be rendered before something else. + // For example, when texts are rendered before our circles, rectangles, etc., the other objects can't be transparent anymore + int weight = object.getRenderObject().getWeight(); + Class objectClass = object.getClass(); + + // Get or create the batch map for the current weight + Map, List> batchesForWeight = prioritizedBatches.computeIfAbsent(weight, k -> new HashMap<>()); + + List batch = batchesForWeight.computeIfAbsent(objectClass, k -> new ArrayList<>()); + + batch.add(object); + } + + for (Map, List> batchesForWeight : prioritizedBatches.values()) { + for (List batch : batchesForWeight.values()) { + + if (!batch.isEmpty()) { + ((ITwoDObjectRenderer) batch.get(0).getRenderObject()).renderBatch(batch, gui, poseStack, partialTick, screenWidth, screenHeight); + } + } + } + poseStack.popPose(); + + } + +} diff --git a/src/main/java/de/srendi/advancedperipherals/client/smartglasses/OverlayObjectHolder.java b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/OverlayObjectHolder.java new file mode 100644 index 000000000..e319679fd --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/OverlayObjectHolder.java @@ -0,0 +1,60 @@ +package de.srendi.advancedperipherals.client.smartglasses; + +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.ObjectDecodeRegistry; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.three_dim.BlockObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.three_dim.BoxObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.three_dim.SphereObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.three_dim.TorusObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.two_dim.CircleObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.two_dim.ItemObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.two_dim.LineObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.two_dim.RectangleObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.RenderableObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.two_dim.TextObject; + +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; + +/** + * Static holder for client side renderable objects - will change + */ +public class OverlayObjectHolder { + + public static Map objects = new HashMap<>(); + + public static void addOrUpdateObject(RenderableObject object) { + objects.put(object.getId(), object); + } + + public static void addOrUpdateObjects(Collection objects) { + for (RenderableObject renderableObject : objects) { + addOrUpdateObject(renderableObject); + } + } + + public static void removeObject(int id) { + objects.remove(id); + } + + public static Collection getObjects() { + return objects.values(); + } + + public static void clear() { + objects.clear(); + } + + public static void registerDecodeObjects() { + ObjectDecodeRegistry.register(RectangleObject.TYPE_ID, RectangleObject::decode); + ObjectDecodeRegistry.register(CircleObject.TYPE_ID, CircleObject::decode); + ObjectDecodeRegistry.register(TextObject.TYPE_ID, TextObject::decode); + ObjectDecodeRegistry.register(ItemObject.TYPE_ID, ItemObject::decode); + ObjectDecodeRegistry.register(LineObject.TYPE_ID, LineObject::decode); + + ObjectDecodeRegistry.register(BoxObject.TYPE_ID, BoxObject::decode); + ObjectDecodeRegistry.register(BlockObject.TYPE_ID, BlockObject::decode); + ObjectDecodeRegistry.register(SphereObject.TYPE_ID, SphereObject::decode); + ObjectDecodeRegistry.register(TorusObject.TYPE_ID, TorusObject::decode); + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/IObjectRenderer.java b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/IObjectRenderer.java new file mode 100644 index 000000000..aeefb36a9 --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/IObjectRenderer.java @@ -0,0 +1,13 @@ +package de.srendi.advancedperipherals.client.smartglasses.objects; + +public interface IObjectRenderer { + /** + * Get the weight of the renderer. Lower weight means higher priority and it will render first. + * Some things need to be rendered before others to prevent color and opacity issues. + * @return the weight of the renderer. + */ + default int getWeight() { + return 100; + } + +} diff --git a/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/threedim/BlockRenderer.java b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/threedim/BlockRenderer.java new file mode 100644 index 000000000..152f9c3fe --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/threedim/BlockRenderer.java @@ -0,0 +1,65 @@ +package de.srendi.advancedperipherals.client.smartglasses.objects.threedim; + +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.vertex.BufferBuilder; +import com.mojang.blaze3d.vertex.BufferUploader; +import com.mojang.blaze3d.vertex.DefaultVertexFormat; +import com.mojang.blaze3d.vertex.PoseStack; +import com.mojang.math.Quaternion; +import de.srendi.advancedperipherals.client.RenderUtil; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.three_dim.BlockObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.three_dim.ThreeDimensionalObject; +import de.srendi.advancedperipherals.common.util.RegistryUtil; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.GameRenderer; +import net.minecraft.client.renderer.RenderType; +import net.minecraft.core.BlockPos; +import net.minecraft.world.level.block.Block; +import net.minecraft.world.phys.Vec3; +import net.minecraftforge.client.event.RenderLevelStageEvent; +import net.minecraftforge.registries.ForgeRegistries; + +import java.util.List; + +public class BlockRenderer implements IThreeDObjectRenderer { + + @Override + public void renderBatch(List batch, RenderLevelStageEvent event, PoseStack poseStack, Vec3 view, BufferBuilder bufferBuilder) { + poseStack.pushPose(); + + for (ThreeDimensionalObject obj : batch) { + poseStack.pushPose(); + onPreRender(obj); + + bufferBuilder.begin(RenderType.solid().mode(), DefaultVertexFormat.BLOCK); + + BlockObject block = (BlockObject) obj; + + poseStack.translate(-view.x + block.getX(), -view.y + block.getY(), -view.z + block.getZ()); + poseStack.mulPose(new Quaternion(block.rotX, block.rotY, block.rotZ, true)); + poseStack.translate(-0.5f, -0.5f, -0.5f); + float alpha = block.opacity; + float red = RenderUtil.getRed(block.color); + float green = RenderUtil.getGreen(block.color); + float blue = RenderUtil.getBlue(block.color); + + RenderSystem.setShader(GameRenderer::getBlockShader); + RenderSystem.setShaderColor(red, green, blue, alpha); + + Block blockToRender = RegistryUtil.getRegistryEntry(block.block, ForgeRegistries.BLOCKS); + BlockPos blockPos = new BlockPos(obj.getX(), obj.getY(), obj.getZ()); + + if (blockToRender != null) + Minecraft.getInstance().getBlockRenderer().renderBatched(blockToRender.defaultBlockState(), blockPos, event.getCamera().getEntity().level, poseStack, bufferBuilder, false, event.getCamera().getEntity().level.random); + + poseStack.popPose(); + BufferUploader.drawWithShader(bufferBuilder.end()); + onPostRender(obj); + RenderSystem.setShaderColor(1f, 1f, 1f, 1f); + } + + + poseStack.popPose(); + + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/threedim/BoxRenderer.java b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/threedim/BoxRenderer.java new file mode 100644 index 000000000..e773a6ec4 --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/threedim/BoxRenderer.java @@ -0,0 +1,47 @@ +package de.srendi.advancedperipherals.client.smartglasses.objects.threedim; + +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.vertex.BufferBuilder; +import com.mojang.blaze3d.vertex.BufferUploader; +import com.mojang.blaze3d.vertex.DefaultVertexFormat; +import com.mojang.blaze3d.vertex.PoseStack; +import com.mojang.blaze3d.vertex.VertexFormat; +import de.srendi.advancedperipherals.client.RenderUtil; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.three_dim.BoxObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.three_dim.ThreeDimensionalObject; +import net.minecraft.client.renderer.GameRenderer; +import net.minecraft.world.phys.Vec3; +import net.minecraftforge.client.event.RenderLevelStageEvent; + +import java.util.List; + +public class BoxRenderer implements IThreeDObjectRenderer { + + @Override + public void renderBatch(List batch, RenderLevelStageEvent event, PoseStack poseStack, Vec3 view, BufferBuilder bufferBuilder) { + poseStack.pushPose(); + + for (ThreeDimensionalObject obj : batch) { + poseStack.pushPose(); + onPreRender(obj); + bufferBuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR_NORMAL); + + BoxObject box = (BoxObject) obj; + + RenderSystem.setShader(GameRenderer::getPositionColorShader); + float alpha = box.opacity; + float red = RenderUtil.getRed(box.color); + float green = RenderUtil.getGreen(box.color); + float blue = RenderUtil.getBlue(box.color); + + poseStack.translate(-view.x + box.getX(), -view.y + box.getY(), -view.z + box.getZ()); + RenderUtil.drawBox(poseStack, bufferBuilder, red, green, blue, alpha, box.x, box.y, box.z, obj.rotX, obj.rotY, obj.rotZ, obj.maxX, obj.maxY, obj.maxZ); + BufferUploader.drawWithShader(bufferBuilder.end()); + onPostRender(obj); + + poseStack.popPose(); + } + + poseStack.popPose(); + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/threedim/IThreeDObjectRenderer.java b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/threedim/IThreeDObjectRenderer.java new file mode 100644 index 000000000..119277f6f --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/threedim/IThreeDObjectRenderer.java @@ -0,0 +1,30 @@ +package de.srendi.advancedperipherals.client.smartglasses.objects.threedim; + +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.vertex.BufferBuilder; +import com.mojang.blaze3d.vertex.PoseStack; +import de.srendi.advancedperipherals.client.smartglasses.objects.IObjectRenderer; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.three_dim.ThreeDimensionalObject; +import net.minecraft.world.phys.Vec3; +import net.minecraftforge.client.event.RenderLevelStageEvent; + +import java.util.List; + +public interface IThreeDObjectRenderer extends IObjectRenderer { + + void renderBatch(List batch, RenderLevelStageEvent event, PoseStack poseStack, Vec3 view, BufferBuilder bufferBuilder); + + default void onPostRender(ThreeDimensionalObject object) { + if (object.disableCulling) + RenderSystem.enableCull(); + if (object.disableDepthTest) + RenderSystem.enableDepthTest(); + } + + default void onPreRender(ThreeDimensionalObject object) { + if (object.disableCulling) + RenderSystem.disableCull(); + if (object.disableDepthTest) + RenderSystem.disableDepthTest(); + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/threedim/SphereRenderer.java b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/threedim/SphereRenderer.java new file mode 100644 index 000000000..71388a20e --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/threedim/SphereRenderer.java @@ -0,0 +1,49 @@ +package de.srendi.advancedperipherals.client.smartglasses.objects.threedim; + +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.vertex.BufferBuilder; +import com.mojang.blaze3d.vertex.PoseStack; +import com.mojang.blaze3d.vertex.VertexConsumer; +import de.srendi.advancedperipherals.client.RenderUtil; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.three_dim.SphereObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.three_dim.ThreeDimensionalObject; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.GameRenderer; +import net.minecraft.client.renderer.RenderType; +import net.minecraft.client.renderer.texture.TextureAtlas; +import net.minecraft.world.phys.Vec3; +import net.minecraftforge.client.event.RenderLevelStageEvent; + +import java.util.List; + +public class SphereRenderer implements IThreeDObjectRenderer { + + @Override + public void renderBatch(List batch, RenderLevelStageEvent event, PoseStack poseStack, Vec3 view, BufferBuilder bufferBuilder) { + poseStack.pushPose(); + + for (ThreeDimensionalObject obj : batch) { + poseStack.pushPose(); + onPreRender(obj); + VertexConsumer boxVertexConsumer = Minecraft.getInstance().renderBuffers().bufferSource().getBuffer(RenderType.entitySmoothCutout(TextureAtlas.LOCATION_BLOCKS)); + + SphereObject sphere = (SphereObject) obj; + + RenderSystem.setShader(GameRenderer::getPositionColorShader); + float alpha = sphere.opacity; + float red = RenderUtil.getRed(sphere.color); + float green = RenderUtil.getRed(sphere.color); + float blue = RenderUtil.getRed(sphere.color); + + poseStack.translate(-view.x, -view.y, -view.z); + RenderUtil.drawSphere(poseStack, boxVertexConsumer, sphere.radius, sphere.x, sphere.y, sphere.z, sphere.rotX, sphere.rotY, sphere.rotZ, red, green, blue, alpha, sphere.sectors, sphere.stacks); + onPostRender(obj); + + poseStack.popPose(); + } + + + poseStack.popPose(); + + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/threedim/TorusRenderer.java b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/threedim/TorusRenderer.java new file mode 100644 index 000000000..7921b8a71 --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/threedim/TorusRenderer.java @@ -0,0 +1,47 @@ +package de.srendi.advancedperipherals.client.smartglasses.objects.threedim; + +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.vertex.BufferBuilder; +import com.mojang.blaze3d.vertex.BufferUploader; +import com.mojang.blaze3d.vertex.DefaultVertexFormat; +import com.mojang.blaze3d.vertex.PoseStack; +import com.mojang.blaze3d.vertex.VertexFormat; +import de.srendi.advancedperipherals.client.RenderUtil; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.three_dim.ThreeDimensionalObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.three_dim.TorusObject; +import net.minecraft.client.renderer.GameRenderer; +import net.minecraft.world.phys.Vec3; +import net.minecraftforge.client.event.RenderLevelStageEvent; + +import java.util.List; + +public class TorusRenderer implements IThreeDObjectRenderer { + + @Override + public void renderBatch(List batch, RenderLevelStageEvent event, PoseStack poseStack, Vec3 view, BufferBuilder bufferBuilder) { + poseStack.pushPose(); + + for (ThreeDimensionalObject obj : batch) { + poseStack.pushPose(); + onPreRender(obj); + bufferBuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR_NORMAL); + + TorusObject torus = (TorusObject) obj; + + RenderSystem.setShader(GameRenderer::getPositionColorShader); + float alpha = torus.opacity; + float red = RenderUtil.getRed(torus.color); + float green = RenderUtil.getGreen(torus.color); + float blue = RenderUtil.getBlue(torus.color); + + poseStack.translate(-view.x + torus.x, -view.y + torus.y, -view.z + torus.z); + RenderUtil.drawTorus(poseStack, bufferBuilder, torus.majorRadius, torus.minorRadius, 0, 0, 0, torus.rotX, torus.rotY, torus.rotZ, red, green, blue, alpha, torus.rings, torus.sides); + BufferUploader.drawWithShader(bufferBuilder.end()); + onPostRender(obj); + + poseStack.popPose(); + } + + poseStack.popPose(); + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/twodim/CircleRenderer.java b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/twodim/CircleRenderer.java new file mode 100644 index 000000000..5929b3e8e --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/twodim/CircleRenderer.java @@ -0,0 +1,189 @@ +package de.srendi.advancedperipherals.client.smartglasses.objects.twodim; + +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.vertex.BufferBuilder; +import com.mojang.blaze3d.vertex.BufferUploader; +import com.mojang.blaze3d.vertex.DefaultVertexFormat; +import com.mojang.blaze3d.vertex.PoseStack; +import com.mojang.blaze3d.vertex.Tesselator; +import com.mojang.blaze3d.vertex.VertexFormat; +import com.mojang.math.Matrix4f; +import com.mojang.math.Quaternion; +import com.mojang.math.Vector3f; +import de.srendi.advancedperipherals.client.RenderUtil; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.two_dim.CircleObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.RenderableObject; +import net.minecraft.client.renderer.GameRenderer; +import net.minecraftforge.client.gui.overlay.ForgeGui; + +import java.util.List; + +public class CircleRenderer implements ITwoDObjectRenderer { + + @Override + public void renderBatch(List objects, ForgeGui gui, PoseStack poseStack, float partialTick, int screenWidth, int screenHeight) { + for (RenderableObject obj : objects) { + + CircleObject circle = (CircleObject) obj; + + float alpha = circle.opacity; + float red = RenderUtil.getRed(circle.color); + float green = RenderUtil.getGreen(circle.color); + float blue = RenderUtil.getBlue(circle.color); + + drawCircle(poseStack, circle, red, green, blue, alpha); + } + } + + public void drawCircle(PoseStack t, CircleObject circle, float red, float green, float blue, float alpha) { + float r = circle.radius; + float cx = circle.x; + float cy = circle.y; + float cz = circle.z; + float rotX = circle.rotX; + float rotY = circle.rotY; + float rotZ = circle.rotZ; + float borderWidth = circle.borderWidth; + int segments = circle.segments; + + boolean isFilled = circle.filled; + boolean isPixelated = circle.pixelated; + + PoseStack poseStack = new PoseStack(); + + poseStack.translate(cx, cy, cz); + + poseStack.pushPose(); + + poseStack.mulPose(Vector3f.XP.rotationDegrees(rotX)); + poseStack.mulPose(Vector3f.YP.rotationDegrees(rotY)); + poseStack.mulPose(Vector3f.ZP.rotationDegrees(rotZ)); + + RenderSystem.disableCull(); + + RenderSystem.setShader(GameRenderer::getPositionColorShader); + BufferBuilder bufferbuilder = Tesselator.getInstance().getBuilder(); + + Matrix4f matrix = poseStack.last().pose(); + + // Normal, smooth lines + if (!isPixelated) { + if (isFilled) { + + bufferbuilder.begin(VertexFormat.Mode.TRIANGLE_FAN, DefaultVertexFormat.POSITION_COLOR); + + bufferbuilder.vertex(matrix, 0, 0, 0f).color(red, green, blue, alpha).endVertex(); + + double angleStep = Math.PI * 2 / segments; + + for (int i = 0; i <= segments; i++) { + double angle = i * angleStep; + double x = r * Math.sin(angle); + double y = r * Math.cos(angle); + + bufferbuilder.vertex(matrix, (float) x, (float) y, 0).color(red, green, blue, alpha).endVertex(); + } + + } else { + float outerRadius = r; + float innerRadius = r - borderWidth; + + bufferbuilder.begin(VertexFormat.Mode.TRIANGLE_STRIP, DefaultVertexFormat.POSITION_COLOR); + + double angleStep = Math.PI * 2 / segments; + + for (int i = 0; i <= segments; i++) { + double angle = i * angleStep; + + // Outer circle vertex + double outerX = innerRadius * Math.sin(angle); + double outerY = innerRadius * Math.cos(angle); + bufferbuilder.vertex(matrix, (float) outerX, (float) outerY, 0f).color(red, green, blue, alpha).endVertex(); + + // Inner circle vertex + double innerX = outerRadius * Math.sin(angle); + double innerY = outerRadius * Math.cos(angle); + bufferbuilder.vertex(matrix, (float) innerX, (float) innerY, 0f).color(red, green, blue, alpha).endVertex(); + } + } + + BufferUploader.drawWithShader(bufferbuilder.end()); + + return; + } + + // Pixelated lines + bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR); + + final float PIXEL_SIZE = borderWidth; // Defines the size of each "pixel" square + + // The thickness of the hollow line in terms of pixel units. + // A value of 1.0f means the line will be roughly one pixel thick. + final float LINE_THICKNESS_PIXELS = 1f; + + // Calculate the effective min/max coordinates in the relative space + float effectiveMinX = -r - PIXEL_SIZE; + float effectiveMaxX = r + PIXEL_SIZE; + float effectiveMinY = -r - PIXEL_SIZE; + float effectiveMaxY = r + PIXEL_SIZE; + +// Start the loop at the first multiple of PIXEL_SIZE that is less than or equal to effectiveMinX/Y + float startX = (float) Math.floor(effectiveMinX / PIXEL_SIZE) * PIXEL_SIZE; + float startY = (float) Math.floor(effectiveMinY / PIXEL_SIZE) * PIXEL_SIZE; + + + for (float x = startX; x <= effectiveMaxX; x += PIXEL_SIZE) { + for (float y = startY; y <= effectiveMaxY; y += PIXEL_SIZE) { + // Calculate the center of the current pixel cell. + // This is where you determine if the *center* of this block should be drawn. + float pixelCenterX = x + (PIXEL_SIZE / 2.0F); + float pixelCenterY = y + (PIXEL_SIZE / 2.0F); + + // Distance is calculated from (pixelCenterX, pixelCenterY) to (0,0) + double distanceToCenter = Math.sqrt( + Math.pow(pixelCenterX, 2) + Math.pow(pixelCenterY, 2) + ); + + boolean shouldDrawPixel; + + if (!isFilled) { + float outerRadius = r + (LINE_THICKNESS_PIXELS * (PIXEL_SIZE / 2.0F)); + float innerRadius = r - (LINE_THICKNESS_PIXELS * (PIXEL_SIZE / 2.0F)); + + if (innerRadius < 0) innerRadius = 0; + + shouldDrawPixel = (distanceToCenter <= outerRadius) && (distanceToCenter >= innerRadius); + } else { + shouldDrawPixel = distanceToCenter <= r + (PIXEL_SIZE / 2.0F); + } + + if (shouldDrawPixel) { + // Vertices for the QUAD (a PIXEL_SIZE x PIXEL_SIZE square) + // These coordinates are now relative to the current origin (0,0,0) + float p_x1 = x; + float p_y1 = y; + float p_z = 0f; // z-coordinate is relative to cz, so 0 in this space + + float p_x2 = x + PIXEL_SIZE; + float p_y2 = y + PIXEL_SIZE; + + // Vertices for the QUAD + // Ensure proper winding order (counter-clockwise for front face) + bufferbuilder.vertex(matrix, p_x1, p_y2, p_z).color(red, green, blue, alpha).endVertex(); // Bottom-left + bufferbuilder.vertex(matrix, p_x2, p_y2, p_z).color(red, green, blue, alpha).endVertex(); // Bottom-right + bufferbuilder.vertex(matrix, p_x2, p_y1, p_z).color(red, green, blue, alpha).endVertex(); // Top-right + bufferbuilder.vertex(matrix, p_x1, p_y1, p_z).color(red, green, blue, alpha).endVertex(); // Top-left + } + } + } + + RenderSystem.enableCull(); + + BufferUploader.drawWithShader(bufferbuilder.end()); + + + poseStack.popPose(); + + } +} + diff --git a/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/twodim/ITwoDObjectRenderer.java b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/twodim/ITwoDObjectRenderer.java new file mode 100644 index 000000000..543f3580c --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/twodim/ITwoDObjectRenderer.java @@ -0,0 +1,14 @@ +package de.srendi.advancedperipherals.client.smartglasses.objects.twodim; + +import com.mojang.blaze3d.vertex.PoseStack; +import de.srendi.advancedperipherals.client.smartglasses.objects.IObjectRenderer; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.RenderableObject; +import net.minecraftforge.client.gui.overlay.ForgeGui; + +import java.util.List; + +public interface ITwoDObjectRenderer extends IObjectRenderer { + + void renderBatch(List object, ForgeGui gui, PoseStack poseStack, float partialTick, int screenWidth, int screenHeight); + +} diff --git a/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/twodim/ItemRenderer.java b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/twodim/ItemRenderer.java new file mode 100644 index 000000000..6d2ff7ccb --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/twodim/ItemRenderer.java @@ -0,0 +1,29 @@ +package de.srendi.advancedperipherals.client.smartglasses.objects.twodim; + +import com.mojang.blaze3d.vertex.PoseStack; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.two_dim.ItemObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.RenderableObject; +import de.srendi.advancedperipherals.common.util.RegistryUtil; +import net.minecraft.client.Minecraft; +import net.minecraft.world.item.Item; +import net.minecraft.world.item.ItemStack; +import net.minecraftforge.client.gui.overlay.ForgeGui; +import net.minecraftforge.registries.ForgeRegistries; + +import java.util.List; + +public class ItemRenderer implements ITwoDObjectRenderer { + + @Override + public void renderBatch(List objects, ForgeGui gui, PoseStack poseStack, float partialTick, int screenWidth, int screenHeight) { + Minecraft minecraft = Minecraft.getInstance(); + + for (RenderableObject obj : objects) { + Item renderItem = RegistryUtil.getRegistryEntry(((ItemObject) obj).item, ForgeRegistries.ITEMS); + if (renderItem == null) + continue; + minecraft.getItemRenderer().renderGuiItem(new ItemStack(renderItem), (int) obj.x, (int) obj.y); + } + + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/twodim/LineRenderer.java b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/twodim/LineRenderer.java new file mode 100644 index 000000000..71579398a --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/twodim/LineRenderer.java @@ -0,0 +1,103 @@ +package de.srendi.advancedperipherals.client.smartglasses.objects.twodim; + +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.vertex.BufferBuilder; +import com.mojang.blaze3d.vertex.BufferUploader; +import com.mojang.blaze3d.vertex.DefaultVertexFormat; +import com.mojang.blaze3d.vertex.PoseStack; +import com.mojang.blaze3d.vertex.Tesselator; +import com.mojang.blaze3d.vertex.VertexFormat; +import com.mojang.math.Matrix4f; +import de.srendi.advancedperipherals.client.RenderUtil; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.RenderableObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.two_dim.LineObject; +import net.minecraft.client.renderer.GameRenderer; +import net.minecraftforge.client.gui.overlay.ForgeGui; + +import java.util.List; + +public class LineRenderer implements ITwoDObjectRenderer { + + @Override + public void renderBatch(List objects, ForgeGui gui, PoseStack poseStack, float partialTick, int screenWidth, int screenHeight) { + RenderSystem.setShader(GameRenderer::getPositionColorShader); + BufferBuilder bufferbuilder = Tesselator.getInstance().getBuilder(); + Matrix4f matrix = poseStack.last().pose(); + + for (RenderableObject obj : objects) { + + LineObject line = (LineObject) obj; + + float alpha = obj.opacity; + float red = RenderUtil.getRed(obj.color); + float green = RenderUtil.getGreen(obj.color); + float blue = RenderUtil.getBlue(obj.color); + + // Start and end points of the line + float x1 = obj.x; + float y1 = obj.y; + float z1 = obj.z; + + float x2 = obj.maxX; + float y2 = obj.maxY; + float z2 = obj.maxZ; + + // Normal, smooth lines + if (!line.pixelated) { + bufferbuilder.begin(VertexFormat.Mode.DEBUG_LINE_STRIP, DefaultVertexFormat.POSITION_COLOR); + bufferbuilder.vertex(matrix, x1, y1, 0).color(red, green, blue, alpha).endVertex(); + bufferbuilder.vertex(matrix, x2, y2, 0).color(red, green, blue, alpha).endVertex(); + BufferUploader.drawWithShader(bufferbuilder.end()); + + continue; // Skip the rest of the loop for this object + } + + // Pixelated lines + bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR); + + // Calculate the delta for each axis + float dx = x2 - x1; + float dy = y2 - y1; + float dz = z2 - z1; + + final float PIXEL_SIZE = line.pixelSize; + + float maxDim = Math.max(Math.abs(dx), Math.max(Math.abs(dy), Math.abs(dz))); + int numPixels = (int) Math.ceil(maxDim / PIXEL_SIZE); + + if (numPixels == 0) { + numPixels = 1; // Always draw at least one pixel for very short lines + } + + // Iterate and draw a square for each "pixel" + for (int i = 0; i <= numPixels; i++) { + float t = (float) i / numPixels; // Interpolation factor (0.0 to 1.0) + + // Calculate the exact point on the line + float currentX = x1 + dx * t; + float currentY = y1 + dy * t; + float currentZ = z1 + dz * t; + + // Snap current point to the nearest pixel grid for consistent placement. + // This is key for placing pixels at corners or full side of each other. + currentX = Math.round(currentX / PIXEL_SIZE) * PIXEL_SIZE; + currentY = Math.round(currentY / PIXEL_SIZE) * PIXEL_SIZE; + currentZ = Math.round(currentZ / PIXEL_SIZE) * PIXEL_SIZE; + + float p_x1 = currentX; + float p_y1 = currentY; + float p_z1 = currentZ; + + float p_x2 = currentX + PIXEL_SIZE; + float p_y2 = currentY + PIXEL_SIZE; + float p_z2 = currentZ; + + bufferbuilder.vertex(matrix, p_x1, p_y2, p_z1).color(red, green, blue, alpha).endVertex(); // Bottom-left + bufferbuilder.vertex(matrix, p_x2, p_y2, p_z1).color(red, green, blue, alpha).endVertex(); // Bottom-right + bufferbuilder.vertex(matrix, p_x2, p_y1, p_z2).color(red, green, blue, alpha).endVertex(); // Top-right + bufferbuilder.vertex(matrix, p_x1, p_y1, p_z2).color(red, green, blue, alpha).endVertex(); // Top-left + } + BufferUploader.drawWithShader(bufferbuilder.end()); + } + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/twodim/RectangleRenderer.java b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/twodim/RectangleRenderer.java new file mode 100644 index 000000000..55618cf74 --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/twodim/RectangleRenderer.java @@ -0,0 +1,60 @@ +package de.srendi.advancedperipherals.client.smartglasses.objects.twodim; + +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.vertex.BufferBuilder; +import com.mojang.blaze3d.vertex.BufferUploader; +import com.mojang.blaze3d.vertex.DefaultVertexFormat; +import com.mojang.blaze3d.vertex.PoseStack; +import com.mojang.blaze3d.vertex.Tesselator; +import com.mojang.blaze3d.vertex.VertexFormat; +import com.mojang.math.Matrix4f; +import com.mojang.math.Vector3f; +import de.srendi.advancedperipherals.client.RenderUtil; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.RenderableObject; +import net.minecraft.client.renderer.GameRenderer; +import net.minecraftforge.client.gui.overlay.ForgeGui; + +import java.util.List; + +public class RectangleRenderer implements ITwoDObjectRenderer { + + @Override + public void renderBatch(List objects, ForgeGui gui, PoseStack ignored, float partialTick, int screenWidth, int screenHeight) { + RenderSystem.setShader(GameRenderer::getPositionColorShader); + BufferBuilder bufferbuilder = Tesselator.getInstance().getBuilder(); + + bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR); + + for (RenderableObject obj : objects) { + float rotX = obj.rotX; + float rotY = obj.rotY; + float rotZ = obj.rotZ; + + PoseStack poseStack = new PoseStack(); + + poseStack.translate(obj.x, obj.y, obj.z); + + poseStack.pushPose(); + + Matrix4f matrix = poseStack.last().pose(); + + poseStack.mulPose(Vector3f.XP.rotationDegrees(rotX)); + poseStack.mulPose(Vector3f.YP.rotationDegrees(rotY)); + poseStack.mulPose(Vector3f.ZP.rotationDegrees(rotZ)); + + float alpha = obj.opacity; + float red = RenderUtil.getRed(obj.color); + float green = RenderUtil.getGreen(obj.color); + float blue = RenderUtil.getBlue(obj.color); + + bufferbuilder.vertex(matrix, 0, obj.maxY - obj.y, 0).color(red, green, blue, alpha).endVertex(); + bufferbuilder.vertex(matrix, obj.maxX - obj.x, obj.maxY - obj.y, 0).color(red, green, blue, alpha).endVertex(); + bufferbuilder.vertex(matrix, obj.maxX - obj.x, 0, 0).color(red, green, blue, alpha).endVertex(); + bufferbuilder.vertex(matrix, 0, 0, 0).color(red, green, blue, alpha).endVertex(); + poseStack.popPose(); + + } + + BufferUploader.drawWithShader(bufferbuilder.end()); + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/twodim/TextRenderer.java b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/twodim/TextRenderer.java new file mode 100644 index 000000000..ecde02ad7 --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/client/smartglasses/objects/twodim/TextRenderer.java @@ -0,0 +1,55 @@ +package de.srendi.advancedperipherals.client.smartglasses.objects.twodim; + +import com.mojang.blaze3d.vertex.PoseStack; +import com.mojang.math.Matrix4f; +import com.mojang.math.Vector3f; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.RenderableObject; +import de.srendi.advancedperipherals.common.smartglasses.modules.overlay.objects.two_dim.TextObject; +import net.minecraft.client.Minecraft; +import net.minecraftforge.client.gui.overlay.ForgeGui; + +import java.util.List; + +public class TextRenderer implements ITwoDObjectRenderer { + + @Override + public void renderBatch(List objects, ForgeGui gui, PoseStack ignored, float partialTick, int screenWidth, int screenHeight) { + Minecraft minecraft = Minecraft.getInstance(); + for (RenderableObject obj : objects) { + TextObject text = (TextObject) obj; + float rotX = obj.rotX; + float rotY = obj.rotY; + float rotZ = obj.rotZ; + + float x = text.x; + + if (text.center) { + x -= (minecraft.font.width(text.content) * text.fontSize) / 2f; + } + + PoseStack poseStack = new PoseStack(); + + poseStack.translate(x / text.fontSize, text.y / text.fontSize, obj.z); + + poseStack.pushPose(); + + poseStack.mulPose(Vector3f.XP.rotationDegrees(rotX)); + poseStack.mulPose(Vector3f.YP.rotationDegrees(rotY)); + poseStack.mulPose(Vector3f.ZP.rotationDegrees(rotZ)); + + poseStack.scale(text.fontSize, text.fontSize, 1); + + if (!text.shadow) { + minecraft.font.drawShadow(poseStack, text.content, 0, 0, text.color); + } else { + minecraft.font.draw(poseStack, text.content, 0, 0, text.color); + } + poseStack.popPose(); + } + } + + @Override + public int getWeight() { + return 110; + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/client/widgets/SmartGlassesSettingsSwitch.java b/src/main/java/de/srendi/advancedperipherals/client/widgets/SmartGlassesSettingsSwitch.java new file mode 100644 index 000000000..a6ab0c0cc --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/client/widgets/SmartGlassesSettingsSwitch.java @@ -0,0 +1,85 @@ +package de.srendi.advancedperipherals.client.widgets; + +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.vertex.PoseStack; +import dan200.computercraft.client.gui.widgets.ComputerSidebar; +import de.srendi.advancedperipherals.AdvancedPeripherals; +import de.srendi.advancedperipherals.client.screens.SmartGlassesScreen; +import de.srendi.advancedperipherals.common.smartglasses.SlotType; +import de.srendi.advancedperipherals.common.smartglasses.SmartGlassesSlot; +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.components.AbstractWidget; +import net.minecraft.client.gui.narration.NarrationElementOutput; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.world.inventory.Slot; +import org.jetbrains.annotations.NotNull; + +import java.util.Collections; + +public class SmartGlassesSettingsSwitch extends AbstractWidget { + + private static final ResourceLocation BACKGROUND = new ResourceLocation(AdvancedPeripherals.MOD_ID, "textures/gui/smart_glasses_gui.png"); + + private final SmartGlassesScreen screen; + private final SlotType type; + private boolean isEnabled; + + public SmartGlassesSettingsSwitch(int x, int y, SlotType type, SmartGlassesScreen screen) { + super(screen.getGuiLeft() + x + ComputerSidebar.WIDTH, screen.getGuiTop() + y, 21, 22, type.getName()); + this.screen = screen; + this.type = type; + this.isEnabled = type == SlotType.defaultType(); + } + + @Override + public void render(@NotNull PoseStack pPoseStack, int pMouseX, int pMouseY, float pPartialTick) { + renderBg(pPoseStack, Minecraft.getInstance(), pMouseX, pMouseY); + } + + @Override + public void renderButton(@NotNull PoseStack pPoseStack, int pMouseX, int pMouseY, float pPartialTick) { + // Disable rendering of default buttons + } + + @Override + protected void renderBg(@NotNull PoseStack pPoseStack, @NotNull Minecraft pMinecraft, int pMouseX, int pMouseY) { + RenderSystem.setShaderTexture(0, BACKGROUND); + if (isEnabled) { + blit(pPoseStack, this.x - 3, this.y, 45, 217, 24, 22); + } else { + blit(pPoseStack, this.x, this.y, 23, 217, 21, 22); + } + } + + @Override + public void onClick(double pMouseX, double pMouseY) { + if (this.isEnabled) + return; + for (Slot slot : screen.getMenu().slots) { + if (slot instanceof SmartGlassesSlot smartGlassesSlot) { + if (smartGlassesSlot.slotType == this.type) { + smartGlassesSlot.setEnabled(true); + continue; + } + smartGlassesSlot.setEnabled(false); + } + } + screen.renderables.forEach(renderable -> { + if (renderable instanceof SmartGlassesSettingsSwitch smartGlassesSettingsSwitch) { + smartGlassesSettingsSwitch.isEnabled = false; + } + }); + screen.setCurrentType(this.type); + this.isEnabled = true; + } + + public void renderTooltip(PoseStack poseStack, int x, int y) { + if (screen != null && isMouseOver(x, y)) + screen.renderComponentTooltip(poseStack, Collections.singletonList(type.getName()), x, y); + } + + @Override + public void updateNarration(@NotNull NarrationElementOutput pNarrationElementOutput) { + + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/APAddons.java b/src/main/java/de/srendi/advancedperipherals/common/addons/APAddons.java index c26e2652a..bdc4e4265 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/APAddons.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/APAddons.java @@ -1,41 +1,72 @@ package de.srendi.advancedperipherals.common.addons; import de.srendi.advancedperipherals.AdvancedPeripherals; -import de.srendi.advancedperipherals.common.addons.refinedstorage.RefinedStorage; +import de.srendi.advancedperipherals.common.addons.refinedstorage.RSApi; +import de.srendi.advancedperipherals.common.addons.valkyrienskies.ValkyrienSkies; +import net.minecraft.core.BlockPos; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.world.entity.player.Player; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.level.Level; import net.minecraftforge.eventbus.api.SubscribeEvent; +import net.minecraftforge.fml.InterModComms; import net.minecraftforge.fml.ModList; import net.minecraftforge.fml.common.Mod; import net.minecraftforge.fml.event.lifecycle.InterModEnqueueEvent; +import top.theillusivec4.curios.api.CuriosApi; +import top.theillusivec4.curios.api.SlotResult; +import top.theillusivec4.curios.api.SlotTypeMessage; + +import java.util.List; @Mod.EventBusSubscriber(modid = AdvancedPeripherals.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD) public class APAddons { - public static final String CURIOS_MODID = "curios"; - public static final String REFINEDSTORAGE_MODID = "refinedstorage"; - public static final String AE_THINGS_MODID = "ae2things"; public static final String AE_ADDITIONS_MODID = "ae2additions"; + public static final String AE_THINGS_MODID = "ae2things"; + public static final String APPLIEDENERGISTICS_MODID = "ae2"; public static final String APP_MEKANISTICS_MODID = "appmek"; + public static final String BOTANIA_MODID = "botania"; + public static final String CREATE_MODID = "create"; + public static final String CURIOS_MODID = "curios"; + public static final String DIMSTORAGE_MODID = "dimstorage"; + public static final String MEKANISM_MODID = "mekanism"; + public static final String POWAH_MODID = "powah"; + public static final String REFINEDSTORAGE_MODID = "refinedstorage"; + public static final String VALKYRIEN_SKIES_MODID = "valkyrienskies"; - public static boolean curiosLoaded; - public static boolean refinedStorageLoaded; - public static boolean aeThingsLoaded; public static boolean aeAdditionsLoaded; + public static boolean aeThingsLoaded; public static boolean appMekLoaded; + public static boolean appliedEnergisticsLoaded; + public static boolean botaniaLoaded; + public static boolean createLoaded; + public static boolean curiosLoaded; + public static boolean dimstorageLoaded; + public static boolean mekanismLoaded; + public static boolean powahLoaded; + public static boolean refinedStorageLoaded; + public static boolean vs2Loaded; - private APAddons() { - } - - public static void commonSetup() { + // Use static so these checks run as early as possible, so we can use them for our registries + static { ModList modList = ModList.get(); - curiosLoaded = modList.isLoaded(CURIOS_MODID); - refinedStorageLoaded = modList.isLoaded(REFINEDSTORAGE_MODID); - aeThingsLoaded = modList.isLoaded(AE_THINGS_MODID); aeAdditionsLoaded = modList.isLoaded(AE_ADDITIONS_MODID); + aeThingsLoaded = modList.isLoaded(AE_THINGS_MODID); appMekLoaded = modList.isLoaded(APP_MEKANISTICS_MODID); + appliedEnergisticsLoaded = modList.isLoaded(APPLIEDENERGISTICS_MODID); + botaniaLoaded = modList.isLoaded(BOTANIA_MODID); + createLoaded = modList.isLoaded(CREATE_MODID); + curiosLoaded = modList.isLoaded(CURIOS_MODID); + dimstorageLoaded = modList.isLoaded(DIMSTORAGE_MODID); + mekanismLoaded = modList.isLoaded(MEKANISM_MODID); + powahLoaded = modList.isLoaded(POWAH_MODID); + refinedStorageLoaded = modList.isLoaded(REFINEDSTORAGE_MODID); + vs2Loaded = modList.isLoaded(VALKYRIEN_SKIES_MODID); - if (refinedStorageLoaded) - RefinedStorage.instance = new RefinedStorage(); - + if (refinedStorageLoaded) { + RSApi.instance = new RSApi(); + } } @SubscribeEvent @@ -43,6 +74,27 @@ public static void interModComms(InterModEnqueueEvent event) { if (!curiosLoaded) return; - // InterModComms.sendTo("curios", SlotTypeMessage.REGISTER_TYPE, () -> new SlotTypeMessage.Builder("glasses").size(1).build()); + InterModComms.sendTo(CURIOS_MODID, SlotTypeMessage.REGISTER_TYPE, + () -> new SlotTypeMessage.Builder("glasses") + .size(1) + .icon(new ResourceLocation(AdvancedPeripherals.MOD_ID, "slot/empty_glasses_slot")) + .build()); + } + + public static ItemStack getCurioGlasses(Player player) { + if (!curiosLoaded) + return ItemStack.EMPTY; + List curioSlots = CuriosApi.getCuriosHelper().findCurios(player, "glasses"); + if (curioSlots.isEmpty()) + return ItemStack.EMPTY; + + return curioSlots.get(0).stack(); + } + + public static boolean isBlockOnShip(Level level, BlockPos pos) { + if (!vs2Loaded) { + return false; + } + return ValkyrienSkies.isBlockOnShip(level, pos); } } diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/ae2/AE2Registries.java b/src/main/java/de/srendi/advancedperipherals/common/addons/ae2/AE2Registries.java new file mode 100644 index 000000000..b4759df1d --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/ae2/AE2Registries.java @@ -0,0 +1,42 @@ +package de.srendi.advancedperipherals.common.addons.ae2; + +import appeng.api.features.P2PTunnelAttunement; +import appeng.api.parts.IPart; +import appeng.api.parts.IPartItem; +import appeng.api.parts.PartModels; +import appeng.items.parts.PartItem; +import appeng.items.parts.PartModelsHelper; +import dan200.computercraft.shared.Registry.ModItems; +import de.srendi.advancedperipherals.common.setup.APRegistration; +import net.minecraft.data.tags.TagsProvider; +import net.minecraft.tags.TagKey; +import net.minecraft.world.item.Item; +import net.minecraftforge.registries.RegistryObject; + +import java.util.function.Function; + +public final class AE2Registries { + private AE2Registries() {} + + public static final RegistryObject> CABLE_P2P_TUNNEL = registerPart("cable_p2p_tunnel", WiredCableP2PTunnelPart.class, WiredCableP2PTunnelPart::new); + + private static RegistryObject> registerPart(String id, Class clazz, Function, T> factory) { + PartModels.registerModels(PartModelsHelper.createModels(clazz)); + return APRegistration.ITEMS.register(id, () -> new PartItem<>(new Item.Properties(), clazz, factory)); + } + + public static void finishRegister() { + P2PTunnelAttunement.registerAttunementTag(CABLE_P2P_TUNNEL.get()); + } + + public static TagKey getCableP2PTag() { + return P2PTunnelAttunement.getAttunementTag(CABLE_P2P_TUNNEL.get()); + } + + public static void registerTags(Function, TagsProvider.TagAppender> tagger) { + tagger.apply(getCableP2PTag()) + .add(ModItems.CABLE.get()) + .add(ModItems.WIRED_MODEM.get()) + .add(ModItems.WIRED_MODEM_FULL.get()); + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/ae2/AEApi.java b/src/main/java/de/srendi/advancedperipherals/common/addons/ae2/AEApi.java new file mode 100644 index 000000000..51958de66 --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/ae2/AEApi.java @@ -0,0 +1,961 @@ +package de.srendi.advancedperipherals.common.addons.ae2; + +import appeng.api.crafting.IPatternDetails; +import appeng.api.inventories.InternalInventory; +import appeng.api.networking.IGrid; +import appeng.api.networking.IGridNode; +import appeng.api.networking.crafting.CraftingJobStatus; +import appeng.api.networking.crafting.ICraftingCPU; +import appeng.api.networking.crafting.ICraftingService; +import appeng.api.networking.storage.IStorageService; +import appeng.api.stacks.AEFluidKey; +import appeng.api.stacks.AEItemKey; +import appeng.api.stacks.AEKey; +import appeng.api.stacks.AEKeyType; +import appeng.api.stacks.GenericStack; +import appeng.api.stacks.KeyCounter; +import appeng.api.storage.AEKeyFilter; +import appeng.api.storage.IStorageProvider; +import appeng.api.storage.MEStorage; +import appeng.api.storage.cells.IBasicCellItem; +import appeng.blockentity.storage.DriveBlockEntity; +import appeng.crafting.execution.CraftingCpuLogic; +import appeng.crafting.pattern.EncodedPatternItem; +import appeng.helpers.iface.PatternContainer; +import appeng.items.storage.BasicStorageCell; +import appeng.me.cells.BasicCellHandler; +import appeng.me.cells.BasicCellInventory; +import appeng.me.cluster.implementations.CraftingCPUCluster; +import appeng.parts.storagebus.StorageBusPart; +import com.the9grounds.aeadditions.item.storage.StorageCell; +import com.the9grounds.aeadditions.item.storage.SuperStorageCell; +import de.srendi.advancedperipherals.AdvancedPeripherals; +import de.srendi.advancedperipherals.common.addons.APAddons; +import de.srendi.advancedperipherals.common.util.LuaConverter; +import de.srendi.advancedperipherals.common.util.Pair; +import de.srendi.advancedperipherals.common.util.inventory.FluidFilter; +import de.srendi.advancedperipherals.common.util.inventory.GenericFilter; +import de.srendi.advancedperipherals.common.util.inventory.ItemFilter; +import io.github.projectet.ae2things.item.DISKDrive; +import it.unimi.dsi.fastutil.objects.Object2LongMap; +import me.ramidzkh.mekae2.ae2.MekanismKey; +import me.ramidzkh.mekae2.ae2.MekanismKeyType; +import me.ramidzkh.mekae2.item.ChemicalStorageCell; +import mekanism.api.chemical.merged.MergedChemicalTank; +import mekanism.common.tile.TileEntityChemicalTank; +import net.minecraft.core.BlockPos; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.level.Level; +import net.minecraft.world.level.block.entity.BlockEntity; +import net.minecraftforge.common.capabilities.ForgeCapabilities; +import net.minecraftforge.common.util.LazyOptional; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.capability.IFluidHandler; +import net.minecraftforge.items.IItemHandler; +import org.jetbrains.annotations.Nullable; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; + +public class AEApi { + + public static Pair findAEStackFromStack(MEStorage monitor, @Nullable ICraftingService crafting, ItemStack item) { + return findAEStackFromFilter(monitor, crafting, ItemFilter.fromStack(item)); + } + + public static Pair findAEStackFromFilter(MEStorage monitor, @Nullable ICraftingService crafting, ItemFilter item) { + for (Object2LongMap.Entry temp : monitor.getAvailableStacks()) { + if (temp.getKey() instanceof AEItemKey key && item.test(key.toStack())) + return Pair.of(temp.getLongValue(), key); + } + + if (crafting == null) + return Pair.of(0L, AEItemKey.of(ItemStack.EMPTY)); + + for (var temp : crafting.getCraftables(param -> true)) { + if (temp instanceof AEItemKey key && item.test(key.toStack())) + return Pair.of(0L, key); + } + + return Pair.of(0L, AEItemKey.of(ItemStack.EMPTY)); + } + + public static Pair findAEFluidFromStack(MEStorage monitor, @Nullable ICraftingService crafting, FluidStack item) { + return findAEFluidFromFilter(monitor, crafting, FluidFilter.fromStack(item)); + } + + public static Pair findAEFluidFromFilter(MEStorage monitor, @Nullable ICraftingService crafting, FluidFilter item) { + for (Object2LongMap.Entry temp : monitor.getAvailableStacks()) { + if (temp.getKey() instanceof AEFluidKey key && item.test(key.toStack(1))) + return Pair.of(temp.getLongValue(), key); + } + + if (crafting == null) + return Pair.of(0L, AEFluidKey.of(FluidStack.EMPTY)); + + for (var temp : crafting.getCraftables(param -> true)) { + if (temp instanceof AEFluidKey key && item.test(key.toStack(1))) + return Pair.of(0L, key); + } + + return Pair.of(0L, AEFluidKey.of(FluidStack.EMPTY)); + } + + /** + * Finds a pattern from filters. + * + * @param grid The grid to search patterns from. + * @param level The level of the grid. + * @param inputFilter The input filter to apply, can be null to ignore input filter. + * @param outputFilter The output filter to apply, can be null to ignore output filter. + * @return A Pair object containing the matched pattern and an error message if no pattern is found. + * The pattern can be null if no pattern is found. + * The error message is "NO_PATTERN_FOUND" if no pattern is found. + */ + public static Pair findPatternFromFilters(IGrid grid, Level level, @Nullable GenericFilter inputFilter, @Nullable GenericFilter outputFilter) { + for (IPatternDetails pattern : getPatterns(grid, level)) { + if (pattern.getInputs().length == 0) + continue; + if (pattern.getOutputs().length == 0) + continue; + + boolean inputMatch = false; + boolean outputMatch = false; + + if (inputFilter != null) { + outerLoop: + for (IPatternDetails.IInput input : pattern.getInputs()) { + for (GenericStack possibleInput : input.getPossibleInputs()) { + if (inputFilter.testAE(possibleInput)) { + inputMatch = true; + break outerLoop; + } + } + } + } else { + inputMatch = true; + } + + if (outputFilter != null) { + for (GenericStack output : pattern.getOutputs()) { + if (outputFilter.testAE(output)) { + outputMatch = true; + break; + } + } + } else { + outputMatch = true; + } + + if (inputMatch && outputMatch) + return Pair.of(pattern, null); + } + + return Pair.of(null, "NO_PATTERN_FOUND"); + } + + + public static List listStacks(MEStorage monitor, ICraftingService service) { + List items = new ArrayList<>(); + KeyCounter keyCounter = monitor.getAvailableStacks(); + for (Object2LongMap.Entry aeKey : keyCounter) { + if (aeKey.getKey() instanceof AEItemKey itemKey) { + items.add(parseAeStack(Pair.of(aeKey.getLongValue(), itemKey), service)); + } + } + return items; + } + + public static List listCraftableStacks(MEStorage monitor, ICraftingService service) { + List items = new ArrayList<>(); + KeyCounter keyCounter = monitor.getAvailableStacks(); + Set craftables = service.getCraftables(AEKeyFilter.none()); + for (AEKey aeKey : craftables) { + if (aeKey instanceof AEItemKey) { + items.add(parseAeStack(Pair.of(keyCounter.get(aeKey), aeKey), service)); + } + } + return items; + } + + public static List listFluids(MEStorage monitor, ICraftingService service) { + List items = new ArrayList<>(); + for (Object2LongMap.Entry aeKey : monitor.getAvailableStacks()) { + if (aeKey.getKey() instanceof AEFluidKey itemKey) { + items.add(parseAeStack(Pair.of(aeKey.getLongValue(), itemKey), service)); + } + } + return items; + } + + public static List listGases(MEStorage monitor, ICraftingService service) { + List items = new ArrayList<>(); + for (Object2LongMap.Entry aeKey : monitor.getAvailableStacks()) { + if (APAddons.appMekLoaded && aeKey.getKey() instanceof MekanismKey itemKey) { + items.add(parseAeStack(Pair.of(aeKey.getLongValue(), itemKey), service)); + } + } + return items; + } + + public static List listCraftableFluids(MEStorage monitor, ICraftingService service) { + List items = new ArrayList<>(); + KeyCounter keyCounter = monitor.getAvailableStacks(); + Set craftables = service.getCraftables(AEKeyFilter.none()); + for (AEKey aeKey : craftables) { + if (aeKey instanceof AEFluidKey) { + items.add(parseAeStack(Pair.of(keyCounter.get(aeKey), aeKey), service)); + } + } + return items; + } + + public static List getPatterns(IGrid grid, Level level) { + List patterns = new ArrayList<>(); + for (var machineClass : grid.getMachineClasses()) { + var containerClass = tryCastMachineToContainer(machineClass); + if (containerClass == null) + continue; + + for (var container : grid.getActiveMachines(containerClass)) { + for (ItemStack patternItem : container.getTerminalPatternInventory()) { + if (patternItem.getItem() instanceof EncodedPatternItem item) { + IPatternDetails patternDetails = item.decode(patternItem, level, false); + if (patternDetails == null) + continue; + + patterns.add(patternDetails); + } + } + } + } + return patterns; + } + + public static List listPatterns(IGrid grid, Level level) { + return getPatterns(grid, level).stream().map(AEApi::parsePattern).collect(Collectors.toList()); + } + + public static List listDrives(IGrid grid) { + List drives = new ArrayList<>(); + + for (IGridNode node : grid.getMachineNodes(DriveBlockEntity.class)) { + DriveBlockEntity drive = (DriveBlockEntity) node.getService(IStorageProvider.class); + + // A normal drive has a cellCount of 10 + if (drive == null || drive.getCellCount() != 10) + continue; + + drives.add(parseDrive(drive)); + } + + return drives; + } + + private static Class tryCastMachineToContainer(Class machineClass) { + if (PatternContainer.class.isAssignableFrom(machineClass)) + return machineClass.asSubclass(PatternContainer.class); + + return null; + } + + public static Map parseAeStack(Pair stack, @Nullable ICraftingService service) { + if (stack == null || stack.getRight() == null) + return Collections.emptyMap(); + if (stack.getRight() instanceof AEItemKey itemKey) + return parseItemStack(Pair.of(stack.getLeft(), itemKey), service); + if (stack.getRight() instanceof AEFluidKey fluidKey) + return parseFluidStack(Pair.of(stack.getLeft(), fluidKey), service); + if (APAddons.appMekLoaded && (stack.getRight() instanceof MekanismKey gasKey)) + return parseChemStack(Pair.of(stack.getLeft(), gasKey)); + + AdvancedPeripherals.debug("Could not create table from unknown stack " + stack.getRight().getClass() + " - Report this to the maintainer of ap", org.apache.logging.log4j.Level.WARN); + return Collections.emptyMap(); + } + + public static Map parseGenericStack(GenericStack stack) { + if (stack.what() == null) + return Collections.emptyMap(); + if (stack.what() instanceof AEItemKey aeItemKey) + return parseItemStack(Pair.of(stack.amount(), aeItemKey), null); + if (stack.what() instanceof AEFluidKey aeFluidKey) + return parseFluidStack(Pair.of(stack.amount(), aeFluidKey), null); + + AdvancedPeripherals.debug("Could not create table from unknown stack " + stack.getClass() + " - Report this to the maintainer of ap", org.apache.logging.log4j.Level.WARN); + return Collections.emptyMap(); + } + + public static List parseKeyCounter(KeyCounter counter) { + List parsedKeys = new ArrayList<>(); + for (AEKey key : counter.keySet()) { + parsedKeys.add(parseGenericStack(new GenericStack(key, counter.get(key)))); + } + + return parsedKeys; + } + + public static Map parseDrive(DriveBlockEntity drive) { + Map map = new HashMap<>(); + + map.put("powered", drive.isPowered()); + + long totalBytes = 0; + long usedBytes = 0; + + if (drive.getCellCount() != 10) + return map; + + List driveCells = new ArrayList<>(); + for (ItemStack item : drive.getInternalInventory()) { + if (item.getItem() instanceof BasicStorageCell cell) { + BasicCellInventory cellInventory = BasicCellHandler.INSTANCE.getCellInventory(item, null); + totalBytes += cellInventory.getTotalBytes(); + usedBytes += cellInventory.getUsedBytes(); + + driveCells.add(parseCell(cell, item)); + } + } + + map.put("usedBytes", usedBytes); + map.put("totalBytes", totalBytes); + map.put("cells", driveCells); + map.put("priority", drive.getPriority()); + map.put("menuIcon", LuaConverter.itemToObject(drive.getMainMenuIcon().getItem())); + map.put("position", LuaConverter.posToObject(drive.getBlockPos())); + map.put("name", drive.getCustomInventoryName().getString()); + + return map; + } + + public static Map parseCell(IBasicCellItem cell, ItemStack cellItem) { + Map map = new HashMap<>(); + BasicCellInventory cellInventory = BasicCellHandler.INSTANCE.getCellInventory(cellItem, null); + + map.put("item", LuaConverter.itemToObject(cellItem.getItem())); + map.put("type", cell.getKeyType().toString()); + map.put("bytes", cell.getBytes(cellItem)); + map.put("bytesPerType", cell.getBytesPerType(cellItem)); + map.put("usedBytes", cellInventory.getUsedBytes()); + map.put("totalTypes", cell.getTotalTypes(cellItem)); + map.put("fuzzyMode", cell.getFuzzyMode(cellItem).toString()); + + return map; + } + + private static Map parseItemStack(Pair stack, @Nullable ICraftingService craftingService) { + Map map = LuaConverter.itemStackToObject(stack.getRight().toStack()); + map.put("isCraftable", craftingService != null && craftingService.isCraftable(stack.getRight())); + map.put("count", stack.getLeft()); + return map; + } + + private static Map parseFluidStack(Pair stack, @Nullable ICraftingService craftingService) { + Map map = LuaConverter.fluidStackToObject(stack.getRight().toStack(1)); + map.put("count", stack.getLeft()); + map.put("isCraftable", craftingService != null && craftingService.isCraftable(stack.getRight())); + return map; + } + + private static Map parseChemStack(Pair stack) { + Map map = new HashMap<>(); + long amount = stack.getLeft(); + map.put("name", stack.getRight().getStack().getTypeRegistryName().toString()); + map.put("amount", amount); + map.put("displayName", stack.getRight().getDisplayName().getString()); + map.put("tags", LuaConverter.tagsToList(() -> stack.getRight().getStack().getType().getTags())); + + return map; + } + + public static Map parsePattern(IPatternDetails pattern) { + Map map = new HashMap<>(); + + map.put("inputs", Arrays.stream(pattern.getInputs()).map(AEApi::parsePatternInput).collect(Collectors.toList())); + map.put("outputs", Arrays.stream(pattern.getOutputs()).map(AEApi::parseGenericStack).collect(Collectors.toList())); + map.put("primaryOutput", parseGenericStack(pattern.getPrimaryOutput())); + return map; + } + + public static Map parsePatternInput(IPatternDetails.IInput patternInput) { + Map map = new HashMap<>(); + map.put("primaryInput", parseGenericStack(patternInput.getPossibleInputs()[0])); + map.put("possibleInputs", + Arrays.stream(Arrays.copyOfRange(patternInput.getPossibleInputs(), 1, patternInput.getPossibleInputs().length)) + .map(AEApi::parseGenericStack)); + map.put("multiplier", patternInput.getMultiplier()); + map.put("remaining", patternInput.getRemainingKey(patternInput.getPossibleInputs()[0].what())); + return map; + } + + public static Map parseCraftingCPU(ICraftingCPU cpu, boolean recursive) { + Map map = new HashMap<>(); + long storage = cpu.getAvailableStorage(); + int coProcessors = cpu.getCoProcessors(); + boolean isBusy = cpu.isBusy(); + map.put("storage", storage); + map.put("coProcessors", coProcessors); + map.put("isBusy", isBusy); + if (!recursive) + map.put("craftingJob", cpu.getJobStatus() != null ? parseCraftingJob(cpu.getJobStatus(), null, null) : null); + map.put("name", cpu.getName() != null ? cpu.getName().getString() : "Unnamed"); + map.put("selectionMode", cpu.getSelectionMode().toString()); + + return map; + } + + public static Object parseCraftingJob(CraftingJobStatus status, AECraftJob craftJob, @Nullable ICraftingCPU cpu) { + Map properties = new HashMap<>(); + + properties.put("bridge_id", craftJob == null ? -1 : craftJob.getId()); + properties.put("quantity", status.crafting().amount()); + properties.put("resource", parseGenericStack(status.crafting())); + + if (cpu != null) { + CraftingCpuLogic craftingCpuLogic = ((CraftingCPUCluster) cpu).craftingLogic; + long pending = craftingCpuLogic.getPendingOutputs(status.crafting().what()); + long active = craftingCpuLogic.getWaitingFor(status.crafting().what()); + long crafted = status.crafting().amount() - (pending + active); + properties.put("completion", crafted / (double) status.crafting().amount()); + properties.put("crafted", crafted); + + properties.put("id", craftingCpuLogic.getLastLink().getCraftingID().toString()); + + properties.put("cpu", parseCraftingCPU(cpu, true)); + } + + return properties; + } + + public static MEStorage getMonitor(IGridNode node) { + return node.getGrid().getService(IStorageService.class).getInventory(); + } + + public static boolean isCrafting(ICraftingService grid, GenericFilter filter, + @Nullable ICraftingCPU craftingCPU) { + + // If the passed cpu is null, check all cpus + if (craftingCPU == null) { + // Loop through all crafting cpus and check if the item is being crafted. + for (ICraftingCPU cpu : grid.getCpus()) { + if (cpu.isBusy()) { + CraftingJobStatus jobStatus = cpu.getJobStatus(); + + // avoid null pointer exception + if (jobStatus == null) + continue; + + if (filter.testAE(jobStatus.crafting())) + return true; + } + } + } else { + if (craftingCPU.isBusy()) { + CraftingJobStatus jobStatus = craftingCPU.getJobStatus(); + + // avoid null pointer exception + if (jobStatus == null) + return false; + + return filter.testAE(jobStatus.crafting()); + } + } + + return false; + } + + /// External Storage + /// Total + + public static long getTotalExternalItemStorage(IGridNode node) { + long total = 0; + + for (IGridNode iGridNode : node.getGrid().getMachineNodes(StorageBusPart.class)) { + StorageBusPart bus = (StorageBusPart) iGridNode.getService(IStorageProvider.class); + Level level = bus.getLevel(); + BlockPos connectedInventoryPos = bus.getHost().getBlockEntity().getBlockPos().relative(bus.getSide()); + BlockEntity connectedInventoryEntity = level.getBlockEntity(connectedInventoryPos); + + if (connectedInventoryEntity == null) + continue; + + LazyOptional itemHandler = connectedInventoryEntity.getCapability(ForgeCapabilities.ITEM_HANDLER); + if (itemHandler.isPresent()) { + IItemHandler handler = itemHandler.orElse(null); + for (int i = 0; i < handler.getSlots(); i++) { + total += handler.getSlotLimit(i); + } + } + } + + return total; + } + + public static long getTotalExternalFluidStorage(IGridNode node) { + long total = 0; + + for (IGridNode iGridNode : node.getGrid().getMachineNodes(StorageBusPart.class)) { + StorageBusPart bus = (StorageBusPart) iGridNode.getService(IStorageProvider.class); + Level level = bus.getLevel(); + BlockPos connectedInventoryPos = bus.getHost().getBlockEntity().getBlockPos().relative(bus.getSide()); + BlockEntity connectedInventoryEntity = level.getBlockEntity(connectedInventoryPos); + + if (connectedInventoryEntity == null) + continue; + + LazyOptional fluidHandler = connectedInventoryEntity.getCapability(ForgeCapabilities.FLUID_HANDLER); + if (fluidHandler.isPresent()) { + IFluidHandler handler = fluidHandler.orElse(null); + for (int i = 0; i < handler.getTanks(); i++) { + total += handler.getTankCapacity(i); + } + } + } + + return total; + } + + public static long getTotalExternalChemicalStorage(IGridNode node) { + long total = 0; + + if (!APAddons.appMekLoaded) + return 0; + + for (IGridNode iGridNode : node.getGrid().getMachineNodes(StorageBusPart.class)) { + StorageBusPart bus = (StorageBusPart) iGridNode.getService(IStorageProvider.class); + Level level = bus.getLevel(); + BlockPos connectedInventoryPos = bus.getHost().getBlockEntity().getBlockPos().relative(bus.getSide()); + BlockEntity connectedInventoryEntity = level.getBlockEntity(connectedInventoryPos); + + if (connectedInventoryEntity == null) + continue; + + if (connectedInventoryEntity instanceof TileEntityChemicalTank tank) { + MergedChemicalTank.Current current = tank.getChemicalTank().getCurrent() == MergedChemicalTank.Current.EMPTY ? MergedChemicalTank.Current.GAS : tank.getChemicalTank().getCurrent(); + total += tank.getChemicalTank().getTankFromCurrent(current).getCapacity(); + } + } + + return total; + } + + /// Used + + public static long getUsedExternalItemStorage(IGridNode node) { + long used = 0; + + for (IGridNode iGridNode : node.getGrid().getMachineNodes(StorageBusPart.class)) { + StorageBusPart bus = (StorageBusPart) iGridNode.getService(IStorageProvider.class); + KeyCounter keyCounter = bus.getInternalHandler().getAvailableStacks(); + + for (Object2LongMap.Entry aeKey : keyCounter) { + if (aeKey.getKey() instanceof AEItemKey) + used += aeKey.getLongValue(); + } + } + + return used; + } + + public static long getUsedExternalFluidStorage(IGridNode node) { + long used = 0; + + for (IGridNode iGridNode : node.getGrid().getMachineNodes(StorageBusPart.class)) { + StorageBusPart bus = (StorageBusPart) iGridNode.getService(IStorageProvider.class); + KeyCounter keyCounter = bus.getInternalHandler().getAvailableStacks(); + + for (Object2LongMap.Entry aeKey : keyCounter) { + if (aeKey.getKey() instanceof AEFluidKey) + used += aeKey.getLongValue(); + } + } + + return used; + } + + public static long getUsedExternalChemicalStorage(IGridNode node) { + long used = 0; + + if (!APAddons.appMekLoaded) + return 0; + + for (IGridNode iGridNode : node.getGrid().getMachineNodes(StorageBusPart.class)) { + StorageBusPart bus = (StorageBusPart) iGridNode.getService(IStorageProvider.class); + KeyCounter keyCounter = bus.getInternalHandler().getAvailableStacks(); + + for (Object2LongMap.Entry aeKey : keyCounter) { + if (aeKey.getKey() instanceof MekanismKey) + used += aeKey.getLongValue(); + } + } + + return used; + } + + /// Internal Storage + /// Total + + public static long getTotalItemStorage(IGridNode node) { + long total = 0; + + // note: do not query DriveBlockEntity.class specifically here, because it will avoid subclasses, e.g. the ME Extended Drive from ExtendedAE + Iterator iterator = node.getGrid().getNodes().iterator(); + + while (iterator.hasNext()) { + if (!(iterator.next().getService(IStorageProvider.class) instanceof DriveBlockEntity entity)) + continue; + + InternalInventory inventory = entity.getInternalInventory(); + + for (int i = 0; i < inventory.size(); i++) { + ItemStack stack = inventory.getStackInSlot(i); + + if (stack.isEmpty()) + continue; + + if (stack.getItem() instanceof IBasicCellItem cell) { + if (cell.getKeyType().getClass().isAssignableFrom(AEKeyType.items().getClass())) { + total += cell.getBytes(null); + } + } else if (APAddons.aeThingsLoaded && stack.getItem() instanceof DISKDrive disk) { + if (disk.getKeyType().toString().equals("ae2:i")) { + total += disk.getBytes(null); + } + } else if (APAddons.aeAdditionsLoaded && (stack.getItem() instanceof SuperStorageCell superStorageCell)) { + total += superStorageCell.getKiloBytes() * 1024L; + } else if (APAddons.aeAdditionsLoaded && (stack.getItem() instanceof StorageCell storageCell)) { + if (storageCell.getKeyType() != AEKeyType.items()) + continue; + total += storageCell.getKiloBytes() * 1024; + } + } + } + return total; + } + + public static long getTotalFluidStorage(IGridNode node) { + long total = 0; + + Iterator iterator = node.getGrid().getNodes().iterator(); + + while (iterator.hasNext()) { + if (!(iterator.next().getService(IStorageProvider.class) instanceof DriveBlockEntity entity)) + continue; + + InternalInventory inventory = entity.getInternalInventory(); + + for (int i = 0; i < inventory.size(); i++) { + ItemStack stack = inventory.getStackInSlot(i); + + if (stack.isEmpty()) + continue; + + if (stack.getItem() instanceof IBasicCellItem cell) { + if (cell.getKeyType().getClass().isAssignableFrom(AEKeyType.fluids().getClass())) { + total += cell.getBytes(null); + } + } else if (APAddons.aeAdditionsLoaded && stack.getItem() instanceof SuperStorageCell superStorageCell) { + total += superStorageCell.getKiloBytes() * 1024L; + } else if (APAddons.aeAdditionsLoaded && (stack.getItem() instanceof StorageCell storageCell)) { + if (storageCell.getKeyType() != AEKeyType.fluids()) + continue; + total += storageCell.getKiloBytes() * 1024; + } + } + } + + return total; + } + + public static long getTotalChemicalStorage(IGridNode node) { + long total = 0; + + if (!APAddons.appMekLoaded) + return 0; + + for (IGridNode iGridNode : node.getGrid().getMachineNodes(DriveBlockEntity.class)) { + DriveBlockEntity entity = (DriveBlockEntity) iGridNode.getService(IStorageProvider.class); + if (entity == null) + continue; + + InternalInventory inventory = entity.getInternalInventory(); + + for (int i = 0; i < inventory.size(); i++) { + ItemStack stack = inventory.getStackInSlot(i); + + if (stack.isEmpty()) + continue; + + if (stack.getItem() instanceof ChemicalStorageCell cell) { + if (cell.getKeyType() instanceof MekanismKeyType) { + total += cell.getBytes(null); + } + } + } + } + + return total; + } + + /// Used + + public static long getUsedItemStorage(IGridNode node) { + long used = 0; + + Iterator iterator = node.getGrid().getNodes().iterator(); + + while (iterator.hasNext()) { + if (!(iterator.next().getService(IStorageProvider.class) instanceof DriveBlockEntity entity)) + continue; + + InternalInventory inventory = entity.getInternalInventory(); + + for (int i = 0; i < inventory.size(); i++) { + ItemStack stack = inventory.getStackInSlot(i); + + if (stack.isEmpty()) + continue; + + if (stack.getItem() instanceof IBasicCellItem cell) { + if (cell.getKeyType().getClass().isAssignableFrom(AEKeyType.items().getClass())) { + BasicCellInventory cellInventory = BasicCellHandler.INSTANCE.getCellInventory(stack, null); + + used += cellInventory.getUsedBytes(); + } + } else if (APAddons.aeThingsLoaded && stack.getItem() instanceof DISKDrive disk) { + if (disk.getKeyType().toString().equals("ae2:i")) { + if (stack.getTag() == null) + continue; + long numBytesInCell = stack.getTag().getLong("ic"); + used += numBytesInCell; + } + } else if (APAddons.aeAdditionsLoaded && stack.getItem() instanceof SuperStorageCell) { + if (stack.getTag() == null) + continue; + long numItemsInCell = stack.getTag().getLong("ic"); + + used += numItemsInCell; + } else if (APAddons.aeAdditionsLoaded && stack.getItem() instanceof StorageCell storageCell) { + if (storageCell.getKeyType() != AEKeyType.items()) + continue; + if (stack.getTag() == null) + continue; + long numItemsInCell = stack.getTag().getLong("ic"); + + used += numItemsInCell; + } + } + } + + return used; + } + + public static long getUsedFluidStorage(IGridNode node) { + long used = 0; + + Iterator iterator = node.getGrid().getNodes().iterator(); + + while (iterator.hasNext()) { + if (!(iterator.next().getService(IStorageProvider.class) instanceof DriveBlockEntity entity)) + continue; + + InternalInventory inventory = entity.getInternalInventory(); + + for (int i = 0; i < inventory.size(); i++) { + ItemStack stack = inventory.getStackInSlot(i); + + if (stack.getItem() instanceof IBasicCellItem cell) { + if (cell.getKeyType().getClass().isAssignableFrom(AEKeyType.fluids().getClass())) { + BasicCellInventory cellInventory = BasicCellHandler.INSTANCE.getCellInventory(stack, null); + + used += cellInventory.getUsedBytes(); + } + } else if (APAddons.aeAdditionsLoaded && stack.getItem() instanceof SuperStorageCell) { + if (stack.getTag() == null) + continue; + long numItemsInCell = stack.getTag().getLong("ic"); + + used += numItemsInCell; + } else if (APAddons.aeAdditionsLoaded && stack.getItem() instanceof StorageCell storageCell) { + if (storageCell.getKeyType() != AEKeyType.fluids()) + continue; + if (stack.getTag() == null) + continue; + long numItemsInCell = stack.getTag().getLong("ic"); + + used += numItemsInCell; + } + } + } + + return used; + } + + public static long getUsedChemicalStorage(IGridNode node) { + long used = 0; + + if (!APAddons.appMekLoaded) + return 0; + + for (IGridNode iGridNode : node.getGrid().getMachineNodes(DriveBlockEntity.class)) { + DriveBlockEntity entity = (DriveBlockEntity) iGridNode.getService(IStorageProvider.class); + if (entity == null) + continue; + + InternalInventory inventory = entity.getInternalInventory(); + + for (int i = 0; i < inventory.size(); i++) { + ItemStack stack = inventory.getStackInSlot(i); + + if (stack.getItem() instanceof ChemicalStorageCell) { + BasicCellInventory cellInventory = BasicCellHandler.INSTANCE.getCellInventory(stack, null); + + used = cellInventory.getUsedBytes() / MekanismKeyType.TYPE.getAmountPerByte(); + } + } + } + + return used; + } + + /// Available Storage + + /** + * Calculates the available item storage on a given grid node. + * It subtracts the used item storage from the total item storage. + * + * @param node The grid node to calculate the available item storage for. + * @return The available item storage in bytes. + */ + public static long getAvailableItemStorage(IGridNode node) { + return getTotalItemStorage(node) - getUsedItemStorage(node); + } + + /** + * Calculates the available fluid storage in a given grid node. + * + * @param node The grid node to calculate the available fluid storage for. + * @return The available fluid storage in bytes. + */ + public static long getAvailableFluidStorage(IGridNode node) { + return getTotalFluidStorage(node) - getUsedFluidStorage(node); + } + + public static long getAvailableChemicalStorage(IGridNode node) { + return getTotalChemicalStorage(node) - getUsedChemicalStorage(node); + } + + /** + * Calculates the available external item storage of a given grid node. + * + * @param node The grid node for which to calculate the available external item storage. + * @return The available external item storage. + */ + public static long getAvailableExternalItemStorage(IGridNode node) { + return getTotalExternalItemStorage(node) - getUsedExternalItemStorage(node); + } + + /** + * Calculates the available external fluid storage on a given grid node by subtracting the used external fluid storage + * from the total external fluid storage. + * + * @param node The grid node on which to calculate the available external fluid storage. + * @return The available external fluid storage on the grid node. + */ + public static long getAvailableExternalFluidStorage(IGridNode node) { + return getTotalExternalFluidStorage(node) - getUsedExternalFluidStorage(node); + } + + public static long getAvailableExternalChemicalStorage(IGridNode node) { + return getTotalExternalChemicalStorage(node) - getUsedExternalChemicalStorage(node); + } + + public static ICraftingCPU getCraftingCPU(IGridNode node, String cpuName) { + if (cpuName.isEmpty()) return null; + ICraftingService grid = node.getGrid().getService(ICraftingService.class); + if (grid == null) return null; + + Iterator iterator = grid.getCpus().iterator(); + if (!iterator.hasNext()) return null; + + while (iterator.hasNext()) { + ICraftingCPU cpu = iterator.next(); + + if (cpu.getName() != null && cpu.getName().getString().equals(cpuName)) { + return cpu; + } + } + + return null; + } + + public static List listCells(IGridNode node) { + List items = new ArrayList<>(); + + Iterator iterator = node.getGrid().getNodes().iterator(); + + if (!iterator.hasNext()) return items; + while (iterator.hasNext()) { + IStorageProvider entity = iterator.next().getService(IStorageProvider.class); + if (!(entity instanceof DriveBlockEntity drive)) + continue; + + InternalInventory inventory = drive.getInternalInventory(); + + for (int i = 0; i < inventory.size(); i++) { + ItemStack stack = inventory.getStackInSlot(i); + + if (stack.isEmpty()) + continue; + + if (stack.getItem() instanceof IBasicCellItem cell) { + items.add(parseCell(cell, stack)); + } else if (APAddons.aeThingsLoaded && stack.getItem() instanceof DISKDrive disk) { + items.add(getObjectFromDisk(disk, stack)); + } else if (APAddons.aeAdditionsLoaded && stack.getItem() instanceof SuperStorageCell superStorageCell) { + items.add(getObjectFromSuperCell(superStorageCell, stack)); + } + } + } + + return items; + } + + private static Map getObjectFromDisk(DISKDrive drive, ItemStack stack) { + Map map = new HashMap<>(); + + map.put("item", stack.getItem().toString()); + + String cellType = ""; + + if (drive.getKeyType().toString().equals("ae2:i")) { + cellType = "item"; + } else if (drive.getKeyType().toString().equals("ae2:f")) { + cellType = "fluid"; + } + + map.put("cellType", cellType); + map.put("totalBytes", drive.getBytes(null)); + + return map; + } + + private static Map getObjectFromSuperCell(SuperStorageCell cell, ItemStack stack) { + Map map = new HashMap<>(); + + map.put("item", stack.getItem().toString()); + + String cellType = "all"; + + map.put("cellType", cellType); + map.put("totalBytes", cell.getBytes(stack)); + + return map; + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/ae2/AECraftJob.java b/src/main/java/de/srendi/advancedperipherals/common/addons/ae2/AECraftJob.java new file mode 100644 index 000000000..f59291c09 --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/ae2/AECraftJob.java @@ -0,0 +1,312 @@ +package de.srendi.advancedperipherals.common.addons.ae2; + +import appeng.api.networking.IGrid; +import appeng.api.networking.IGridNode; +import appeng.api.networking.crafting.CalculationStrategy; +import appeng.api.networking.crafting.CraftingJobStatus; +import appeng.api.networking.crafting.ICraftingCPU; +import appeng.api.networking.crafting.ICraftingLink; +import appeng.api.networking.crafting.ICraftingPlan; +import appeng.api.networking.crafting.ICraftingRequester; +import appeng.api.networking.crafting.ICraftingService; +import appeng.api.networking.crafting.ICraftingSimulationRequester; +import appeng.api.networking.crafting.ICraftingSubmitResult; +import appeng.api.networking.security.IActionSource; +import appeng.api.stacks.AEKey; +import appeng.api.stacks.KeyCounter; +import appeng.me.cluster.implementations.CraftingCPUCluster; +import dan200.computercraft.api.lua.LuaFunction; +import dan200.computercraft.api.peripheral.IComputerAccess; +import de.srendi.advancedperipherals.AdvancedPeripherals; +import de.srendi.advancedperipherals.common.blocks.blockentities.MeBridgeEntity; +import de.srendi.advancedperipherals.common.util.BasicCraftJob; +import de.srendi.advancedperipherals.common.util.StatusConstants; +import net.minecraft.world.level.Level; +import org.jetbrains.annotations.Nullable; + +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Future; +import java.util.function.Supplier; + +//TODO needs to persistent - should be stored in the me bridge +// We also need to do the same for the rs bridge. So we want to create a proper interface to keep the lua functions the same +public class AECraftJob extends BasicCraftJob { + + private final IGridNode node; + private final IActionSource source; + private final ICraftingSimulationRequester simulationRequester; + private final ICraftingRequester requester; + private ICraftingCPU targetCpu; + private final AEKey toCraft; + + private Future futureJob; + private ICraftingPlan currentJob; + @Nullable + private ICraftingLink jobLink; // Job after calculation was done + // Because the properties in `CraftingJobStatus` are set when the object is created, we need to create a supplier which + // always re-fetches the object from the cpu + private Supplier jobStatus; + // In the case the job is done and would return null, we have this cached one. + private CraftingJobStatus cachedStatus; + + public AECraftJob(Level world, final IComputerAccess computer, IGridNode node, AEKey item, long amount, MeBridgeEntity bridge, ICraftingCPU target) { + super(computer, "ae", world, amount); + this.node = node; + this.source = bridge; + this.toCraft = item; + this.simulationRequester = bridge; + this.requester = bridge; + this.targetCpu = target; + } + + @LuaFunction + public final Object getCraftingCPU() { + return AEApi.parseCraftingCPU(targetCpu, true); + } + + @Nullable + public ICraftingLink getJobLink() { + return jobLink; + } + + public ICraftingCPU getTargetCpu() { + return targetCpu; + } + + public AEKey getToCraft() { + return toCraft; + } + + @Override + protected boolean isJobDone() { + return jobLink != null && jobLink.isDone(); + } + + @Override + protected boolean isJobCanceled() { + return jobLink != null && jobLink.isCanceled(); + } + + @Override + public Object getParsedRequestedItem() { + if (getJobStatus() == null) { + return null; + } + return AEApi.parseGenericStack(getJobStatus().crafting()); + } + + @Override + public long getElapsedTime() { + if (getJobStatus() == null) { + return -1; + } + return getJobStatus().elapsedTimeNanos(); + } + + @Override + public long getTotalItems() { + if (getJobStatus() == null) { + return -1; + } + return getJobStatus().totalItems(); + } + + @Override + public long getItemProgress() { + if (getJobStatus() == null) { + return -1; + } + return getJobStatus().progress(); + } + + @Override + public Object getEmittedItems() { + if (currentJob == null) { + return null; + } + return AEApi.parseKeyCounter(currentJob.emittedItems()); + } + + @Override + public Object getUsedItems() { + if (currentJob == null) { + return null; + } + return AEApi.parseKeyCounter(currentJob.usedItems()); + } + + @Override + public Object getMissingItems() { + if (currentJob == null) { + return null; + } + return AEApi.parseKeyCounter(currentJob.missingItems()); + } + + @Override + public boolean hasMultiplePaths() { + if (currentJob == null) { + return false; + } + return currentJob.multiplePaths(); + } + + @Override + public Object getFinalOutput() { + if (currentJob == null) { + return null; + } + return AEApi.parseGenericStack(currentJob.finalOutput()); + } + + @Override + public boolean cancel() { + if (targetCpu instanceof CraftingCPUCluster cluster) { + if (cluster.isBusy()) { + cluster.cancel(); + return true; + } + } + return false; + } + + @LuaFunction + public long getUsedBytes() { + if (currentJob == null) { + return -1; + } + return currentJob.bytes(); + } + + public AECraftJob withJobStatus(Supplier jobStatus) { + this.jobStatus = jobStatus; + return this; + } + + public AECraftJob withCPU(ICraftingCPU craftingCpu) { + if (this.targetCpu == null) { + this.targetCpu = craftingCpu; + } + return this; + } + + public void startCalculation() { + if (startedCalculation) { + return; + } + startedCalculation = true; + + IGrid grid = node.getGrid(); + + ICraftingService craftingService = grid.getService(ICraftingService.class); + + if (!craftingService.isCraftable(toCraft)) { + fireEvent(true, StatusConstants.NOT_CRAFTABLE); + calculationNotSuccessful = true; + return; + } + + futureJob = craftingService.beginCraftingCalculation(world, this.simulationRequester, toCraft, amount, CalculationStrategy.REPORT_MISSING_ITEMS); + fireEvent(false, StatusConstants.CALCULATION_STARTED); + } + + public void maybeCraft() { + if (startedCrafting || futureJob == null || !futureJob.isDone()) { + return; + } + ICraftingPlan job; + + try { + job = futureJob.get(); + } catch (ExecutionException | InterruptedException ex) { + AdvancedPeripherals.debug("Tried to get job, but job calculation is not done. Should be done.", org.apache.logging.log4j.Level.ERROR); + ex.printStackTrace(); + fireEvent(true, StatusConstants.UNKNOWN_ERROR); + return; + } + + if (job == null) { + AdvancedPeripherals.debug("Job is null, should not be null.", org.apache.logging.log4j.Level.ERROR); + fireEvent(true, StatusConstants.UNKNOWN_ERROR); + return; + } + this.currentJob = job; + + KeyCounter missing = job.missingItems(); + if (!missing.isEmpty()) { + fireEvent(true, StatusConstants.MISSING_ITEMS); + calculationNotSuccessful = true; + return; + } + + IGrid grid = node.getGrid(); + + ICraftingService craftingService = grid.getService(ICraftingService.class); + ICraftingSubmitResult submitResult = craftingService.submitJob(job, requester, targetCpu, false, this.source); + if (!submitResult.successful()) { + calculationNotSuccessful = true; + fireEvent(true, submitResult.errorCode().toString()); + return; + } + + this.jobLink = submitResult.link(); + this.futureJob = null; + setStartedCrafting(); + prepareCPUAndStatus(craftingService); + } + + public void jobStateChanged() { + ICraftingLink jobLink = this.jobLink; + if (jobLink == null) { + fireEvent(true, StatusConstants.UNKNOWN_ERROR); + return; + } + + if (jobLink.isCanceled() && !isJobCanceled) { + fireEvent(false, StatusConstants.JOB_CANCELED); + setJobCanceled(); + return; + } + + if (jobLink.isDone() && !isJobDone) { + fireEvent(false, StatusConstants.JOB_DONE); + setJobDone(); + } + } + + private void prepareCPUAndStatus(ICraftingService service) { + if (jobLink == null || jobStatus != null || !startedCrafting) { + return; + } + for (ICraftingCPU cpu : service.getCpus()) { + if (cpu instanceof CraftingCPUCluster cpuCluster) { + if (cpuCluster.craftingLogic.getLastLink() != null && cpuCluster.craftingLogic.getLastLink().getCraftingID().equals(jobLink.getCraftingID())) { + this.jobStatus = () -> { + // Compare the id of the job in the cpu. This job object can exist longer than the job needs time to complete. So the cpu could have a new job + if (cpuCluster.craftingLogic.getLastLink() != null && cpuCluster.craftingLogic.getLastLink().getCraftingID().equals(jobLink.getCraftingID())) + return cpuCluster.getJobStatus(); + return null; + }; + cpuCluster.craftingLogic.addListener((key) -> { + // The last time the listeners are called from the cpu logic is when the job is finished + // These listeners are not intended by ae2 to be used like this, but it works, and we don't modify the key + if (cpuCluster.getJobStatus() != null) { + this.cachedStatus = cpuCluster.getJobStatus(); + } + }); + this.targetCpu = cpu; + return; + } + } + } + AdvancedPeripherals.debug("Could not find CPU or job link even after job started", org.apache.logging.log4j.Level.WARN); + } + + private CraftingJobStatus getJobStatus() { + if (jobStatus == null || jobStatus.get() == null && cachedStatus != null) { + return cachedStatus; + } + cachedStatus = jobStatus.get(); + return jobStatus.get(); + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/appliedenergistics/MeBridgeEntityListener.java b/src/main/java/de/srendi/advancedperipherals/common/addons/ae2/MEBridgeEntityListener.java similarity index 57% rename from src/main/java/de/srendi/advancedperipherals/common/addons/appliedenergistics/MeBridgeEntityListener.java rename to src/main/java/de/srendi/advancedperipherals/common/addons/ae2/MEBridgeEntityListener.java index 1aee16c85..439caf900 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/appliedenergistics/MeBridgeEntityListener.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/ae2/MEBridgeEntityListener.java @@ -1,21 +1,20 @@ -package de.srendi.advancedperipherals.common.addons.appliedenergistics; +package de.srendi.advancedperipherals.common.addons.ae2; import appeng.api.networking.IGridNode; import appeng.api.networking.IGridNodeListener; import de.srendi.advancedperipherals.common.blocks.blockentities.MeBridgeEntity; -//TODO: Maybe do something special with these methods? -public class MeBridgeEntityListener implements IGridNodeListener { +public class MEBridgeEntityListener implements IGridNodeListener { - public static final MeBridgeEntityListener INSTANCE = new MeBridgeEntityListener(); + public static final MEBridgeEntityListener INSTANCE = new MEBridgeEntityListener(); @Override public void onSecurityBreak(MeBridgeEntity nodeOwner, IGridNode node) { - + // Maybe do something special with these methods? } @Override public void onSaveChanges(MeBridgeEntity nodeOwner, IGridNode node) { - + // Maybe do something special with these methods? } } diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/appliedenergistics/MeFluidHandler.java b/src/main/java/de/srendi/advancedperipherals/common/addons/ae2/MEFluidHandler.java similarity index 77% rename from src/main/java/de/srendi/advancedperipherals/common/addons/appliedenergistics/MeFluidHandler.java rename to src/main/java/de/srendi/advancedperipherals/common/addons/ae2/MEFluidHandler.java index 8072a777d..73936fb83 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/appliedenergistics/MeFluidHandler.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/ae2/MEFluidHandler.java @@ -1,9 +1,10 @@ -package de.srendi.advancedperipherals.common.addons.appliedenergistics; +package de.srendi.advancedperipherals.common.addons.ae2; import appeng.api.config.Actionable; import appeng.api.networking.security.IActionSource; import appeng.api.stacks.AEFluidKey; import appeng.api.storage.MEStorage; +import de.srendi.advancedperipherals.common.addons.computercraft.peripheral.MEBridgePeripheral; import de.srendi.advancedperipherals.common.util.Pair; import de.srendi.advancedperipherals.common.util.inventory.FluidFilter; import de.srendi.advancedperipherals.common.util.inventory.IStorageSystemFluidHandler; @@ -12,23 +13,24 @@ /** * Used to transfer item between an inventory and the ME system. - * @see de.srendi.advancedperipherals.common.addons.computercraft.peripheral.MeBridgePeripheral + * + * @see MEBridgePeripheral */ -public class MeFluidHandler implements IStorageSystemFluidHandler { +public class MEFluidHandler implements IStorageSystemFluidHandler { @NotNull private final MEStorage storageMonitor; @NotNull private final IActionSource actionSource; - public MeFluidHandler(@NotNull MEStorage storageMonitor, @NotNull IActionSource actionSource) { + public MEFluidHandler(@NotNull MEStorage storageMonitor, @NotNull IActionSource actionSource) { this.storageMonitor = storageMonitor; this.actionSource = actionSource; } @Override public int fill(FluidStack resource, FluidAction action) { - if(resource.isEmpty()) + if (resource.isEmpty()) return 0; AEFluidKey itemKey = AEFluidKey.of(resource.getFluid()); long inserted = storageMonitor.insert(itemKey, resource.getAmount(), action == FluidAction.SIMULATE ? Actionable.SIMULATE : Actionable.MODULATE, actionSource); @@ -39,8 +41,8 @@ public int fill(FluidStack resource, FluidAction action) { @NotNull @Override public FluidStack drain(FluidFilter filter, FluidAction simulate) { - Pair itemKey = AppEngApi.findAEFluidFromFilter(storageMonitor, null, filter); - if(itemKey == null) + Pair itemKey = AEApi.findAEFluidFromFilter(storageMonitor, null, filter); + if (itemKey == null) return FluidStack.EMPTY; long extracted = storageMonitor.extract(itemKey.getRight(), filter.getCount(), simulate == FluidAction.SIMULATE ? Actionable.SIMULATE : Actionable.MODULATE, actionSource); return new FluidStack(itemKey.getRight().getFluid(), (int) Math.min(extracted, Integer.MAX_VALUE)); diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/appliedenergistics/MeItemHandler.java b/src/main/java/de/srendi/advancedperipherals/common/addons/ae2/MEItemHandler.java similarity index 82% rename from src/main/java/de/srendi/advancedperipherals/common/addons/appliedenergistics/MeItemHandler.java rename to src/main/java/de/srendi/advancedperipherals/common/addons/ae2/MEItemHandler.java index a3542cda3..4fdc79dac 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/appliedenergistics/MeItemHandler.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/ae2/MEItemHandler.java @@ -1,9 +1,10 @@ -package de.srendi.advancedperipherals.common.addons.appliedenergistics; +package de.srendi.advancedperipherals.common.addons.ae2; import appeng.api.config.Actionable; import appeng.api.networking.security.IActionSource; import appeng.api.stacks.AEItemKey; import appeng.api.storage.MEStorage; +import de.srendi.advancedperipherals.common.addons.computercraft.peripheral.MEBridgePeripheral; import de.srendi.advancedperipherals.common.util.Pair; import de.srendi.advancedperipherals.common.util.inventory.IStorageSystemItemHandler; import de.srendi.advancedperipherals.common.util.inventory.ItemFilter; @@ -13,16 +14,16 @@ /** * Used to transfer item between an inventory and the ME system. * - * @see de.srendi.advancedperipherals.common.addons.computercraft.peripheral.MeBridgePeripheral + * @see MEBridgePeripheral */ -public class MeItemHandler implements IStorageSystemItemHandler { +public class MEItemHandler implements IStorageSystemItemHandler { @NotNull private final MEStorage storageMonitor; @NotNull private final IActionSource actionSource; - public MeItemHandler(@NotNull MEStorage storageMonitor, @NotNull IActionSource actionSource) { + public MEItemHandler(@NotNull MEStorage storageMonitor, @NotNull IActionSource actionSource) { this.storageMonitor = storageMonitor; this.actionSource = actionSource; } @@ -40,7 +41,7 @@ public ItemStack insertItem(int slot, @NotNull ItemStack stack, boolean simulate @Override public ItemStack extractItem(ItemFilter filter, int count, boolean simulate) { - Pair itemKey = AppEngApi.findAEStackFromFilter(storageMonitor, null, filter); + Pair itemKey = AEApi.findAEStackFromFilter(storageMonitor, null, filter); if (itemKey.getRight() == null) return ItemStack.EMPTY; long extracted = storageMonitor.extract(itemKey.getRight(), count, simulate ? Actionable.SIMULATE : Actionable.MODULATE, actionSource); diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/ae2/WiredCableP2PTunnelPart.java b/src/main/java/de/srendi/advancedperipherals/common/addons/ae2/WiredCableP2PTunnelPart.java new file mode 100644 index 000000000..596ce5e62 --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/ae2/WiredCableP2PTunnelPart.java @@ -0,0 +1,174 @@ +package de.srendi.advancedperipherals.common.addons.ae2; + +import appeng.api.networking.IGridNodeListener; +import appeng.api.parts.IPartItem; +import appeng.api.parts.IPartModel; +import appeng.items.parts.PartModels; +import appeng.parts.p2p.CapabilityP2PTunnelPart; +import appeng.parts.p2p.P2PModels; +import dan200.computercraft.api.ComputerCraftAPI; +import dan200.computercraft.api.network.wired.IWiredElement; +import dan200.computercraft.api.network.wired.IWiredNetworkChange; +import dan200.computercraft.api.network.wired.IWiredNode; +import dan200.computercraft.shared.Capabilities; +import de.srendi.advancedperipherals.AdvancedPeripherals; +import net.minecraft.core.BlockPos; +import net.minecraft.world.level.BlockGetter; +import net.minecraft.world.level.Level; +import net.minecraft.world.level.block.entity.BlockEntity; +import net.minecraft.world.phys.Vec3; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import javax.annotation.Nonnull; + +public class WiredCableP2PTunnelPart extends CapabilityP2PTunnelPart { + private static final P2PModels MODELS = new P2PModels(AdvancedPeripherals.getRL("part/p2p/p2p_tunnel_cable")); + + private final IWiredElement element = new P2PWiredElement(); + private final IWiredElement outElement = new P2PWiredElement(); + private final IWiredNode node = this.element.getNode(); + private Set connected = new HashSet<>(); + private boolean activated = false; + + public WiredCableP2PTunnelPart(IPartItem partItem) { + super(partItem, Capabilities.CAPABILITY_WIRED_ELEMENT); + this.inputHandler = outElement; + this.outputHandler = outElement; + this.emptyHandler = null; // should never used + } + + @PartModels + public static List getModels() { + return MODELS.getModels(); + } + + @Override + public IPartModel getStaticModels() { + return MODELS.getModel(this.isPowered(), this.isActive()); + } + + @Override + public void onTunnelConfigChange() { + super.onTunnelConfigChange(); + this.connectionsChanged(); + } + + @Override + public void onTunnelNetworkChange() { + super.onTunnelNetworkChange(); + this.connectionsChanged(); + } + + protected void connectionsChanged() { + if (this.isClientSide()) { + return; + } + if (!this.isActive()) { + return; + } + if (!this.activated) { + this.activated = true; + this.node.connectTo(this.outElement.getNode()); + } + + Stream nodeStream = this.getOutputStream().filter(out -> out != this); + WiredCableP2PTunnelPart in = this.getInput(); + if (in != null && in != this) { + nodeStream = Stream.concat(nodeStream, Stream.of(in)); + } + Set nodes = nodeStream.collect(Collectors.toCollection(HashSet::new)); + + for (WiredCableP2PTunnelPart part : this.connected.stream().filter(n -> !nodes.contains(n)).collect(Collectors.toList())) { + if (part.connected.contains(this)) { + this.node.disconnectFrom(part.node); + part.connected.remove(this); + } + this.connected.remove(part); + } + + for (WiredCableP2PTunnelPart part : nodes) { + if (!this.connected.contains(part)) { + this.node.connectTo(part.node); + this.connected.add(part); + part.connected.add(this); + } + } + } + + @Override + protected void onMainNodeStateChanged(IGridNodeListener.State reason) { + super.onMainNodeStateChanged(reason); + if (reason == IGridNodeListener.State.GRID_BOOT) { + return; + } + if (this.isActive()) { + if (!this.getMainNode().hasGridBooted()) { + return; + } + this.connectionsChanged(); + this.refreshConnection(); + } else if (this.activated) { + this.activated = false; + this.node.remove(); + this.connected.clear(); + } + } + + protected BlockPos getFacingPos() { + return this.getHost().getLocation().getPos().relative(this.getSide()); + } + + protected void refreshConnection() { + BlockEntity cable = this.getLevel().getBlockEntity(this.getFacingPos()); + IWiredElement elem = cable == null ? null : cable.getCapability(Capabilities.CAPABILITY_WIRED_ELEMENT, this.getSide().getOpposite()).orElse(null); + if (elem == null) { + return; + } + elem.getNode().connectTo(this.outElement.getNode()); + } + + @Override + public void onNeighborChanged(BlockGetter level, BlockPos pos, BlockPos neighbor) { + if (!this.getFacingPos().equals(neighbor)) { + return; + } + if (this.activated) { + this.refreshConnection(); + } + } + + private class P2PWiredElement implements IWiredElement { + private final IWiredNode node = ComputerCraftAPI.createWiredNodeForElement(this); + + @Nonnull + @Override + public IWiredNode getNode() { + return node; + } + + @Nonnull + @Override + public String getSenderID() { + return "p2p"; + } + + @Nonnull + @Override + public Level getLevel() { + return WiredCableP2PTunnelPart.this.getLevel(); + } + + @Nonnull + @Override + public Vec3 getPosition() { + return Vec3.atCenterOf(WiredCableP2PTunnelPart.this.getBlockEntity().getBlockPos()); + } + + @Override + public void networkChanged(IWiredNetworkChange change) {} + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/appliedenergistics/AppEngApi.java b/src/main/java/de/srendi/advancedperipherals/common/addons/appliedenergistics/AppEngApi.java deleted file mode 100644 index 3bc0c6d8e..000000000 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/appliedenergistics/AppEngApi.java +++ /dev/null @@ -1,641 +0,0 @@ -package de.srendi.advancedperipherals.common.addons.appliedenergistics; - -import appeng.api.inventories.InternalInventory; -import appeng.api.networking.IGridNode; -import appeng.api.networking.crafting.CraftingJobStatus; -import appeng.api.networking.crafting.ICraftingCPU; -import appeng.api.networking.crafting.ICraftingService; -import appeng.api.networking.storage.IStorageService; -import appeng.api.stacks.*; -import appeng.api.storage.AEKeyFilter; -import appeng.api.storage.IStorageProvider; -import appeng.api.storage.MEStorage; -import appeng.api.storage.cells.IBasicCellItem; -import appeng.blockentity.storage.DriveBlockEntity; -import appeng.parts.storagebus.StorageBusPart; -import com.the9grounds.aeadditions.item.storage.StorageCell; -import com.the9grounds.aeadditions.item.storage.SuperStorageCell; -import dan200.computercraft.shared.util.NBTUtil; -import de.srendi.advancedperipherals.AdvancedPeripherals; -import de.srendi.advancedperipherals.common.addons.APAddons; -import de.srendi.advancedperipherals.common.util.LuaConverter; -import de.srendi.advancedperipherals.common.util.Pair; -import de.srendi.advancedperipherals.common.util.inventory.FluidFilter; -import de.srendi.advancedperipherals.common.util.inventory.ItemFilter; -import de.srendi.advancedperipherals.common.util.inventory.ItemUtil; -import io.github.projectet.ae2things.item.DISKDrive; -import it.unimi.dsi.fastutil.objects.Object2LongMap; -import me.ramidzkh.mekae2.ae2.MekanismKey; -import net.minecraft.core.BlockPos; -import net.minecraft.nbt.CompoundTag; -import net.minecraft.world.item.ItemStack; -import net.minecraft.world.level.block.entity.BlockEntity; -import net.minecraftforge.common.capabilities.ForgeCapabilities; -import net.minecraftforge.common.util.LazyOptional; -import net.minecraftforge.fluids.FluidStack; -import net.minecraftforge.fluids.capability.IFluidHandler; -import net.minecraftforge.items.IItemHandler; -import net.minecraftforge.registries.ForgeRegistries; -import org.apache.logging.log4j.Level; -import org.jetbrains.annotations.Nullable; - -import java.util.*; - -public class AppEngApi { - - public static Pair findAEStackFromStack(MEStorage monitor, @Nullable ICraftingService crafting, ItemStack item) { - return findAEStackFromFilter(monitor, crafting, ItemFilter.fromStack(item)); - } - - public static Pair findAEStackFromFilter(MEStorage monitor, @Nullable ICraftingService crafting, ItemFilter item) { - for (Object2LongMap.Entry temp : monitor.getAvailableStacks()) { - if (temp.getKey() instanceof AEItemKey key && item.test(key.toStack())) - return Pair.of(temp.getLongValue(), key); - } - - if (crafting == null) - return Pair.of(0L, AEItemKey.of(ItemStack.EMPTY)); - - for (var temp : crafting.getCraftables(param -> true)) { - if (temp instanceof AEItemKey key && item.test(key.toStack())) - return Pair.of(0L, key); - } - - return Pair.of(0L, AEItemKey.of(ItemStack.EMPTY)); - } - - public static Pair findAEFluidFromStack(MEStorage monitor, @Nullable ICraftingService crafting, FluidStack item) { - return findAEFluidFromFilter(monitor, crafting, FluidFilter.fromStack(item)); - } - - public static Pair findAEFluidFromFilter(MEStorage monitor, @Nullable ICraftingService crafting, FluidFilter item) { - for (Object2LongMap.Entry temp : monitor.getAvailableStacks()) { - if (temp.getKey() instanceof AEFluidKey key && item.test(key.toStack(1))) - return Pair.of(temp.getLongValue(), key); - } - - if (crafting == null) - return null; - - for (var temp : crafting.getCraftables(param -> true)) { - if (temp instanceof AEFluidKey key && item.test(key.toStack(1))) - return Pair.of(0L, key); - } - - return null; - } - - public static List listStacks(MEStorage monitor, ICraftingService service) { - List items = new ArrayList<>(); - KeyCounter keyCounter = monitor.getAvailableStacks(); - for (Object2LongMap.Entry aeKey : keyCounter) { - if (aeKey.getKey() instanceof AEItemKey itemKey) { - items.add(getObjectFromStack(Pair.of(aeKey.getLongValue(), itemKey), service)); - } - } - return items; - } - - public static List listCraftableStacks(MEStorage monitor, ICraftingService service) { - List items = new ArrayList<>(); - KeyCounter keyCounter = monitor.getAvailableStacks(); - Set craftables = service.getCraftables(AEKeyFilter.none()); - for (AEKey aeKey : craftables) { - if (aeKey instanceof AEItemKey) { - items.add(getObjectFromStack(Pair.of(keyCounter.get(aeKey), aeKey), service)); - } - } - return items; - } - - public static List listFluids(MEStorage monitor, ICraftingService service) { - List items = new ArrayList<>(); - for (Object2LongMap.Entry aeKey : monitor.getAvailableStacks()) { - if (aeKey.getKey() instanceof AEFluidKey itemKey) { - items.add(getObjectFromStack(Pair.of(aeKey.getLongValue(), itemKey), service)); - } - } - return items; - } - - public static List listGases(MEStorage monitor, ICraftingService service, int flag) { - List items = new ArrayList<>(); - for (Object2LongMap.Entry aeKey : monitor.getAvailableStacks()) { - if (APAddons.appMekLoaded && aeKey.getKey() instanceof MekanismKey itemKey) { - items.add(getObjectFromStack(Pair.of(aeKey.getLongValue(), itemKey), service)); - } - } - return items; - } - - public static List listCraftableFluids(MEStorage monitor, ICraftingService service) { - List items = new ArrayList<>(); - KeyCounter keyCounter = monitor.getAvailableStacks(); - Set craftables = service.getCraftables(AEKeyFilter.none()); - for (AEKey aeKey : craftables) { - if (aeKey instanceof AEFluidKey) { - items.add(getObjectFromStack(Pair.of(keyCounter.get(aeKey), aeKey), service)); - } - } - return items; - } - - public static Map getObjectFromStack(Pair stack, @Nullable ICraftingService service) { - if (stack.getRight() == null) - return Collections.emptyMap(); - if (stack.getRight() instanceof AEItemKey itemKey) - return getObjectFromItemStack(Pair.of(stack.getLeft(), itemKey), service); - if (stack.getRight() instanceof AEFluidKey fluidKey) - return getObjectFromFluidStack(Pair.of(stack.getLeft(), fluidKey), service); - if (APAddons.appMekLoaded && (stack.getRight() instanceof MekanismKey gasKey)) - return getObjectFromGasStack(Pair.of(stack.getLeft(), gasKey), service); - - AdvancedPeripherals.debug("Could not create table from unknown stack " + stack.getRight().getClass() + " - Report this to the maintainer of ap", Level.ERROR); - return Collections.emptyMap(); - } - - private static Map getObjectFromItemStack(Pair stack, @Nullable ICraftingService craftingService) { - Map map = new HashMap<>(); - String displayName = stack.getRight().getDisplayName().getString(); - CompoundTag nbt = stack.getRight().toTag(); - long amount = stack.getLeft(); - map.put("fingerprint", ItemUtil.getFingerprint(stack.getRight().toStack())); - map.put("name", ItemUtil.getRegistryKey(stack.getRight().getItem()).toString()); - map.put("amount", amount); - map.put("displayName", displayName); - map.put("nbt", NBTUtil.toLua(nbt)); - map.put("tags", LuaConverter.tagsToList(() -> stack.getRight().getItem().builtInRegistryHolder().tags())); - map.put("isCraftable", craftingService != null && craftingService.isCraftable(stack.getRight())); - - return map; - } - - private static Map getObjectFromFluidStack(Pair stack, @Nullable ICraftingService craftingService) { - Map map = new HashMap<>(); - long amount = stack.getLeft(); - map.put("name", ForgeRegistries.FLUIDS.getKey(stack.getRight().getFluid()).toString()); - map.put("amount", amount); - map.put("displayName", stack.getRight().getDisplayName().getString()); - map.put("tags", LuaConverter.tagsToList(() -> stack.getRight().getFluid().builtInRegistryHolder().tags())); - map.put("isCraftable", craftingService != null && craftingService.isCraftable(stack.getRight())); - - return map; - } - - private static Map getObjectFromGasStack(Pair stack, @Nullable ICraftingService craftingService) { - Map map = new HashMap<>(); - long amount = stack.getLeft(); - map.put("name", stack.getRight().getStack().getTypeRegistryName().toString()); - map.put("amount", amount); - map.put("displayName", stack.getRight().getDisplayName().getString()); - map.put("tags", LuaConverter.tagsToList(() -> stack.getRight().getStack().getType().getTags())); - - return map; - } - - public static Map getObjectFromCPU(ICraftingCPU cpu) { - Map map = new HashMap<>(); - long storage = cpu.getAvailableStorage(); - int coProcessors = cpu.getCoProcessors(); - boolean isBusy = cpu.isBusy(); - map.put("storage", storage); - map.put("coProcessors", coProcessors); - map.put("isBusy", isBusy); - map.put("craftingJob", cpu.getJobStatus() != null ? getObjectFromJob(cpu.getJobStatus()) : null); - map.put("name", cpu.getName() != null ? cpu.getName().getString() : "Unnamed"); - map.put("selectionMode", cpu.getSelectionMode().toString()); - - return map; - } - - public static Map getObjectFromJob(CraftingJobStatus job) { - Map map = new HashMap<>(); - map.put("storage", getObjectFromGenericStack(job.crafting())); - map.put("elapsedTimeNanos", job.elapsedTimeNanos()); - map.put("totalItem", job.totalItems()); - map.put("progress", job.progress()); - - return map; - } - - public static Map getObjectFromGenericStack(GenericStack stack) { - if (stack.what() == null) - return Collections.emptyMap(); - if (stack.what() instanceof AEItemKey aeItemKey) - return getObjectFromItemStack(Pair.of(stack.amount(), aeItemKey), null); - if (stack.what() instanceof AEFluidKey aeFluidKey) - return getObjectFromFluidStack(Pair.of(stack.amount(), aeFluidKey), null); - return Collections.emptyMap(); - } - - public static MEStorage getMonitor(IGridNode node) { - return node.getGrid().getService(IStorageService.class).getInventory(); - } - - public static boolean isItemCrafting(MEStorage monitor, ICraftingService grid, ItemFilter filter, - @Nullable ICraftingCPU craftingCPU) { - Pair stack = AppEngApi.findAEStackFromFilter(monitor, grid, filter); - - // If the item stack does not exist, it cannot be crafted. - if (stack == null) - return false; - - // If the passed cpu is null, check all cpus - if (craftingCPU == null) { - // Loop through all crafting cpus and check if the item is being crafted. - for (ICraftingCPU cpu : grid.getCpus()) { - if (cpu.isBusy()) { - CraftingJobStatus jobStatus = cpu.getJobStatus(); - - // avoid null pointer exception - if (jobStatus == null) - continue; - - if (jobStatus.crafting().what().equals(stack.getRight())) - return true; - } - } - } else { - if (craftingCPU.isBusy()) { - CraftingJobStatus jobStatus = craftingCPU.getJobStatus(); - - // avoid null pointer exception - if (jobStatus == null) - return false; - - return jobStatus.crafting().what().equals(stack.getRight()); - } - } - - return false; - } - - public static boolean isFluidCrafting(MEStorage monitor, ICraftingService grid, FluidFilter filter, - @Nullable ICraftingCPU craftingCPU) { - Pair stack = AppEngApi.findAEFluidFromFilter(monitor, grid, filter); - - // If the fluid stack does not exist, it cannot be crafted. - if (stack == null) - return false; - - // If the passed cpu is null, check all cpus - if (craftingCPU == null) { - // Loop through all crafting cpus and check if the fluid is being crafted. - for (ICraftingCPU cpu : grid.getCpus()) { - if (cpu.isBusy()) { - CraftingJobStatus jobStatus = cpu.getJobStatus(); - - // avoid null pointer exception - if (jobStatus == null) - continue; - - if (jobStatus.crafting().what().equals(stack.getRight())) - return true; - } - } - } else { - if (craftingCPU.isBusy()) { - CraftingJobStatus jobStatus = craftingCPU.getJobStatus(); - - // avoid null pointer exception - if (jobStatus == null) - return false; - - return jobStatus.crafting().what().equals(stack.getRight()); - } - } - - return false; - } - - public static long getTotalItemStorage(IGridNode node) { - long total = 0; - - // note: do not query DriveBlockEntity.class specifically here, because it will avoid subclasses, e.g. the ME Extended Drive from ExtendedAE - Iterator iterator = node.getGrid().getNodes().iterator(); - - while (iterator.hasNext()) { - if (!(iterator.next().getService(IStorageProvider.class) instanceof DriveBlockEntity entity)) - continue; - - InternalInventory inventory = entity.getInternalInventory(); - - for (int i = 0; i < inventory.size(); i++) { - ItemStack stack = inventory.getStackInSlot(i); - - if (stack.isEmpty()) - continue; - - if (stack.getItem() instanceof IBasicCellItem cell) { - if (cell.getKeyType().getClass().isAssignableFrom(AEKeyType.items().getClass())) { - total += cell.getBytes(null); - } - } else if (APAddons.aeThingsLoaded && stack.getItem() instanceof DISKDrive disk) { - if (disk.getKeyType().toString().equals("ae2:i")) { - total += disk.getBytes(null); - } - } else if (APAddons.aeAdditionsLoaded && (stack.getItem() instanceof SuperStorageCell superStorageCell)) { - total += superStorageCell.getKiloBytes() * 1024; - } else if (APAddons.aeAdditionsLoaded && (stack.getItem() instanceof StorageCell storageCell)) { - if (storageCell.getKeyType() != AEKeyType.items()) - continue; - total += storageCell.getKiloBytes() * 1024; - } - } - } - - iterator = node.getGrid().getMachineNodes(StorageBusPart.class).iterator(); - - while (iterator.hasNext()) { - StorageBusPart bus = (StorageBusPart) iterator.next().getService(IStorageProvider.class); - net.minecraft.world.level.Level level = bus.getLevel(); - BlockPos connectedInventoryPos = bus.getHost().getBlockEntity().getBlockPos().relative(bus.getSide()); - BlockEntity connectedInventoryEntity = level.getBlockEntity(connectedInventoryPos); - if (connectedInventoryEntity == null) - continue; - - LazyOptional itemHandler = connectedInventoryEntity.getCapability(ForgeCapabilities.ITEM_HANDLER); - if (itemHandler.isPresent()) { - IItemHandler handler = itemHandler.orElse(null); - for (int i = 0; i < handler.getSlots(); i++) { - total += handler.getSlotLimit(i); - } - } - } - - return total; - } - - public static long getTotalFluidStorage(IGridNode node) { - long total = 0; - - Iterator iterator = node.getGrid().getNodes().iterator(); - - while (iterator.hasNext()) { - if (!(iterator.next().getService(IStorageProvider.class) instanceof DriveBlockEntity entity)) - continue; - - InternalInventory inventory = entity.getInternalInventory(); - - for (int i = 0; i < inventory.size(); i++) { - ItemStack stack = inventory.getStackInSlot(i); - - if (stack.isEmpty()) - continue; - - if (stack.getItem() instanceof IBasicCellItem cell) { - if (cell.getKeyType().getClass().isAssignableFrom(AEKeyType.fluids().getClass())) { - total += cell.getBytes(null); - } - } else if (APAddons.aeAdditionsLoaded && stack.getItem() instanceof SuperStorageCell superStorageCell) { - total += superStorageCell.getKiloBytes() * 1024; - } else if (APAddons.aeAdditionsLoaded && (stack.getItem() instanceof StorageCell storageCell)) { - if (storageCell.getKeyType() != AEKeyType.fluids()) - continue; - total += storageCell.getKiloBytes() * 1024; - } - } - } - - iterator = node.getGrid().getMachineNodes(StorageBusPart.class).iterator(); - - while (iterator.hasNext()) { - StorageBusPart bus = (StorageBusPart) iterator.next().getService(IStorageProvider.class); - net.minecraft.world.level.Level level = bus.getLevel(); - BlockPos connectedInventoryPos = bus.getHost().getBlockEntity().getBlockPos().relative(bus.getSide()); - BlockEntity connectedInventoryEntity = level.getBlockEntity(connectedInventoryPos); - if (connectedInventoryEntity == null) - continue; - - LazyOptional fluidHandler = connectedInventoryEntity.getCapability(ForgeCapabilities.FLUID_HANDLER); - if (fluidHandler.isPresent()) { - IFluidHandler handler = fluidHandler.orElse(null); - for (int i = 0; i < handler.getTanks(); i++) { - total += handler.getTankCapacity(i); - } - } - } - - return total; - } - - public static long getUsedItemStorage(IGridNode node) { - long used = 0; - - Iterator iterator = node.getGrid().getNodes().iterator(); - - while (iterator.hasNext()) { - if (!(iterator.next().getService(IStorageProvider.class) instanceof DriveBlockEntity entity)) - continue; - - InternalInventory inventory = entity.getInternalInventory(); - - for (int i = 0; i < inventory.size(); i++) { - ItemStack stack = inventory.getStackInSlot(i); - - if (stack.isEmpty()) - continue; - - if (stack.getItem() instanceof IBasicCellItem cell) { - int bytesPerType = cell.getBytesPerType(null); - - if (cell.getKeyType().getClass().isAssignableFrom(AEKeyType.items().getClass())) { - if (stack.getTag() == null) - continue; - int numOfType = stack.getTag().getLongArray("amts").length; - long numItemsInCell = stack.getTag().getLong("ic"); - - used += ((int) Math.ceil(((double) numItemsInCell) / 8)) + ((long) bytesPerType * numOfType); - } - } else if (APAddons.aeThingsLoaded && stack.getItem() instanceof DISKDrive disk) { - if (disk.getKeyType().toString().equals("ae2:i")) { - if (stack.getTag() == null) - continue; - long numBytesInCell = stack.getTag().getLong("ic"); - used += numBytesInCell; - } - } else if (APAddons.aeAdditionsLoaded && stack.getItem() instanceof SuperStorageCell) { - if (stack.getTag() == null) - continue; - long numItemsInCell = stack.getTag().getLong("ic"); - - used += numItemsInCell; - } else if (APAddons.aeAdditionsLoaded && stack.getItem() instanceof StorageCell storageCell) { - if (storageCell.getKeyType() != AEKeyType.items()) - continue; - if (stack.getTag() == null) - continue; - long numItemsInCell = stack.getTag().getLong("ic"); - - used += numItemsInCell; - } - } - } - - iterator = node.getGrid().getMachineNodes(StorageBusPart.class).iterator(); - - while (iterator.hasNext()) { - StorageBusPart bus = (StorageBusPart) iterator.next().getService(IStorageProvider.class); - KeyCounter keyCounter = bus.getInternalHandler().getAvailableStacks(); - - for (Object2LongMap.Entry aeKey : keyCounter) { - if (aeKey.getKey() instanceof AEItemKey) { - used += aeKey.getLongValue(); - } - } - } - - return used; - } - - public static long getUsedFluidStorage(IGridNode node) { - long used = 0; - - Iterator iterator = node.getGrid().getNodes().iterator(); - - while (iterator.hasNext()) { - if (!(iterator.next().getService(IStorageProvider.class) instanceof DriveBlockEntity entity)) - continue; - - InternalInventory inventory = entity.getInternalInventory(); - - for (int i = 0; i < inventory.size(); i++) { - ItemStack stack = inventory.getStackInSlot(i); - - if (stack.getItem() instanceof IBasicCellItem cell) { - int bytesPerType = cell.getBytesPerType(null); - - if (cell.getKeyType().getClass().isAssignableFrom(AEKeyType.fluids().getClass())) { - if (stack.getTag() == null) - continue; - int numOfType = stack.getTag().getLongArray("amts").length; - long numBucketsInCell = stack.getTag().getLong("ic") / 1000; - - used += ((int) Math.ceil(((double) numBucketsInCell) / 8)) + ((long) bytesPerType * numOfType); - } - } else if (APAddons.aeAdditionsLoaded && stack.getItem() instanceof SuperStorageCell) { - if (stack.getTag() == null) - continue; - long numItemsInCell = stack.getTag().getLong("ic"); - - used += numItemsInCell; - } else if (APAddons.aeAdditionsLoaded && stack.getItem() instanceof StorageCell storageCell) { - if (storageCell.getKeyType() != AEKeyType.fluids()) - continue; - if (stack.getTag() == null) - continue; - long numItemsInCell = stack.getTag().getLong("ic"); - - used += numItemsInCell; - } - } - } - - iterator = node.getGrid().getMachineNodes(StorageBusPart.class).iterator(); - - while (iterator.hasNext()) { - StorageBusPart bus = (StorageBusPart) iterator.next().getService(IStorageProvider.class); - KeyCounter keyCounter = bus.getInternalHandler().getAvailableStacks(); - - for (Object2LongMap.Entry aeKey : keyCounter) { - if (aeKey.getKey() instanceof AEFluidKey fluidKey) { - used += aeKey.getLongValue(); - } - } - } - - return used; - } - - public static long getAvailableItemStorage(IGridNode node) { - return getTotalItemStorage(node) - getUsedItemStorage(node); - } - - public static long getAvailableFluidStorage(IGridNode node) { - return getTotalFluidStorage(node) - getUsedFluidStorage(node); - } - - public static List listCells(IGridNode node) { - List items = new ArrayList<>(); - - Iterator iterator = node.getGrid().getNodes().iterator(); - - if (!iterator.hasNext()) return items; - while (iterator.hasNext()) { - IStorageProvider entity = iterator.next().getService(IStorageProvider.class); - if (!(entity instanceof DriveBlockEntity drive)) - continue; - - InternalInventory inventory = drive.getInternalInventory(); - - for (int i = 0; i < inventory.size(); i++) { - ItemStack stack = inventory.getStackInSlot(i); - - if (stack.isEmpty()) - continue; - - if (stack.getItem() instanceof IBasicCellItem cell) { - items.add(getObjectFromCell(cell, stack)); - } else if (APAddons.aeThingsLoaded && stack.getItem() instanceof DISKDrive disk) { - items.add(getObjectFromDisk(disk, stack)); - } else if (APAddons.aeAdditionsLoaded && stack.getItem() instanceof SuperStorageCell superStorageCell) { - items.add(getObjectFromSuperCell(superStorageCell, stack)); - } - } - } - - return items; - } - - private static Map getObjectFromCell(IBasicCellItem cell, ItemStack stack) { - Map map = new HashMap<>(); - - map.put("item", ItemUtil.getRegistryKey(stack.getItem()).toString()); - - String cellType = ""; - - if (cell.getKeyType().getClass().isAssignableFrom(AEKeyType.items().getClass())) { - cellType = "item"; - } else if (cell.getKeyType().getClass().isAssignableFrom(AEKeyType.fluids().getClass())) { - cellType = "fluid"; - } - - map.put("cellType", cellType); - map.put("bytesPerType", cell.getBytesPerType(null)); - map.put("totalBytes", cell.getBytes(null)); - - return map; - } - - private static Map getObjectFromDisk(DISKDrive drive, ItemStack stack) { - Map map = new HashMap<>(); - - map.put("item", stack.getItem().toString()); - - String cellType = ""; - - if (drive.getKeyType().toString().equals("ae2:i")) { - cellType = "item"; - } else if (drive.getKeyType().toString().equals("ae2:f")) { - cellType = "fluid"; - } - - map.put("cellType", cellType); - map.put("totalBytes", drive.getBytes(null)); - - return map; - } - - private static Map getObjectFromSuperCell(SuperStorageCell cell, ItemStack stack) { - Map map = new HashMap<>(); - - map.put("item", stack.getItem().toString()); - - String cellType = "all"; - - map.put("cellType", cellType); - map.put("totalBytes", cell.getBytes(stack)); - - return map; - } -} diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/appliedenergistics/CraftJob.java b/src/main/java/de/srendi/advancedperipherals/common/addons/appliedenergistics/CraftJob.java deleted file mode 100644 index 1b2d5d9a9..000000000 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/appliedenergistics/CraftJob.java +++ /dev/null @@ -1,135 +0,0 @@ -package de.srendi.advancedperipherals.common.addons.appliedenergistics; - -import appeng.api.networking.IGrid; -import appeng.api.networking.IGridNode; -import appeng.api.networking.crafting.*; -import appeng.api.networking.security.IActionSource; -import appeng.api.stacks.AEKey; -import dan200.computercraft.api.lua.ILuaCallback; -import dan200.computercraft.api.lua.LuaException; -import dan200.computercraft.api.lua.MethodResult; -import dan200.computercraft.api.peripheral.IComputerAccess; -import de.srendi.advancedperipherals.AdvancedPeripherals; -import net.minecraft.world.level.Level; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - -import java.util.concurrent.ExecutionException; -import java.util.concurrent.Future; - -public class CraftJob implements ILuaCallback { - - public static final String EVENT = "crafting"; - - private final IComputerAccess computer; - private final IGridNode node; - private final IActionSource source; - private final ICraftingSimulationRequester requester; - private final ICraftingCPU target; - private final AEKey item; - - private final long amount; - private final Level world; - private Future futureJob; - private boolean startedCrafting = false; - - private MethodResult result; - private LuaException exception; - - public CraftJob(Level world, final IComputerAccess computer, IGridNode node, AEKey item, long amount, IActionSource source, - ICraftingSimulationRequester requester, ICraftingCPU target) { - this.computer = computer; - this.node = node; - this.world = world; - this.source = source; - this.item = item; - this.amount = amount; - this.requester = requester; - this.target = target; - } - - protected void fireEvent(boolean success, @Nullable String exception) { - this.result = MethodResult.of(success, exception); - this.exception = new LuaException(exception); - this.computer.queueEvent(EVENT, success, exception); - - } - - protected void fireNotConnected() { - fireEvent(false, "not connected"); - } - - public void setStartedCrafting(boolean startedCrafting) { - this.startedCrafting = startedCrafting; - } - - public boolean isCraftingStarted() { - return startedCrafting; - } - - public void startCrafting() { - IGrid grid = node.getGrid(); - if (grid == null) { //true when the block is not connected - fireNotConnected(); - return; - } - - ICraftingService crafting = grid.getService(ICraftingService.class); - - if (item == null) { - AdvancedPeripherals.debug("Could not get AEItem from monitor", org.apache.logging.log4j.Level.FATAL); - return; - } - - if (!crafting.isCraftable(item)) { - fireEvent(false, item.getId().toString() + " is not craftable"); - return; - } - - futureJob = crafting.beginCraftingCalculation(world, this.requester, item, amount, CalculationStrategy.REPORT_MISSING_ITEMS); - fireEvent(true, "Started calculation of the recipe. After it's finished, the system will start crafting the item."); - } - - public void maybeCraft() { - if (startedCrafting || futureJob == null || !futureJob.isDone()) - return; - ICraftingPlan job; - try { - job = futureJob.get(); - } catch (ExecutionException | InterruptedException ex) { - AdvancedPeripherals.debug("Tried to get job, but job calculation is not done. Should be done.", org.apache.logging.log4j.Level.FATAL); - ex.printStackTrace(); - return; - } - - if (job == null) { - AdvancedPeripherals.debug("Job is null, should not be null.", org.apache.logging.log4j.Level.FATAL); - return; - } - - if (job.simulation()) { - return; - } - - IGrid grid = node.getGrid(); - if (grid == null) { - return; - } - - //TODO: Create events or methods like `isCraftingFinished` or `getCraftingJobState` - ICraftingService crafting = grid.getService(ICraftingService.class); - crafting.submitJob(job, null, target, false, this.source); - - setStartedCrafting(true); - - this.futureJob = null; - } - - @NotNull - @Override - public MethodResult resume(Object[] objects) { - if (result != null) return result; - if (exception != null) return MethodResult.of(exception); - return MethodResult.of(); - } -} diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/botania/ManaFlowerIntegration.java b/src/main/java/de/srendi/advancedperipherals/common/addons/botania/ManaFlowerIntegration.java index a4eb92215..fd45750e4 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/botania/ManaFlowerIntegration.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/botania/ManaFlowerIntegration.java @@ -16,7 +16,7 @@ public ManaFlowerIntegration(BlockEntity entity) { @NotNull @Override public String getType() { - return "manaFlower"; + return "mana_flower"; } @LuaFunction(mainThread = true) diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/botania/ManaPoolIntegration.java b/src/main/java/de/srendi/advancedperipherals/common/addons/botania/ManaPoolIntegration.java index cea44bbe9..2d2fb83c9 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/botania/ManaPoolIntegration.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/botania/ManaPoolIntegration.java @@ -15,7 +15,7 @@ public ManaPoolIntegration(BlockEntity entity) { @NotNull @Override public String getType() { - return "manaPool"; + return "mana_pool"; } @LuaFunction(mainThread = true) diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/botania/SpreaderIntegration.java b/src/main/java/de/srendi/advancedperipherals/common/addons/botania/SpreaderIntegration.java index e0ea451f9..d615db44f 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/botania/SpreaderIntegration.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/botania/SpreaderIntegration.java @@ -16,7 +16,7 @@ public SpreaderIntegration(BlockEntity entity) { @NotNull @Override public String getType() { - return "manaSpreader"; + return "mana_spreader"; } @LuaFunction(mainThread = true) diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/integrations/BeaconIntegration.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/integrations/BeaconIntegration.java index 09e655726..0a35755df 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/integrations/BeaconIntegration.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/integrations/BeaconIntegration.java @@ -2,7 +2,6 @@ import dan200.computercraft.api.lua.LuaFunction; import de.srendi.advancedperipherals.lib.peripherals.BlockEntityIntegrationPeripheral; -import net.minecraft.nbt.CompoundTag; import net.minecraft.world.level.block.entity.BeaconBlockEntity; import net.minecraft.world.level.block.entity.BlockEntity; import org.jetbrains.annotations.NotNull; @@ -20,9 +19,7 @@ public BeaconIntegration(BlockEntity entity) { @LuaFunction(mainThread = true) public final int getLevel() { - // because levels are now protected field .... why? - CompoundTag savedData = blockEntity.saveWithoutMetadata(); - return savedData.getInt("Levels"); + return blockEntity.levels; } @LuaFunction(mainThread = true) diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/integrations/IntegrationPeripheralProvider.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/integrations/IntegrationPeripheralProvider.java index f5c2fef95..eaf6cda03 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/integrations/IntegrationPeripheralProvider.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/integrations/IntegrationPeripheralProvider.java @@ -3,6 +3,7 @@ import dan200.computercraft.api.peripheral.IPeripheral; import dan200.computercraft.api.peripheral.IPeripheralProvider; import de.srendi.advancedperipherals.AdvancedPeripherals; +import de.srendi.advancedperipherals.common.addons.APAddons; import de.srendi.advancedperipherals.common.util.Platform; import de.srendi.advancedperipherals.lib.integrations.IPeripheralIntegration; import de.srendi.advancedperipherals.lib.peripherals.BlockEntityIntegrationPeripheral; @@ -23,7 +24,14 @@ public class IntegrationPeripheralProvider implements IPeripheralProvider { - private static final String[] SUPPORTED_MODS = new String[]{"botania", "create", "mekanism", "powah"}; + private static final String[] SUPPORTED_MODS = new String[]{ + APAddons.BOTANIA_MODID, + APAddons.CREATE_MODID, + APAddons.MEKANISM_MODID, + APAddons.POWAH_MODID, + APAddons.DIMSTORAGE_MODID, + APAddons.VALKYRIEN_SKIES_MODID, + }; private static final PriorityQueue integrations = new PriorityQueue<>(Comparator.comparingInt(IPeripheralIntegration::getPriority)); diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/operations/SimpleFreeOperation.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/operations/SimpleFreeOperation.java index b86b1aa39..5ed3604c4 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/operations/SimpleFreeOperation.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/operations/SimpleFreeOperation.java @@ -7,7 +7,8 @@ import java.util.Map; public enum SimpleFreeOperation implements IPeripheralOperation { - CHAT_MESSAGE(100); + CHAT_MESSAGE(1000), + SADDLE_CAPTURE(5000); private final int defaultCooldown; private ForgeConfigSpec.IntValue cooldown; @@ -18,7 +19,7 @@ public enum SimpleFreeOperation implements IPeripheralOperation { @Override public void addToConfig(ForgeConfigSpec.Builder builder) { - cooldown = builder.defineInRange(settingsName() + "Cooldown", defaultCooldown, 1_000, Integer.MAX_VALUE); + cooldown = builder.defineInRange(settingsName() + "Cooldown", defaultCooldown, 100, Integer.MAX_VALUE); } @Override diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/operations/SingleOperation.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/operations/SingleOperation.java index 90205db17..980c329b9 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/operations/SingleOperation.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/operations/SingleOperation.java @@ -5,16 +5,20 @@ import java.util.HashMap; import java.util.Map; -import java.util.function.Function; +import java.util.function.UnaryOperator; public enum SingleOperation implements IPeripheralOperation { DIG(1000, 1), USE_ON_BLOCK(5000, 1), + UPDATE_BLOCK(500, 1), SUCK(1000, 1), USE_ON_ANIMAL(2500, 10), CAPTURE_ANIMAL(50_000, 100), WARP(1000, DistancePolicy.IGNORED, CountPolicy.MULTIPLY, 1, DistancePolicy.SQRT, CountPolicy.MULTIPLY), - ACCURE_PLACE(1000, DistancePolicy.IGNORED, CountPolicy.MULTIPLY, 1, DistancePolicy.LINEAR, CountPolicy.MULTIPLY); + ACCURE_PLACE(1000, DistancePolicy.IGNORED, CountPolicy.MULTIPLY, 1, DistancePolicy.LINEAR, CountPolicy.MULTIPLY), + PREPARE_PORTAL(3_000, 600), + ACTIVE_PORTAL(60_000, 1), + MOUNT_SHIP(1000, 1); private final int defaultCooldown; private final DistancePolicy distanceCooldownPolicy; @@ -35,7 +39,7 @@ public enum SingleOperation implements IPeripheralOperation d), SQRT(d -> (int) Math.sqrt(d)); - private final Function factorFunction; + private final UnaryOperator factorFunction; - DistancePolicy(Function factorFunction) { + DistancePolicy(UnaryOperator factorFunction) { this.factorFunction = factorFunction; } @@ -90,11 +94,12 @@ public int getFactor(int distance) { } public enum CountPolicy { + IGNORED(c -> 1), MULTIPLY(c -> c); - private final Function factorFunction; + private final UnaryOperator factorFunction; - CountPolicy(Function factorFunction) { + CountPolicy(UnaryOperator factorFunction) { this.factorFunction = factorFunction; } diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/operations/SphereOperation.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/operations/SphereOperation.java index 147b06400..54217cede 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/operations/SphereOperation.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/operations/SphereOperation.java @@ -9,7 +9,8 @@ public enum SphereOperation implements IPeripheralOperation { SCAN_BLOCKS(2_000, 8, 16, 0.17), - SCAN_ENTITIES(2_000, 8, 16, 0.17); + SCAN_ENTITIES(2_000, 8, 16, 0.17), + SCAN_SHIPS(2_500, 8 * 3, 16 * 10 /* common view distance */, 0.17); private final int defaultCooldown; private final int defaultMaxFreeRadius; @@ -29,7 +30,7 @@ public enum SphereOperation implements IPeripheralOperation, IOwnerAbility> abilities; - public BasePeripheralOwner() { + protected BasePeripheralOwner() { abilities = new HashMap<>(); } diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/BlockEntityPeripheralOwner.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/BlockEntityPeripheralOwner.java index 2ea0bd6a3..0a593045a 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/BlockEntityPeripheralOwner.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/BlockEntityPeripheralOwner.java @@ -1,7 +1,7 @@ package de.srendi.advancedperipherals.common.addons.computercraft.owner; +import dan200.computercraft.api.peripheral.IPeripheral; import de.srendi.advancedperipherals.common.blocks.base.BaseBlock; -import de.srendi.advancedperipherals.common.blocks.blockentities.InventoryManagerEntity; import de.srendi.advancedperipherals.common.util.DataStorageUtil; import de.srendi.advancedperipherals.common.util.fakeplayer.APFakePlayer; import de.srendi.advancedperipherals.lib.peripherals.IPeripheralTileEntity; @@ -11,16 +11,16 @@ import net.minecraft.nbt.CompoundTag; import net.minecraft.network.chat.Component; import net.minecraft.world.Nameable; +import net.minecraft.world.entity.Entity; import net.minecraft.world.entity.player.Player; import net.minecraft.world.item.ItemStack; import net.minecraft.world.level.Level; -import net.minecraft.world.level.block.JigsawBlock; import net.minecraft.world.level.block.entity.BlockEntity; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import java.util.Objects; -import java.util.function.Function; +import org.apache.commons.lang3.NotImplementedException; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; public class BlockEntityPeripheralOwner extends BasePeripheralOwner { @@ -61,7 +61,7 @@ public BlockPos getPos() { @NotNull @Override public Direction getFacing() { - return tileEntity.getBlockState().getValue(JigsawBlock.ORIENTATION).front(); + return getOrientation().front(); } @NotNull @@ -70,11 +70,15 @@ public FrontAndTop getOrientation() { return tileEntity.getBlockState().getValue(BaseBlock.ORIENTATION); } + @Nullable + @Override + public Entity getHoldingEntity() { + return null; + } + @Nullable @Override public Player getOwner() { - if (tileEntity instanceof InventoryManagerEntity inventoryManagerEntity) - return inventoryManagerEntity.getOwnerPlayer(); return null; } @@ -90,8 +94,8 @@ public void markDataStorageDirty() { } @Override - public T1 withPlayer(Function function) { - throw new RuntimeException("Not implemented yet"); + public T1 withPlayer(APFakePlayer.Action function) { + throw new NotImplementedException(); } @Override @@ -102,7 +106,7 @@ public ItemStack getToolInMainHand() { @Override public ItemStack storeItem(ItemStack stored) { // TODO: tricks with capability needed - throw new RuntimeException("Not implemented yet"); + throw new NotImplementedException(); } @Override @@ -124,4 +128,9 @@ public BlockEntityPeripheralOwner attachFuel() { attachAbility(PeripheralOwnerAbility.FUEL, new TileEntityFuelAbility<>(this)); return this; } + + @Override + public U getConnectedPeripheral(Class type) { + throw new NotImplementedException(); + } } diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/FuelAbility.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/FuelAbility.java index 07245d648..80ecdefb0 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/FuelAbility.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/FuelAbility.java @@ -14,7 +14,7 @@ public abstract class FuelAbility implements IOwnerA protected @NotNull T owner; - public FuelAbility(@NotNull T owner) { + protected FuelAbility(@NotNull T owner) { this.owner = owner; } diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/IPeripheralOwner.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/IPeripheralOwner.java index c99e9442b..fc737aa5a 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/IPeripheralOwner.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/IPeripheralOwner.java @@ -1,19 +1,26 @@ package de.srendi.advancedperipherals.common.addons.computercraft.owner; +import dan200.computercraft.api.peripheral.IPeripheral; +import de.srendi.advancedperipherals.common.addons.APAddons; +import de.srendi.advancedperipherals.common.addons.valkyrienskies.ValkyrienSkies; import de.srendi.advancedperipherals.common.util.fakeplayer.APFakePlayer; import de.srendi.advancedperipherals.lib.peripherals.IPeripheralOperation; import net.minecraft.core.BlockPos; import net.minecraft.core.Direction; import net.minecraft.core.FrontAndTop; import net.minecraft.nbt.CompoundTag; +import net.minecraft.world.entity.Entity; +import net.minecraft.world.entity.OwnableEntity; import net.minecraft.world.entity.player.Player; import net.minecraft.world.item.ItemStack; import net.minecraft.world.level.Level; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; +import net.minecraft.world.phys.Vec3; import java.util.Collection; -import java.util.function.Function; +import java.util.HashSet; +import java.util.Set; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; public interface IPeripheralOwner { @@ -23,17 +30,47 @@ public interface IPeripheralOwner { @NotNull BlockPos getPos(); + @NotNull + default Vec3 getCenterPos() { + return Vec3.atCenterOf(getPos()); + } + @NotNull Direction getFacing(); @NotNull FrontAndTop getOrientation(); - @Nullable Player getOwner(); + @NotNull + default Vec3 getDirection() { + Vec3 dir = Vec3.atLowerCornerOf(getFacing().getNormal()); + if (!APAddons.vs2Loaded) { + return dir; + } + return ValkyrienSkies.transformToWorldDir(getLevel(), getPos(), dir); + } + + @Nullable Entity getHoldingEntity(); + + @Nullable + default Player getOwner() { + Entity owner = getHoldingEntity(); + Set checked = new HashSet<>(); + while (owner != null && checked.add(owner)) { + if (owner instanceof Player player) { + return (Player) player; + } + if (!(owner instanceof OwnableEntity ownable)) { + break; + } + owner = ownable.getOwner(); + } + return null; + } @NotNull CompoundTag getDataStorage(); void markDataStorageDirty(); - T withPlayer(Function function); + T withPlayer(APFakePlayer.Action function); ItemStack getToolInMainHand(); @@ -64,4 +101,10 @@ default void attachOperation(Collection> operations) { for (IPeripheralOperation operation : operations) operationAbility.registerOperation(operation); } + + T getConnectedPeripheral(Class type); + + default boolean hasConnectedPeripheral(Class type) { + return getConnectedPeripheral(type) != null; + } } diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/InventoryManagerOwner.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/InventoryManagerOwner.java new file mode 100644 index 000000000..c9bc48605 --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/InventoryManagerOwner.java @@ -0,0 +1,17 @@ +package de.srendi.advancedperipherals.common.addons.computercraft.owner; + +import de.srendi.advancedperipherals.common.blocks.blockentities.InventoryManagerEntity; +import net.minecraft.world.entity.player.Player; +import org.jetbrains.annotations.Nullable; + +public class InventoryManagerOwner extends BlockEntityPeripheralOwner { + public InventoryManagerOwner(InventoryManagerEntity tile) { + super(tile); + } + + @Nullable + @Override + public Player getOwner() { + return tileEntity.getOwnerPlayer(); + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/PeripheralOwnerAbility.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/PeripheralOwnerAbility.java index 4f5627f5e..fefa8a5be 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/PeripheralOwnerAbility.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/PeripheralOwnerAbility.java @@ -5,6 +5,6 @@ public class PeripheralOwnerAbility { public static final PeripheralOwnerAbility> FUEL = new PeripheralOwnerAbility<>(); public static final PeripheralOwnerAbility OPERATION = new PeripheralOwnerAbility<>(); - public PeripheralOwnerAbility() { + private PeripheralOwnerAbility() { } } diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/PocketPeripheralOwner.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/PocketPeripheralOwner.java index 5cd8e588c..21dc65ae6 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/PocketPeripheralOwner.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/PocketPeripheralOwner.java @@ -1,30 +1,35 @@ package de.srendi.advancedperipherals.common.addons.computercraft.owner; +import dan200.computercraft.api.peripheral.IPeripheral; import dan200.computercraft.api.pocket.IPocketAccess; +import dan200.computercraft.api.pocket.IPocketUpgrade; import de.srendi.advancedperipherals.common.configuration.APConfig; import de.srendi.advancedperipherals.common.util.DataStorageUtil; import de.srendi.advancedperipherals.common.util.fakeplayer.APFakePlayer; +import de.srendi.advancedperipherals.lib.peripherals.IBasePeripheral; import net.minecraft.core.BlockPos; import net.minecraft.core.Direction; import net.minecraft.core.FrontAndTop; import net.minecraft.nbt.CompoundTag; import net.minecraft.world.entity.Entity; -import net.minecraft.world.entity.player.Player; import net.minecraft.world.item.ItemStack; import net.minecraft.world.level.Level; +import net.minecraft.world.phys.Vec3; +import org.apache.commons.lang3.NotImplementedException; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.function.Function; - public class PocketPeripheralOwner extends BasePeripheralOwner { private final IPocketAccess pocket; + private final IPocketUpgrade upgrade; - public PocketPeripheralOwner(IPocketAccess pocket) { + public PocketPeripheralOwner(IPocketAccess pocket, IPocketUpgrade upgrade) { super(); this.pocket = pocket; - if(APConfig.PERIPHERALS_CONFIG.disablePocketFuelConsumption.get()) + this.upgrade = upgrade; + if (APConfig.PERIPHERALS_CONFIG.disablePocketFuelConsumption.get()) { attachAbility(PeripheralOwnerAbility.FUEL, new InfinitePocketFuelAbility(this)); + } } @Nullable @@ -37,48 +42,58 @@ public String getCustomName() { @Override public Level getLevel() { Entity owner = pocket.getEntity(); - if (owner == null) return null; - return owner.getCommandSenderWorld(); + return owner == null ? null : owner.getCommandSenderWorld(); } @NotNull @Override public BlockPos getPos() { Entity owner = pocket.getEntity(); - if (owner == null) return new BlockPos(0, 0, 0); - return owner.blockPosition(); + return owner == null ? BlockPos.ZERO : new BlockPos(owner.getEyePosition()); } @NotNull @Override - public Direction getFacing() { + public Vec3 getCenterPos() { Entity owner = pocket.getEntity(); - if (owner == null) return Direction.NORTH; - return owner.getDirection(); + return owner == null ? Vec3.ZERO : owner.getEyePosition(); } + @NotNull + @Override + public Direction getFacing() { + Vec3 dir = getDirection(); + return Direction.getNearest(dir.x, dir.y, dir.z); + } - /** - * Not used for pockets - */ @NotNull @Override public FrontAndTop getOrientation() { - return FrontAndTop.NORTH_UP; + Entity owner = pocket.getEntity(); + if (owner == null) { + return FrontAndTop.NORTH_UP; + } + Vec3 up = owner.getUpVector(1.0f); + return FrontAndTop.fromFrontAndTop(getFacing(), Direction.getNearest(up.x, up.y, up.z)); } - @Nullable + @NotNull @Override - public Player getOwner() { + public Vec3 getDirection() { Entity owner = pocket.getEntity(); - if (owner instanceof Player player) return player; - return null; + return owner == null ? /* North */ new Vec3(0, 0, -1) : owner.getLookAngle(); + } + + @Nullable + @Override + public Entity getHoldingEntity() { + return pocket.getEntity(); } @NotNull @Override public CompoundTag getDataStorage() { - return DataStorageUtil.getDataStorage(pocket); + return DataStorageUtil.getDataStorage(pocket, upgrade); } @Override @@ -87,8 +102,8 @@ public void markDataStorageDirty() { } @Override - public T withPlayer(Function function) { - throw new RuntimeException("Not implemented yet"); + public T withPlayer(APFakePlayer.Action function) { + throw new NotImplementedException(); } @Override @@ -98,13 +113,12 @@ public ItemStack getToolInMainHand() { @Override public ItemStack storeItem(ItemStack stored) { - // Tricks with inventory needed - throw new RuntimeException("Not implemented yet"); + throw new NotImplementedException(); } @Override public void destroyUpgrade() { - throw new RuntimeException("Not implemented yet"); + throw new NotImplementedException(); } @Override @@ -116,4 +130,18 @@ public boolean isMovementPossible(@NotNull Level level, @NotNull BlockPos pos) { public boolean move(@NotNull Level level, @NotNull BlockPos pos) { return false; } + + @Override + public T getConnectedPeripheral(Class type) { + IPeripheral foundPeripheral = pocket.getUpgrades().values().stream() + .filter(peripheral -> { + if (peripheral == null || type.isInstance(peripheral)) { + return false; + } + return peripheral instanceof IBasePeripheral basePeripheral ? basePeripheral.isEnabled() : true; + }) + .findFirst() + .orElse(null); + return (T) foundPeripheral; + } } diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/TurtlePeripheralOwner.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/TurtlePeripheralOwner.java index c2709e02d..e8365fcc7 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/TurtlePeripheralOwner.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/owner/TurtlePeripheralOwner.java @@ -2,6 +2,7 @@ import com.mojang.authlib.GameProfile; import dan200.computercraft.ComputerCraft; +import dan200.computercraft.api.peripheral.IPeripheral; import dan200.computercraft.api.turtle.ITurtleAccess; import dan200.computercraft.api.turtle.TurtleSide; import dan200.computercraft.shared.TurtlePermissions; @@ -9,17 +10,20 @@ import de.srendi.advancedperipherals.common.util.DataStorageUtil; import de.srendi.advancedperipherals.common.util.fakeplayer.APFakePlayer; import de.srendi.advancedperipherals.common.util.fakeplayer.FakePlayerProviderTurtle; +import de.srendi.advancedperipherals.lib.peripherals.IBasePeripheral; import net.minecraft.core.BlockPos; import net.minecraft.core.Direction; import net.minecraft.core.FrontAndTop; import net.minecraft.nbt.CompoundTag; +import net.minecraft.world.entity.Entity; import net.minecraft.world.entity.player.Player; import net.minecraft.world.item.ItemStack; import net.minecraft.world.level.Level; +import net.minecraftforge.items.wrapper.InvWrapper; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.function.Function; +import java.util.stream.Stream; public class TurtlePeripheralOwner extends BasePeripheralOwner { public final ITurtleAccess turtle; @@ -61,6 +65,12 @@ public FrontAndTop getOrientation() { return FrontAndTop.fromFrontAndTop(getFacing(), Direction.UP); } + @Nullable + @Override + public Entity getHoldingEntity() { + return null; + } + @Nullable @Override public Player getOwner() { @@ -81,7 +91,7 @@ public void markDataStorageDirty() { } @Override - public T withPlayer(Function function) { + public T withPlayer(APFakePlayer.Action function) { return FakePlayerProviderTurtle.withPlayer(turtle, function); } @@ -92,7 +102,7 @@ public ItemStack getToolInMainHand() { @Override public ItemStack storeItem(ItemStack stored) { - return InventoryUtil.storeItems(stored, turtle.getItemHandler(), turtle.getSelectedSlot()); + return InventoryUtil.storeItems(stored, new InvWrapper(turtle.getInventory()), turtle.getSelectedSlot()); } @Override @@ -131,4 +141,19 @@ public TurtlePeripheralOwner attachFuel(int maxFuelConsumptionLevel) { attachAbility(PeripheralOwnerAbility.FUEL, new TurtleFuelAbility(this, maxFuelConsumptionLevel)); return this; } + + @Override + public T getConnectedPeripheral(Class type) { + IPeripheral foundPeripheral = Stream.of(TurtleSide.values()) + .map(side -> turtle.getPeripheral(side)) + .filter(peripheral -> { + if (peripheral == null || type.isInstance(peripheral)) { + return false; + } + return peripheral instanceof IBasePeripheral basePeripheral ? basePeripheral.isEnabled() : true; + }) + .findFirst() + .orElse(null); + return (T) foundPeripheral; + } } diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/BaseDetectorPeripheral.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/BaseDetectorPeripheral.java new file mode 100644 index 000000000..843c5554f --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/BaseDetectorPeripheral.java @@ -0,0 +1,42 @@ +package de.srendi.advancedperipherals.common.addons.computercraft.peripheral; + +import dan200.computercraft.api.lua.LuaFunction; +import de.srendi.advancedperipherals.common.addons.computercraft.owner.BlockEntityPeripheralOwner; +import de.srendi.advancedperipherals.common.blocks.base.BaseDetectorEntity; +import de.srendi.advancedperipherals.lib.peripherals.BasePeripheral; + +public abstract class BaseDetectorPeripheral extends BasePeripheral> { + protected BaseDetectorPeripheral(String type, E tileEntity) { + super(type, new BlockEntityPeripheralOwner<>(tileEntity)); + } + + @LuaFunction + public final long getMaxTransferRate() { + return owner.tileEntity.getMaxTransferRate(); + } + + @LuaFunction + public final long getTransferRateLimit() { + return owner.tileEntity.getTransferRateLimit(); + } + + @LuaFunction + public final void setTransferRateLimit(long transferRate) { + owner.tileEntity.setTransferRateLimit(transferRate); + } + + @LuaFunction + public final long getTransferRate() { + return owner.tileEntity.getTransferRate(); + } + + @LuaFunction + public final String getLastTransferedId() { + return owner.tileEntity.getLastTransferedId(); + } + + @LuaFunction + public final String getReadyTransferId() { + return owner.tileEntity.getReadyTransferId(); + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/BlockReaderPeripheral.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/BlockReaderPeripheral.java index 086fa4fe9..ce78b5077 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/BlockReaderPeripheral.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/BlockReaderPeripheral.java @@ -18,7 +18,7 @@ public class BlockReaderPeripheral extends BasePeripheral> { - public static final String PERIPHERAL_TYPE = "blockReader"; + public static final String PERIPHERAL_TYPE = "block_reader"; public BlockReaderPeripheral(BlockReaderEntity tileEntity) { super(PERIPHERAL_TYPE, new BlockEntityPeripheralOwner<>(tileEntity)); diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/ChatBoxPeripheral.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/ChatBoxPeripheral.java index 91f82b2e2..920f64f13 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/ChatBoxPeripheral.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/ChatBoxPeripheral.java @@ -7,6 +7,7 @@ import dan200.computercraft.api.lua.MethodResult; import dan200.computercraft.api.peripheral.IComputerAccess; import dan200.computercraft.api.pocket.IPocketAccess; +import dan200.computercraft.api.pocket.IPocketUpgrade; import dan200.computercraft.api.turtle.ITurtleAccess; import dan200.computercraft.api.turtle.TurtleSide; import de.srendi.advancedperipherals.AdvancedPeripherals; @@ -17,16 +18,16 @@ import de.srendi.advancedperipherals.common.blocks.base.PeripheralBlockEntity; import de.srendi.advancedperipherals.common.configuration.APConfig; import de.srendi.advancedperipherals.common.events.Events; +import de.srendi.advancedperipherals.common.network.APNetworking; +import de.srendi.advancedperipherals.common.network.toclient.ToastToClientPacket; import de.srendi.advancedperipherals.common.util.CoordUtil; import de.srendi.advancedperipherals.common.util.StringUtil; import de.srendi.advancedperipherals.lib.peripherals.BasePeripheral; import de.srendi.advancedperipherals.lib.peripherals.IPeripheralFunction; -import de.srendi.advancedperipherals.network.APNetworking; -import de.srendi.advancedperipherals.network.toclient.ToastToClientPacket; import net.minecraft.ChatFormatting; +import net.minecraft.network.chat.ClickEvent; import net.minecraft.network.chat.Component; import net.minecraft.network.chat.ComponentContents; -import net.minecraft.network.chat.ClickEvent; import net.minecraft.network.chat.HoverEvent; import net.minecraft.network.chat.MutableComponent; import net.minecraft.network.chat.Style; @@ -35,7 +36,6 @@ import net.minecraft.world.item.TooltipFlag; import net.minecraft.world.level.Level; import net.minecraftforge.server.ServerLifecycleHooks; - import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -44,12 +44,12 @@ import java.util.UUID; import java.util.function.Predicate; -import static de.srendi.advancedperipherals.common.commands.APCommands.ROOT_SAFE_EXEC_LITERAL; import static de.srendi.advancedperipherals.common.addons.computercraft.operations.SimpleFreeOperation.CHAT_MESSAGE; +import static de.srendi.advancedperipherals.common.commands.APCommands.ROOT_SAFE_EXEC_LITERAL; public class ChatBoxPeripheral extends BasePeripheral { - public static final String PERIPHERAL_TYPE = "chatBox"; + public static final String PERIPHERAL_TYPE = "chat_box"; private long lastConsumedMessage; @@ -67,8 +67,8 @@ public ChatBoxPeripheral(ITurtleAccess turtle, TurtleSide side) { this(new TurtlePeripheralOwner(turtle, side)); } - public ChatBoxPeripheral(IPocketAccess pocket) { - this(new PocketPeripheralOwner(pocket)); + public ChatBoxPeripheral(IPocketAccess pocket, IPocketUpgrade upgrade) { + this(new PocketPeripheralOwner(pocket, upgrade)); } @Override @@ -251,7 +251,7 @@ public final MethodResult sendFormattedMessage(@NotNull IArguments arguments) th if (!APConfig.PERIPHERALS_CONFIG.chatBoxMultiDimensional.get() && player.getLevel().dimension() != dimension) { continue; } - if (CoordUtil.isInRange(getPos(), getLevel(), player, range, maxRange)) { + if (CoordUtil.isInRange(getPhysicsPos(), getLevel(), player, range, maxRange)) { player.sendSystemMessage(preparedMessage); } } @@ -294,7 +294,7 @@ public final MethodResult sendMessage(@NotNull IArguments arguments) throws LuaE if (!APConfig.PERIPHERALS_CONFIG.chatBoxMultiDimensional.get() && player.getLevel().dimension() != dimension) { continue; } - if (CoordUtil.isInRange(getPos(), getLevel(), player, range, maxRange)) { + if (CoordUtil.isInRange(getPhysicsPos(), getLevel(), player, range, maxRange)) { player.sendSystemMessage(preparedMessage); } } @@ -341,7 +341,7 @@ public final MethodResult sendFormattedMessageToPlayer(@NotNull IArguments argum return MethodResult.of(false, "NOT_SAME_DIMENSION"); } - if (CoordUtil.isInRange(getPos(), getLevel(), player, range, maxRange)) { + if (CoordUtil.isInRange(getPhysicsPos(), getLevel(), player, range, maxRange)) { player.sendSystemMessage(preparedMessage); } return MethodResult.of(true); @@ -399,7 +399,7 @@ public final MethodResult sendFormattedToastToPlayer(@NotNull IArguments argumen return MethodResult.of(false, "NOT_SAME_DIMENSION"); } - if (CoordUtil.isInRange(getPos(), getLevel(), player, range, maxRange)) { + if (CoordUtil.isInRange(getPhysicsPos(), getLevel(), player, range, maxRange)) { ToastToClientPacket packet = new ToastToClientPacket(titleComponent, preparedMessage); APNetworking.sendTo(packet, player); } @@ -438,7 +438,7 @@ public final MethodResult sendMessageToPlayer(@NotNull IArguments arguments) thr return MethodResult.of(false, "NOT_SAME_DIMENSION"); } - if (CoordUtil.isInRange(getPos(), getLevel(), player, range, maxRange)) { + if (CoordUtil.isInRange(getPhysicsPos(), getLevel(), player, range, maxRange)) { player.sendSystemMessage(preparedMessage, false); } return MethodResult.of(true); @@ -477,7 +477,7 @@ public final MethodResult sendToastToPlayer(@NotNull IArguments arguments) throw return MethodResult.of(false, "NOT_SAME_DIMENSION"); } - if (CoordUtil.isInRange(getPos(), getLevel(), player, range, maxRange)) { + if (CoordUtil.isInRange(getPhysicsPos(), getLevel(), player, range, maxRange)) { ToastToClientPacket packet = new ToastToClientPacket(Component.literal(title), preparedMessage); APNetworking.sendTo(packet, player); } @@ -485,6 +485,7 @@ public final MethodResult sendToastToPlayer(@NotNull IArguments arguments) throw }); } + @Override public void update() { lastConsumedMessage = Events.traverseChatMessages(lastConsumedMessage, message -> { for (IComputerAccess computer : getConnectedComputers()) { diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/ChunkyPeripheral.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/ChunkyPeripheral.java index 94829b12f..428574bcb 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/ChunkyPeripheral.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/ChunkyPeripheral.java @@ -1,5 +1,6 @@ package de.srendi.advancedperipherals.common.addons.computercraft.peripheral; +import dan200.computercraft.api.lua.LuaFunction; import dan200.computercraft.api.peripheral.IComputerAccess; import dan200.computercraft.api.turtle.ITurtleAccess; import dan200.computercraft.api.turtle.TurtleSide; @@ -44,6 +45,11 @@ public boolean isEnabled() { return APConfig.PERIPHERALS_CONFIG.enableChunkyTurtle.get(); } + @LuaFunction + public int getRadius() { + return ChunkManager.getMaxLoadRadius(); + } + public void updateChunkState() { // TODO: should find someway to update after turtle moved or while moving, but not every tick ServerLevel level = (ServerLevel) getLevel(); @@ -72,7 +78,7 @@ protected void setLoadedChunk(@Nullable ChunkPos newChunk, ChunkManager manager, } @Override - public void attach(IComputerAccess computer) { + public void attach(@NotNull IComputerAccess computer) { super.attach(computer); ServerLevel level = (ServerLevel) owner.getLevel(); ChunkManager manager = ChunkManager.get(Objects.requireNonNull(level)); diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/ColonyPeripheral.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/ColonyPeripheral.java index 5a689c538..8b5a9a1e9 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/ColonyPeripheral.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/ColonyPeripheral.java @@ -18,6 +18,7 @@ import dan200.computercraft.api.lua.LuaException; import dan200.computercraft.api.lua.LuaFunction; import dan200.computercraft.api.pocket.IPocketAccess; +import dan200.computercraft.api.pocket.IPocketUpgrade; import de.srendi.advancedperipherals.AdvancedPeripherals; import de.srendi.advancedperipherals.common.addons.computercraft.owner.BlockEntityPeripheralOwner; import de.srendi.advancedperipherals.common.addons.computercraft.owner.IPeripheralOwner; @@ -32,12 +33,17 @@ import net.minecraft.resources.ResourceLocation; import net.minecraftforge.fml.ModList; -import java.util.*; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; import java.util.stream.Collectors; public class ColonyPeripheral extends BasePeripheral { - public static final String PERIPHERAL_TYPE = "colonyIntegrator"; + public static final String PERIPHERAL_TYPE = "colony_integrator"; protected boolean hasPermission = true; @@ -45,8 +51,8 @@ public ColonyPeripheral(PeripheralBlockEntity tileEntity) { super(PERIPHERAL_TYPE, new BlockEntityPeripheralOwner<>(tileEntity)); } - public ColonyPeripheral(IPocketAccess access) { - super(PERIPHERAL_TYPE, new PocketPeripheralOwner(access)); + public ColonyPeripheral(IPocketAccess access, IPocketUpgrade upgrade) { + super(PERIPHERAL_TYPE, new PocketPeripheralOwner(access, upgrade)); } @Override @@ -272,7 +278,7 @@ public final Object getRequests() throws LuaException { map.put("state", request.getState().toString()); map.put("count", deliverableRequest.getCount()); map.put("minCount", deliverableRequest.getMinimumCount()); - map.put("items", request.getDisplayStacks().stream().map(LuaConverter::stackToObject).collect(Collectors.toList())); + map.put("items", request.getDisplayStacks().stream().map(LuaConverter::itemStackToObject).collect(Collectors.toList())); map.put("target", request.getRequester().getRequesterDisplayName(requestManager, request).getString()); result.add(map); }); diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/DisabledPeripheral.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/DisabledPeripheral.java new file mode 100644 index 000000000..0fb89318f --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/DisabledPeripheral.java @@ -0,0 +1,75 @@ +package de.srendi.advancedperipherals.common.addons.computercraft.peripheral; + +import dan200.computercraft.api.lua.IArguments; +import dan200.computercraft.api.lua.IDynamicLuaObject; +import dan200.computercraft.api.lua.ILuaContext; +import dan200.computercraft.api.lua.LuaException; +import dan200.computercraft.api.lua.LuaFunction; +import dan200.computercraft.api.lua.MethodResult; +import dan200.computercraft.api.peripheral.IComputerAccess; +import dan200.computercraft.api.peripheral.IDynamicPeripheral; +import dan200.computercraft.api.peripheral.IPeripheral; + +import java.lang.reflect.Method; +import java.util.Objects; +import java.util.stream.Stream; + +public class DisabledPeripheral implements IDynamicPeripheral { + private static final MethodResult TRUE_RESULT = MethodResult.of(true); + + private final IPeripheral basePeripheral; + private final String[] methods; + + public DisabledPeripheral(IPeripheral basePeripheral) { + this.basePeripheral = basePeripheral; + Stream.Builder builder = Stream.builder(); + builder.add("peripheralDisabled"); + for (Method method : basePeripheral.getClass().getMethods()) { + LuaFunction annotation = method.getAnnotation(LuaFunction.class); + if (annotation == null) { + continue; + } + String[] names = annotation.value(); + if (names.length == 0) { + builder.add(method.getName()); + } else { + for (String name : names) { + builder.add(name); + } + } + } + Stream methodStream = builder.build(); + if (basePeripheral instanceof IDynamicPeripheral dynPeripheral) { + methodStream = Stream.concat(methodStream, Stream.of(dynPeripheral.getMethodNames())); + } + this.methods = methodStream.toArray(String[]::new); + } + + @Override + public String getType() { + return this.basePeripheral.getType(); + } + + @Override + public Object getTarget() { + return this.basePeripheral.getTarget(); + } + + @Override + public boolean equals(IPeripheral other) { + return other instanceof DisabledPeripheral disabled && this.basePeripheral.equals(disabled.basePeripheral); + } + + @Override + public String[] getMethodNames() { + return this.methods; + } + + @Override + public MethodResult callMethod(IComputerAccess computer, ILuaContext context, int method, IArguments arguments) throws LuaException { + if (method == 0) { + return TRUE_RESULT; + } + throw new LuaException("This peripheral is disabled, please contact server administrator if you want to use it"); + } +} diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/DistanceDetectorPeripheral.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/DistanceDetectorPeripheral.java new file mode 100644 index 000000000..aeba25afc --- /dev/null +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/DistanceDetectorPeripheral.java @@ -0,0 +1,331 @@ +package de.srendi.advancedperipherals.common.addons.computercraft.peripheral; + +import dan200.computercraft.api.lua.IArguments; +import dan200.computercraft.api.lua.LuaException; +import dan200.computercraft.api.lua.LuaFunction; +import dan200.computercraft.api.pocket.IPocketAccess; +import dan200.computercraft.api.pocket.IPocketUpgrade; +import de.srendi.advancedperipherals.common.addons.computercraft.owner.BlockEntityPeripheralOwner; +import de.srendi.advancedperipherals.common.addons.computercraft.owner.IPeripheralOwner; +import de.srendi.advancedperipherals.common.addons.computercraft.owner.PocketPeripheralOwner; +import de.srendi.advancedperipherals.common.blocks.blockentities.DistanceDetectorEntity; +import de.srendi.advancedperipherals.common.configuration.APConfig; +import de.srendi.advancedperipherals.common.util.HitResultUtil; +import de.srendi.advancedperipherals.lib.peripherals.BasePeripheral; +import net.minecraft.nbt.CompoundTag; +import net.minecraft.world.level.ClipContext; +import net.minecraft.world.level.Level; +import net.minecraft.world.phys.HitResult; +import net.minecraft.world.phys.Vec3; + +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; + +public class DistanceDetectorPeripheral extends BasePeripheral { + + public static final String PERIPHERAL_TYPE = "distance_detector"; + + private final AtomicBoolean isDirty = new AtomicBoolean(false); + private final DistanceDetectorEntity tileEntity; + private final AtomicInteger maxRange; + private volatile float currentDistance; + private final AtomicBoolean showLaser; + private volatile boolean calculatePeriodically; + private volatile boolean ignoreTransparent; + private final AtomicReference detectionType; + + public DistanceDetectorPeripheral(DistanceDetectorEntity tileEntity) { + super(PERIPHERAL_TYPE, new BlockEntityPeripheralOwner<>(tileEntity)); + this.tileEntity = tileEntity; + this.maxRange = new AtomicInteger(Float.floatToRawIntBits(this.tileEntity.getMaxRange())); + this.currentDistance = this.tileEntity.getCurrentDistance(); + this.showLaser = new AtomicBoolean(this.tileEntity.getShowLaser()); + this.calculatePeriodically = this.tileEntity.getCalculatePeriodically(); + this.ignoreTransparent = this.tileEntity.getIgnoreTransparent(); + this.detectionType = new AtomicReference<>(this.tileEntity.getDetectionType()); + } + + protected DistanceDetectorPeripheral(IPeripheralOwner owner) { + super(PERIPHERAL_TYPE, owner); + this.tileEntity = null; + CompoundTag data = this.owner.getDataStorage(); + this.maxRange = new AtomicInteger(Float.floatToRawIntBits(data.contains("maxRange") ? data.getFloat("maxRange") : this.getConfiguredMaxRange())); + this.currentDistance = data.contains("currentDistance") ? data.getFloat("currentDistance") : -1; + this.showLaser = new AtomicBoolean(data.contains("showLaser") ? data.getBoolean("showLaser") : true); + this.calculatePeriodically = data.contains("calculatePeriodically") ? data.getBoolean("calculatePeriodically") : false; + this.ignoreTransparent = data.contains("ignoreTransparent") ? data.getBoolean("ignoreTransparent") : true; + this.detectionType = new AtomicReference<>(data.contains("detectionType") ? DetectionType.values()[data.getByte("detectionType")] : DetectionType.BOTH); + } + + public DistanceDetectorPeripheral(IPocketAccess pocket, IPocketUpgrade upgrade) { + this(new PocketPeripheralOwner(pocket, upgrade)); + } + + @Override + public boolean isEnabled() { + return APConfig.PERIPHERALS_CONFIG.enableDistanceDetector.get(); + } + + public float getConfiguredMaxRange() { + return APConfig.PERIPHERALS_CONFIG.distanceDetectorRange.get().floatValue(); + } + + public int getUpdateRate() { + return APConfig.PERIPHERALS_CONFIG.distanceDetectorUpdateRate.get(); + } + + public float getMaxRange() { + return Float.intBitsToFloat(this.maxRange.get()); + } + + public void setMaxRange(float maxRange) { + maxRange = Math.min(Math.max(maxRange, 0), this.getConfiguredMaxRange()); + int maxRangeBits = Float.floatToRawIntBits(maxRange); + if (this.maxRange.getAndSet(maxRangeBits) == maxRange) { + return; + } + if (this.tileEntity != null) { + this.tileEntity.setMaxRange(maxRange); + this.tileEntity.sendUpdate(); + } + this.isDirty.set(true); + } + + public float getCurrentDistance() { + return this.currentDistance; + } + + public void setCurrentDistance(float currentDistance) { + this.currentDistance = currentDistance; + if (this.tileEntity != null) { + this.tileEntity.setCurrentDistance(currentDistance); + this.tileEntity.sendUpdate(); + } + this.isDirty.set(true); + } + + public boolean getCalculatePeriodically() { + return this.calculatePeriodically; + } + + public void setCalculatePeriodically(boolean calculatePeriodically) { + this.calculatePeriodically = calculatePeriodically; + if (this.tileEntity != null) { + this.tileEntity.setCalculatePeriodically(calculatePeriodically); + } + this.isDirty.set(true); + } + + public boolean getShowLaser() { + return this.showLaser.get(); + } + + public void setShowLaser(boolean showLaser) { + if (this.showLaser.getAndSet(showLaser) == showLaser) { + return; + } + if (this.tileEntity != null) { + this.tileEntity.setShowLaser(showLaser); + this.tileEntity.sendUpdate(); + } + this.isDirty.set(true); + } + + public boolean getIgnoreTransparent() { + return this.ignoreTransparent; + } + + public void setIgnoreTransparent(boolean ignoreTransparent) { + this.ignoreTransparent = ignoreTransparent; + if (this.tileEntity != null) { + this.tileEntity.setIgnoreTransparent(ignoreTransparent); + } + this.isDirty.set(true); + } + + public DetectionType getDetectionType() { + return this.detectionType.get(); + } + + public void setDetectionType(DetectionType detectionType) { + if (this.detectionType.getAndSet(detectionType) == detectionType) { + return; + } + if (this.tileEntity != null) { + this.tileEntity.setDetectionType(detectionType); + } + this.isDirty.set(true); + } + + @LuaFunction + public final void setLaserVisibility(boolean laser) { + this.setShowLaser(laser); + } + + @LuaFunction + public final boolean getLaserVisibility() { + return this.getShowLaser(); + } + + @LuaFunction(value = "setIgnoreTransparency") + public final void setIgnoreTransparencyLua(boolean enable) { + this.setIgnoreTransparent(enable); + } + + @LuaFunction + public final boolean ignoresTransparency() { + return this.getIgnoreTransparent(); + } + + @LuaFunction + public final void setDetectionMode(IArguments args) throws LuaException { + Object mode = args.get(0); + if (mode == null) { + throw new LuaException("arg #1 must provide a mode name or an index between [0, 2]"); + } + DetectionType detectionType; + if (mode instanceof Number modeInd) { + int index = Math.min(Math.max(modeInd.intValue(), 0), 2); + detectionType = DetectionType.values()[index]; + } else if (mode instanceof String modeStr) { + detectionType = switch (modeStr.toUpperCase()) { + case "BLOCK" -> DetectionType.BLOCK; + case "ENTITY" -> DetectionType.ENTITY; + case "BOTH" -> DetectionType.BOTH; + default -> throw new LuaException("Unknown detection mode '" + mode + "'"); + }; + } else { + throw new LuaException("arg #1 must be a string or a number"); + } + this.setDetectionType(detectionType); + } + + @LuaFunction + public final boolean detectsEntities() { + return this.getDetectionType().detectEntity(); + } + + @LuaFunction + public final boolean detectsBlocks() { + return this.getDetectionType().detectBlock(); + } + + @LuaFunction + public final String getDetectionMode() { + return this.getDetectionType().toString(); + } + + @LuaFunction + public final double getDistance() { + return this.getCurrentDistance(); + } + + @LuaFunction(mainThread = true) + public final double calculateDistance() { + return this.calculateAndUpdateDistance(); + } + + @LuaFunction + public final boolean shouldCalculatePeriodically() { + return this.getCalculatePeriodically(); + } + + @LuaFunction(value = "setCalculatePeriodically") + public final void setCalculatePeriodicallyLua(boolean shouldCalculatePeriodically) { + this.setCalculatePeriodically(shouldCalculatePeriodically); + } + + @LuaFunction(value = "setMaxRange") + public final void setMaxRangeLua(double maxDistance) { + this.setMaxRange((float) maxDistance); + } + + @LuaFunction(value = "getMaxRange") + public final double getMaxRangeLua() { + return this.getMaxRange(); + } + + protected double calculateDistanceImpl() { + final double maxRange = this.getMaxRange(); + Vec3 direction = this.owner.getDirection(); + Vec3 center = this.getPhysicsPos(); + Vec3 from = center; + Vec3 to = from.add(direction.scale(maxRange)); + + HitResult result = this.getHitResult(from, to); + if (result.getType() == HitResult.Type.MISS) { + return -1; + } + double distance = result.getLocation().distanceTo(center); + if (this.tileEntity != null) { + distance -= 0.5; + } + return distance; + } + + /** + * calculateAndUpdateDistance should only invokes from server main thread + */ + public double calculateAndUpdateDistance() { + double distance = this.calculateDistanceImpl(); + this.setCurrentDistance((float) distance); + return distance; + } + + @Override + public void update() { + if (this.getCalculatePeriodically() && this.getLevel().getGameTime() % this.getUpdateRate() == 0) { + // We calculate the distance every 2 ticks, so we do not have to run the getDistance function of the peripheral + // on the main thread which prevents the 1 tick yield time of the function. + // The calculateDistance function is not thread safe, so we have to run it on the main thread. + // It should be okay to run that function every 2 ticks, calculating it does not take too much time. + this.calculateAndUpdateDistance(); + } + + if (this.isDirty.getAndSet(false)) { + if (this.tileEntity == null) { + CompoundTag data = this.owner.getDataStorage(); + data.putFloat("maxRange", this.getMaxRange()); + data.putFloat("currentDistance", this.getCurrentDistance()); + data.putBoolean("showLaser", this.getShowLaser()); + data.putBoolean("calculatePeriodically", this.getCalculatePeriodically()); + data.putBoolean("ignoreTransparent", this.getIgnoreTransparent()); + data.putByte("detectionType", (byte) this.getDetectionType().ordinal()); + } + this.owner.markDataStorageDirty(); + } + } + + protected HitResult getHitResult(Vec3 from, Vec3 to) { + Level level = this.getLevel(); + ClipContext.ShapeGetter shapeGetter = this.ignoreTransparent ? HitResultUtil.IgnoreNoOccludedContext.INSTANCE : ClipContext.Block.COLLIDER; + return switch (this.getDetectionType()) { + case ENTITY -> HitResultUtil.getEntityHitResult(from, to, level, this.owner.getHoldingEntity()); + case BLOCK -> HitResultUtil.getBlockHitResult(from, to, level, shapeGetter, this.getPos()); + case BOTH -> HitResultUtil.getHitResult(from, to, level, shapeGetter, this.owner); + }; + } + + public enum DetectionType { + BLOCK(true, false), + ENTITY(false, true), + BOTH(true, true); + + private final boolean block, entity; + + DetectionType(boolean block, boolean entity) { + this.block = block; + this.entity = entity; + } + + public boolean detectBlock() { + return this.block; + } + + public boolean detectEntity() { + return this.entity; + } + } + +} diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/EnergyDetectorPeripheral.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/EnergyDetectorPeripheral.java index 8b0e016f2..5aff47acd 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/EnergyDetectorPeripheral.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/EnergyDetectorPeripheral.java @@ -1,37 +1,18 @@ package de.srendi.advancedperipherals.common.addons.computercraft.peripheral; -import dan200.computercraft.api.lua.LuaFunction; -import de.srendi.advancedperipherals.common.addons.computercraft.owner.BlockEntityPeripheralOwner; import de.srendi.advancedperipherals.common.blocks.blockentities.EnergyDetectorEntity; import de.srendi.advancedperipherals.common.configuration.APConfig; -import de.srendi.advancedperipherals.lib.peripherals.BasePeripheral; -public class EnergyDetectorPeripheral extends BasePeripheral> { +public class EnergyDetectorPeripheral extends BaseDetectorPeripheral { - public static final String PERIPHERAL_TYPE = "energyDetector"; + public static final String TYPE = "energy_detector"; public EnergyDetectorPeripheral(EnergyDetectorEntity tileEntity) { - super(PERIPHERAL_TYPE, new BlockEntityPeripheralOwner<>(tileEntity)); + super(TYPE, tileEntity); } @Override public boolean isEnabled() { return APConfig.PERIPHERALS_CONFIG.enableEnergyDetector.get(); } - - @LuaFunction(mainThread = true) - public final int getTransferRateLimit() { - return owner.tileEntity.storageProxy.getMaxTransferRate(); - } - - @LuaFunction(mainThread = true) - public final void setTransferRateLimit(long transferRate) { - transferRate = Math.max(0, Math.min(APConfig.PERIPHERALS_CONFIG.energyDetectorMaxFlow.get(), transferRate)); - owner.tileEntity.storageProxy.setMaxTransferRate((int) transferRate); - } - - @LuaFunction(mainThread = true) - public final int getTransferRate() { - return owner.tileEntity.transferRate; - } } diff --git a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/EnvironmentDetectorPeripheral.java b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/EnvironmentDetectorPeripheral.java index f37aa156e..62db06f6a 100644 --- a/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/EnvironmentDetectorPeripheral.java +++ b/src/main/java/de/srendi/advancedperipherals/common/addons/computercraft/peripheral/EnvironmentDetectorPeripheral.java @@ -4,10 +4,11 @@ import dan200.computercraft.api.lua.LuaException; import dan200.computercraft.api.lua.LuaFunction; import dan200.computercraft.api.lua.MethodResult; -import dan200.computercraft.api.peripheral.IComputerAccess; import dan200.computercraft.api.pocket.IPocketAccess; +import dan200.computercraft.api.pocket.IPocketUpgrade; import dan200.computercraft.api.turtle.ITurtleAccess; import dan200.computercraft.api.turtle.TurtleSide; + import de.srendi.advancedperipherals.common.addons.computercraft.operations.SphereOperationContext; import de.srendi.advancedperipherals.common.addons.computercraft.owner.BlockEntityPeripheralOwner; import de.srendi.advancedperipherals.common.addons.computercraft.owner.IPeripheralOwner; @@ -18,13 +19,12 @@ import de.srendi.advancedperipherals.common.util.LuaConverter; import de.srendi.advancedperipherals.lib.peripherals.BasePeripheral; import de.srendi.advancedperipherals.lib.peripherals.IPeripheralPlugin; -import net.minecraft.core.BlockPos; + import net.minecraft.resources.ResourceKey; import net.minecraft.util.Mth; import net.minecraft.world.entity.Entity; import net.minecraft.world.entity.LivingEntity; import net.minecraft.world.entity.player.Player; -import net.minecraft.world.item.ItemStack; import net.minecraft.world.level.ChunkPos; import net.minecraft.world.level.Level; import net.minecraft.world.level.LightLayer; @@ -32,28 +32,35 @@ import net.minecraft.world.level.biome.Biome; import net.minecraft.world.level.levelgen.WorldgenRandom; import net.minecraft.world.phys.AABB; +import net.minecraft.world.phys.Vec3; import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.event.entity.player.SleepingTimeCheckEvent; import net.minecraftforge.eventbus.api.Event; import net.minecraftforge.server.ServerLifecycleHooks; -import org.jetbrains.annotations.NotNull; - -import java.util.*; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; import java.util.function.Function; +import org.jetbrains.annotations.NotNull; import static de.srendi.advancedperipherals.common.addons.computercraft.operations.SphereOperation.SCAN_ENTITIES; public class EnvironmentDetectorPeripheral extends BasePeripheral { - public static final String PERIPHERAL_TYPE = "environmentDetector"; - private static final List> PERIPHERAL_PLUGINS = new LinkedList<>(); + public static final String PERIPHERAL_TYPE = "environment_detector"; + private static final List> PERIPHERAL_PLUGINS = new ArrayList<>(); protected EnvironmentDetectorPeripheral(IPeripheralOwner owner) { super(PERIPHERAL_TYPE, owner); owner.attachOperation(SCAN_ENTITIES); - for (Function plugin : PERIPHERAL_PLUGINS) + for (Function plugin : PERIPHERAL_PLUGINS) { addPlugin(plugin.apply(owner)); + } } public EnvironmentDetectorPeripheral(PeripheralBlockEntity tileEntity) { @@ -64,8 +71,8 @@ public EnvironmentDetectorPeripheral(ITurtleAccess turtle, TurtleSide side) { this(new TurtlePeripheralOwner(turtle, side).attachFuel(1)); } - public EnvironmentDetectorPeripheral(IPocketAccess pocket) { - this(new PocketPeripheralOwner(pocket)); + public EnvironmentDetectorPeripheral(IPocketAccess pocket, IPocketUpgrade upgrade) { + this(new PocketPeripheralOwner(pocket, upgrade)); } private static int estimateCost(int radius) { @@ -89,24 +96,24 @@ public boolean isEnabled() { @LuaFunction(mainThread = true) public final String getBiome() { - Optional