Reorganize source, create basic threading and server

Need to create main world loop and have it message with web server

5 files changed, 319 insertions, 0 deletions

diff --git a/src/chunk.rhm b/src/chunk.rhm
new file mode 100644
index 0000000..3ded42d
--- /dev/null
+++ b/src/chunk.rhm
@@ -0,0 +1,58 @@
+#lang rhombus/static
+
+export:
+    Direction
+    TileType
+    Tile
+    Chunk
+    flip_block
+
+enum Direction:
+    north
+    north_east
+    east
+    south_east
+    south
+    south_west
+    west
+    north_west
+
+enum TileType:
+    empty
+    wall_north
+
+fun flip_block(block :: maybe(Direction)) :: maybe(Direction):
+    match block
+    | Direction.north: Direction.south
+    | Direction.north_east: Direction.south_west
+    | Direction.east: Direction.west
+    | Direction.south_east: Direction.north_west
+    | Direction.south: Direction.north
+    | Direction.south_west: Direction.north_east
+    | Direction.west: Direction.east
+    | Direction.north_west: Direction.south_east
+    | ~else: #false
+
+class Tile(type :: TileType):
+    method get_block() :: maybe(Direction):
+        match type
+        | TileType.empty: #false
+        | TileType.wall_north: Direction.north
+
+class Chunk(width :: Int,
+            height :: Int,
+            offset_x :: Int,
+            offset_y :: Int,
+            tiles :: Array.now_of(Tile),
+            neighbours :: MutableMap.now_of(Direction, Chunk)):
+    constructor(width :: Int, height :: Int, offset_x :: Int, offset_y :: Int):
+        super(width, height, offset_x, offset_y, Array.make(width * height, Tile(TileType.empty)), MutableMap())
+
+    method add_neighbour(chunk :: Chunk, direction :: Direction):
+        neighbours[direction] := chunk
+
+    method get_tile(x :: Int, y :: Int) :: Tile:
+        tiles[y * width + x]
+
+    method set_tile(x :: Int, y :: Int, tile :: Tile):
+        tiles[y * width + x] := tile
diff --git a/src/entity.rhm b/src/entity.rhm
new file mode 100644
index 0000000..3fcd812
--- /dev/null
+++ b/src/entity.rhm
@@ -0,0 +1,147 @@
+#lang rhombus/static
+import:
+    rhombus/random
+    "chunk.rhm" open
+    "item.rhm" open
+
+export:
+    Entity
+    EntityGatherable
+    EntityPlayer
+    ActionResponse
+    Slot
+
+let rand = random.Random()
+
+class Entity(id:: Int, mutable x :: Int, mutable y :: Int, mutable current_chunk :: Chunk):
+    nonfinal
+    // Validate that the provided coordinates are within the max distance range of
+    // entities current coordinates.
+    method validate_dist(x :: Int, y :: Int, max_dist :: Int):
+        let diff_x = math.abs(this.x - x)
+        let diff_y = math.abs(this.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)
+
+    // Validate that the x,y coordinates map to a chunk that is
+    // near the current coordinates of the entity
+    method validate_chunk(x :: Int, y :: Int) :: maybe(Chunk):
+        let current_chunk = this.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(Direction.north, #false)
+        | more_x && less_y:   current_chunk.neighbours.get(Direction.north_east, #false)
+        | more_x && inside_y: current_chunk.neighbours.get(Direction.east, #false)
+        | more_x && more_y:   current_chunk.neighbours.get(Direction.south_east, #false)
+        | inside_x && more_y: current_chunk.neighbours.get(Direction.south, #false)
+        | less_x && more_y:   current_chunk.neighbours.get(Direction.south_west, #false)
+        | less_x && inside_y: current_chunk.neighbours.get(Direction.west, #false)
+        | less_x && less_y:   current_chunk.neighbours.get(Direction.north_west, #false)
+        | ~else:              current_chunk
+
+        next_chunk
+
+    // Validate that the tile at the coordinates would not block a movement of the entity
+    // to those coordinates from its current coordinates
+    method validate_move(x :: Int, y :: Int, max_dist :: Int, target_chunk :: Chunk):
+        let current_tile = this.current_chunk.get_tile(this.x, this.y)
+        let target_tile = target_chunk.get_tile(x, y)
+        let diff_x = x - this.x
+        let diff_y = y - this.y
+        let direction = cond
+        | diff_x == 0 && diff_y < 0:  Direction.north
+        | diff_x > 0  && diff_y < 0:  Direction.north_east
+        | diff_x > 0  && diff_y == 0: Direction.east
+        | diff_x > 0  && diff_y > 0:  Direction.south_east
+        | diff_x == 0 && diff_y > 0:  Direction.south
+        | diff_x < 0 && diff_y > 0:   Direction.south_west
+        | diff_x < 0  && diff_y == 0: Direction.west
+        | diff_x < 0  && diff_y < 0:  Direction.north_west
+        let current_block = current_tile.get_block()
+        let target_block = flip_block(target_tile.get_block())
+        !(direction == current_block || direction == target_block)
+
+    method
+    | move(x :: Int, y :: Int): move(x, y, 1)
+    | move(x :: Int, y :: Int, max_dist :: Int) :: Boolean:
+        let target_chunk = validate_chunk(x, y)
+
+        cond
+        | validate_dist(x, y, max_dist) && target_chunk != #false && validate_move(x, y, max_dist, target_chunk!!):
+            this.current_chunk := target_chunk!!
+            this.x := x
+            this.y := y
+            #true
+        | ~else:
+            #false
+
+class EntityGatherable(quantity :: Int, odds :: Real, cap :: ItemCap):
+    extends Entity
+
+    constructor(id :: Int, x :: Int, y :: Int, current_chunk :: Chunk, cap :: ItemCap):
+        super(id, x, y, current_chunk)(10, 1 / 10, cap)
+
+enum ActionResponse:
+    ok
+    unsuccessful
+    invalid
+    cooldown
+
+enum Slot:
+    right_hand
+
+class EntityPlayer(mutable timer :: Int):
+    extends Entity
+
+    field max_timer = 4
+    field inventory :: Array.now_of(maybe(Stack)) = Array.make(20, #false)
+    field equip :: MutableMap.now_of(Slot, Item) = MutableMap()
+
+    constructor(id :: Int, x :: Int, y :: Int, current_chunk :: Chunk):
+        super(id, x, y, current_chunk)(0)
+
+    method tick():
+        // TODO this "ticks" the entity. Things like healing and other
+        // stuff should happen within here. In the future we probably
+        // want to set a state where the player is gathering and in tick
+        // we calculate the odds that they did gather properly
+        if timer == 0:
+        | timer := max_timer
+        | timer := timer - 1
+
+    method gather(target_entity :: Entity) :: ActionResponse:
+        let x = target_entity.x
+        let y = target_entity.y
+        let target_chunk = validate_chunk(x, y)
+        let right_type = target_entity is_a EntityGatherable
+
+        fun validate_gather_resource(entity :: EntityGatherable) :: ActionResponse:
+            let right_tool = item_get_cap(equip.get(Slot.right_hand, #false)) == entity.cap
+            // TODO odds should change based on skills of player
+            // we should also validate player is carrying the right tool
+            // we should also have the timer count down every tick
+            // not just inside the gathering call
+            let roll = rand.random()
+            cond
+            | !right_tool: ActionResponse.invalid
+            | rand.random() < entity.odds: ActionResponse.ok
+            | ~else: ActionResponse.unsuccessful
+
+        cond
+        | timer != 0: ActionResponse.cooldown
+        | right_type && validate_dist(x, y, 1) && target_chunk != #false:
+            validate_gather_resource(target_entity)
+        | ~else:
+            ActionResponse.invalid
diff --git a/src/item.rhm b/src/item.rhm
new file mode 100644
index 0000000..6716dbc
--- /dev/null
+++ b/src/item.rhm
@@ -0,0 +1,21 @@
+#lang rhombus/static
+
+export:
+    Item
+    Stack
+    ItemCap
+    item_get_cap
+
+enum Item:
+    bronze_axe
+
+enum ItemCap:
+    none
+    chop
+
+fun item_get_cap(item :: maybe(Item)) :: ItemCap:
+    match item:
+    | Item.bronze_axe: ItemCap.chop
+    | ~else: ItemCap.none
+
+class Stack(item :: Item, quantity :: Int)
diff --git a/src/test.rhm b/src/test.rhm
new file mode 100644
index 0000000..5648c53
--- /dev/null
+++ b/src/test.rhm
@@ -0,0 +1,67 @@
+#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): reset_entity(entity, 0, 0)
+| reset_entity(entity :: world.Entity, x :: Int, y :: Int):
+    entity.x := x
+    entity.y := y
+
+let wrld = world.World()
+let chunk = world.Chunk(64, 64, 0, 0)
+wrld.chunks.add(chunk)
+let entity = world.EntityPlayer(0, 0, 0, chunk)
+wrld.entities.add(entity)
+
+
+reset_entity(entity)
+test(entity.move(1, 0), "move horizontal")
+
+reset_entity(entity, 1, 1)
+test(entity.move(0, 1), "move vertical")
+
+reset_entity(entity)
+test(entity.move(1, 1), "move diagonal")
+
+reset_entity(entity)
+test(!entity.move(2, 0), "move diagonal")
+
+reset_entity(entity)
+test(!entity.move(0, 0), "starting pos")
+
+let new_chunk = world.Chunk(64, 64, 1, 0)
+chunk.add_neighbour(new_chunk, world.Direction.east)
+reset_entity(entity, 63, 0)
+test(entity.move(64, 0), "cross chunk")
+test(entity.current_chunk == new_chunk, "changed chunk")
+
+entity.current_chunk := chunk
+reset_entity(entity, 0, 1)
+entity.current_chunk.set_tile(0, 1, world.Tile(#'wall_north))
+test(!entity.move(0, 0), "blocked by wall")
+test(entity.move(1,1), "move by wall")
+
+reset_entity(entity, 0, 0)
+entity.equip[world.Slot.right_hand] := world.Item.bronze_axe
+let other_ent = world.EntityGatherable(1, 1, 1, chunk, world.ItemCap.chop)
+let gather_result = entity.gather(other_ent)
+test(gather_result == world.ActionResponse.ok || gather_result == world.ActionResponse.unsuccessful, "gathering")
+
+reset_entity(other_ent, 2, 2)
+entity.timer := 0
+test(entity.gather(other_ent) == world.ActionResponse.invalid, "gather too far away")
+
+reset_entity(other_ent, 64, 0)
+reset_entity(entity, 63, 0)
+entity.timer := 0
+let gather_result = entity.gather(other_ent)
+test(gather_result == world.ActionResponse.ok || gather_result == world.ActionResponse.unsuccessful, "gather accross chunk")
+entity.tick()
+test(entity.gather(other_ent) == world.ActionResponse.cooldown, "gather cooldown")
diff --git a/src/world.rhm b/src/world.rhm
new file mode 100644
index 0000000..9357422
--- /dev/null
+++ b/src/world.rhm
@@ -0,0 +1,26 @@
+#lang rhombus/static
+import:
+    "chunk.rhm" open
+    "entity.rhm" open
+    "item.rhm" open
+
+export:
+    Chunk
+    ActionResponse
+    Direction
+    World
+    Tile
+    Entity
+    EntityPlayer
+    EntityGatherable
+    Direction
+    ItemCap
+    Item
+    Slot
+
+class World(chunks :: MutableList.now_of(Chunk),
+            entities :: MutableList.now_of(Entity)):
+
+    constructor():
+        super(MutableList(), MutableList())
+