infinite-fusion 0.2.0

A simple crate for reading Pokemon Infinite Fusion's data
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Module for the base stats for a pokemon
//! note: u8 is opt-in since species data contains a couple entries with stats over 255.
//! If you're already doing some work to manually skip that data then opting into u8 saves a few bytes thus pushing [`BaseStats`]'s size under 8 bytes.

use serde::{Deserialize, Serialize};

// could've type aliased on "BaseStat" but that just doesn't feel as clean since it would make the API look weird and complicated in rust-analyser
// does come with the consequence i need to mirror changes between them but oh well
// also i really wanted to try out cfg_select lol
cfg_select! {
    feature = "u8_stats" => {
        #[doc = "Base stats for a given pokemon"]
        #[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Deserialize, Serialize)]
        pub struct BaseStats {
            #[serde(rename = "HP")]
            pub hp: u8,
            #[serde(rename = "ATTACK")]
            pub atk: u8,
            #[serde(rename = "DEFENSE")]
            pub def: u8,
            #[serde(rename = "SPECIAL_ATTACK")]
            pub spa: u8,
            #[serde(rename = "SPECIAL_DEFENSE")]
            pub spd: u8,
            #[serde(rename = "SPEED")]
            pub spe: u8,
        }

        impl BaseStats {
            pub fn hp(&self) -> u8 {
                self.hp
            }

            pub fn atk(&self) -> u8 {
                self.atk
            }

            pub fn def(&self) -> u8 {
                self.def
            }

            pub fn spa(&self) -> u8 {
                self.spa
            }

            pub fn spd(&self) -> u8 {
                self.spd
            }

            pub fn spe(&self) -> u8 {
                self.spe
            }

            pub fn bst(&self) -> u16 {
                self.hp as u16
                + self.atk as u16
                + self.def as u16
                + self.spa as u16
                + self.spd as u16
                + self.spe as u16
            }
        }

        fn fuse_calc(dominant: u8, other: u8) -> u8 {
            (((dominant as f32 * 2.0) / 3.0) + (other as f32 / 3.0)).floor() as u8
        }
    }
    _ => {
        #[doc = "Base stats for a given pokemon"]
        #[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Deserialize, Serialize)]
        pub struct BaseStats {
            #[serde(rename = "HP")]
            pub hp: u16,
            #[serde(rename = "ATTACK")]
            pub atk: u16,
            #[serde(rename = "DEFENSE")]
            pub def: u16,
            #[serde(rename = "SPECIAL_ATTACK")]
            pub spa: u16,
            #[serde(rename = "SPECIAL_DEFENSE")]
            pub spd: u16,
            #[serde(rename = "SPEED")]
            pub spe: u16,
        }

        impl BaseStats {
            pub fn hp(&self) -> u16 {
                self.hp
            }

            pub fn atk(&self) -> u16 {
                self.atk
            }

            pub fn def(&self) -> u16 {
                self.def
            }

            pub fn spa(&self) -> u16 {
                self.spa
            }

            pub fn spd(&self) -> u16 {
                self.spd
            }

            pub fn spe(&self) -> u16 {
                self.spe
            }

            pub fn bst(&self) -> u16 {
                self.hp
                + self.atk
                + self.def
                + self.spa
                + self.spd
                + self.spe
            }
        }

        fn fuse_calc(dominant: u16, other: u16) -> u16 {
            (((dominant as f32 * 2.0) / 3.0) + (other as f32 / 3.0)).floor() as u16
        }
    }
}

impl BaseStats {
    /// Fuse two sets of base stats, taking self as the head and the other as the body
    pub fn fuse(&self, body: &Self) -> BaseStats {
        // Head dominant
        let hp = fuse_calc(self.hp, body.hp);
        let spd = fuse_calc(self.spd, body.spd);
        let spa = fuse_calc(self.spa, body.spa);

        // Body dominant
        let atk = fuse_calc(body.atk, self.atk);
        let def = fuse_calc(body.def, self.def);
        let spe = fuse_calc(body.spe, self.spe);
        BaseStats {
            hp,
            atk,
            def,
            spa,
            spd,
            spe,
        }
    }
}