More codec improvements, data updates

- Creates copy of World registry key codec for use in DimensionalPos
- Swaps machine tile getSpawn to use a DimensionalPos instead of BlockPos
- Minor Codec renames
- Move CMInternalData into CompactRoomData
- RoomData now private, with access limited via CompactRoomData
- PSD now calls getSpawn on the room data, instead of fetching entire RD instance and manually setting WSD dirty
- Overhaul to DimPos to include a rotation (for spawning) and improve Codec usage (no more string serializing)
- TeleEventHandler updated to call CompactRoomData#getInnerBounds
- Add extra methods to MathUtil for chunk and BlockPos calculation
- New room generation on player first entry improved
- Teleportation into rooms now respects spawn rotation
- Update unit tests to swap codec references

Author: robotgryphon

src/main/java/com/robotgryphon/compactmachines/block/tiles/CompactMachineTile.java

@@ -2,7 +2,6 @@
 
 import com.robotgryphon.compactmachines.config.ServerConfig;
 import com.robotgryphon.compactmachines.core.Registration;
-import com.robotgryphon.compactmachines.data.machine.CompactMachineInternalData;
 import com.robotgryphon.compactmachines.data.persistent.CompactRoomData;
 import com.robotgryphon.compactmachines.data.persistent.MachineConnections;
 import com.robotgryphon.compactmachines.data.player.CompactMachinePlayerData;
@@ -210,13 +209,13 @@ public CompoundNBT getUpdateTag() {
     }
 
     public Optional<ChunkPos> getInternalChunkPos() {
-        if(level instanceof ServerWorld) {
+        if (level instanceof ServerWorld) {
             MinecraftServer serv = level.getServer();
-            if(serv == null)
+            if (serv == null)
                 return Optional.empty();
 
             MachineConnections connections = MachineConnections.get(serv);
-            if(connections == null)
+            if (connections == null)
                 return Optional.empty();
 
             return connections.graph.getConnectedRoom(this.machineId);
@@ -290,11 +289,11 @@ protected void doChunkload(boolean force) {
     }
 
     public void doPostPlaced() {
-        if(this.level == null || this.level.isClientSide)
+        if (this.level == null || this.level.isClientSide)
             return;
 
         MinecraftServer serv = this.level.getServer();
-        if(serv == null)
+        if (serv == null)
             return;
 
         DimensionalPosition dp = new DimensionalPosition(
@@ -309,7 +308,7 @@ public void doPostPlaced() {
     }
 
     public void handlePlayerLeft(UUID playerID) {
-        if(this.playerData != null)
+        if (this.playerData != null)
             this.playerData.removePlayer(playerID);
     }
 
@@ -323,27 +322,26 @@ public boolean mapped() {
         return getInternalChunkPos().isPresent();
     }
 
-    public Optional<BlockPos> getSpawn() {
-        if(level instanceof ServerWorld) {
+    public Optional<DimensionalPosition> getSpawn() {
+        if (level instanceof ServerWorld) {
             ServerWorld serverWorld = (ServerWorld) level;
             MinecraftServer serv = serverWorld.getServer();
 
             MachineConnections connections = MachineConnections.get(serv);
-            if(connections == null)
+            if (connections == null)
                 return Optional.empty();
 
             Optional<ChunkPos> connectedRoom = connections.graph.getConnectedRoom(machineId);
 
-            if(!connectedRoom.isPresent())
+            if (!connectedRoom.isPresent())
                 return Optional.empty();
 
             CompactRoomData roomData = CompactRoomData.get(serv);
-                if(roomData == null)
-                    return Optional.empty();
+            if (roomData == null)
+                return Optional.empty();
 
             ChunkPos chunk = connectedRoom.get();
-            return roomData.forChunk(chunk)
-                    .map(CompactMachineInternalData::getSpawn);
+            return Optional.ofNullable(roomData.getSpawn(chunk));
         }
 
         return Optional.empty();

src/main/java/com/robotgryphon/compactmachines/data/codec/CodecExtensions.java

@@ -2,24 +2,20 @@
 
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.DataResult;
-import com.mojang.serialization.DynamicOps;
-import com.mojang.serialization.codecs.PrimitiveCodec;
-import com.mojang.serialization.codecs.RecordCodecBuilder;
+import net.minecraft.util.RegistryKey;
+import net.minecraft.util.ResourceLocation;
 import net.minecraft.util.Util;
 import net.minecraft.util.math.ChunkPos;
 import net.minecraft.util.math.vector.Vector3d;
-import org.lwjgl.system.CallbackI;
+import net.minecraft.util.registry.Registry;
+import net.minecraft.world.World;
 
-import java.util.Arrays;
-import java.util.List;
 import java.util.UUID;
-import java.util.stream.BaseStream;
-import java.util.stream.Collectors;
 import java.util.stream.DoubleStream;
 import java.util.stream.IntStream;
 
 public abstract class CodecExtensions {
-    public static Codec<UUID> UUID_CODEC = Codec.STRING
+    public static final Codec<UUID> UUID_CODEC = Codec.STRING
             .comapFlatMap((s) -> {
                 try {
                     return DataResult.success(UUID.fromString(s));
@@ -28,11 +24,14 @@ public abstract class CodecExtensions {
                 }
             }, UUID::toString).stable();
 
-    public static Codec<Vector3d> VECTOR3D_CODEC = DoubleStreamExtensions.CODEC
+    public static final Codec<RegistryKey<World>> WORLD_REGISTRY_KEY = ResourceLocation.CODEC
+            .xmap(RegistryKey.elementKey(Registry.DIMENSION_REGISTRY), RegistryKey::location);
+
+    public static final Codec<Vector3d> VECTOR3D = DoubleStreamExtensions.CODEC
             .comapFlatMap(i -> DoubleStreamExtensions.fixedDoubleSize(i, 3)
                     .map(out -> new Vector3d(out[0], out[1], out[2])), vec -> DoubleStream.of(vec.x, vec.y, vec.z));
 
-    public static Codec<ChunkPos> CHUNKPOS_CODEC = Codec.INT_STREAM
+    public static final Codec<ChunkPos> CHUNKPOS = Codec.INT_STREAM
             .comapFlatMap(i -> Util.fixedSize(i, 2)
                     .map(arr -> new ChunkPos(arr[0], arr[1])), pos -> IntStream.of(pos.x, pos.z));
 }

src/main/java/com/robotgryphon/compactmachines/data/graph/CompactMachineConnectionGraph.java

@@ -133,7 +133,7 @@ private static class CompactMachineConnectionInfo {
         private final List<Integer> connectedMachines;
 
         public static final Codec<CompactMachineConnectionInfo> CODEC = RecordCodecBuilder.create(i -> i.group(
-                CodecExtensions.CHUNKPOS_CODEC
+                CodecExtensions.CHUNKPOS
                         .fieldOf("machine")
                         .forGetter(CompactMachineConnectionInfo::room),