Create 6.0 support

common/build.gradle

···
         url = "https://maven.terraformersmc.com/"
     }
     maven { url 'https://jitpack.io' }
+    exclusiveContent {
+        forRepository {
+            maven {
+                name = "Fabricators of Create"
+                url = "https://mvn.devos.one/snapshots"
+            }
+        }
+        filter {
+            includeGroup "io.github.fabricators_of_create"
+            includeGroup "io.github.fabricators_of_create.Porting-Lib"
+            includeGroup "com.tterrag.registrate_fabric"
+            includeGroup "io.github.tropheusj"
+            includeGroup "com.simibubi.create"
+        }
+    }
 }
 
 dependencies {
···
     // EMI
     modCompileOnly("dev.emi:emi-xplat-intermediary:$emi_version+$minecraft_version:api")
 
-    // Ponder
+    // Create
     modCompileOnly("net.createmod.ponder:Ponder-Fabric-${minecraft_version}:${ponder_version}")
-
+    modCompileOnly("com.simibubi.create:create-fucked-up-${minecraft_version}:6.0.6+053024d") { transitive = false }
 }
 
 loom {

common/src/main/java/net/lerariemann/infinity/block/custom/RailHelper.java

···
+package net.lerariemann.infinity.block.custom;
+
+import com.mojang.serialization.MapCodec;
+import dev.architectury.platform.Platform;
+import net.lerariemann.infinity.compat.CreateCompat;
+import net.lerariemann.infinity.registry.core.ModBlockEntities;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.BlockWithEntity;
+import net.minecraft.block.Blocks;
+import net.minecraft.block.entity.BlockEntity;
+import net.minecraft.server.world.ServerWorld;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.random.Random;
+import net.minecraft.world.World;
+import org.jetbrains.annotations.Nullable;
+
+public class RailHelper extends BlockWithEntity {
+    public RailHelper(Settings settings) {
+        super(settings);
+    }
+
+    @Override
+    protected MapCodec<? extends BlockWithEntity> getCodec() {
+        return null;
+    }
+
+    @Override
+    public void onBlockAdded(BlockState state, World world, BlockPos pos, BlockState oldState, boolean notify) {
+        world.scheduleBlockTick(pos, this, 1);
+    }
+
+    @Override
+    public void scheduledTick(BlockState state, ServerWorld world, BlockPos pos, Random random) {
+        if (Platform.isModLoaded("create")) {
+            CreateCompat.reattachRails(world, pos, getBlockEntity(world, pos));
+        }
+        else world.setBlockState(pos, Blocks.AIR.getDefaultState());
+    }
+
+    public static RHBEntity getBlockEntity(ServerWorld world, BlockPos pos) {
+        return ((RHBEntity)world.getBlockEntity(pos));
+    }
+
+    @Override
+    public @Nullable BlockEntity createBlockEntity(BlockPos pos, BlockState state) {
+        return new RHBEntity(pos, state);
+    }
+
+    public static class RHBEntity extends BlockEntity {
+        public Identifier trackBlock;
+        public String shape;
+
+        public RHBEntity(BlockPos pos, BlockState state) {
+            super(ModBlockEntities.RAIL_HELPER.get(), pos, state);
+            trackBlock = null;
+            shape = "xo";
+        }
+    }
+}

common/src/main/java/net/lerariemann/infinity/compat/CreateCompat.java

···
+package net.lerariemann.infinity.compat;
+
+import com.simibubi.create.api.contraption.train.PortalTrackProvider;
+import com.simibubi.create.content.trains.track.AllPortalTracks;
+import com.simibubi.create.content.trains.track.TrackBlock;
+import com.simibubi.create.content.trains.track.TrackShape;
+import net.createmod.catnip.math.BlockFace;
+import net.lerariemann.infinity.block.custom.RailHelper;
+import net.lerariemann.infinity.block.entity.InfinityPortalBlockEntity;
+import net.lerariemann.infinity.registry.core.ModBlocks;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
+import net.minecraft.registry.Registries;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.world.ServerWorld;
+import net.minecraft.state.property.Properties;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Direction;
+import net.minecraft.world.World;
+
+import java.util.Optional;
+import java.util.Set;
+
+public class CreateCompat {
+    private static PortalTrackProvider.Exit infinityPortalProvider(ServerWorld worldFrom, BlockFace blockFace) {
+        MinecraftServer server = worldFrom.getServer();
+//        if (!server.isNetherAllowed()) return null;
+        BlockPos posFrom = blockFace.getConnectedPos();
+        if (worldFrom.getBlockEntity(posFrom) instanceof InfinityPortalBlockEntity ipbe
+                && ipbe.isConnectedBothSides()) { //we only allow trains through if portals are in sync
+            ServerWorld worldTo = ipbe.getDimensionAsWorld();
+            BlockPos posTo = ipbe.getOtherSidePos();
+            assert posTo != null;
+            Direction targetDirection = blockFace.getFace();
+            Direction.Axis axisTo = worldTo.getBlockState(posTo).get(Properties.HORIZONTAL_AXIS);
+            if (targetDirection.getAxis().equals(axisTo)) {
+                targetDirection = targetDirection.rotateYClockwise();
+            }
+            return new PortalTrackProvider.Exit(worldTo, new BlockFace(posTo.offset(targetDirection), targetDirection.getOpposite()));
+        }
+        return null;
+    }
+
+    public static void register() {
+        AllPortalTracks.tryRegisterIntegration(ModBlocks.PORTAL.get().arch$registryName(), CreateCompat::infinityPortalProvider);
+    }
+
+    public static void tryModifyRails(InfinityPortalBlockEntity ipbe) {
+        World w = ipbe.getWorld();
+        if (w instanceof ServerWorld worldFrom) {
+            BlockPos posFrom = ipbe.getPos();
+            BlockState state = worldFrom.getBlockState(posFrom);
+            if (!state.isOf(ModBlocks.PORTAL.get())) return;
+            Set<Direction> toCheck = state.get(Properties.HORIZONTAL_AXIS).equals(Direction.Axis.X) ?
+                    Set.of(Direction.NORTH, Direction.SOUTH) : Set.of(Direction.EAST, Direction.WEST);
+            for (Direction dir : toCheck) {
+                BlockPos posTrack = posFrom.offset(dir);
+                BlockState bs = worldFrom.getBlockState(posTrack);
+                if (bs.getBlock() instanceof TrackBlock)
+                    modifyRails(ipbe, worldFrom, posTrack, bs);
+            }
+        }
+    }
+
+    public static void modifyRails(InfinityPortalBlockEntity ipbe, ServerWorld worldFrom,
+                                   BlockPos posTrack, BlockState bs) {
+        if (ipbe.isConnectedBothSides()) {
+            if (!bs.contains(TrackBlock.SHAPE)) return;
+            worldFrom.setBlockState(posTrack, ModBlocks.RAIL_HELPER.get().getDefaultState());
+            RailHelper.RHBEntity e = RailHelper.getBlockEntity(worldFrom, posTrack);
+            e.trackBlock = Registries.BLOCK.getId(bs.getBlock());
+            e.shape = switch (bs.get(TrackBlock.SHAPE)) {
+                case TN, TS -> "zo";
+                default -> "xo";
+            };
+        }
+        worldFrom.setBlockState(posTrack, Blocks.AIR.getDefaultState());
+    }
+    public static void reattachRails(ServerWorld world, BlockPos pos, RailHelper.RHBEntity e) {
+        BlockState bs;
+        Optional<Block> b = Registries.BLOCK.getOrEmpty(e.trackBlock);
+        if (b.isEmpty() || !(b.get() instanceof TrackBlock)) bs = Blocks.AIR.getDefaultState();
+        else bs = b.get().getDefaultState().with(TrackBlock.SHAPE, e.shape.equals("zo") ? TrackShape.ZO : TrackShape.XO);
+        world.setBlockState(pos, bs);
+    }
+}

common/src/main/java/net/lerariemann/infinity/registry/core/ModBlockEntities.java

···
 import dev.architectury.registry.registries.DeferredRegister;
 import dev.architectury.registry.registries.RegistrySupplier;
 import net.lerariemann.infinity.InfinityMod;
+import net.lerariemann.infinity.block.custom.RailHelper;
 import net.lerariemann.infinity.block.entity.*;
 import net.minecraft.block.entity.BlockEntityType;
 import net.minecraft.datafixer.TypeReferences;
···
                     BlockEntityType.Builder.create(ChromaticBlockEntity::new,
                             ModBlocks.CHROMATIC_WOOL.get(),
                             ModBlocks.CHROMATIC_CARPET.get()).build(type("chromatic")));
