library

book.rs (8258B)

---

 use std::{
     collections::{HashMap, hash_map::Keys},
     fmt::{Display, Write},
     slice::Iter,
 };
 
 use anyhow::{Result, anyhow};
 use lazy_static::lazy_static;
 use macroquad::math::{Rect, Vec2};
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 use crate::game::RectSerde;
 
 lazy_static! {
     pub static ref BOOKS: BookDatabase =
         BookDatabase::from_csv(include_str!("../../assets/books.csv"))
             .expect("Failed to parse book database");
 }
 
 pub type BookId = Uuid;
 pub type BookshelfId = Uuid;
 
 #[derive(
     Clone, Copy, Debug, Default, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize,
 )]
 pub struct SlotAddress {
     bookshelf_id: BookshelfId,
     shelf_index: usize,
     position: usize,
 }
 
 impl SlotAddress {
     pub fn new(bookshelf_id: BookshelfId, shelf_index: usize, position: usize) -> Self {
         SlotAddress {
             bookshelf_id,
             shelf_index,
             position,
         }
     }
     pub fn bookshelf_id(&self) -> BookshelfId {
         self.bookshelf_id
     }
     pub fn shelf_index(&self) -> usize {
         self.shelf_index
     }
     pub fn position(&self) -> usize {
         self.position
     }
 }
 
 #[derive(
     Clone, Copy, Debug, Default, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize,
 )]
 pub enum Slot {
     Book {
         book_id: BookId,
     },
     #[default]
     Empty,
 }
 
 #[derive(Clone, Debug, Default, Deserialize, PartialEq, PartialOrd, Serialize)]
 pub struct Bookshelf {
     bounds: RectSerde,
     shelves: Vec<Vec<Slot>>,
 }
 
 impl Bookshelf {
     pub const BOOK_WIDTH: f32 = 10.;
     pub const BOOK_HEIGHT: f32 = 30.;
     pub const FRAME_THICKNESS: f32 = 4.;
     pub const SHELF_THICKNESS: f32 = 4.;
     pub(crate) fn new(position: Vec2, shelf_count: usize, books_per_shelf: usize) -> Self {
         Self {
             bounds: Rect::new(
                 position.x,
                 position.y,
                 books_per_shelf as f32 * Self::BOOK_WIDTH + Self::FRAME_THICKNESS * 2.,
                 shelf_count as f32 * Self::BOOK_HEIGHT
                     + shelf_count.saturating_sub(1) as f32 * Self::SHELF_THICKNESS
                     + Self::FRAME_THICKNESS * 2.,
             )
             .into(),
             shelves: vec![vec![Slot::Empty; books_per_shelf]; shelf_count],
         }
     }
     pub fn rect(&self) -> Rect {
         self.bounds.into()
     }
     pub fn iter(&self) -> Iter<'_, Vec<Slot>> {
         self.shelves.iter()
     }
     pub fn shelf_count(&self) -> usize {
         self.shelves.len()
     }
     pub fn get_shelf_mut(&mut self, index: usize) -> Option<&mut Vec<Slot>> {
         self.shelves.get_mut(index)
     }
     pub fn get_slot(&self, slot_address: &SlotAddress) -> Option<&Slot> {
         if let Some(shelf) = self.shelves.get(slot_address.shelf_index) {
             shelf.get(slot_address.position)
         } else {
             None
         }
     }
     pub fn get_slot_mut(&mut self, slot_address: &SlotAddress) -> Option<&mut Slot> {
         if let Some(shelf) = self.shelves.get_mut(slot_address.shelf_index) {
             shelf.get_mut(slot_address.position)
         } else {
             None
         }
     }
 }
 
 #[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize)]
 pub struct FloorBook {
     id: BookId,
     position: Vec2,
     collider: RectSerde,
 }
 
 impl FloorBook {
     pub(crate) fn new(id: BookId, position: Vec2, collider: Rect) -> Self {
         Self {
             id,
             position,
             collider: collider.into(),
         }
     }
     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(),
         }
     }
     pub(crate) fn keys(&self) -> Keys<'_, BookId, BookMetadata> {
         self.books.keys()
     }
     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
         )
     }
 }