joeyahines/play-of-the-game
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

session handling for players and hosts

Browse Source
This commit is contained in:
Joey Hines 2025-05-17 12:23:19 -06:00
parent fee5576efd
commit b6a4936247
Signed by: joeyahines
GPG Key ID: 38BA6F25C94C9382
11 changed files with 221 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
backend/.gitignore vendored
View File

@ -3,3 +3,4 @@
/build
erl_crash.dump
config.toml
/store

76
backend/src/app/router.gleam
View File

@ -7,6 +7,7 @@ import gleam/erlang/process
import gleam/float
import gleam/http/request.{type Request}
import gleam/http/response.{type Response}
import gleam/int
import gleam/io
import gleam/json
import gleam/list
@ -15,6 +16,10 @@ import gleam/otp/actor
import gleam/result
import gleam/string
import mist.{type Connection, type ResponseData}
import player
import player_session
import session
import storail
pub fn handle_request(
req: Request(Connection),
@ -122,8 +127,42 @@ fn handle_ws_message(state, conn, message) {
}
}
fn register_user(
ctx: web.Context,
username: String,
gamecode: 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(gamecode))
|> crypto.digest
let token_hash =
crypto.new_hasher(crypto.Sha512)
|> crypto.hash_chunk(token)
|> crypto.digest
|> bit_array.base64_encode(True)
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:),
)
let token = bit_array.base64_encode(token, True)
#(token, user_id)
}
fn handle_client_msg(
_ctx: web.Context,
ctx: web.Context,
req: web.ClientRequest,
) -> web.GameResponse {
case req.msg {
@ -131,25 +170,30 @@ fn handle_client_msg(
io.println("Got buzz in @ " <> float.to_string(time))
web.AckBuzzer
}
web.Register(username, gamecode) -> {
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(gamecode))
|> crypto.digest
web.Register(gamecode, username) -> {
let #(token, user_id) = register_user(ctx, username, gamecode)
let key = storail.key(ctx.sessions, gamecode)
let assert Ok(session) = storail.read(key)
let token_hash =
crypto.new_hasher(crypto.Sha512)
|> crypto.hash_chunk(token)
|> crypto.digest
let player = player.Player(name: username, id: user_id, score: 0)
let session =
session.Session(
..session,
players: list.append(session.players, [player]),
)
io.println("New token: " <> bit_array.base64_encode(token_hash, True))
let token = bit_array.base64_encode(token, True)
let assert Ok(Nil) = storail.write(key, session)
web.JoinResponse(username, token)
}
web.CreateRoom(gamecode, username) -> {
let #(token, user_id) = register_user(ctx, username, gamecode)
let key = storail.key(ctx.sessions, gamecode)
let session = session.Session(gamecode, user_id, [])
let assert Ok(Nil) = storail.write(key, session)
web.HostResponse(username, token)
}
}
}

41
backend/src/app/web.gleam
View File