+    public static final RegistrySupplier<BlockEntityType<RailHelper.RHBEntity>> RAIL_HELPER =
+            BLOCK_ENTITY_TYPES.register("rail_helper_block_entity", () ->
+                    BlockEntityType.Builder.create(RailHelper.RHBEntity::new,
+                            ModBlocks.RAIL_HELPER.get()).build(type("rail_helper_block_entity")));
 
 
     public static void registerBlockEntities() {

common/src/main/java/net/lerariemann/infinity/registry/core/ModBlocks.java

···
 import net.lerariemann.infinity.util.PlatformMethods;
 import net.lerariemann.infinity.block.custom.*;
 import net.minecraft.block.*;
+import net.minecraft.block.piston.PistonBehavior;
 import net.minecraft.registry.RegistryKeys;
 import net.minecraft.sound.BlockSoundGroup;
 
···
             new NotesBlock(AbstractBlock.Settings.copy(Blocks.NOTE_BLOCK).ticksRandomly()));
     public static final RegistrySupplier<Block> HAUNTED_AIR = BLOCKS.register("haunted_air", () ->
             new HauntedBlock(Blocks.AIR));
+    public static final RegistrySupplier<RailHelper> RAIL_HELPER = BLOCKS.register("rail_helper", () ->
+            new RailHelper(AbstractBlock.Settings.create().strength(-1.0F, 3600000.8F).mapColor(MapColor.CLEAR).dropsNothing().nonOpaque().allowsSpawning(Blocks::never).noBlockBreakParticles().pistonBehavior(PistonBehavior.BLOCK)));
 
     public static void registerModBlocks() {
         InfinityMod.LOGGER.debug("Registering blocks for " + MOD_ID);

common/src/main/java/net/lerariemann/infinity/util/teleport/PortalCreator.java

···
 import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.access.MinecraftServerAccess;
 import net.lerariemann.infinity.block.custom.Boopable;
+import net.lerariemann.infinity.compat.CreateCompat;
 import net.lerariemann.infinity.compat.DimLibCompat;
 import net.lerariemann.infinity.registry.core.ModBlocks;
 import net.lerariemann.infinity.block.custom.InfinityPortalBlock;
···
 
     static PortalModifierUnion forInitialSetupping(ServerWorld world, BlockPos pos, Identifier id, boolean open) {
         PortalColorApplier applier = PortalColorApplier.of(id, world.getServer());
-        return new PortalModifierUnion()
+        PortalModifierUnion union = new PortalModifierUnion()
                 .addSetupper(infPortalSetupper(world, pos))
-                .addModifier(npbe -> {
-                    npbe.setDimension(id);
-                    npbe.setColor(applier.apply(npbe.getPos()));
-                    npbe.setOpen(open);
-                    npbe.markDirty();
-                });
+                .addModifier(nbpe -> nbpe.setDimension(id))
+                .addModifier(npbe -> npbe.setColor(applier.apply(npbe.getPos())))
+                .addModifier(npbe -> npbe.setOpen(open))
+                .addModifier(BlockEntity::markDirty);
+        if (Platform.isModLoaded("create")) {
+            union.addModifier(CreateCompat::tryModifyRails);
+        }
+        return union;
     }
 
     /**

gradle.properties

···
 org.gradle.parallel=true
 
 # Mod properties
-mod_version = 2.5.0
+mod_version = 2.5.1
 maven_group = net.lerariemann
 archives_name = infinity
 enabled_platforms = fabric,neoforge
-tbversion = 0
+tbversion = 1
 
 # Minecraft properties
 minecraft_version = 1.21.1
···
 cct_version = 1.115.0
 emi_version = 1.1.18
 dimlib_version = v1.1.0-mc1.21.1
-ponder_version = 1.0.52
+
+# Create - NeoForge
+create_forge_version = 6.0.6-98
+ponder_version = 1.0.59
+flywheel_forge_version = 1.0.4
+registrate_forge_version = MC1.21-1.3.0+62

neoforge/src/main/java/net/lerariemann/infinity/neoforge/InfinityModNeoForge.java

···
 package net.lerariemann.infinity.neoforge;
 
+import dev.architectury.platform.Platform;
 import net.lerariemann.infinity.InfinityMod;
+import net.lerariemann.infinity.compat.CreateCompat;
 import net.lerariemann.infinity.util.neoforge.NeoItems;
 import net.lerariemann.infinity.registry.core.ModBlocks;
 import net.lerariemann.infinity.registry.core.ModEntities;
···
         ModStats.load();
         ModBlocks.registerFlammableBlocks();
         ModItemFunctions.registerDispenserBehaviour();
+        if (Platform.isModLoaded("create"))
+            CreateCompat.register();
     }
 
     public static MinecraftClient client() {