Fix local tile offset calculation for large coordinates

src/world.rs

@@ -4,7 +4,7 @@ use rand::{thread_rng, Rng};
 type ChunkPosScalar = i16;
 
 #[derive(Hash, PartialEq, Eq, Debug, Clone, Copy)]
-struct ChunkPos {
+pub struct ChunkPos {
     x: ChunkPosScalar,
     y: ChunkPosScalar,
 }
@@ -33,50 +33,78 @@ impl World {
     }
 }
 
+#[derive(Debug, Clone, Copy)]
 pub struct TilePos {
     pub x: TilePosScalar,
     pub y: TilePosScalar,
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub struct ChunkLocalTilePos {
     pub x: ChunkLocalTilePosScalar,
     pub y: ChunkLocalTilePosScalar,
 }
 
-type ChunkLocalTilePosScalar = i16;
+type ChunkLocalTilePosScalar = u8;
 
 impl TilePos {
-    fn to_chunk_and_local(&self) -> (ChunkPos, ChunkLocalTilePos) {
-        // 0,0 is chunk (0, 0)
-        // -1, -1 is chunk (-1, -1)
-        // For negative offsets, local offset starts from `CHUNK_EXTENT`
-        let mut chk = ChunkPos {
-            x: (self.x / CHUNK_EXTENT as i32) as i16,
-            y: (self.y / CHUNK_EXTENT as i32) as i16,
+    pub fn to_chunk_and_local(self) -> (ChunkPos, ChunkLocalTilePos) {
+        let chk = ChunkPos {
+            x: chk_pos(self.x),
+            y: chk_pos(self.y),
         };
-        if self.x.is_negative() {
-            chk.x -= 1;
-        }
-        if self.y.is_negative() {
-            chk.y -= 1;
-        }
         let local = ChunkLocalTilePos {
-            x: if chk.x.is_negative() {
-                ((CHUNK_EXTENT as i32 + self.x) % CHUNK_EXTENT as i32) as i16
-            } else {
-                (self.x % CHUNK_EXTENT as i32) as i16
-            },
-            y: if chk.y.is_negative() {
-                ((CHUNK_EXTENT as i32 + self.y) % CHUNK_EXTENT as i32) as i16
-            } else {
-                (self.y % CHUNK_EXTENT as i32) as i16
-            },
+            x: chunk_local(self.x),
+            y: chunk_local(self.y),
         };
         (chk, local)
     }
 }
 
+fn chk_pos(tile: TilePosScalar) -> ChunkPosScalar {
+    if tile.is_negative() {
+        ((tile + 1) / CHUNK_EXTENT as i32) as i16 - 1
+    } else {
+        (tile / CHUNK_EXTENT as i32) as i16
+    }
+}
+
+#[test]
+fn test_chk_pos() {
+    assert_eq!(chk_pos(0), 0);
+    assert_eq!(chk_pos(1), 0);
+    assert_eq!(chk_pos(127), 0);
+    assert_eq!(chk_pos(128), 1);
+    assert_eq!(chk_pos(-1), -1);
+    assert_eq!(chk_pos(-2), -1);
+    assert_eq!(chk_pos(-127), -1);
+    assert_eq!(chk_pos(-128), -1);
+    assert_eq!(chk_pos(-129), -2);
+}
+
+/*fn chunk_local(global: TilePosScalar) -> ChunkLocalTilePosScalar {
+    if global.is_negative() {
+        (CHUNK_EXTENT as i32 + global % CHUNK_EXTENT as i32) as u8
+    } else {
+        (global % CHUNK_EXTENT as i32) as u8
+    }
+}*/
+
+fn chunk_local(global: TilePosScalar) -> ChunkLocalTilePosScalar {
+    let mut result = global % CHUNK_EXTENT as i32;
+    if result.is_negative() {
+        result += CHUNK_EXTENT as i32;
+    }
+    result as u8
+}
+
+#[test]
+fn test_chunk_local() {
+    assert_eq!(chunk_local(0), 0);
+    assert_eq!(chunk_local(-1), 127);
+    assert_eq!(chunk_local(-128), 0);
+}
+
 #[test]
 fn test_to_chunk_and_local() {
     assert_eq!(
@@ -91,10 +119,22 @@ fn test_to_chunk_and_local() {
         TilePos { x: -1, y: -1 }.to_chunk_and_local(),
         (
             ChunkPos { x: -1, y: -1 },
-            ChunkLocalTilePos {
-                x: CHUNK_EXTENT as i16 - 1,
-                y: CHUNK_EXTENT as i16 - 1
-            }
+            ChunkLocalTilePos { x: 127, y: 127 }
+        )
+    );
+    assert_eq!(
+        TilePos { x: -127, y: -127 }.to_chunk_and_local(),
+        (ChunkPos { x: -1, y: -1 }, ChunkLocalTilePos { x: 1, y: 1 })
+    );
+    assert_eq!(
+        TilePos { x: -128, y: -128 }.to_chunk_and_local(),
+        (ChunkPos { x: -1, y: -1 }, ChunkLocalTilePos { x: 0, y: 0 })
+    );
+    assert_eq!(
+        TilePos { x: -129, y: -129 }.to_chunk_and_local(),
+        (
+            ChunkPos { x: -2, y: -2 },
+            ChunkLocalTilePos { x: 127, y: 127 }
         )
     );
 }