better f4

common/src/main/java/net/lerariemann/infinity/InfinityModClient.java

···
 
 import dev.architectury.registry.client.keymappings.KeyMappingRegistry;
 import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
-import net.lerariemann.infinity.util.screen.F4Screen;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
+import net.lerariemann.infinity.item.F4Item;
 import net.lerariemann.infinity.registry.core.ModEntities;
 import net.lerariemann.infinity.registry.core.ModItems;
 import net.lerariemann.infinity.registry.var.ModPayloads;
 import net.lerariemann.infinity.registry.var.ModScreenHandlers;
 import net.minecraft.client.option.KeyBinding;
 import net.minecraft.client.util.InputUtil;
+import net.minecraft.item.ItemStack;
 import net.minecraft.util.Hand;
+import net.minecraft.util.TypedActionResult;
 import net.minecraft.util.math.noise.DoublePerlinNoiseSampler;
 import net.minecraft.util.math.random.CheckedRandom;
 import org.lwjgl.glfw.GLFW;
 
 public class InfinityModClient {
     public final static DoublePerlinNoiseSampler sampler = DoublePerlinNoiseSampler.create(new CheckedRandom(0L), -3, 1.0, 1.0, 1.0, 0.0);
-    public static KeyBinding f4ConfigKey = new KeyBinding("key.infinity.f4_config",
+    public static KeyBinding f4ConfigKey = new KeyBinding("key.infinity.f4",
             InputUtil.Type.KEYSYM,
             GLFW.GLFW_KEY_F4,
             "key.categories.misc");
···
         ClientTickEvents.END_CLIENT_TICK.register(client -> {
             while (f4ConfigKey.wasPressed()) if (client.player != null
                     && client.player.getStackInHand(Hand.MAIN_HAND).isOf(ModItems.F4.get())) {
-                client.setScreen(F4Screen.of(client.player));
+                ClientPlayNetworking.send(ModPayloads.DeployF4.INSTANCE);
+                TypedActionResult<ItemStack> result = F4Item.deploy(client.world, client.player, Hand.MAIN_HAND);
+                client.player.setStackInHand(Hand.MAIN_HAND, result.getValue());
             }
         });
     }

common/src/main/java/net/lerariemann/infinity/item/F4Item.java

···
 import net.lerariemann.infinity.registry.core.ModComponentTypes;
 import net.lerariemann.infinity.registry.core.ModItems;
 import net.lerariemann.infinity.util.InfinityMethods;
+import net.lerariemann.infinity.util.screen.F4Screen;
 import net.lerariemann.infinity.util.teleport.InfinityPortal;
 import net.minecraft.block.BlockState;
 import net.minecraft.block.Blocks;
 import net.minecraft.block.NetherPortalBlock;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.network.ClientPlayerEntity;
 import net.minecraft.component.ComponentMap;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.ItemUsageContext;
 import net.minecraft.item.tooltip.TooltipType;
+import net.minecraft.sound.SoundCategory;
 import net.minecraft.sound.SoundEvents;
 import net.minecraft.state.property.Properties;
 import net.minecraft.text.MutableText;
···
         }
         useCharges -= obsNotReplaced;
 
-        player.playSound(SoundEvents.BLOCK_BELL_USE, 1, 0.75f);
+        world.playSound(player, player.getBlockPos(), SoundEvents.BLOCK_BELL_USE, SoundCategory.BLOCKS, 1, 0.75f);
         stack.applyComponentsFrom(ComponentMap.builder()
                 .add(ModComponentTypes.CHARGE.get(), charges - useCharges).build());
         return stack;
