working gameplay loop, better UI. Needs a bit of work

backend/src/app/router.gleam

@@ -100,6 +100,7 @@ fn handle_ws_message(
       actor.continue(state)
     }
     mist.Custom(resp) -> {
+      echo resp
       let assert Ok(_) = mist.send_text_frame(conn, resp)
       actor.continue(state)
     }

backend/src/app/web.gleam

@@ -11,6 +11,7 @@ import gleam/int
 import gleam/io
 import gleam/json
 import gleam/list
+import gleam/option.{None, Some}
 import gleam/otp/actor
 import player
 import player_session
@@ -53,6 +54,32 @@ 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,
@@ -69,6 +96,9 @@ fn handle_player(
         <> " at "
         <> float.to_string(time),
       )
+
+      set_buzz_in(socket_state, player_state, time)
+
       #(
         socket_state,
         json.to_string(player_client.encode_player_server_messages(
@@ -143,13 +173,20 @@ fn handle_new_user(
       let key = storail.key(socket_state.ctx.sessions, game_code)
       let assert Ok(session) = storail.read(key)
 
-      let player = player.Player(name: username, id: user_id, score: 0)
+      let player =
+        player.Player(name: username, id: user_id, score: 0, buzz_in_time: None)
       let session =
         session.Session(
           ..session,
           players: dict.insert(session.players, player.id, player),
         )
 
+      send_message_to_host(
+        socket_state,
+        session.host_user_id,
+        host_client.UpdatePlayerStates(session.players),
+      )
+
       let assert Ok(Nil) = storail.write(key, session)
 
       #(
@@ -157,7 +194,7 @@ fn handle_new_user(
           ..socket_state,
           state: Player(player_client.PlayerState(user_id, game_code)),
         ),
-        new_user_client.RegisterResponse(token, username),
+        new_user_client.RegisterResponse(username, token),
       )
     }
   }
@@ -212,6 +249,41 @@ fn send_message_to_player(
   |> 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,
@@ -225,6 +297,11 @@ fn handle_host(
 
   let #(socket_state, resp) = case msg {
     host_client.ResetAllBuzers -> {
+      dict.to_list(session.players)
+      |> list.each(fn(player_entry) {
+        reset_player_buzzer(socket_state, session_key, player_entry.0)
+      })
+
       broadcast_message_to_players(
         socket_state,
         session,
@@ -233,12 +310,13 @@ fn handle_host(
       #(socket_state, host_client.Ack)
     }
     host_client.ResetPlayerBuzzer(id) -> {
+      reset_player_buzzer(socket_state, session_key, id)
       send_message_to_player(socket_state, id, player_client.ResetBuzzer)
       #(socket_state, host_client.Ack)
     }
     host_client.UpdateScore(id, score) -> {
       let assert Ok(player) = dict.get(session.players, id)
-      let player = player.Player(..player, score:)
+      let player = player.Player(..player, score: player.score + score)
       let session =
         session.Session(
           ..session,
@@ -252,6 +330,12 @@ fn handle_host(
         player_client.UpdatePointTotal(player.score),
       )
 
+      send_message_to_host(
+        socket_state,
+        session.host_user_id,
+        host_client.UpdatePlayerStates(session.players),
+      )
+
       #(socket_state, host_client.Ack)
     }
   }