library

game.rs (16025B)

---

 use std::{
     collections::HashMap,
     fmt::Display,
     io::Write,
     time::{Duration, SystemTime},
 };
 
 use anyhow::{Result, anyhow};
 use lazy_static::lazy_static;
 use macroquad::{
     math::{Rect, Vec2},
     rand::{rand, srand},
 };
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 lazy_static! {
     pub static ref BOOKS: BookDatabase =
         BookDatabase::from_csv(include_str!("../assets/books.csv"))
             .expect("Failed to parse book database");
 }
 
 pub const TICK_DURATION: Duration = Duration::from_micros(16_667);
 
 pub type BookId = Uuid;
 pub type Players = HashMap<Uuid, Player>;
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub struct GameState {
     timestamp: SystemTime,
     players: Players,
     bookshelves: Vec<Bookshelf>,
     floor_books: Vec<FloorBook>,
 }
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub enum Update {
     InsertPlayer { id: Uuid, player: Player },
     RemovePlayer { player_id: Uuid },
 }
 
 /// Equivalent to [macroquad::math::Rect::overlaps], except using strict comparison (i.e., `<` and
 /// `>` instead of `<=` and `>=`)
 fn rects_strictly_overlap(a: &Rect, b: &Rect) -> bool {
     a.left() < b.right() && a.right() > b.left() && a.top() < b.bottom() && a.bottom() > b.top()
 }
 
 impl GameState {
     pub const MAX_PLAYER_SPEED_PX_S: f32 = 75.;
 
     pub fn update(&mut self, update: &Update) {
         match update {
             Update::InsertPlayer { id, player } => self.players.insert(*id, player.clone()),
             Update::RemovePlayer { player_id } => self.players.remove(player_id),
         };
     }
     pub fn apply(&mut self, action: &Action) {
         match action.kind() {
             ActionKind::Join { name } => {
                 self.players.insert(action.player_id, Player::new(name));
             }
             ActionKind::Move { new_position } => {
                 if let Some(player) = self.players.get_mut(&action.player_id)
                     && let Ok(dt) = action.timestamp.duration_since(player.timestamp)
                 {
                     let velocity = (new_position - player.position) / dt.as_secs_f32();
                     let limited_velocity = if velocity.length() > GameState::MAX_PLAYER_SPEED_PX_S {
                         velocity.normalize() * GameState::MAX_PLAYER_SPEED_PX_S
                     } else {
                         velocity
                     };
                     player.position += limited_velocity * dt.as_secs_f32();
 
                     // Handle collisions with bookshelves
                     let player_collider = player.collider.rect().offset(player.position);
                     for bookshelf in self.bookshelves.iter() {
                         // If the player's movement would cause their collider to intersect with a
                         // bookshelf's collider, then compute the minimum axis-aligned motion
                         // required to make them touch but not intersect
                         let bookshelf_collider: Rect = bookshelf.bounds.into();
                         let (a, b) = (bookshelf_collider, player_collider);
                         if rects_strictly_overlap(&a, &b) {
                             // Compute the required motion in each possible direction and select the
                             // smallest among them
                             let up = Vec2::new(0., a.top() - b.bottom());
                             let down = Vec2::new(0., a.bottom() - b.top());
                             let left = Vec2::new(a.left() - b.right(), 0.);
                             let right = Vec2::new(a.right() - b.left(), 0.);
                             let min_y = if up.y.abs() < down.y.abs() { up } else { down };
                             let min_x = if right.x.abs() < left.x.abs() {
                                 right
                             } else {
                                 left
                             };
                             let min = if min_x.x.abs() < min_y.y.abs() {
                                 min_x
                             } else {
                                 min_y
                             };
                             player.position += min;
                         }
                     }
                 }
             }
         }
     }
     pub fn interpolate(
         old: &Self,
         new: &Self,
         basis: SystemTime,
         local_player_id: Option<Uuid>,
     ) -> GameState {
         let mut output = GameState::default();
         for (new_id, new_player) in new.players.iter() {
             if let Some(old_player) = old.players.get(new_id) {
                 if let Some(ref lpid) = local_player_id
                     && new_id == lpid
                 {
                     output.players.insert(*new_id, new_player.clone());
                 } else {
                     let span = new.timestamp.duration_since(old.timestamp);
                     let fraction = SystemTime::now().duration_since(basis);
                     let t = match (fraction, span) {
                         (Ok(f), Ok(s)) => (f.as_secs_f32() / s.as_secs_f32()).clamp(0., 1.),
                         _ => return new.clone(),
                     };
                     let interpolated_player = Player {
                         position: (new_player.position() - old_player.position()) * t
                             + old_player.position(),
                         ..new_player.clone()
                     };
                     output.players.insert(*new_id, interpolated_player);
                 }
             } else {
                 output.players.insert(*new_id, new_player.clone());
             }
         }
         output
     }
     pub fn get_player(&self, id: &Uuid) -> Option<&Player> {
         self.players.get(id)
     }
     pub fn get_player_mut(&mut self, id: &Uuid) -> Option<&mut Player> {
         self.players.get_mut(id)
     }
     pub fn players(&self) -> &HashMap<Uuid, Player> {
         &self.players
     }
     pub fn insert_player(&mut self, id: Uuid, player: Player) -> Option<Player> {
         self.players.insert(id, player)
     }
     pub fn remove_player(&mut self, id: &Uuid) -> Option<Player> {
         self.players.remove(id)
     }
     pub fn set_timestamp(&mut self, timestamp: SystemTime) {
         self.timestamp = timestamp;
     }
     pub fn get_timestamp(&self) -> SystemTime {
         self.timestamp
     }
     pub fn update_timestamp(&mut self) {
         self.set_timestamp(SystemTime::now());
     }
     pub fn bookshelves(&self) -> &Vec<Bookshelf> {
         self.bookshelves.as_ref()
     }
     pub fn floor_books(&self) -> &Vec<FloorBook> {
         self.floor_books.as_ref()
     }
 }
 
 impl Default for GameState {
     fn default() -> Self {
         Self {
             timestamp: SystemTime::now(),
             players: HashMap::with_capacity(32),
             bookshelves: vec![
                 Bookshelf {
                     bounds: RectSerde {
                         x: -200.,
                         y: -100.,
                         w: 100.,
                         h: 500.,
                     },
                 },
                 Bookshelf {
                     bounds: RectSerde {
                         x: -400.,
                         y: -100.,
                         w: 100.,
                         h: 500.,
                     },
                 },
             ],
             floor_books: {
                 srand(0);
                 BOOKS
                     .books
                     .keys()
                     .map(|&id| FloorBook {
                         id,
                         position: Vec2::new((rand() % 750) as f32, (rand() % 750) as f32),
                         collider: Rect::new(0., 0., 30., 23.6).into(),
                     })
                     .collect()
             },
         }
     }
 }
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub struct Player {
     name: String,
     position: Vec2,
     sprite_index: SpriteIndex,
     collider: RectSerde,
     timestamp: SystemTime,
 }
 
 impl Player {
     fn new(name: String) -> Self {
         Player {
             name,
             position: Vec2::ZERO,
             sprite_index: SpriteIndex::Meeple,
             collider: RectSerde::new(0., 0., 43.4, 40.2),
             timestamp: SystemTime::now(),
         }
     }
     pub fn name(&self) -> String {
         self.name.clone()
     }
     pub fn position(&self) -> Vec2 {
         self.position
     }
     pub fn sprite_index(&self) -> SpriteIndex {
         self.sprite_index
     }
     pub fn collider(&self) -> RectSerde {
         self.collider
     }
 }
 
 #[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, PartialOrd, Serialize)]
 pub struct RectSerde {
     x: f32,
     y: f32,
     w: f32,
     h: f32,
 }
 
 impl RectSerde {
     pub fn new(x: f32, y: f32, w: f32, h: f32) -> Self {
         RectSerde { x, y, w, h }
     }
     pub fn rect(&self) -> Rect {
         (*self).into()
     }
 }
 
 impl From<Rect> for RectSerde {
     fn from(value: Rect) -> Self {
         RectSerde {
             x: value.x,
             y: value.y,
             w: value.w,
             h: value.h,
         }
     }
 }
 
 impl From<RectSerde> for Rect {
     fn from(value: RectSerde) -> Self {
         Rect::new(value.x, value.y, value.w, value.h)
     }
 }
 
 #[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, PartialOrd, Serialize)]
 pub struct Bookshelf {
     bounds: RectSerde,
 }
 
 impl Bookshelf {
     pub fn rect(&self) -> Rect {
         self.bounds.into()
     }
 }
 
 #[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize)]
 pub struct FloorBook {
     id: BookId,
     position: Vec2,
     collider: RectSerde,
 }
 
 impl FloorBook {
     pub fn id(&self) -> BookId {
         self.id
     }
     pub fn position(&self) -> Vec2 {
         self.position
     }
     pub fn collider(&self) -> RectSerde {
         self.collider
     }
 }
 
 pub struct BookDatabase {
     books: HashMap<BookId, BookMetadata>,
 }
 
 fn _csv_escape(input: &String) -> String {
     if input.contains(',') {
         format!("\"{input}\"")
     } else {
         input.clone()
     }
 }
 
 impl BookDatabase {
     const CSV_HEADER: &str = "id,title,author,publish_year";
 
     fn new() -> Self {
         BookDatabase {
             books: HashMap::new(),
         }
     }
     fn _to_csv(&self, output: &mut impl Write) -> Result<()> {
         writeln!(output, "{}", BookDatabase::CSV_HEADER)?;
         for (id, metadata) in self.books.iter() {
             let BookMetadata {
                 title,
                 author,
                 publish_year,
             } = metadata;
             writeln!(
                 output,
                 "{},{},{},{}",
                 id,
                 _csv_escape(title),
                 _csv_escape(author),
                 _csv_escape(publish_year),
             )?;
         }
         Ok(())
     }
     fn from_csv(input: &str) -> Result<Self> {
         let mut output = BookDatabase::new();
         for (line_index, line) in input.lines().enumerate() {
             if line_index == 0 {
                 if line != BookDatabase::CSV_HEADER {
                     return Err(anyhow!(
                         "Invalid CSV header: expected '{}' but got '{}'",
                         BookDatabase::CSV_HEADER,
                         line
                     ));
                 }
                 continue;
             }
             let mut fields = vec![];
             #[derive(Clone, Copy, Debug)]
             enum State {
                 Start,
                 FieldData,
                 Quote,
                 FieldEnd,
             }
             let mut state = State::Start;
             let mut new_field = String::new();
             let mut quoted_field = false;
             for c in line.chars() {
                 match (c, state) {
                     ('"', State::Start | State::FieldEnd) => {
                         quoted_field = true;
                         state = State::FieldData;
                     }
                     ('"', State::FieldData) => state = State::Quote,
                     ('"', State::Quote) => {
                         if quoted_field {
                             new_field.push('"');
                         }
                     }
                     (',', State::Start | State::FieldEnd) => state = State::FieldEnd,
                     (',', State::FieldData) => {
                         if quoted_field {
                             new_field.push(',');
                         } else {
                             state = State::FieldEnd;
                         }
                     }
                     (',', State::Quote) => {
                         if quoted_field {
                             state = State::FieldEnd;
                         }
                     }
                     (d, _) => {
                         new_field.push(d);
                         state = State::FieldData;
                     }
                 }
                 if let State::FieldEnd = state {
                     fields.push(new_field.clone());
                     new_field.clear();
                     quoted_field = false;
                 }
             }
             fields.push(new_field);
             if fields.len() != 4 {
                 return Err(anyhow!(
                     "Error on line {}: expected 4 fields but got {}",
                     line_index + 1,
                     fields.len()
                 ));
             }
             let id = fields[0].parse()?;
             let title = fields[1].clone();
             let author = fields[2].clone();
             let publish_year = fields[3].clone();
             output.books.insert(
                 id,
                 BookMetadata {
                     title,
                     author,
                     publish_year,
                 },
             );
         }
         Ok(output)
     }
     pub fn get(&self, k: &BookId) -> Option<&BookMetadata> {
         self.books.get(k)
     }
 }
 
 #[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct BookMetadata {
     title: String,
     author: String,
     publish_year: String,
 }
 
 impl Display for BookMetadata {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
             "{} by {} ({})",
             self.title, self.author, self.publish_year
         )
     }
 }
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub struct Action {
     sequence_number: u32,
     timestamp: SystemTime,
     player_id: Uuid,
     kind: ActionKind,
 }
 
 impl Action {
     pub fn new(sequence_number: u32, player_id: Uuid, kind: ActionKind) -> Self {
         Action {
             sequence_number,
             timestamp: SystemTime::now(),
             player_id,
             kind,
         }
     }
     pub fn sequence_number(&self) -> u32 {
         self.sequence_number
     }
     pub fn player_id(&self) -> Uuid {
         self.player_id
     }
     pub fn kind(&self) -> ActionKind {
         self.kind.clone()
     }
 }
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub enum ActionKind {
     Join { name: String },
     Move { new_position: Vec2 },
 }
 
 #[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
 pub enum SpriteIndex {
     Meeple,
     FloorBook,
 }
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub struct Response {
     timestamp: SystemTime,
     sequence_number: u32,
     kind: ResponseKind,
 }
 
 impl Response {
     pub fn new(timestamp: SystemTime, sequence_number: u32, kind: ResponseKind) -> Self {
         Response {
             timestamp,
             sequence_number,
             kind,
         }
     }
     pub fn timestamp(&self) -> SystemTime {
         self.timestamp
     }
     pub fn sequence_number(&self) -> u32 {
         self.sequence_number
     }
     pub fn kind(&self) -> ResponseKind {
         self.kind.clone()
     }
 }
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub enum ResponseKind {
     SetId { id: Uuid },
     UpdateGameState { updates: Vec<Update> },
     ReplaceGameState { new_game_state: GameState },
 }