BillySheet-Rust/src/sheet.rs

use eframe::egui::widgets::DragValue;
use eframe::egui::Ui;
use serde::{Deserialize, Serialize};
use std::io::Write as _;

use crate::gui::SheetGui;

#[derive(Debug, Serialize, Deserialize)]
pub enum Classe {
    Warrior,
    Cautious,
    Farmer,
    Resourceful,
}

#[derive(Debug, Serialize, Deserialize)]
enum CharacteristicType {
    Address,
    Stamina,
    Luck,
    Skill,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CharacterSheet {
    character_class: Classe,
    /// Field to write the personality/
    pub character: String,
    address: Characteristic,
    stamina: Characteristic,
    luck: Characteristic,
    skill: Characteristic,
    health: u32,
    armor: u32,
    damage: u32,
    glory: u32,
    money: u32,
}

pub fn write_sheet(path: &std::path::Path, sheet: &CharacterSheet) -> std::io::Result<()> {
    let sheet_str = serde_json::to_string_pretty(&sheet)?;
    let mut file = std::fs::File::create(path)?;
    write!(file, "{}", sheet_str)
}

impl CharacterSheet {
    pub fn character_class(&self) -> &Classe {
        &self.character_class
    }
    pub fn character(&self) -> &str {
        &self.character
    }
    pub fn address(&self) -> &Characteristic {
        &self.address
    }
    pub fn stamina(&self) -> &Characteristic {
        &self.stamina
    }
    pub fn luck(&self) -> &Characteristic {
        &self.luck
    }
    pub fn skill(&self) -> &Characteristic {
        &self.skill
    }
    pub fn health(&self) -> u32 {
        self.health
    }
    pub fn armor(&self) -> u32 {
        self.armor
    }
    pub fn damage(&self) -> u32 {
        self.damage
    }
    pub fn glory(&self) -> u32 {
        self.glory
    }
    pub fn money(&self) -> u32 {
        self.money
    }
}

impl SheetGui for CharacterSheet {
    fn shortcut(
        &self,
        ui: &mut Ui,
        category: &str,
        character_field: &Characteristic,
    ) -> (u32, u32, u32) {
        let mut base = character_field.base;
        let mut carac = character_field.carac;
        let mut materiel = character_field.materiel;
        ui.heading(category);
        ui.horizontal(|ui| {
            ui.label("Base");
            ui.add(DragValue::new(&mut base));
        });
        ui.horizontal(|ui| {
            ui.label("Carac.");
            ui.add(DragValue::new(&mut carac));
        });
        ui.horizontal(|ui| {
            ui.label("Matériel");
            ui.add(DragValue::new(&mut materiel));
        });
        (base, carac, materiel)
    }

    fn gui_address(&mut self, ui: &mut Ui) {
        let workaround = self as &CharacterSheet;
        (self.address.base, self.address.carac, self.address.materiel) =
            self.shortcut(ui, "Adresse", workaround.address());
        ui.label("Ne peut dépasser 5");
    }

    fn gui_stamina(&mut self, ui: &mut Ui) {
        let workaround = self as &CharacterSheet;
        (self.stamina.base, self.stamina.carac, self.stamina.materiel) =
            self.shortcut(ui, "Endurance", workaround.stamina());
    }

    fn gui_luck(&mut self, ui: &mut Ui) {
        let workaround = self as &CharacterSheet;
        (self.luck.base, self.luck.carac, self.luck.materiel) =
            self.shortcut(ui, "Chance", workaround.luck());
    }

    fn gui_skill(&mut self, ui: &mut Ui) {
        let workaround = self as &CharacterSheet;
        (self.skill.base, self.skill.carac, self.skill.materiel) =
            self.shortcut(ui, "Habileté", workaround.skill());
    }

    fn secondary_stats(&mut self, ui: &mut Ui) {
        let workaround = self as &CharacterSheet;
        let mut damage = workaround.damage;
        let mut armor = workaround.armor;

        ui.heading("Stat. secondaires");
        ui.horizontal(|ui| {
            ui.label("Dégâts");
            ui.add(DragValue::new(&mut damage));
        });

        ui.horizontal(|ui| {
            ui.label("Armure");
            ui.add(DragValue::new(&mut armor));
        });
        ui.label("Critique");
    }
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Characteristic {
    characteristic_type: CharacteristicType,
    pub base: u32,
    pub carac: u32,
    pub materiel: u32,
    pub additional: u32,
}

impl Default for CharacterSheet {
    fn default() -> Self {
        Self {
            character_class: Classe::Warrior,
            character: "Billy".to_string(),
            address: Characteristic {
                characteristic_type: CharacteristicType::Address,
                base: 0,
                carac: 0,
                materiel: 0,
                additional: 1,
            },
            stamina: Characteristic {
                characteristic_type: CharacteristicType::Stamina,
                base: 2,
                carac: 0,
                materiel: 0,
                additional: 0,
            },
            luck: Characteristic {
                characteristic_type: CharacteristicType::Luck,
                base: 3,
                carac: 0,
                materiel: 0,
                additional: 0,
            },
            skill: Characteristic {
                characteristic_type: CharacteristicType::Skill,
                base: 2,
                carac: 0,
                materiel: 0,
                additional: 0,
            },
            health: 0,
            armor: 0,
            damage: 0,
            glory: 0,
            money: 0,
        }
    }
}