Initial commit

3 files changed, 119 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..d992b6f
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+Session.vim
diff --git a/main.rhm b/main.rhm
new file mode 100644
index 0000000..3ab966f
--- /dev/null
+++ b/main.rhm
@@ -0,0 +1,39 @@
+#lang rhombus/static
+
+import "world.rhm"
+
+fun test(test_result :: Boolean, test_str :: String):
+    if test_result
+    | println("Passed " +& test_str)
+    | println("Failed " +& test_str)
+
+fun reset_entity(entity :: world.Entity):
+    entity.x := 0
+    entity.y := 0
+
+let wrld = world.World()
+let chunk = world.Chunk(64, 64, 0, 0)
+wrld.chunks.add(chunk)
+let entity = world.Entity(0, 0, 0, chunk)
+wrld.entities.add(entity)
+
+
+reset_entity(entity)
+test(wrld.entity_move(0, 1, 0), "move horizontal")
+
+reset_entity(entity)
+test(wrld.entity_move(0, 0, 1), "move vertical")
+
+reset_entity(entity)
+test(wrld.entity_move(0, 1, 1), "move diagonal")
+
+reset_entity(entity)
+test(!wrld.entity_move(0, 2, 0), "move diagonal")
+
+reset_entity(entity)
+test(!wrld.entity_move(0, 0, 0), "starting pos")
+
+//world.entities
+println(@str{Entity is @(entity.x) @(entity.y)})
+
+
diff --git a/world.rhm b/world.rhm
new file mode 100644
index 0000000..043504b
--- /dev/null
+++ b/world.rhm
@@ -0,0 +1,79 @@
+#lang rhombus/static
+
+export:
+    Chunk
+    Entity
+    World
+
+class Chunk(width :: Int,
+            height :: Int,
+            offset_x :: Int,
+            offset_y :: Int,
+            tiles :: Array.now_of(Int),
+            neighbours :: MutableMap.now_of(Symbol, Chunk)):
+    constructor(width :: Int, height :: Int, offset_x :: Int, offset_y :: Int):
+        super(width, height, offset_x, offset_y, Array.make(width * height, 0), MutableMap())
+
+    method get_tile(x :: Int, y :: Int):
+        tiles[y * width + x]
+
+class Entity(id:: Int, mutable x :: Int, mutable y :: Int, mutable current_chunk :: Chunk)
+
+class World(chunks :: MutableList.now_of(Chunk),
+            entities :: MutableList.now_of(Entity)):
+
+    constructor():
+        super(MutableList(), MutableList())
+
+    method
+    | entity_move(id :: Int, x :: Int, y :: Int): entity_move(id, x, y, 1)
+    | entity_move(id :: Int, x :: Int, y :: Int, max_dist :: Int) :: Boolean:
+        let validate_dist = fun (entity :: Entity) :: Boolean:
+            let diff_x = math.abs(entity.x - x)
+            let diff_y = math.abs(entity.y - y)
+            // Diagonal case is moving in the same direction (same x & y) and that amount
+            // is less than or equal to max distance
+            let diagonal = diff_x == diff_y && diff_x <= max_dist
+            let x_axis = diff_x <= max_dist && diff_y == 0
+            let y_axis = diff_y <= max_dist && diff_x == 0
+            let no_movement = diff_x == 0 && diff_y == 0
+            !no_movement && (diagonal || x_axis || y_axis)
+
+        let validate_chunk = fun (entity :: Entity) :: Boolean:
+            let current_chunk = entity.current_chunk
+            let local_x = x - current_chunk.offset_x * current_chunk.width
+            let local_y = y - current_chunk.offset_y * current_chunk.height
+            let less_x = local_x < 0
+            let less_y = local_y < 0
+            let more_x = local_x >= current_chunk.width
+            let more_y = local_y >= current_chunk.height
+            let inside_x = !(less_x || more_x)
+            let inside_y = !(less_y || more_y)
+            let next_chunk :: maybe(Chunk) = cond
+            | inside_x && less_y: current_chunk.neighbours.get(#'north, #false)
+            | more_x && less_y:   current_chunk.neighbours.get(#'north_east, #false)
+            | more_x && inside_y: current_chunk.neighbours.get(#'east, #false)
+            | more_x && more_y:   current_chunk.neighbours.get(#'south_east, #false)
+            | inside_x && more_y: current_chunk.neighbours.get(#'south, #false)
+            | less_x && more_y:   current_chunk.neighbours.get(#'south_west, #false)
+            | less_x && inside_y: current_chunk.neighbours.get(#'west, #false)
+            | less_x && less_y:   current_chunk.neighbours.get(#'north_west, #false)
+            | ~else:              current_chunk
+
+            cond
+            | !next_chunk: #false
+            | ~else:
+                entity.current_chunk := next_chunk!!
+                #true
+
+        let entity :: maybe(Entity) = entities.find((fun (ent :: Entity) :: Boolean: ent.id == id))
+        cond
+        | !entity:
+            println("Can't find entity")
+            #false
+        | validate_dist(entity!!) && validate_chunk(entity!!):
+            entity!!.x := x
+            entity!!.y := y
+            #true
+        | ~else:
+            #false