gamemstr-common 0.1.0

Common code for the gamemstr project
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use core::fmt;

use serde::{Deserialize, Serialize};

use crate::{creature::Creature, item::Item, spell::Spell, world::campaign::Campaign};

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Player {
    pub creature: Creature,
    pub race: Race,
    pub class: Class,
    pub level: u8,
    pub experience: u32,
    pub inventory: Vec<Item>,
    pub spells: Vec<Spell>,
    pub campaign: Campaign,
}

impl Player {
    pub fn new(
        creature: Creature,
        race: Race,
        class: Class,
        level: u8,
        experience: u32,
        campaign: Campaign,
    ) -> Self {
        Self {
            creature,
            race,
            class,
            level,
            experience,
            inventory: Vec::new(),
            spells: Vec::new(),
            campaign,
        }
    }
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum Race {
    Human,
    Elf,
    Dwarf,
    Halfling,
    Gnome,
    HalfElf,
    HalfOrc,
    Tiefling,
}

impl fmt::Display for Race {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub enum Class {
    Barbarian,
    Bard,
    Cleric,
    Druid,
    Fighter,
    Monk,
    Paladin,
    Ranger,
    Rogue,
    Sorcerer,
    Warlock,
    Wizard,
}

impl fmt::Display for Class {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}

#[derive(Serialize, Deserialize, Debug)]
pub struct PlayerRequest {
    pub creature: Option<Creature>,
    pub race: Option<Race>,
    pub class: Option<Class>,
    pub level: Option<u8>,
    pub experience: Option<u32>,
    pub inventory: Option<Vec<Item>>,
    pub spells: Option<Vec<Spell>>,
    pub campaign: Option<Campaign>,
}

impl PlayerRequest {
    pub fn to_player(&self) -> Option<Player> {
        match &self.creature {
            Some(creature) => Some(Player {
                creature: creature.clone(),
                race: self.race.clone().expect("no race provided"),
                class: self.class.clone().expect("no class provided"),
                level: self.level.expect("no level provided"),
                experience: self.experience.expect("no experience provided"),
                inventory: self.inventory.clone().expect("no inventory provided"),
                spells: self.spells.clone().expect("no spells provided"),
                campaign: self.campaign.clone().expect("no campaign provided"),
            }),
            None => None,
        }
    }
}