Add more packets and get json lib working with server data

2 files changed, 56 insertions, 17 deletions

diff --git a/src/chunk.rhm b/src/chunk.rhm
index 3ded42d..673d6e9 100644
--- a/src/chunk.rhm
+++ b/src/chunk.rhm
@@ -39,6 +39,14 @@ class Tile(type :: TileType):
         | TileType.empty: #false
         | TileType.wall_north: Direction.north
 
+    method to_tile_int():
+        match type
+        | TileType.empty: 0
+        | TileType.wall_north: 1
+
+    method to_map() :: Map:
+        {"type": to_tile_int()}
+
 class Chunk(width :: Int,
             height :: Int,
             offset_x :: Int,
@@ -56,3 +64,13 @@ class Chunk(width :: Int,
 
     method set_tile(x :: Int, y :: Int, tile :: Tile):
         tiles[y * width + x] := tile
+
+    method to_map() :: Map:
+        {"width": width,
+         "height": height,
+         "offset_x": offset_x,
+         "offset_y": offset_y,
+         "tiles": for:
+                    each tile :: Tile in tiles
+                    tile.to_map()
+                    ~into List}
diff --git a/src/world.rhm b/src/world.rhm
index 13fe048..01a1553 100644
--- a/src/world.rhm
+++ b/src/world.rhm
@@ -6,35 +6,55 @@ import:
     "../thread/thread.rhm" open
 
 export:
-    Chunk
-    ActionResponse
-    Direction
-    World
-    Tile
-    Entity
-    EntityPlayer
-    EntityGatherable
-    Direction
-    ItemCap
-    Item
-    Slot
+    all_defined
+
 
 class MessageLogin(user :: String, thr)
 
+class MessageLoginResponse(user_id :: Int):
+    // TODO can I automate this?
+    method to_map() :: Map:
+        {"user_id": user_id}
+
+class MessageGetChunks(user_id :: Int, thr)
+
+class MessageGetChunksResponse(chunk :: Chunk):
+    method to_map() :: Map:
+        chunk.to_map()
+
 class World(chunks :: MutableList.now_of(Chunk),
-            entities :: MutableList.now_of(Entity)):
+            entities :: MutableMap.now_of(Int, Entity)):
 
     field thread_evt = thread_receive_evt()
     field tick_length = 0.6 // tick length is 600ms
 
+    // TODO this should really go to some user DB
+    field user_id = 100
+
     constructor():
-        super(MutableList(), MutableList())
+        super(MutableList(), MutableMap())
+
+    method init():
+        let chunk = Chunk(64, 64, 0, 0)
+        chunks.add(chunk)
 
     method login(user :: String, thr):
-        // TODO should be accessing some DB to get player
-        let player = EntityPlayer(0, 0, 0, chunks)
+        // TODO should be accessing some DB to get player and it should
+        // return some session token that the client would use when refering
+        // to the player
+        let player = EntityPlayer(user_id, 0, 0, chunks[0])
         player.equip[Slot.right_hand] := Item.bronze_axe
-        entities.add(player)
+        entities[user_id] := player
+        let resp = MessageLoginResponse(user_id)
+        user_id := user_id + 1
+        thread_send(thr, resp)
+
+    method get_chunk(user_id :: Int, thr):
+        // TODO there should be a session token to user entity system
+        let player :: Entity = entities[user_id]
+        let chunk = player.current_chunk
+        let resp = MessageGetChunksResponse(chunk)
+        thread_send(thr, resp)
 
     method process_messages(timestamp :: Real):
         let time_passed = current_timestamp() - timestamp
@@ -44,6 +64,7 @@ class World(chunks :: MutableList.now_of(Chunk),
         | let msg = thread_receive()
           match msg
           | MessageLogin(user, thr): login(user, thr)
+          | MessageGetChunks(user_id, thr): get_chunk(user_id, thr)
           | ~else: println("Unknown message " +& msg)
           process_messages(timestamp)
         | #true // Return here