1
use crate::action::Action;
2
use crate::specs::{Buff, BuffState, Recipe, Stats, Success};
3
use crate::Parameters;
4
use std::fmt::{Debug, Display, Formatter};
5

            
6
#[derive(Clone)]
7
pub struct Craft<'a> {
8
    pub recipe: Recipe,
9
    pub stats: Stats,
10
    pub buffs: BuffState,
11
    pub step_count: u32,
12
    pub durability: i32,
13
    pub progression: u32,
14
    pub quality: u32,
15
    pub cp: i32,
16
    pub success: Success,
17
    pub actions: Vec<&'a Action>,
18
    pub args: Parameters,
19
}
20

            
21
impl<'a> Craft<'a> {
22
    pub fn new(recipe: Recipe, stats: Stats, params: Parameters) -> Craft<'a> {
23
        Self {
24
            recipe,
25
            stats,
26
            buffs: BuffState::default(),
27
            step_count: 0,
28
            durability: recipe.durability as i32,
29
            progression: 0,
30
            quality: 0,
31
            cp: stats.max_cp as i32,
32
            success: Success::Pending,
33
            actions: Vec::new(),
34
            args: params,
35
        }
36
    }
37

            
38
    pub fn get_base_progression(&self) -> u32 {
39
        let base_value = (self.stats.craftsmanship as f64 / 10.0)
40
            / (self.recipe.progress_divider as f64 / 100.0)
41
            + 2.0;
42
        (base_value * (self.recipe.progress_modifier as f64 / 100.0) as f64).floor() as u32
43
    }
44

            
45
    pub fn get_base_quality(&self) -> u32 {
46
        let base_value = (self.stats.control as f64 / 10.0)
47
            / (self.recipe.quality_divider as f64 / 100.0)
48
            + 35.0;
49
        (base_value * (self.recipe.quality_modifier as f64 / 100.0) as f64).floor() as u32
50
    }
51

            
52
    pub fn run_action(&mut self, action: &'a Action) -> &mut Craft<'a> {
53
        if !action.can_use(self) {
54
            self.success = Success::Failure;
55
            return self;
56
        }
57
        self.step_count += 1;
58
        self.cp -= action.get_cp_cost(self) as i32;
59
        self.durability -= action.get_durability_cost(self) as i32;
60
        self.progression += (action.get_progress(self) as f64
61
            * (self.get_base_progression() as f64 / 100.0))
62
            .floor() as u32;
63
        self.quality += (action.get_quality(self) as f64 * (self.get_base_quality() as f64 / 100.0))
64
            .floor() as u32;
65
        if self.progression >= self.recipe.progress {
66
            self.success = Success::Success;
67
        }
68
        if self.durability <= 0 {
69
            self.success = Success::Failure;
70
        }
71
        if self.buffs.manipulation > 0 {
72
            self.durability += 5;
73
        }
74
        if action.quality > 0 {
75
            self.buffs.inner_quiet += 1;
76
        }
77
        self.buffs.tick();
78
        if action.progress > 0 {
79
            self.buffs.remove(Buff::MuscleMemory);
80
        }
81
        if action.quality > 0 {
82
            self.buffs.remove(Buff::GreatStrides);
83
        }
84
        if let Some((buff, duration)) = action.get_buff() {
85
            self.buffs.apply(buff, duration);
86
        }
87
        if self.durability > self.recipe.durability as i32 {
88
            self.durability = self.recipe.durability as i32;
89
        }
90
        if self.buffs.inner_quiet > 10 {
91
            self.buffs.inner_quiet = 10;
92
        }
93

            
94
        self.actions.push(action);
95
        return self;
96
    }
97

            
98
    // Assumes the craft is finished and tries to add the last actions
99
    // pub fn add_last_actions(&mut self)->&Self{
100
    //     let arg = (self.recipe.progress as f32 - self.progression as f32) / self.get_base_progression() as f32;
101
    //     self.durability+=10;
102
    //     if 0.0 < arg && arg < 1.2 { self.run_action(&ACTIONS.basic_synthesis);}
103
    //     if 1.2 <= arg && arg < 1.8 { self.cp+=7; self.run_action(&ACTIONS.careful_synthesis); }
104
    //     if 1.8 <= arg && arg < 2.0 {
105
    //         self.cp+=12;
106
    //         self.run_action(&ACTIONS.observe);
107
    //         self.run_action(&ACTIONS.focused_synthesis);
108
    //     }
109
    //     self
110
    // }
111
}
112

            
113
impl<'a> Debug for Craft<'a> {
114
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
115
        let mut binding = f.debug_struct("");
116
        binding
117
            .field("step_count", &self.step_count)
118
            .field("progression", &format!("{:?}/{:?}", &self.progression, &self.recipe.progress))
119
            .field("quality", &format!("{:?}/{:?}", &self.quality, &self.recipe.quality))
120
            .field("durability", &format!("{:?}/{:?}", &self.durability, &self.recipe.durability))
121
            // .field("cp", &format!("{:?}/{:?}", &self.cp, &self.stats.max_cp))
122
        ;
123
        binding.field("actions", &self.actions);
124
        binding.finish()
125
    }
126
}
127

            
128
impl<'a> Display for Craft<'a> {
129
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
130
        f.debug_struct("Craft")
131
            .field("step_count", &self.step_count)
132
            .field(
133
                "progression",
134
                &format!("{:?}/{:?}", &self.progression, &self.recipe.progress),
135
            )
136
            .field(
137
                "quality",
138
                &format!("{:?}/{:?}", &self.quality, &self.recipe.quality),
139
            )
140
            .field(
141
                "durability",
142
                &format!("{:?}/{:?}", &self.durability, &self.recipe.durability),
143
            )
144
            .field("cp", &format!("{:?}/{:?}", &self.cp, &self.stats.max_cp))
145
            .finish()
146
    }
147
}