@ -2,15 +2,39 @@ import config
import gleam/dynamic/decode
import gleam/erlang/process
import gleam/json
import player_session
import session
import storail
pub type ClientMessage {
BuzzIn(time: Float)
Register(game_code: String, username: String)
CreateRoom(game_code: String, username: String)
}
fn client_message_decoder() -> decode.Decoder(ClientMessage) {
pub fn encode_client_message(client_message: ClientMessage) -> json.Json {
case client_message {
BuzzIn(..) ->
json.object([
#("type", json.string("buzz_in")),
#("time", json.float(client_message.time)),
])
Register(..) ->
json.object([
#("type", json.string("register")),
#("game_code", json.string(client_message.game_code)),
#("username", json.string(client_message.username)),
])
CreateRoom(..) ->
json.object([
#("type", json.string("create_room")),
#("game_code", json.string(client_message.game_code)),
#("username", json.string(client_message.username)),
])
}
}
pub fn client_message_decoder() -> decode.Decoder(ClientMessage) {
use variant <- decode.field("type", decode.string)
case variant {
"BuzzIn" -> {
@ -22,7 +46,12 @@ fn client_message_decoder() -> decode.Decoder(ClientMessage) {
use username <- decode.field("username", decode.string)
decode.success(Register(game_code:, username:))
}
_ -> decode.failure(BuzzIn(time: 0.0), "ClientMessage")
"CreateRoom" -> {
use game_code <- decode.field("game_code", decode.string)
use username <- decode.field("username", decode.string)
decode.success(CreateRoom(game_code:, username:))
}
_ -> decode.failure(BuzzIn(0.0), "ClientMessage")
}
}
@ -38,6 +67,7 @@ pub fn client_request_decoder() -> decode.Decoder(ClientRequest) {
pub type GameResponse {
JoinResponse(username: String, token: String)
HostResponse(username: String, token: String)
AckBuzzer
ResetBuzzer
UpdatePointTotal(score: Int)
@ -51,6 +81,12 @@ pub fn encode_game_response(game_response: GameResponse) -> json.Json {
#("username", json.string(game_response.username)),
#("token", json.string(game_response.token)),
])
HostResponse(..) ->
json.object([
#("type", json.string("HostResponse")),
#("username", json.string(game_response.username)),
#("token", json.string(game_response.token)),
])
AckBuzzer -> json.object([#("type", json.string("AckBuzzer"))])
ResetBuzzer -> json.object([#("type", json.string("ResetBuzzer"))])
UpdatePointTotal(..) ->
@ -65,6 +101,7 @@ pub type Context {
Context(
config: config.Config,
sessions: storail.Collection(session.Session),
player_sessions: storail.Collection(player_session.PlayerSession),
selector: process.Selector(ClientRequest),
)
}

13
backend/src/backend.gleam
View File

@ -6,6 +6,7 @@ import gleam/erlang/process
import gleam/result
import glint
import mist
import player_session
import session
import storail
@ -30,6 +31,17 @@ pub fn setup_session_collection(
)
}
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()
@ -52,6 +64,7 @@ pub fn run_server() -> glint.Command(Result(Nil, Error)) {
web.Context(
config: cfg,
sessions: setup_session_collection(storail_cfg),
player_sessions: setup_player_session_collection(storail_cfg),
selector: process.new_selector(),
)

31
frontend/src/host_screen.rs Normal file
View File

@ -0,0 +1,31 @@
use macroquad::{
color::{BLACK, WHITE},
text::draw_text,
window::{clear_background, screen_height, screen_width},
};
use crate::screen::Screen;
#[derive(Default)]
pub struct HostScreen {}
impl Screen for HostScreen {
fn handle_frame(&mut self, _ctx: &mut crate::context::Context) {
clear_background(WHITE);
draw_text(
"I'm the host!",
screen_width() / 2.0,
screen_height() / 2.0,
100.0,
BLACK,
);
}
fn handle_messages(
&mut self,
_ctx: &mut crate::context::Context,
) -> Option<crate::StateTransition> {
None
}
}

44
frontend/src/login_screen.rs
View File

@ -11,6 +11,7 @@ pub struct LoginScreen {
new_username: String,
new_room_code: String,
sent_join: bool,
sent_host: bool,
retry_count: usize,
error_msg: bool,
}
@ -23,6 +24,8 @@ impl Screen for LoginScreen {
let window_size = Vec2::new(screen_width() * 0.25, screen_height() * 0.25);
let mut pressed_join = false;
let mut pressed_host = false;
root_ui().window(
hash!("Window"),
Vec2::new(
@ -47,6 +50,16 @@ impl Screen for LoginScreen {
pressed_join = true;
}
});
ui.group(hash!("Host Group"), group_size, |ui| {
if ui.button(Vec2::new(group_size.x * 0.45, 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| {
@ -64,16 +77,37 @@ impl Screen for LoginScreen {
self.sent_join = true;
}
if pressed_host {
ctx.send_msg(&ClientMessage::CreateRoom(Register {
game_code: self.new_room_code.clone(),
username: self.new_username.clone(),
}));
self.sent_host = true;
}
}
fn handle_messages(&mut self, ctx: &mut Context) -> Option<StateTransition> {
if self.sent_join {
if self.sent_join || self.sent_host {
let msg = ctx.recv_msg();
if let Some(GameResponse::JoinResponse { username, token }) = msg {
ctx.username = username;
ctx.token = token;
return Some(StateTransition::JoinAsPlayer);
if let Some(msg) = msg {
match msg {
GameResponse::JoinResponse { username, token } => {
ctx.username = username;
ctx.token = token;
return Some(StateTransition::JoinAsPlayer);
}
GameResponse::HostResponse { username, token } => {
ctx.username = username;
ctx.token = token;
return Some(StateTransition::JoinAsHost);
}
_ => {
warn!("Got unexpected message: {:?}", msg)
}
}
}
self.retry_count += 1;

9
frontend/src/main.rs
View File

@ -1,10 +1,12 @@
use context::Context;
use host_screen::HostScreen;
use login_screen::LoginScreen;
use macroquad::prelude::*;
use player_screen::PlayerScreen;
use screen::Screen;
mod context;
mod host_screen;
mod login_screen;
mod model;
mod player_screen;
@ -14,15 +16,18 @@ pub enum State {
Init,
Login(LoginScreen),
PlayerScreen(PlayerScreen),
HostScreen(HostScreen),
}
impl State {
pub fn transition_state(&self, transition: StateTransition) -> Self {
info!("Applying transition: {:?}", transition);
match transition {
StateTransition::Init | StateTransition::LeaveGame => {
Self::Login(LoginScreen::default())
}
StateTransition::JoinAsPlayer => Self::PlayerScreen(PlayerScreen::default()),
StateTransition::JoinAsHost => Self::HostScreen(HostScreen::default()),
}
}
@ -31,6 +36,7 @@ impl State {
Self::Init => {}
Self::Login(login_screen) => login_screen.handle_frame(ctx),
Self::PlayerScreen(player_screen) => player_screen.handle_frame(ctx),
State::HostScreen(host_screen) => host_screen.handle_frame(ctx),
}
}
@ -39,13 +45,16 @@ impl State {
Self::Init => Some(StateTransition::Init),
State::Login(login_screen) => login_screen.handle_messages(ctx),
State::PlayerScreen(player_screen) => player_screen.handle_messages(ctx),
State::HostScreen(host_screen) => host_screen.handle_messages(ctx),
}
}
}
#[derive(Debug)]
pub enum StateTransition {
Init,
JoinAsPlayer,
JoinAsHost,
LeaveGame,
}

4
frontend/src/model/mod.rs
View File

@ -10,6 +10,7 @@ pub mod register;
pub enum ClientMessage {
BuzzIn(BuzzIn),
Register(Register),
CreateRoom(Register),
}
#[derive(Debug, Serialize)]
@ -22,7 +23,8 @@ pub struct ClientRequest {
#[serde(tag = "type")]
pub enum GameResponse {
JoinResponse { username: String, token: String },
HostResponse { username: String, token: String },
AckBuzzer,
ResetBuzzer,
UpdatePountTotal { score: i32 },
UpdatePointTotal { score: i32 },
}

3
frontend/src/player_screen.rs
View File

@ -28,10 +28,11 @@ impl Screen for PlayerScreen {
info!("Button press reset");
self.button_pressed = false;
}
crate::model::GameResponse::UpdatePountTotal { score } => {
crate::model::GameResponse::UpdatePointTotal { score } => {
info!("Score updated to: {}", score);
self.score = score;
}
_ => {}
}
}

21
shared/src/player_session.gleam Normal file
View File

@ -0,0 +1,21 @@
import gleam/dynamic/decode
import gleam/json
pub type PlayerSession {
PlayerSession(id: Int, token_hash: String, username: String)
}
pub fn encode_player_session(player_session: PlayerSession) -> json.Json {
json.object([
#("id", json.int(player_session.id)),
#("token_hash", json.string(player_session.token_hash)),
#("username", json.string(player_session.username)),
])
}
pub fn player_session_decoder() -> decode.Decoder(PlayerSession) {
use id <- decode.field("id", decode.int)
use token_hash <- decode.field("token_hash", decode.string)
use username <- decode.field("username", decode.string)
decode.success(PlayerSession(id:, token_hash:, username:))
}

6
shared/src/session.gleam
View File

@ -4,12 +4,12 @@ import gleam/list
import player
pub type Session {
Session(id: Int, host_user_id: Int, players: List(player.Player))
Session(id: String, host_user_id: Int, players: List(player.Player))
}
pub fn serialize(session: Session) -> json.Json {
json.object([
#("id", json.int(session.id)),
#("id", json.string(session.id)),
#("host_user_id", json.int(session.host_user_id)),
#(
"players",
@ -22,7 +22,7 @@ pub fn serialize(session: Session) -> json.Json {
}
pub fn decoder() -> decode.Decoder(Session) {
use id <- decode.field("id", decode.int)
use id <- decode.field("id", decode.string)
use host_user_id <- decode.field("host_user_id", decode.int)
use players <- decode.field("players", decode.list(player.decoder()))