···
 
     @Override
     public TypedActionResult<ItemStack> use(World world, PlayerEntity player, Hand hand) {
+        if (player instanceof ClientPlayerEntity clientPlayer) {
+            MinecraftClient.getInstance().setScreen(F4Screen.of(clientPlayer));
+        }
+        return TypedActionResult.success(player.getStackInHand(hand));
+    }
+
+    public static TypedActionResult<ItemStack> deploy(World world, PlayerEntity player, Hand hand) {
         Direction dir = player.getHorizontalFacing();
         Direction.Axis dir2 = dir.rotateClockwise(Direction.Axis.Y).getAxis();
         BlockPos lowerCenter = player.getBlockPos().offset(dir, 4);
···
         boolean positionFound = true;
         for (i = 0; i <= 8 && !world.isOutOfHeightLimit(lowerY + i + size_y); i++) {
             positionFound = true;
-            for (int j = 0; j <= size_y+1; j++) for (int k = -1; k <= size_x; k++) {
+            for (int j = 0; j <= size_y+1 && positionFound; j++) for (int k = -1; k <= size_x; k++) {
                 BlockState bs = world.getBlockState(lowerCenter.up(i+j-1).offset(dir2, k - (size_x /2)));
-                if (!bs.isAir() && !bs.isOf(Blocks.OBSIDIAN)) {
-                    i += j;
-                    positionFound = false;
-                    break;
+                if (bs.isReplaceable()) continue;
+                if (bs.isOf(Blocks.OBSIDIAN)) {
+                    if (j == 0 || j == size_y+1 || k == -1 || k == size_x) continue;
+                    i += j-1;
                 }
+                else i += j;
+                positionFound = false;
+                break;
             }
             if (positionFound) break;
         }
···
         //validating the place position
         for (int j = -1; j <= size_y; j++) for (int k = -1; k <= size_x; k++) {
             bs = world.getBlockState(pos.up(j).offset(dir2, k - (size_x /2)));
-            if (!bs.isAir() && !bs.isOf(Blocks.OBSIDIAN)) {
-                return ActionResult.FAIL;
-            }
+            if (bs.isOf(Blocks.OBSIDIAN) && (j == -1 || j == size_y || k == -1 || k == size_x)) continue;
+            if (!bs.isReplaceable()) return ActionResult.FAIL;
         }
 
         ItemStack newStack = placePortal(world, player, context.getStack().copy(), pos,
···
         }
         int obsidian = 0;
         for (BlockPos bp : toRemove) if (!toLeave.contains(bp)) { //double check since we're checking the corners twice
-            world.removeBlock(bp, false);
+            world.setBlockState(bp,  Blocks.AIR.getDefaultState(), 3, 0);
             obsidian++;
         }
+        for (int i = 0; i <= portal.width; i++) for (int j = -1; j <= portal.height; j++)
+            world.setBlockState(portal.lowerLeft.offset(axis, i).up(j), Blocks.AIR.getDefaultState(), 3, 0);
         stack.applyComponentsFrom(ComponentMap.builder()
                 .add(ModComponentTypes.CHARGE.get(), getCharge(stack) + obsidian).build());
+        world.playSound(null, origin, SoundEvents.BLOCK_GLASS_BREAK, SoundCategory.BLOCKS, 1, 0.75f);
         return stack;
     }
 }

common/src/main/java/net/lerariemann/infinity/registry/var/ModPayloads.java

···
 import net.lerariemann.infinity.access.InfinityOptionsAccess;
 import net.lerariemann.infinity.access.WorldRendererAccess;
 import net.lerariemann.infinity.iridescence.Iridescence;
+import net.lerariemann.infinity.item.F4Item;
 import net.lerariemann.infinity.registry.core.ModComponentTypes;
 import net.lerariemann.infinity.registry.core.ModItems;
 import net.lerariemann.infinity.util.loading.DimensionGrabber;
···
 import net.minecraft.network.codec.PacketCodec;
 import net.minecraft.network.codec.PacketCodecs;
 import net.minecraft.network.packet.CustomPayload;
-import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ServerWorld;
+import net.minecraft.util.Hand;
 import net.minecraft.util.Identifier;
+import net.minecraft.util.TypedActionResult;
 
 import java.nio.file.Path;
 import java.util.Objects;
···
     }
 
     public record F4Payload(int slot, int width, int height) implements CustomPayload {
-        public static final CustomPayload.Id<F4Payload> ID = new CustomPayload.Id<>(InfinityMethods.getId("f4"));
+        public static final CustomPayload.Id<F4Payload> ID = new CustomPayload.Id<>(InfinityMethods.getId("receive_f4"));
         public static final PacketCodec<RegistryByteBuf, F4Payload> CODEC = PacketCodec.tuple(
                 PacketCodecs.VAR_INT, F4Payload::slot,
                 PacketCodecs.VAR_INT, F4Payload::width,
···
         }
     }
     public static void receiveF4(F4Payload payload, ServerPlayNetworking.Context context) {
-        try (MinecraftServer server = context.server()) {
-            server.execute(() -> {
-                ItemStack st = context.player().getInventory().getStack(payload.slot);
-                if (st.isOf(ModItems.F4.get())) {
-                    ItemStack newStack = st.copy();
-                    newStack.applyComponentsFrom(ComponentMap.builder()
-                            .add(ModComponentTypes.SIZE_X.get(), Math.clamp(payload.width, 1, 21))
-                            .add(ModComponentTypes.SIZE_Y.get(), Math.clamp(payload.height, 1, 21))
-                            .build());
-                    context.player().getInventory().setStack(payload.slot, newStack);
-                }
-            });
+        ItemStack st = context.player().getInventory().getStack(payload.slot);
+        if (st.isOf(ModItems.F4.get())) {
+            ItemStack newStack = st.copy();
+            newStack.applyComponentsFrom(ComponentMap.builder()
+                    .add(ModComponentTypes.SIZE_X.get(), Math.clamp(payload.width, 1, 21))
+                    .add(ModComponentTypes.SIZE_Y.get(), Math.clamp(payload.height, 1, 21))
+                    .build());
+            context.player().getInventory().setStack(payload.slot, newStack);
+        }
+    }
+    public record DeployF4() implements CustomPayload {
+        public static final DeployF4 INSTANCE = new DeployF4();
+        public static final CustomPayload.Id<DeployF4> ID = new CustomPayload.Id<>(InfinityMethods.getId("deploy_f4"));
+        public static final PacketCodec<RegistryByteBuf, DeployF4> CODEC = PacketCodec.unit(INSTANCE);
+        @Override
+        public CustomPayload.Id<? extends CustomPayload> getId() {
+            return ID;
+        }
+    }
+    public static void deployF4(DeployF4 payload, ServerPlayNetworking.Context context) {
+        ServerPlayerEntity player = context.player();
+        ItemStack st = player.getStackInHand(Hand.MAIN_HAND);
+        if (st.isOf(ModItems.F4.get())) {
+            TypedActionResult<ItemStack> result = F4Item.deploy(player.getServerWorld(), player, Hand.MAIN_HAND);
+            player.setStackInHand(Hand.MAIN_HAND, result.getValue());
         }
     }
 
···
         PayloadTypeRegistry.playS2C().register(ShaderRePayload.ID, ShaderRePayload.CODEC);
         PayloadTypeRegistry.playS2C().register(StarsRePayLoad.ID, StarsRePayLoad.CODEC);
         PayloadTypeRegistry.playC2S().register(F4Payload.ID, F4Payload.CODEC);
+        PayloadTypeRegistry.playC2S().register(DeployF4.ID, DeployF4.CODEC);
         ServerPlayNetworking.registerGlobalReceiver(F4Payload.ID, ModPayloads::receiveF4);
+        ServerPlayNetworking.registerGlobalReceiver(DeployF4.ID, ModPayloads::deployF4);
     }
 
     public static void registerPayloadsClient() {

common/src/main/resources/assets/infinity/lang/en_us.json

···
   "item.infinity.star_of_lang": "Star of Lang",
   "item.infinity.iridescent_star": "Iridescent Star",
   "item.infinity.f4": "F4",
-  "key.infinity.f4_config": "Open F4 config menu",
+  "key.infinity.f4": "Place a Nether Portal",
   "lore.infinity.altar": "This block can be crafted by throwing a Lectern into an Infinity Portal. Using a diamond on it will play a fun animation!",
   "lore.infinity.ant": "This strange block rapidly moves, changing White Concrete to Black Concrete and back again, referencing \"Langton's ant\".",
   "lore.infinity.book_box": "This block can be found in the Infinite Library. Using it will give you a randomly generated book based on the block's position.",