rocalc 0.3.1

一款用于计算洛克王国：世界精灵对决的Rust库
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

use crate::core::*;

/// 创建精灵实体
///
/// 定义精灵的性格、种族值和个体值，用于计算精灵的面板数值
/// 下面使用 **new** 方法创建一个 Tri 实例，并展示如何利用已创建的 Tri 实例和 **cor** 方法来计算精灵的面板数值
#[derive(Debug, Copy, Clone)]
pub struct Tri {
    pub car: Car,               // 性格
    pub rac: Six,               // 种族值
    pub ind: [(Panel, f32); 3], // 固定三个个体值
}

impl Tri {
    /// 创建Tri实例
    ///
    /// new接受性格、种族值和个体值作为参数
    ///
    /// # Example
    ///
    /// ```rust
    /// use rocalc::*;
    ///
    /// let wolf_rac = get_race_value("恶魔狼王", "your_path.csv").unwrap();
    /// const wolf_ind: [(Panel, f32); 3] = [
    ///     (Panel::Hp, 10.0),
    ///     (Panel::Spd, 10.0),
    ///     (Panel::Atk, 10.0),
    /// ];
    /// let mut wolf_tri = Tri::new(rocalc::Car::Sanguine, &wolf_rac, &wolf_ind);
    /// ```
    ///
    pub fn new(car: Car, rac: &Six, ind: &[(Panel, f32); 3]) -> Self {
        Self {
            car,
            rac: *rac,
            ind: *ind,
        }
    }

    /// 依次进行种族值修正、个体值修正、性格修正和常数修正，得到最终的面板数值
    ///
    /// # Example
    ///
    /// ```rust
    /// # use rocalc::*;
    /// #
    /// # let wolf_rac = get_race_value("恶魔狼王", "your_path.csv").unwrap();
    /// # const wolf_ind: [(Panel, f32); 3] = [
    /// #     (Panel::Hp, 10.0),
    /// #     (Panel::Spd, 10.0),
    /// #     (Panel::Atk, 10.0),
    /// # ];
    /// # let mut wolf_tri = Tri::new(rocalc::Car::Sanguine, &wolf_rac, &wolf_ind);
    /// let wolf_panel = wolf_tri.cor(); // 恶魔狼王的面板数值
    /// ```
    pub fn cor(&self) -> Six {
        //        let mut dest_panel: Six = self.rac.clone();
        let mut dest_panel: Six = self.rac;
        self.rac_cor(&mut dest_panel);
        self.ind_cor(&mut dest_panel);
        self.car_cor(&mut dest_panel);
        self.con_cor(&mut dest_panel);
        dest_panel
    }

    /// 种族值修正
    fn rac_cor(&self, panel: &mut Six) {
        macro_rules! cor_panel {
            ( $($field:ident),* ) => {
                $(
                    //self.rac.$field = 1.1 * self.rac.$field + 10.0;
                    panel.$field = 1.1 * panel.$field + 10.0;
                )*
            };
        }

        //self.rac.hp = 1.7 * self.rac.hp + 70.0;
        panel.hp = 1.7 * panel.hp + 70.0;
        cor_panel!(atk, dfe, m_atk, m_dfe, spd);
    }

    /// 个体值修正
    fn ind_cor(&self, panel: &mut Six) {
        for (ind_type, value) in &self.ind {
            match ind_type {
                Panel::Hp => panel.hp += value * 6.0 * 0.85,
                Panel::Atk => panel.atk += value * 6.0 * 0.55,
                Panel::MAtk => panel.m_atk += value * 6.0 * 0.55,
                Panel::Dfe => panel.dfe += value * 6.0 * 0.55,
                Panel::MDfe => panel.m_dfe += value * 6.0 * 0.55,
                Panel::Spd => panel.spd += value * 6.0 * 0.55,
            }
        }
    }

    /// 性格修正
    fn car_cor(&self, panel: &mut Six) {
        //let keys = get_key(&self.car);
        let keys = &self.car.get_key();
        {
            let plus = get_field_mut(panel, keys[0]);
            if let Some(p) = plus {
                *p *= 1.2;
            }
        }

        let sub = get_field_mut(panel, keys[1]);
        if let Some(s) = sub {
            *s *= 0.9;
        }
    }

    /// 常数修正
    fn con_cor(&self, panel: &mut Six) {
        macro_rules! apply_to_all {
           ( $($field:ident),* ) => {
               $(
                   panel.$field += 50.0;
               )*
           };
       }
        panel.hp += 100.0;
        apply_to_all!(atk, dfe, m_atk, m_dfe, spd);
    }
}