fix ws/wss check

backend/gleam.toml

@@ -14,7 +14,6 @@ version = "1.0.0"
 
 [dependencies]
 gleam_stdlib = ">= 0.44.0 and < 2.0.0"
-storail = ">= 3.0.0 and < 4.0.0"
 tom = ">= 1.1.1 and < 2.0.0"
 simplifile = ">= 2.2.1 and < 3.0.0"
 glint = ">= 1.2.1 and < 2.0.0"
@@ -26,6 +25,7 @@ gleam_http = ">= 4.0.0 and < 5.0.0"
 gleam_otp = ">= 0.16.1 and < 1.0.0"
 gleam_crypto = ">= 1.5.0 and < 2.0.0"
 gleam_json = ">= 2.3.0 and < 3.0.0"
+gleescript = ">= 1.4.0 and < 2.0.0"
 
 [dev-dependencies]
 gleeunit = ">= 1.0.0 and < 2.0.0"

backend/manifest.toml

@@ -3,8 +3,6 @@
 
 packages = [
   { name = "argv", version = "1.0.2", build_tools = ["gleam"], requirements = [], otp_app = "argv", source = "hex", outer_checksum = "BA1FF0929525DEBA1CE67256E5ADF77A7CDDFE729E3E3F57A5BDCAA031DED09D" },
-  { name = "directories", version = "1.2.0", build_tools = ["gleam"], requirements = ["envoy", "gleam_stdlib", "platform", "simplifile"], otp_app = "directories", source = "hex", outer_checksum = "D13090CFCDF6759B87217E8DDD73A75903A700148A82C1D33799F333E249BF9E" },
-  { name = "envoy", version = "1.0.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "envoy", source = "hex", outer_checksum = "95FD059345AA982E89A0B6E2A3BF1CF43E17A7048DCD85B5B65D3B9E4E39D359" },
   { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },
   { name = "gleam_community_ansi", version = "1.4.3", build_tools = ["gleam"], requirements = ["gleam_community_colour", "gleam_regexp", "gleam_stdlib"], otp_app = "gleam_community_ansi", source = "hex", outer_checksum = "8A62AE9CC6EA65BEA630D95016D6C07E4F9973565FA3D0DE68DC4200D8E0DD27" },
   { name = "gleam_community_colour", version = "2.0.0", build_tools = ["gleam"], requirements = ["gleam_json", "gleam_stdlib"], otp_app = "gleam_community_colour", source = "hex", outer_checksum = "FDD6AC62C6EC8506C005949A4FCEF032038191D5EAAEC3C9A203CD53AE956ACA" },
@@ -16,6 +14,7 @@ packages = [
   { name = "gleam_regexp", version = "1.1.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_regexp", source = "hex", outer_checksum = "9C215C6CA84A5B35BB934A9B61A9A306EC743153BE2B0425A0D032E477B062A9" },
   { name = "gleam_stdlib", version = "0.59.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "F8FEE9B35797301994B81AF75508CF87C328FE1585558B0FFD188DC2B32EAA95" },
   { name = "gleam_yielder", version = "1.1.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_yielder", source = "hex", outer_checksum = "8E4E4ECFA7982859F430C57F549200C7749823C106759F4A19A78AEA6687717A" },
+  { name = "gleescript", version = "1.4.0", build_tools = ["gleam"], requirements = ["argv", "filepath", "gleam_erlang", "gleam_stdlib", "simplifile", "snag", "tom"], otp_app = "gleescript", source = "hex", outer_checksum = "8CDDD29F91064E69950A91A40061785F10275ADB70A0520075591F61A724C455" },
   { name = "gleeunit", version = "1.3.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "A7DD6C07B7DA49A6E28796058AA89E651D233B357D5607006D70619CD89DAAAB" },
   { name = "glint", version = "1.2.1", build_tools = ["gleam"], requirements = ["gleam_community_ansi", "gleam_community_colour", "gleam_stdlib", "snag"], otp_app = "glint", source = "hex", outer_checksum = "2214C7CEFDE457CEE62140C3D4899B964E05236DA74E4243DFADF4AF29C382BB" },
   { name = "glisten", version = "7.0.1", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_otp", "gleam_stdlib", "logging", "telemetry"], otp_app = "glisten", source = "hex", outer_checksum = "1A53CF9FB3231A93FF7F1BD519A43DC968C1722F126CDD278403A78725FC5189" },
@@ -23,11 +22,9 @@ packages = [
   { name = "hpack_erl", version = "0.3.0", build_tools = ["rebar3"], requirements = [], otp_app = "hpack", source = "hex", outer_checksum = "D6137D7079169D8C485C6962DFE261AF5B9EF60FBC557344511C1E65E3D95FB0" },
   { name = "logging", version = "1.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "logging", source = "hex", outer_checksum = "1098FBF10B54B44C2C7FDF0B01C1253CAFACDACABEFB4B0D027803246753E06D" },
   { name = "mist", version = "4.0.7", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_http", "gleam_otp", "gleam_stdlib", "gleam_yielder", "glisten", "gramps", "hpack_erl", "logging"], otp_app = "mist", source = "hex", outer_checksum = "F7D15A1E3232E124C7CE31900253633434E59B34ED0E99F273DEE61CDB573CDD" },
-  { name = "platform", version = "1.0.0", build_tools = ["gleam"], requirements = [], otp_app = "platform", source = "hex", outer_checksum = "8339420A95AD89AAC0F82F4C3DB8DD401041742D6C3F46132A8739F6AEB75391" },
   { name = "shared", version = "1.0.0", build_tools = ["gleam"], requirements = ["gleam_crypto", "gleam_json", "gleam_stdlib"], source = "local", path = "../shared" },
   { name = "simplifile", version = "2.2.1", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "C88E0EE2D509F6D86EB55161D631657675AA7684DAB83822F7E59EB93D9A60E3" },
   { name = "snag", version = "1.1.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "snag", source = "hex", outer_checksum = "7E9F06390040EB5FAB392CE642771484136F2EC103A92AE11BA898C8167E6E17" },
-  { name = "storail", version = "3.0.0", build_tools = ["gleam"], requirements = ["directories", "filepath", "gleam_crypto", "gleam_json", "gleam_stdlib", "simplifile"], otp_app = "storail", source = "hex", outer_checksum = "D032EE5C89AA4B6306FF81929BF9B5DD2583E9F743F0047788AE5F1F52AFE3B4" },
   { name = "telemetry", version = "1.3.0", build_tools = ["rebar3"], requirements = [], otp_app = "telemetry", source = "hex", outer_checksum = "7015FC8919DBE63764F4B4B87A95B7C0996BD539E0D499BE6EC9D7F3875B79E6" },
   { name = "tom", version = "1.1.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "tom", source = "hex", outer_checksum = "0910EE688A713994515ACAF1F486A4F05752E585B9E3209D8F35A85B234C2719" },
 ]
@@ -40,10 +37,10 @@ gleam_http = { version = ">= 4.0.0 and < 5.0.0" }
 gleam_json = { version = ">= 2.3.0 and < 3.0.0" }
 gleam_otp = { version = ">= 0.16.1 and < 1.0.0" }
 gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }
+gleescript = { version = ">= 1.4.0 and < 2.0.0" }
 gleeunit = { version = ">= 1.0.0 and < 2.0.0" }
 glint = { version = ">= 1.2.1 and < 2.0.0" }
 mist = { version = ">= 4.0.7 and < 5.0.0" }
 shared = { path = "../shared" }
 simplifile = { version = ">= 2.2.1 and < 3.0.0" }
-storail = { version = ">= 3.0.0 and < 4.0.0" }
 tom = { version = ">= 1.1.1 and < 2.0.0" }

backend/src/app/clients/host_client.gleam

@@ -12,6 +12,7 @@ pub type HostClientMessages {
   ResetAllBuzers
   ResetPlayerBuzzer(user_id: Int)
   UpdateScore(user_id: Int, diff: Int)
+  EndGame
 }
 
 pub fn host_client_messages_decoder() -> decode.Decoder(HostClientMessages) {
@@ -27,6 +28,7 @@ pub fn host_client_messages_decoder() -> decode.Decoder(HostClientMessages) {
       use diff <- decode.field("diff", decode.int)
       decode.success(UpdateScore(user_id:, diff:))
     }
+    "EndGame" -> decode.success(EndGame)
     _ -> decode.failure(ResetAllBuzers, "HostClientMessages")
   }
 }
@@ -34,6 +36,7 @@ pub fn host_client_messages_decoder() -> decode.Decoder(HostClientMessages) {
 pub type HostServerMessages {
   Ack
   UpdatePlayerStates(players: dict.Dict(Int, player.Player))
+  ExitGame
 }
 
 pub fn encode_host_server_messages(
@@ -53,5 +56,6 @@ pub fn encode_host_server_messages(
           ),
         ),
       ])
+    ExitGame -> json.object([#("type", json.string("ExitGame"))])
   }
 }

backend/src/app/clients/new_user_client.gleam

@@ -6,8 +6,8 @@ pub type NewUserState {
 }
 
 pub type NewUserClientMessages {
-  JoinAsPlayer(token: String, user_id: Int, game_id: String)
+  JoinAsPlayer(token: String, user_id: Int, game_code: String)
-  JoinAsHost(token: String, user_id: Int, game_id: String)
+  JoinAsHost(token: String, user_id: Int, game_code: String)
 }
 
 pub fn new_user_client_messages_decoder() -> decode.Decoder(
@@ -18,14 +18,14 @@ pub fn new_user_client_messages_decoder() -> decode.Decoder(
     "JoinAsPlayer" -> {
       use token <- decode.field("token", decode.string)
       use user_id <- decode.field("user_id", decode.int)
-      use game_id <- decode.field("game_id", decode.string)
+      use game_code <- decode.field("game_code", decode.string)
-      decode.success(JoinAsPlayer(token:, user_id:, game_id:))
+      decode.success(JoinAsPlayer(token:, user_id:, game_code:))
     }
     "JoinAsHost" -> {
       use token <- decode.field("token", decode.string)
       use user_id <- decode.field("user_id", decode.int)
-      use game_id <- decode.field("game_id", decode.string)
+      use game_code <- decode.field("game_code", decode.string)
-      decode.success(JoinAsHost(token:, user_id:, game_id:))
+      decode.success(JoinAsHost(token:, user_id:, game_code:))
     }
     _ -> decode.failure(JoinAsPlayer("", 0, ""), "NewUserClientMessages")
   }
@@ -39,8 +39,10 @@ pub type NewUserServerMessages {
 pub fn encode_new_user_server_messages(
   new_user_server_messages: NewUserServerMessages,
 ) -> json.Json {
-  case new_user_server_messages {
+  let msg_type = case new_user_server_messages {
-    RegisterResponse -> json.string("register_response")
+    RegisterResponse -> json.string("RegisterResponse")
-    HostRegisterResponse -> json.string("host_register_response")
+    HostRegisterResponse -> json.string("HostRegisterResponse")
   }
+
+  json.object([#("type", msg_type)])
 }

backend/src/app/clients/player_client.gleam

@@ -18,6 +18,7 @@ pub type PlayerServerMessages {
   Ack
   UpdatePointTotal(score: Int)
   ResetBuzzer
+  ExitGame
 }
 
 pub fn encode_player_server_messages(
@@ -31,5 +32,6 @@ pub fn encode_player_server_messages(
         #("score", json.int(player_server_messages.score)),
       ])
     ResetBuzzer -> json.object([#("type", json.string("ResetBuzzer"))])
+    ExitGame -> json.object([#("type", json.string("ExitGame"))])
   }
 }

backend/src/app/router.gleam

@@ -2,7 +2,6 @@ import app/clients/new_user_client
 import app/web
 import gleam/bit_array
 import gleam/bytes_tree
-import gleam/dict
 import gleam/erlang/process
 import gleam/http/cookie
 import gleam/http/request.{type Request}
@@ -17,9 +16,9 @@ import gleam/string
 import login
 import mist.{type Connection, type ResponseData}
 import player
-import session
+import player_manager
+import session_manager
 import socket_manager
-import storail
 
 type JoinAs {
   JoinAsHost
@@ -53,33 +52,37 @@ fn server_login(
   let assert Ok(body) = bit_array.to_string(req.body)
 
   let assert Ok(login_req) = json.parse(body, login.login_request_decoder())
-  let #(token, user_id) =
+  let assert Ok(#(user_id, token)) =
-    web.register_user(ctx, login_req.username, login_req.game_code)
+    player_manager.add_player(
+      ctx.players,
+      login_req.username,
+      login_req.game_code,
+    )
 
   let _ = case join_type {
     JoinAsHost -> {
-      let key = storail.key(ctx.sessions, login_req.game_code)
+      let assert Ok(_) =
-      let session = session.Session(login_req.game_code, user_id, dict.new())
+        session_manager.create_new_game(
-      let assert Ok(Nil) = storail.write(key, session)
+          ctx.sessions,
+          login_req.game_code,
+          user_id,
+        )
+
+      Nil
     }
     JoinAsPlayer -> {
-      let key = storail.key(ctx.sessions, login_req.game_code)
+      let assert Ok(_) =
-      let assert Ok(session) = storail.read(key)
+        session_manager.add_player_to_game(
-
+          ctx.sessions,
-      let player =
+          login_req.game_code,
           player.Player(
             name: login_req.username,
             id: user_id,
             score: 0,
             buzz_in_time: None,
+          ),
         )
-      let session =
+      Nil
-        session.Session(
-          ..session,
-          players: dict.insert(session.players, player.id, player),
-        )
-
-      let assert Ok(Nil) = storail.write(key, session)
     }
   }
 
@@ -87,22 +90,30 @@ fn server_login(
     JoinAsHost -> "host"
     JoinAsPlayer -> "player"
   }
+  let cookie_attr =
+    cookie.Attributes(..cookie.defaults(req.scheme), http_only: False)
 
   response.new(200)
-  |> response.set_cookie(
+  |> response.set_cookie("play_of_the_game/token", token, cookie_attr)
-    "play_of_the_game/token",
-    token,
-    cookie.defaults(req.scheme),
-  )
   |> response.set_cookie(
     "play_of_the_game/client_type",
     join_type_name,
-    cookie.defaults(req.scheme),
+    cookie_attr,
   )
   |> response.set_cookie(
     "play_of_the_game/username",
     login_req.username,
-    cookie.defaults(req.scheme),
+    cookie_attr,
+  )
+  |> response.set_cookie(
+    "play_of_the_game/user_id",
+    int.to_string(user_id),
+    cookie_attr,
+  )
+  |> response.set_cookie(
+    "play_of_the_game/game_code",
+    login_req.game_code,
+    cookie_attr,
   )
   |> response.set_body(mist.Bytes(bytes_tree.new()))
 }
@@ -162,14 +173,12 @@ fn handle_ws_message(
   conn,
   message: mist.WebsocketMessage(String),
 ) {
-  io.println("Got WS message")
   case message {
     mist.Text(msg) -> {
       echo msg
 
       let #(state, resp) = web.handle_client_msg(state, msg)
 
-      echo resp
       let assert Ok(_) = mist.send_text_frame(conn, resp)
 
       actor.continue(state)

backend/src/app/web.gleam

@@ -2,22 +2,14 @@ import app/clients/host_client
 import app/clients/new_user_client
 import app/clients/player_client
 import config
-import gleam/bit_array
-import gleam/crypto
-import gleam/dict
 import gleam/erlang/process
 import gleam/float
 import gleam/int
 import gleam/io
 import gleam/json
-import gleam/list
+import player_manager
-import gleam/option.{None, Some}
+import session_manager
-import gleam/otp/actor
-import player
-import player_session
-import session
 import socket_manager
-import storail
 
 pub type Error {
   InvalidToken
@@ -26,8 +18,8 @@ pub type Error {
 pub type Context {
   Context(
     config: config.Config,
-    sessions: storail.Collection(session.Session),
+    sessions: session_manager.SessionManager,
-    player_sessions: storail.Collection(player_session.PlayerSession),
+    players: player_manager.PlayerManager,
     socket_manager: socket_manager.SocketManager(String),
   )
 }
@@ -58,32 +50,6 @@ pub fn handle_client_msg(
   }
 }
 
-fn set_buzz_in(
-  socket_state: SocketState,
-  player_state: player_client.PlayerState,
-  time: Float,
-) {
-  let key = storail.key(socket_state.ctx.sessions, player_state.game_id)
-  let assert Ok(session) = storail.read(key)
-
-  let players =
-    dict.upsert(session.players, player_state.user_id, fn(player) {
-      let assert Some(player) = player
-
-      player.Player(..player, buzz_in_time: Some(time))
-    })
-
-  let session = session.Session(..session, players:)
-
-  let assert Ok(_) = storail.write(key, session)
-
-  send_message_to_host(
-    socket_state,
-    session.host_user_id,
-    host_client.UpdatePlayerStates(session.players),
-  )
-}
-
 fn handle_player(
   socket_state: SocketState,
   player_state: player_client.PlayerState,
@@ -101,7 +67,13 @@ fn handle_player(
         <> float.to_string(time),
       )
 
-      set_buzz_in(socket_state, player_state, time)
+      let assert Ok(_) =
+        session_manager.buzz_in_player(
+          socket_state.ctx.sessions,
+          player_state.game_id,
+          player_state.user_id,
+          time,
+        )
 
       #(
         socket_state,
@@ -113,67 +85,6 @@ fn handle_player(
   }
 }
 
-pub fn register_user(
-  ctx: Context,
-  username: String,
-  game_code: String,
-) -> #(String, Int) {
-  let secret = crypto.strong_random_bytes(16)
-  let token =
-    crypto.new_hasher(crypto.Sha512)
-    |> crypto.hash_chunk(secret)
-    |> crypto.hash_chunk(bit_array.from_string(username))
-    |> crypto.hash_chunk(bit_array.from_string(game_code))
-    |> crypto.digest
-    |> bit_array.base64_encode(True)
-
-  let token_hash = player_session.hash_token(token)
-
-  let assert <<user_id:int-size(64)>> = crypto.strong_random_bytes(8)
-
-  let key = storail.key(ctx.player_sessions, int.to_base16(user_id))
-
-  let assert Ok(Nil) =
-    storail.write(
-      key,
-      player_session.PlayerSession(
-        id: user_id,
-        token_hash:,
-        username:,
-        socket_id: None,
-      ),
-    )
-
-  #(token, user_id)
-}
-
-pub fn attach_socket_to_user(
-  state: SocketState,
-  user_id: Int,
-  token: String,
-) -> Result(Nil, Error) {
-  let key = storail.key(state.ctx.player_sessions, int.to_base16(user_id))
-  let assert Ok(player_state) = storail.read(key)
-
-  let hashed_token = player_session.hash_token(token)
-
-  case hashed_token == player_state.token_hash {
-    False -> Error(InvalidToken)
-    True -> {
-      let assert Ok(Nil) =
-        storail.write(
-          key,
-          player_session.PlayerSession(
-            ..player_state,
-            socket_id: Some(state.id),
-          ),
-        )
-
-      Ok(Nil)
-    }
-  }
-}
-
 fn handle_new_user(
   socket_state: SocketState,
   _new_user_state: new_user_client.NewUserState,
@@ -184,18 +95,14 @@ fn handle_new_user(
 
   let #(socket_state, new_user_msg) = case msg {
     new_user_client.JoinAsHost(token, user_id, game_id) -> {
-      let assert Ok(_) = attach_socket_to_user(socket_state, user_id, token)
+      let assert Ok(_) =
-
+        player_manager.attack_socket_to_player(
-      #(
+          socket_state.ctx.players,
-        SocketState(
+          user_id,
-          ..socket_state,
+          socket_state.id,
-          state: Player(player_client.PlayerState(user_id:, game_id:)),
+          token,
-        ),
-        new_user_client.HostRegisterResponse,
         )
-    }
+
-    new_user_client.JoinAsPlayer(token, user_id, game_id) -> {
-      let assert Ok(_) = attach_socket_to_user(socket_state, user_id, token)
       #(
         SocketState(
           ..socket_state,
@@ -204,6 +111,23 @@ fn handle_new_user(
         new_user_client.HostRegisterResponse,
       )
     }
+    new_user_client.JoinAsPlayer(token, user_id, game_id) -> {
+      let assert Ok(_) =
+        player_manager.attack_socket_to_player(
+          socket_state.ctx.players,
+          user_id,
+          socket_state.id,
+          token,
+        )
+
+      #(
+        SocketState(
+          ..socket_state,
+          state: Player(player_client.PlayerState(user_id:, game_id:)),
+        ),
+        new_user_client.RegisterResponse,
+      )
+    }
   }
 
   #(
@@ -212,86 +136,6 @@ fn handle_new_user(
   )
 }
 
-fn get_player_session_from_id(
-  ctx: Context,
-  id: Int,
-) -> player_session.PlayerSession {
-  let player_key = storail.key(ctx.player_sessions, int.to_base16(id))
-  let assert Ok(player) = storail.read(player_key)
-  player
-}
-
-fn get_player_session_subject(
-  ctx: Context,
-  player: player_session.PlayerSession,
-) -> process.Subject(String) {
-  let assert Some(id) = player.socket_id
-  let assert Ok(subject) =
-    socket_manager.get_socket_subj_by_id(ctx.socket_manager, id)
-  subject
-}
-
-fn broadcast_message_to_players(
-  socket_state: SocketState,
-  session: session.Session,
-  msg: player_client.PlayerServerMessages,
-) {
-  dict.keys(session.players)
-  |> list.map(get_player_session_from_id(socket_state.ctx, _))
-  |> list.map(get_player_session_subject(socket_state.ctx, _))
-  |> list.each(fn(subject) {
-    let client_msg = player_client.encode_player_server_messages(msg)
-    actor.send(subject, json.to_string(client_msg))
-  })
-}
-
-fn send_message_to_player(
-  socket_state: SocketState,
-  id: Int,
-  msg: player_client.PlayerServerMessages,
-) {
-  let client_msg = player_client.encode_player_server_messages(msg)
-
-  get_player_session_from_id(socket_state.ctx, id)
-  |> get_player_session_subject(socket_state.ctx, _)
-  |> actor.send(json.to_string(client_msg))
-}
-
-fn send_message_to_host(
-  socket_state: SocketState,
-  id: Int,
-  msg: host_client.HostServerMessages,
-) {
-  let client_msg = host_client.encode_host_server_messages(msg)
-
-  get_player_session_from_id(socket_state.ctx, id)
-  |> get_player_session_subject(socket_state.ctx, _)
-  |> actor.send(json.to_string(client_msg))
-}
-
-fn reset_player_buzzer(
-  socket_state: SocketState,
-  session_key: storail.Key(session.Session),
-  id: Int,
-) {
-  let assert Ok(session) = storail.read(session_key)
-
-  let assert Ok(player) = dict.get(session.players, id)
-  let player = player.Player(..player, buzz_in_time: None)
-
-  let players = dict.insert(session.players, id, player)
-
-  let session = session.Session(..session, players: players)
-
-  let assert Ok(_) = storail.write(session_key, session)
-
-  send_message_to_host(
-    socket_state,
-    session.host_user_id,
-    host_client.UpdatePlayerStates(session.players),
-  )
-}
-
 fn handle_host(
   socket_state: SocketState,
   host_state: host_client.HostState,
@@ -300,49 +144,39 @@ fn handle_host(
   let assert Ok(msg) =
     json.parse(msg, host_client.host_client_messages_decoder())
 
-  let session_key = storail.key(socket_state.ctx.sessions, host_state.game_id)
-  let assert Ok(session) = storail.read(session_key)
-
   let #(socket_state, resp) = case msg {
     host_client.ResetAllBuzers -> {
-      dict.to_list(session.players)
+      let assert Ok(_) =
-      |> list.each(fn(player_entry) {
+        session_manager.reset_all_buzzers(
-        reset_player_buzzer(socket_state, session_key, player_entry.0)
+          socket_state.ctx.sessions,
-      })
+          host_state.game_id,
-
-      broadcast_message_to_players(
-        socket_state,
-        session,
-        player_client.ResetBuzzer,
         )
       #(socket_state, host_client.Ack)
     }
     host_client.ResetPlayerBuzzer(id) -> {
-      reset_player_buzzer(socket_state, session_key, id)
+      let assert Ok(_) =
-      send_message_to_player(socket_state, id, player_client.ResetBuzzer)
+        session_manager.reset_player_buzzer(
+          socket_state.ctx.sessions,
+          host_state.game_id,
+          id,
+        )
+
       #(socket_state, host_client.Ack)
     }
     host_client.UpdateScore(id, score) -> {
-      let assert Ok(player) = dict.get(session.players, id)
+      let assert Ok(_) =
-      let player = player.Player(..player, score: player.score + score)
+        session_manager.updater_player_score(
-      let session =
+          socket_state.ctx.sessions,
-        session.Session(
+          host_state.game_id,
-          ..session,
-          players: dict.insert(session.players, player.id, player),
-        )
-      let assert Ok(_) = storail.write(session_key, session)
-
-      send_message_to_player(
-        socket_state,
           id,
-        player_client.UpdatePointTotal(player.score),
+          score,
         )
 
-      send_message_to_host(
+      #(socket_state, host_client.Ack)
-        socket_state,
+    }
-        session.host_user_id,
+    host_client.EndGame -> {
-        host_client.UpdatePlayerStates(session.players),
+      let assert Ok(_) =
-      )
+        session_manager.end_game(socket_state.ctx.sessions, host_state.game_id)
 
       #(socket_state, host_client.Ack)
     }

backend/src/backend.gleam

@@ -6,10 +6,9 @@ import gleam/erlang/process
 import gleam/result
 import glint
 import mist
-import player_session
+import player_manager
-import session
+import session_manager
 import socket_manager
-import storail
 
 pub type Error {
   ConfigError(config.ConfigError)
@@ -21,28 +20,6 @@ pub fn error_string(err: Error) -> String {
   }
 }
 
-pub fn setup_session_collection(
-  config: storail.Config,
-) -> storail.Collection(session.Session) {
-  storail.Collection(
-    name: "Sessions",
-    to_json: session.serialize,
-    decoder: session.decoder(),
-    config:,
-  )
-}
-
-pub fn setup_player_session_collection(
-  config: storail.Config,
-) -> storail.Collection(player_session.PlayerSession) {
-  storail.Collection(
-    name: "PlayerSessions",
-    to_json: player_session.encode_player_session,
-    decoder: player_session.player_session_decoder(),
-    config:,
-  )
-}
-
 pub fn run_server() -> glint.Command(Result(Nil, Error)) {
   use <- glint.command_help("Runs the backend of Play of the Game")
   use _, args, _ <- glint.command()
@@ -59,14 +36,16 @@ pub fn run_server() -> glint.Command(Result(Nil, Error)) {
     }),
   )
 
-  let storail_cfg = storail.Config(cfg.storage_path)
+  let player_manager = player_manager.new()
+  let socket_manager = socket_manager.new()
+  let session_manager = session_manager.new(player_manager, socket_manager)
 
   let ctx =
     web.Context(
       config: cfg,
-      sessions: setup_session_collection(storail_cfg),
+      players: player_manager,
-      player_sessions: setup_player_session_collection(storail_cfg),
+      socket_manager:,
-      socket_manager: socket_manager.new(),
+      sessions: session_manager,
     )
 
   let handler = router.handle_request(_, ctx)

backend/src/manager.gleam

@@ -0,0 +1,30 @@
+import gleam/erlang/process
+import gleam/otp/actor
+
+pub const call_timeout = 1000
+
+pub type Manager(resp_type, msg_type) {
+  Manager(subject: process.Subject(Request(resp_type, msg_type)))
+}
+
+pub type State(state_type) {
+  State(internal: state_type)
+}
+
+pub type Request(resp_type, msg_type) {
+  Request(reply_to: process.Subject(resp_type), msg: msg_type)
+}
+
+pub fn new(
+  init_state: fn() -> state_type,
+  handle: fn(Request(resp_type, msg_type), State(state_type)) ->
+    actor.Next(Request(resp_type, msg_type), State(state_type)),
+) -> Manager(resp_type, msg_type) {
+  let assert Ok(subject) = actor.start(State(init_state()), handle)
+
+  Manager(subject)
+}
+
+pub fn call(manager: Manager(resp_type, msg_type), msg: msg_type) -> resp_type {
+  actor.call(manager.subject, Request(_, msg), call_timeout)
+}

backend/src/player_manager.gleam

@@ -0,0 +1,263 @@
+import gleam/bit_array
+import gleam/crypto
+import gleam/dict
+import gleam/erlang/process
+import gleam/int
+import gleam/io
+import gleam/option.{type Option, None, Some}
+import gleam/otp/actor
+import gleam/result
+import manager
+import player_session
+
+pub type PlayerManager =
+  manager.Manager(Response, Message)
+
+pub type Message {
+  AddPlayer(username: String, game_code: String)
+  AttachSocketToPlayer(user_id: Int, socket_id: Int, token_hash: String)
+  RemoveSocket(user_id: Int)
+  RemovePlayer(user_id: Int)
+  GetPlayerSocket(user_id: Int)
+}
+
+pub type PlayerError {
+  PlayerNotFound(Int)
+  UsernameAlreadyExists(String)
+  TokenHashMistmatch
+}
+
+pub fn error_to_string(error: PlayerError) -> String {
+  case error {
+    PlayerNotFound(id) -> "Player of id=" <> int.to_string(id) <> " not found"
+    UsernameAlreadyExists(username) ->
+      "Username '" <> username <> "' already exists!"
+    TokenHashMistmatch -> "Error authenticating user"
+  }
+}
+
+pub type Return {
+  Ack
+  AddPlayerResp(user_id: Int, token: String)
+  GetPlayerSocketResp(socket_id: Option(Int))
+}
+
+pub type Response =
+  Result(Return, PlayerError)
+
+pub type Request =
+  manager.Request(Response, Message)
+
+pub type InternalState {
+  InternalState(
+    next_id: Int,
+    players: dict.Dict(Int, player_session.PlayerSession),
+  )
+}
+
+pub type State =
+  manager.State(InternalState)
+
+fn call(
+  player_manager: PlayerManager,
+  msg: Message,
+) -> Result(Return, PlayerError) {
+  manager.call(player_manager, msg)
+}
+
+pub fn new() -> PlayerManager {
+  manager.new(fn() { InternalState(0, dict.new()) }, handle)
+}
+
+pub fn add_player(
+  player_manager: PlayerManager,
+  username: String,
+  gamecode: String,
+) -> Result(#(Int, String), PlayerError) {
+  use ret <- result.try(call(player_manager, AddPlayer(username, gamecode)))
+
+  let assert AddPlayerResp(user_id, token) = ret
+  Ok(#(user_id, token))
+}
+
+pub fn attack_socket_to_player(
+  player_manager: PlayerManager,
+  user_id: Int,
+  socket_id: Int,
+  token_hash: String,
+) -> Result(Nil, PlayerError) {
+  use _ret <- result.try(call(
+    player_manager,
+    AttachSocketToPlayer(user_id, socket_id, token_hash),
+  ))
+
+  Ok(Nil)
+}
+
+pub fn remove_socket(
+  player_manager: PlayerManager,
+  user_id: Int,
+) -> Result(Nil, PlayerError) {
+  use _ret <- result.try(call(player_manager, RemoveSocket(user_id)))
+
+  Ok(Nil)
+}
+
+pub fn remove_player(
+  player_manager: PlayerManager,
+  user_id: Int,
+) -> Result(Nil, PlayerError) {
+  use _ret <- result.try(call(player_manager, RemovePlayer(user_id)))
+
+  Ok(Nil)
+}
+
+pub fn get_player_socket(
+  player_manager: PlayerManager,
+  user_id: Int,
+) -> Result(Option(Int), PlayerError) {
+  use ret <- result.try(call(player_manager, GetPlayerSocket(user_id)))
+
+  let assert GetPlayerSocketResp(socket_id) = ret
+
+  Ok(socket_id)
+}
+
+fn handle(request: Request, state: State) -> actor.Next(Request, State) {
+  let ret = case request.msg {
+    AddPlayer(username, gamecode) ->
+      add_player_internal(state, username, gamecode)
+    AttachSocketToPlayer(user_id, socket_id, token_hash) ->
+      attach_socket_to_player_internal(state, user_id, socket_id, token_hash)
+    RemovePlayer(user_id) -> remove_player_internal(state, user_id)
+    RemoveSocket(user_id) -> remove_socket_internal(state, user_id)
+    GetPlayerSocket(user_id) -> get_player_socket_internal(state, user_id)
+  }
+
+  case ret {
+    Error(err) -> {
+      io.println_error("Player Manager error: " <> error_to_string(err))
+      process.send(request.reply_to, Error(err))
+
+      actor.continue(state)
+    }
+    Ok(#(resp, actor_state)) -> {
+      process.send(request.reply_to, Ok(resp))
+
+      actor_state
+    }
+  }
+}
+
+fn get_player(
+  state: State,
+  player_id: Int,
+) -> Result(player_session.PlayerSession, PlayerError) {
+  result.map_error(dict.get(state.internal.players, player_id), fn(_) {
+    PlayerNotFound(player_id)
+  })
+}
+
+fn add_player_to_state(
+  state: State,
+  player: player_session.PlayerSession,
+) -> State {
+  let players = dict.insert(state.internal.players, player.id, player)
+
+  manager.State(internal: InternalState(..state.internal, players:))
+}
+
+fn add_player_internal(
+  state: State,
+  username: String,
+  game_code: String,
+) -> Result(#(Return, actor.Next(Request, State)), PlayerError) {
+  let secret = crypto.strong_random_bytes(16)
+  let token =
+    crypto.new_hasher(crypto.Sha512)
+    |> crypto.hash_chunk(secret)
+    |> crypto.hash_chunk(bit_array.from_string(username))
+    |> crypto.hash_chunk(bit_array.from_string(game_code))
+    |> crypto.digest
+    |> bit_array.base64_encode(True)
+
+  let token_hash = player_session.hash_token(token)
+
+  let user_id = state.internal.next_id
+
+  let sessions =
+    player_session.PlayerSession(user_id, token_hash, username, None)
+    |> dict.insert(state.internal.players, user_id, _)
+
+  let continue =
+    manager.State(internal: InternalState(state.internal.next_id + 1, sessions))
+    |> actor.continue
+
+  io.print("Adding" <> username <> "id=" <> int.to_string(user_id) <> "to game")
+  #(AddPlayerResp(user_id, token), continue)
+  |> Ok
+}
+
+fn attach_socket_to_player_internal(
+  state: State,
+  user_id: Int,
+  socket_id: Int,
+  token_hash: String,
+) -> Result(#(Return, actor.Next(Request, State)), PlayerError) {
+  use player <- result.try(get_player(state, user_id))
+  use _ <- result.try(
+    case player.token_hash == player_session.hash_token(token_hash) {
+      False -> Error(TokenHashMistmatch)
+      True -> Ok(Nil)
+    },
+  )
+
+  let state =
+    player_session.PlayerSession(..player, socket_id: Some(socket_id))
+    |> add_player_to_state(state, _)
+    |> actor.continue
+
+  #(Ack, state)
+  |> Ok
+}
+
+fn remove_socket_internal(
+  state: State,
+  user_id: Int,
+) -> Result(#(Return, actor.Next(Request, State)), PlayerError) {
+  use player <- result.try(get_player(state, user_id))
+
+  let state =
+    player_session.PlayerSession(..player, socket_id: None)
+    |> add_player_to_state(state, _)
+    |> actor.continue
+
+  #(Ack, state)
+  |> Ok
+}
+
+fn remove_player_internal(
+  state: State,
+  user_id: Int,
+) -> Result(#(Return, actor.Next(Request, State)), PlayerError) {
+  use player <- result.try(get_player(state, user_id))
+
+  let players = dict.delete(state.internal.players, player.id)
+
+  let state =
+    manager.State(internal: InternalState(..state.internal, players:))
+    |> actor.continue
+
+  #(Ack, state)
+  |> Ok
+}
+
+fn get_player_socket_internal(
+  state: State,
+  user_id: Int,
+) -> Result(#(Return, actor.Next(Request, State)), PlayerError) {
+  use player <- result.try(get_player(state, user_id))
+
+  #(GetPlayerSocketResp(player.socket_id), actor.continue(state))
+  |> Ok
+}

backend/src/session_manager.gleam

@@ -0,0 +1,429 @@
+import app/clients/host_client
+import app/clients/player_client
+import gleam/dict
+import gleam/erlang/process
+import gleam/int
+import gleam/io
+import gleam/json
+import gleam/list
+import gleam/option.{type Option, None, Some}
+import gleam/otp/actor
+import gleam/result
+import manager
+import player
+import player_manager
+import session
+import socket_manager
+
+pub type SessionManager =
+  manager.Manager(Response, Message)
+
+pub type Request =
+  manager.Request(Response, Message)
+
+pub type State =
+  manager.State(InternalState)
+
+pub type InternalState {
+  InternalState(
+    games: dict.Dict(String, session.Session),
+    player_manager: player_manager.PlayerManager,
+    socket_manager: socket_manager.SocketManager(String),
+  )
+}
+
+pub fn new(player_manager, socket_manager) -> SessionManager {
+  manager.new(
+    fn() { InternalState(dict.new(), player_manager, socket_manager) },
+    handle,
+  )
+}
+
+pub type Message {
+  CreateNewGame(game_id: String, host_id: Int)
+  EndGame(game_id: String)
+  AddPlayerToGame(game_id: String, player: player.Player)
+  RemovePlayerFromGame(game_id: String, player_id: Int)
+  BuzzInPlayer(game_id: String, player_id: Int, time: Float)
+  ResetAllBuzers(game_id: String)
+  ResetPlayerBuzzer(game_id: String, player_id: Int)
+  UpdatePlayerScore(game_id: String, player_id: Int, score_diff: Int)
+
+  Shutdown
+}
+
+pub type Response =
+  Result(Nil, SessionError)
+
+pub type SessionError {
+  GameAlreadyExists(game_id: String)
+  GameNotFound(game_id: String)
+  PlayerNotFound(player_id: Int)
+}
+
+pub fn error_to_string(error: SessionError) -> String {
+  case error {
+    GameAlreadyExists(game_id) ->
+      "Game with id=" <> game_id <> " already exists."
+    GameNotFound(game_id) -> "Game with id=" <> game_id <> " not found."
+    PlayerNotFound(player_id) ->
+      "Player with id=" <> int.to_string(player_id) <> " not found."
+  }
+}
+
+fn call(
+  session_manager: SessionManager,
+  msg: Message,
+) -> Result(Nil, SessionError) {
+  manager.call(session_manager, msg)
+}
+
+pub fn create_new_game(
+  session_manager: SessionManager,
+  game_id: String,
+  host_id: Int,
+) -> Result(Nil, SessionError) {
+  call(session_manager, CreateNewGame(game_id, host_id))
+}
+
+pub fn end_game(
+  session_manager: SessionManager,
+  game_id: String,
+) -> Result(Nil, SessionError) {
+  call(session_manager, EndGame(game_id))
+}
+
+pub fn add_player_to_game(
+  session_manager: SessionManager,
+  game_id: String,
+  player: player.Player,
+) -> Result(Nil, SessionError) {
+  call(session_manager, AddPlayerToGame(game_id, player))
+}
+
+pub fn remove_player_from_game(
+  session_manager: SessionManager,
+  game_id: String,
+  player_id: Int,
+) -> Result(Nil, SessionError) {
+  call(session_manager, RemovePlayerFromGame(game_id, player_id))
+}
+
+pub fn buzz_in_player(
+  session_manager: SessionManager,
+  game_id: String,
+  player_id: Int,
+  time: Float,
+) -> Result(Nil, SessionError) {
+  call(session_manager, BuzzInPlayer(game_id, player_id, time))
+}
+
+pub fn reset_all_buzzers(
+  session_manager: SessionManager,
+  game_id: String,
+) -> Result(Nil, SessionError) {
+  call(session_manager, ResetAllBuzers(game_id))
+}
+
+pub fn reset_player_buzzer(
+  session_manager: SessionManager,
+  game_id: String,
+  user_id: Int,
+) -> Result(Nil, SessionError) {
+  call(session_manager, ResetPlayerBuzzer(game_id, user_id))
+}
+
+pub fn updater_player_score(
+  session_manager: SessionManager,
+  game_id: String,
+  user_id: Int,
+  score_diff: Int,
+) -> Result(Nil, SessionError) {
+  call(session_manager, UpdatePlayerScore(game_id, user_id, score_diff))
+}
+
+fn get_game(state: State, game_id) -> Result(session.Session, SessionError) {
+  result.map_error(dict.get(state.internal.games, game_id), fn(_) {
+    GameNotFound(game_id)
+  })
+}
+
+fn get_player_in_game(
+  game: session.Session,
+  player_id: Int,
+) -> Result(player.Player, SessionError) {
+  result.map_error(dict.get(game.players, player_id), fn(_) {
+    PlayerNotFound(player_id)
+  })
+}
+
+fn add_game_to_manager(
+  state: State,
+  game_id: String,
+  game: session.Session,
+) -> State {
+  send_message_to_host(
+    state,
+    game.host_user_id,
+    host_client.UpdatePlayerStates(game.players),
+  )
+
+  let games = dict.insert(state.internal.games, game_id, game)
+
+  manager.State(internal: InternalState(..state.internal, games:))
+}
+
+fn add_player_to_game_internal(
+  game: session.Session,
+  player: player.Player,
+) -> session.Session {
+  session.Session(..game, players: dict.insert(game.players, player.id, player))
+}
+
+// Actor Logic
+
+fn get_player_session_subject(
+  state: State,
+  player_id: Int,
+) -> Option(process.Subject(String)) {
+  let assert Ok(socket_id) =
+    player_manager.get_player_socket(state.internal.player_manager, player_id)
+  case socket_id {
+    None -> None
+    Some(id) -> {
+      let assert Ok(subject) =
+        socket_manager.get_socket_subj_by_id(state.internal.socket_manager, id)
+
+      Some(subject)
+    }
+  }
+}
+
+fn send_message_to_socket(state: State, player_id: Int, msg: String) {
+  let subject = get_player_session_subject(state, player_id)
+
+  case subject {
+    None -> Nil
+    Some(subject) -> {
+      actor.send(subject, msg)
+    }
+  }
+}
+
+fn send_message_to_player(
+  state: State,
+  player_id: Int,
+  msg: player_client.PlayerServerMessages,
+) {
+  player_client.encode_player_server_messages(msg)
+  |> json.to_string
+  |> send_message_to_socket(state, player_id, _)
+}
+
+fn broadcast_msg_to_players(
+  state: State,
+  game: session.Session,
+  msg: player_client.PlayerServerMessages,
+) {
+  game.players
+  |> dict.keys
+  |> list.each(fn(player_id) { send_message_to_player(state, player_id, msg) })
+}
+
+fn send_message_to_host(
+  state: State,
+  player_id: Int,
+  msg: host_client.HostServerMessages,
+) {
+  host_client.encode_host_server_messages(msg)
+  |> json.to_string
+  |> send_message_to_socket(state, player_id, _)
+}
+
+fn add_player_internal(
+  state: State,
+  game_id: String,
+  player: player.Player,
+) -> Result(actor.Next(Request, State), SessionError) {
+  use game <- result.try(get_game(state, game_id))
+
+  add_player_to_game_internal(game, player)
+  |> add_game_to_manager(state, game_id, _)
+  |> actor.continue
+  |> Ok
+}
+
+fn buzz_in_player_internal(
+  state: State,
+  game_id: String,
+  player_id: Int,
+  time: Float,
+) -> Result(actor.Next(Request, State), SessionError) {
+  use game <- result.try(get_game(state, game_id))
+  use player <- result.try(get_player_in_game(game, player_id))
+
+  player.Player(..player, buzz_in_time: Some(time))
+  |> add_player_to_game_internal(game, _)
+  |> add_game_to_manager(state, game_id, _)
+  |> actor.continue
+  |> Ok
+}
+
+fn create_new_game_internal(
+  state: State,
+  game_id: String,
+  host_id: Int,
+) -> Result(actor.Next(Request, State), SessionError) {
+  case dict.has_key(state.internal.games, game_id) {
+    True -> Error(GameAlreadyExists(game_id))
+    False -> {
+      session.Session(game_id, host_id, dict.new())
+      |> add_game_to_manager(state, game_id, _)
+      |> actor.continue
+      |> Ok
+    }
+  }
+}
+
+fn end_game_internal(
+  state: State,
+  game_id: String,
+) -> Result(actor.Next(Request, State), SessionError) {
+  use game <- result.try(get_game(state, game_id))
+
+  broadcast_msg_to_players(state, game, player_client.ExitGame)
+  send_message_to_host(state, game.host_user_id, host_client.ExitGame)
+
+  game.players
+  |> dict.each(fn(key, _) {
+    let _ = player_manager.remove_player(state.internal.player_manager, key)
+  })
+
+  let _ =
+    player_manager.remove_player(
+      state.internal.player_manager,
+      game.host_user_id,
+    )
+
+  let games = dict.delete(state.internal.games, game_id)
+
+  manager.State(internal: InternalState(..state.internal, games:))
+  |> actor.continue
+  |> Ok
+}
+
+fn remove_player_from_game_internal(
+  state: State,
+  game_id: String,
+  player_id: Int,
+) -> Result(actor.Next(Request, State), SessionError) {
+  use game <- result.try(get_game(state, game_id))
+  use _ <- result.try(get_player_in_game(game, player_id))
+
+  let players = dict.delete(game.players, player_id)
+
+  session.Session(..game, players: players)
+  |> add_game_to_manager(state, game_id, _)
+  |> actor.continue
+  |> Ok
+}
+
+fn reset_all_buzzers_internal(
+  state: State,
+  game_id: String,
+) -> Result(actor.Next(Request, State), SessionError) {
+  use game <- result.try(get_game(state, game_id))
+
+  let players =
+    dict.map_values(game.players, fn(_, player) {
+      player.Player(..player, buzz_in_time: None)
+    })
+
+  broadcast_msg_to_players(state, game, player_client.ResetBuzzer)
+
+  session.Session(..game, players: players)
+  |> add_game_to_manager(state, game_id, _)
+  |> actor.continue
+  |> Ok
+}
+
+fn reset_player_buzzer_internal(
+  state: State,
+  game_id: String,
+  player_id: Int,
+) -> Result(actor.Next(Request, State), SessionError) {
+  use game <- result.try(get_game(state, game_id))
+  use player <- result.try(get_player_in_game(game, player_id))
+
+  send_message_to_player(state, player.id, player_client.ResetBuzzer)
+
+  player.Player(..player, buzz_in_time: None)
+  |> add_player_internal(state, game_id, _)
+}
+
+fn update_player_score_internal(
+  state: State,
+  game_id: String,
+  player_id: Int,
+  score_diff: Int,
+) -> Result(actor.Next(Request, State), SessionError) {
+  use game <- result.try(get_game(state, game_id))
+  use player <- result.try(get_player_in_game(game, player_id))
+
+  let player = player.Player(..player, score: player.score + score_diff)
+
+  send_message_to_player(
+    state,
+    player_id,
+    player_client.UpdatePointTotal(player.score),
+  )
+
+  player
+  |> add_player_internal(state, game_id, _)
+}
+
+fn handle(request: Request, state: State) -> actor.Next(Request, State) {
+  let ret = case request.msg {
+    AddPlayerToGame(game_id, player) -> {
+      add_player_internal(state, game_id, player)
+    }
+    BuzzInPlayer(game_id, player_id, time) -> {
+      buzz_in_player_internal(state, game_id, player_id, time)
+    }
+    CreateNewGame(game_id, host_id) -> {
+      create_new_game_internal(state, game_id, host_id)
+    }
+    EndGame(game_id) -> {
+      end_game_internal(state, game_id)
+    }
+    RemovePlayerFromGame(game_id, player_id) -> {
+      remove_player_from_game_internal(state, game_id, player_id)
+    }
+    ResetAllBuzers(game_id) -> {
+      reset_all_buzzers_internal(state, game_id)
+    }
+    ResetPlayerBuzzer(game_id, player_id) -> {
+      reset_player_buzzer_internal(state, game_id, player_id)
+    }
+    UpdatePlayerScore(game_id, player_id, score_diff) -> {
+      update_player_score_internal(state, game_id, player_id, score_diff)
+    }
+    Shutdown -> {
+      Ok(actor.Stop(process.Normal))
+    }
+  }
+
+  case ret {
+    Error(err) -> {
+      io.println_error("Session Manager error: " <> error_to_string(err))
+      process.send(request.reply_to, Error(err))
+
+      actor.continue(state)
+    }
+    Ok(actor_state) -> {
+      process.send(request.reply_to, Ok(Nil))
+
+      actor_state
+    }
+  }
+}

backend/test/backend_test.gleam

@@ -1,12 +1,5 @@
 import gleeunit
-import gleeunit/should
 
 pub fn main() {
   gleeunit.main()
 }
-
-// gleeunit test functions end in `_test`
-pub fn hello_world_test() {
-  1
-  |> should.equal(1)
-}

frontend/Cargo.lock

@@ -14,6 +14,21 @@ version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 
+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "autocfg"
 version = "1.4.0"
@@ -59,18 +74,47 @@ version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
 
+[[package]]
+name = "cc"
+version = "1.2.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16595d3be041c03b09d08d0858631facccee9221e579704070e6e9e4915d3bc7"
+dependencies = [
+ "shlex",
+]
+
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "chrono"
+version = "0.4.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d"
+dependencies = [
+ "android-tzdata",
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "wasm-bindgen",
+ "windows-link",
+]
+
 [[package]]
 name = "color_quant"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
 
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
 [[package]]
 name = "cpufeatures"
 version = "0.2.17"
@@ -194,6 +238,9 @@ dependencies = [
  "macroquad",
  "serde",
  "serde_json",
+ "thiserror 2.0.12",
+ "wasm-cookies",
+ "web-sys",
  "web-time",
 ]
 
@@ -252,6 +299,30 @@ version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
 
+[[package]]
+name = "iana-time-zone"
+version = "0.1.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "image"
 version = "0.24.9"
@@ -517,6 +588,12 @@ dependencies = [
  "digest",
 ]
 
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
 [[package]]
 name = "simd-adler32"
 version = "0.3.7"
@@ -540,7 +617,16 @@ version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
+dependencies = [
+ "thiserror-impl 2.0.12",
 ]
 
 [[package]]
@@ -554,6 +640,17 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "thiserror-impl"
+version = "2.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "ttf-parser"
 version = "0.21.1"
@@ -574,7 +671,7 @@ dependencies = [
  "log",
  "rand",
  "sha1",
- "thiserror",
+ "thiserror 1.0.69",
  "utf-8",
 ]
 
@@ -590,6 +687,12 @@ version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 
+[[package]]
+name = "urlencoding"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a1f0175e03a0973cf4afd476bef05c26e228520400eb1fd473ad417b1c00ffb"
+
 [[package]]
 name = "utf-8"
 version = "0.7.6"
@@ -679,6 +782,19 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "wasm-cookies"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "792b7c4fd62cde421f0e757620053efa7b0c23441c05c6ec02baf96cd74973be"
+dependencies = [
+ "chrono",
+ "js-sys",
+ "urlencoding",
+ "wasm-bindgen",
+ "web-sys",
+]
+
 [[package]]
 name = "web-sys"
 version = "0.3.77"
@@ -721,6 +837,65 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "windows-core"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
+
+[[package]]
+name = "windows-result"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "zerocopy"
 version = "0.8.25"

frontend/Cargo.toml

@@ -8,4 +8,7 @@ ewebsock = "0.8.0"
 macroquad = "0.4.14"
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
+thiserror = "2.0.12"
+wasm-cookies = "0.2.1"
+web-sys = { version = "0.3.77", features = ["Window", "Document", "Location", "HtmlDocument"] }
 web-time = "1.1.0"

frontend/build_wasm.sh

@@ -58,56 +58,6 @@ set -- "${POSITIONAL[@]}"
 
 PROJECT_NAME=$1
 
-HTML=$(
-	cat <<-END
-		<html lang="en">
-		<head>
-		    <meta charset="utf-8">
-		    <title>${PROJECT_NAME}</title>
-		    <style>
-		        html,
-		        body,
-		        canvas {
-		            margin: 0px;
-		            padding: 0px;
-		            width: 100%;
-		            height: 100%;
-		            overflow: hidden;
-		            position: absolute;
-		            z-index: 0;
-		        }
-		    </style>
-		</head>
-		<body style="margin: 0; padding: 0; height: 100vh; width: 100vw;">
-		    <canvas id="glcanvas" tabindex='1' hidden></canvas>
-		    <script src="https://not-fl3.github.io/miniquad-samples/mq_js_bundle.js"></script>
-		    <script type="module">
-		        import init, { set_wasm } from "./static/${PROJECT_NAME}.js";
-		        async function impl_run() {
-		            let wbg = await init();
-		            miniquad_add_plugin({
-		                register_plugin: (a) => (a.wbg = wbg),
-		                on_init: () => set_wasm(wasm_exports),
-		                version: "0.0.1",
-		                name: "wbg",
-		            });
-		            load("./static/${PROJECT_NAME}_bg.wasm");
-		        }
-		        window.run = function() {
-		            document.getElementById("run-container").remove();
-		            document.getElementById("glcanvas").removeAttribute("hidden");
-		            document.getElementById("glcanvas").focus();
-		            impl_run();
-		        }
-		    </script>
-		    <div id="run-container" style="display: flex; justify-content: center; align-items: center; height: 100%; flex-direction: column;">
-		        <button onclick="run()">Run Game</button>
-		    </div>
-		</body>
-		</html>
-	END
-)
-
 TARGET_DIR="target/wasm32-unknown-unknown"
 # Build
 if [ -n "$RELEASE" ]; then
@@ -127,6 +77,3 @@ sed -i "s/import \* as __wbg_star0 from 'env';//" dist/"$PROJECT_NAME".js
 sed -i "s/let wasm;/let wasm; export const set_wasm = (w) => wasm = w;/" dist/"$PROJECT_NAME".js
 sed -i "s/imports\['env'\] = __wbg_star0;/return imports.wbg\;/" dist/"$PROJECT_NAME".js
 sed -i "s/const imports = __wbg_get_imports();/return __wbg_get_imports();/" dist/"$PROJECT_NAME".js
-
-# Create index from the HTML variable
-echo "$HTML" >dist/index.html

frontend/index/index.html

@@ -36,7 +36,7 @@
                 var xhr = new XMLHttpRequest();
                 xhr.open("POST", "./login/" + join_type);
                 xhr.onload = function (event) {
-                    console.log("Starting game...", event.target);
+                    console.log("Starting game...", event);
                     document.getElementById("run-container").remove();
                     document
                         .getElementById("glcanvas")
@@ -46,7 +46,7 @@
                 };
                 // or onerror, onabort
                 var formData = new FormData(document.getElementById("login"));
-                xhr.send(JSON.stringify(Object.fromEntries(formData));
+                xhr.send(JSON.stringify(Object.fromEntries(formData)));
             };
         </script>
         <div
@@ -62,8 +62,8 @@
             <form id="login">
                 <label for="username">Username:</label><br />
                 <input type="text" id="username" name="username" /><br />
-                <label for="gamecode">Gamecode:</label><br />
+                <label for="game_code">Gamecode:</label><br />
-                <input type="text" id="gamecode" name="gamecode" /><br />
+                <input type="text" id="game_code" name="game_code" /><br />
             </form>
             <button onclick="run('join')">Join Game</button>
             <button onclick="run('host')">Host Game</button>

frontend/src/cfg.rs

@@ -0,0 +1,66 @@
+use std::str::FromStr;
+
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum CfgError {
+    #[error("Unknown client type: '{0}'")]
+    UnkownClientType(String),
+    #[error("Missing cookie: '{0}'")]
+    MissingCookie(String),
+    #[error("Invalid cookie value: '{0}'")]
+    InvalidCookie(String),
+}
+
+#[derive(Debug, Clone)]
+pub enum ClientType {
+    Host,
+    Player,
+}
+
+impl FromStr for ClientType {
+    type Err = CfgError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "host" => Ok(Self::Host),
+            "player" => Ok(Self::Player),
+            _ => Err(CfgError::UnkownClientType(s.to_string())),
+        }
+    }
+}
+
+pub struct Cfg {
+    pub token: String,
+    pub username: String,
+    pub user_id: u64,
+    pub game_code: String,
+    pub client_type: ClientType,
+}
+
+impl Cfg {
+    pub fn load_from_cookies() -> Result<Self, CfgError> {
+        let client_type = wasm_cookies::get_raw("play_of_the_game/client_type")
+            .ok_or(CfgError::MissingCookie("client_type".to_string()))?;
+        let token = wasm_cookies::get_raw("play_of_the_game/token")
+            .ok_or(CfgError::MissingCookie("token".to_string()))?;
+        let user_id = wasm_cookies::get_raw("play_of_the_game/user_id")
+            .ok_or(CfgError::MissingCookie("user_id".to_string()))?
+            .parse()
+            .map_err(|_| CfgError::InvalidCookie("user_id".to_string()))?;
+        let game_id = wasm_cookies::get_raw("play_of_the_game/game_code")
+            .ok_or(CfgError::MissingCookie("game_id".to_string()))?;
+        let username = wasm_cookies::get_raw("play_of_the_game/username")
+            .ok_or(CfgError::MissingCookie("username".to_string()))?;
+
+        let client_type: ClientType = ClientType::from_str(&client_type)?;
+
+        Ok(Self {
+            token,
+            username,
+            user_id,
+            game_code: game_id,
+            client_type,
+        })
+    }
+}

frontend/src/context.rs

@@ -2,22 +2,31 @@ use ewebsock::WsEvent;
 use macroquad::prelude::{error, info};
 use serde::{Serialize, de::DeserializeOwned};
 
+use crate::cfg::{Cfg, ClientType};
+
 pub struct Context {
     pub sender: ewebsock::WsSender,
     pub reciever: ewebsock::WsReceiver,
     pub token: String,
     pub username: String,
+    pub user_id: u64,
+    pub game_code: String,
+    pub client_type: ClientType,
 }
 
 impl Context {
-    pub fn new(url: &str) -> Context {
+    pub fn new(url: &str, cfg: Cfg) -> Context {
+        info!("Connecting to web socket server @ {}", url);
         let (sender, reciever) = ewebsock::connect(url, ewebsock::Options::default()).unwrap();
 
         Self {
             sender,
             reciever,
-            token: String::new(),
+            token: cfg.token,
-            username: String::new(),
+            username: cfg.username,
+            game_code: cfg.game_code,
+            user_id: cfg.user_id,
+            client_type: cfg.client_type,
         }
     }
 
@@ -34,11 +43,7 @@ impl Context {
                     None
                 }
                 WsEvent::Message(ws_message) => match ws_message {
-                    ewebsock::WsMessage::Text(msg) => {
+                    ewebsock::WsMessage::Text(msg) => serde_json::from_str(&msg).ok(),
-                        let game_resp: T = serde_json::from_str(&msg).unwrap();
-
-                        Some(game_resp)
-                    }
                     _ => None,
                 },
                 WsEvent::Error(err) => {

frontend/src/host_screen.rs

@@ -6,7 +6,10 @@ use macroquad::{
 };
 use serde::{Deserialize, Serialize};
 
-use crate::{font::FontSize, model::player::Player, screen::Screen, ui_scaling::window_width};
+use crate::{
+    font::FontSize, model::player::Player, screen::Screen, ui_scaling::window_width,
+    util::refresh_page,
+};
 
 #[allow(dead_code)]
 #[derive(Serialize)]
@@ -15,6 +18,7 @@ enum HostClientMessages {
     ResetAllBuzers,
     ResetPlayerBuzzer { user_id: u64 },
     UpdateScore { user_id: u64, diff: i32 },
+    EndGame,
 }
 
 #[derive(Deserialize)]
@@ -22,6 +26,7 @@ enum HostClientMessages {
 enum HostServerMessages {
     Ack,
     UpdatePlayerStates { players: HashMap<String, Player> },
+    ExitGame,
 }
 
 #[derive(Default)]
@@ -125,26 +130,23 @@ impl Screen for HostScreen {
                 for user_id in &players {
                     self.draw_user(ctx, user_id, ui, width);
                 }
-            });
 
-        let button_size = screen_width() * 0.025;
+                ui.group(
-        let button_location = Vec2::new(screen_width() * 0.50, screen_height() * 0.90);
+                    hash!("Host Control"),
+                    Vec2::new(width, window_size.y * 0.25),
+                    |ui| {
+                        if ui.button(Vec2::new(width * 0.05, 0.0), "Clear All") {
+                            let msg = HostClientMessages::ResetAllBuzers;
+                            ctx.send_msg(&msg);
+                        }
 
-        draw_circle(
+                        if ui.button(Vec2::new(width * 0.55, 0.0), "End Game") {
-            button_location.x,
+                            let msg = HostClientMessages::EndGame;
-            button_location.y,
+                            ctx.send_msg(&msg);
-            button_size * 1.1,
+                        }
-            DARKBROWN,
+                    },
                 );
-        draw_circle(button_location.x, button_location.y, button_size, RED);
+            });
-        if is_mouse_button_pressed(MouseButton::Left) {
-            let loc = Vec2::from(mouse_position());
-            let normalize = loc - button_location;
-
-            if normalize.length() < button_size {
-                ctx.send_msg(&HostClientMessages::ResetAllBuzers);
-            }
-        }
 
         root_ui().pop_skin();
     }
@@ -162,6 +164,10 @@ impl Screen for HostScreen {
                     info!("Got new player state: {:?}", players);
                     self.players = players;
                 }
+                HostServerMessages::ExitGame => {
+                    info!("Exiting Game");
+                    refresh_page();
+                }
             };
         }
 

frontend/src/login_screen.rs

@@ -2,143 +2,88 @@ use crate::StateTransition;
 use crate::context::Context;
 use crate::font::FontSize;
 use crate::screen::Screen;
-use crate::ui_scaling::window_width;
+use macroquad::prelude::*;
-use macroquad::hash;
-use macroquad::ui::widgets::Window;
-use macroquad::{prelude::*, ui::root_ui};
 use serde::{Deserialize, Serialize};
 
+#[derive(Debug, Serialize)]
+pub struct JoinMessage {
+    pub game_code: String,
+    pub user_id: u64,
+    pub token: String,
+}
+
 #[derive(Debug, Serialize)]
 #[serde(tag = "type")]
 pub enum NewUserClientMessages {
-    Register { game_code: String, username: String },
+    JoinAsPlayer(JoinMessage),
-    CreateRoom { game_code: String, username: String },
+    JoinAsHost(JoinMessage),
 }
 
 #[derive(Debug, Deserialize)]
 #[serde(tag = "type")]
 pub enum NewUserServerMessages {
-    RegisterResponse { username: String, token: String },
+    RegisterResponse,
-    HostRegisterResponse { username: String, token: String },
+    HostRegisterResponse,
 }
 
 #[derive(Default)]
 pub struct LoginScreen {
-    new_username: String,
-    new_room_code: String,
     sent_join: bool,
-    sent_host: bool,
+    retry_time: f64,
-    retry_count: usize,
-    error_msg: bool,
 }
 
 impl Screen for LoginScreen {
     fn handle_frame(&mut self, ctx: &mut Context) {
         clear_background(BEIGE);
 
-        let group_size = Vec2::new(window_width(), screen_height() * 0.05);
+        let txt_size = measure_text("Starting up...", None, FontSize::Large.size(), 1.0);
-        let window_size = Vec2::new(window_width(), screen_height() * 0.4);
 
-        let mut pressed_join = false;
+        draw_text(
-        let mut pressed_host = false;
+            "Starting up...",
-
+            screen_width() * 0.5 - txt_size.width * 0.5,
-        Window::new(
+            screen_height() * 0.5,
-            hash!("Window"),
+            FontSize::Large.size() as f32,
-            Vec2::new(
+            BLACK,
-                screen_width() * 0.5 - window_size.x * 0.5,
-                screen_height() * 0.5 - window_size.x * 0.5,
-            ),
-            window_size,
-        )
-        .movable(false)
-        .ui(&mut root_ui(), |ui| {
-            ui.group(hash!("User Group"), group_size, |ui| {
-                ui.input_text(hash!("Username In"), "Username", &mut self.new_username);
-            });
-            ui.group(hash!("Room Group"), group_size, |ui| {
-                ui.input_text(hash!("Room Code In"), "Room Code", &mut self.new_room_code);
-            });
-            ui.group(hash!("Join Group"), group_size, |ui| {
-                let dim = FontSize::Large.measure("Join");
-                if ui.button(
-                    Vec2::new(group_size.x * 0.50, 0.0) - Vec2::new(dim.width * 0.5, 0.0),
-                    "Join",
-                ) {
-                    info!(
-                        "User pressed joined with name={} room_code={}",
-                        self.new_username, self.new_room_code
         );
 
-                    pressed_join = true;
+        if !self.sent_join {
-                }
-            });
-            ui.group(hash!("Host Group"), group_size, |ui| {
-                let dim = FontSize::Large.measure("Host Game");
-                if ui.button(
-                    Vec2::new(group_size.x * 0.50, 0.0) - Vec2::new(dim.width * 0.5, 0.0),
-                    "Host Game",
-                ) {
-                    info!(
-                        "User pressed host with name={} room_code={}",
-                        self.new_username, self.new_room_code
-                    );
-
-                    pressed_host = true;
-                }
-            });
-
-            if self.error_msg {
-                ui.group(hash!("Error Group"), group_size, |ui| {
-                    ui.label(Vec2::new(0.0, 0.0), "Failed to join game, try again...");
-                });
-            }
-        });
-
-        if pressed_join {
-            ctx.send_msg(&NewUserClientMessages::Register {
-                game_code: self.new_room_code.clone(),
-                username: self.new_username.clone(),
-            });
-
             self.sent_join = true;
-        }
 
-        if pressed_host {
+            let join_msg = JoinMessage {
-            ctx.send_msg(&NewUserClientMessages::CreateRoom {
+                game_code: ctx.game_code.clone(),
-                game_code: self.new_room_code.clone(),
+                user_id: ctx.user_id,
-                username: self.new_username.clone(),
+                token: ctx.token.clone(),
-            });
+            };
 
-            self.sent_host = true;
+            let msg = match ctx.client_type {
+                crate::cfg::ClientType::Host => NewUserClientMessages::JoinAsHost(join_msg),
+                crate::cfg::ClientType::Player => NewUserClientMessages::JoinAsPlayer(join_msg),
+            };
+
+            info!("Sending join request...");
+            ctx.send_msg(&msg);
+            self.retry_time = get_time() + 2.0;
         }
     }
 
     fn handle_messages(&mut self, ctx: &mut Context) -> Option<StateTransition> {
-        if self.sent_join || self.sent_host {
+        if self.sent_join {
             let msg = ctx.recv_msg();
 
             if let Some(msg) = msg {
                 match msg {
-                    NewUserServerMessages::RegisterResponse { username, token } => {
+                    NewUserServerMessages::RegisterResponse => {
-                        ctx.username = username;
-                        ctx.token = token;
                         return Some(StateTransition::JoinAsPlayer);
                     }
-                    NewUserServerMessages::HostRegisterResponse { username, token } => {
+                    NewUserServerMessages::HostRegisterResponse => {
-                        ctx.username = username;
-                        ctx.token = token;
                         return Some(StateTransition::JoinAsHost);
                     }
                 }
             }
 
-            self.retry_count += 1;
+            if get_time() > self.retry_time {
-
-            if self.retry_count > get_fps() as usize * 5 {
                 warn!("Join failed, try again...");
-                self.retry_count = 0;
                 self.sent_join = false;
-                self.error_msg = true;
             }
         }
 

frontend/src/main.rs

@@ -1,3 +1,4 @@
+use cfg::Cfg;
 use context::Context;
 use font::FontSize;
 use host_screen::HostScreen;
@@ -9,6 +10,9 @@ use macroquad::{
 use player_screen::PlayerScreen;
 use screen::Screen;
 
+use crate::util::get_ws_url;
+
+mod cfg;
 mod context;
 mod font;
 mod host_screen;
@@ -17,6 +21,7 @@ mod model;
 mod player_screen;
 mod screen;
 mod ui_scaling;
+mod util;
 
 pub enum State {
     Init,
@@ -98,7 +103,9 @@ pub fn default_skin() -> Skin {
 
 #[macroquad::main("Play of the Game")]
 async fn main() {
-    let mut context = Context::new("ws://127.0.0.1:8080/ws");
+    let cfg = Cfg::load_from_cookies().unwrap();
+
+    let mut context = Context::new(&get_ws_url(), cfg);
 
     let mut state = State::Init;
     state.transition_state(StateTransition::Init);

frontend/src/player_screen.rs

@@ -5,6 +5,7 @@ use crate::StateTransition;
 use crate::context::Context;
 use crate::font::FontSize;
 use crate::screen::Screen;
+use crate::util::refresh_page;
 use macroquad::prelude::*;
 
 #[derive(Serialize, Debug)]
@@ -19,6 +20,7 @@ pub enum PlayerServerMessages {
     Ack,
     UpdatePointTotal { score: i32 },
     ResetBuzzer,
+    ExitGame,
 }
 
 #[derive(Default)]
@@ -45,6 +47,10 @@ impl Screen for PlayerScreen {
                     info!("Score updated to: {}", score);
                     self.score = score;
                 }
+                PlayerServerMessages::ExitGame => {
+                    info!("Exiting Game");
+                    refresh_page();
+                }
             }
         }
 

frontend/src/util.rs

@@ -0,0 +1,26 @@
+use macroquad::prelude::info;
+
+pub fn refresh_page() {
+    let location = web_sys::window()
+        .unwrap()
+        .document()
+        .unwrap()
+        .location()
+        .unwrap();
+
+    location.reload().unwrap();
+}
+
+pub fn get_ws_url() -> String {
+    let location = web_sys::window().unwrap().location();
+
+    info!("Current protocol: {:?}", location.protocol().unwrap());
+
+    let protocol = if location.protocol().unwrap() == "https:" {
+        "wss"
+    } else {
+        "ws"
+    };
+
+    format!("{}://{}/ws", protocol, location.host().unwrap())
+}