zara 1.0.7

Zara survival engine
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275

use crate::health::{StageLevel};
use crate::health::disease::{StageDescription, StageBuilder};

impl StageBuilder {
    fn as_stage_self_heal(&self) -> &dyn StageSelfHeal { self }
    fn as_vitals_node(&self) -> &dyn StageVitalsNode { self }
    fn as_vitals_values(&self) -> &dyn StageVitalsValues { self }
    fn as_drains_node(&self) -> &dyn StageDrainsNode { self }
    fn as_drains_values(&self) -> &dyn StageDrainsValues { self }
    fn as_stage_death_chance(&self) -> &dyn StageDeathChance { self }
    fn as_stage_end(&self) -> &dyn StageEnd { self }
}

/// Stage fluent step trait
pub trait StageInit {
    /// Starts stage building process
    ///
    /// # Parameters
    /// - `level`: level of the stage we will be building
    fn build_for(&self, level: StageLevel) -> &dyn StageSelfHeal;
}

/// Stage fluent step trait
pub trait StageSelfHeal {
    /// Will this stage have a chance of triggering self-healing
    ///
    /// # Parameters
    /// - `probability`: 0..100 chance of self-heal for this stage
    fn self_heal(&self, probability: usize) -> &dyn StageVitalsNode;
    /// This stage has no self-healing probability
    fn no_self_heal(&self) -> &dyn StageVitalsNode;
}

/// Stage fluent step trait
pub trait StageVitalsNode {
    /// Describe how this stage affects vitals
    fn vitals(&self) -> &dyn StageVitalsValues;
}

/// Stage fluent step trait
pub trait StageVitalsValues {
    /// Set the target body temperature for this stage
    ///
    /// # Parameters
    /// - `value`: absolute value (like 37.3)
    fn with_target_body_temp(&self, value: f32) -> &dyn StageVitalsValues;
    /// Set the target heart rate for this stage
    ///
    /// # Parameters
    /// - `value`: absolute value (like 84.)
    fn with_target_heart_rate(&self, value: f32) -> &dyn StageVitalsValues;
    /// Set the target blood pressure for this stage
    ///
    /// # Parameters
    /// - `top`: absolute value (like 120.)
    /// - `bottom`: absolute value (like 70.)
    fn with_target_blood_pressure(&self, top: f32, bottom: f32) -> &dyn StageVitalsValues;

    /// In what time this stage should reach those vitals values (in game time hours)
    ///
    /// # Parameters
    /// - `hours`: number of game hours
    fn will_reach_target_in(&self, hours: f32) -> &dyn StageVitalsValues;
    /// Tells that disease will move on when `will_reach_target_in` time ends.
    ///
    /// Choosing `will_end` on the last stage will cause disease to disappear after last stage ends
    fn will_end(&self) -> &dyn StageDrainsNode;
    /// Tells that disease will stay on this stage as long as this disease is not removed and
    /// will not move on to the next stage.
    ///
    /// Usually `will_last_forever` appears on a last disease stage.
    fn will_last_forever(&self) -> &dyn StageDrainsNode;
}

/// Stage fluent step trait
pub trait StageDrainsNode {
    /// Describe how this stage affects other parameters
    fn drains(&self) -> &dyn StageDrainsValues;
    /// This stage has no effect on other parameters
    fn no_drains(&self) -> &dyn StageDeathChance;
}

/// Stage fluent step trait
pub trait StageDrainsValues {
    /// Set the static drain rate for the stamina for this stage. 0..100 percents per game second.
    ///
    /// # Parameters
    /// - `value`: max drain value for this stage (0..100 percents per game second)
    fn stamina(&self, value: f32) -> &dyn StageDrainsValues;
    /// Set the static drain rate for the food level for this stage. 0..100 percents per game second.
    ///
    /// # Parameters
    /// - `value`: max drain value for this stage (0..100 percents per game second)
    fn food_level(&self, value: f32) -> &dyn StageDrainsValues;
    /// Set the static drain rate for the water level for this stage. 0..100 percents per game second.
    ///
    /// # Parameters
    /// - `value`: max drain value for this stage (0..100 percents per game second)
    fn water_level(&self, value: f32) -> &dyn StageDrainsValues;

    /// Choose this if you want this stage to affect fatigue.
    ///
    /// # Parameters
    /// - `target_delta`: maximum impact on fatigue at the end of this stage (0..100 percents)
    fn affects_fatigue(&self, target_delta: f32) -> &dyn StageDeathChance;
    /// This stage does not affect fatigue
    fn no_fatigue_effect(&self) -> &dyn StageDeathChance;
}

/// Stage fluent step trait
pub trait StageDeathChance {
    /// Set chance of death for this stage. This chance will be tested on every Zara pass
    /// (every real second) while this stage is active
    fn with_chance_of_death(&self, value: usize) -> &dyn StageEnd;
    /// No death chance for this stage
    fn no_death_probability(&self) -> &dyn StageEnd;
}

/// Stage fluent step trait
pub trait StageEnd {
    /// Builds disease stage object with all the information provided
    fn build(&self) -> StageDescription;
}

impl StageInit for StageBuilder {
    fn build_for(&self, level: StageLevel) -> &dyn StageSelfHeal {
        self.level.replace(level);

        self.as_stage_self_heal()
    }
}

impl StageSelfHeal for StageBuilder {
    fn self_heal(&self, probability: usize) -> &dyn StageVitalsNode {
        self.self_heal_chance.replace(Some(probability));

        self.as_vitals_node()
    }

    fn no_self_heal(&self) -> &dyn StageVitalsNode {
        self.as_vitals_node()
    }
}

impl StageVitalsNode for StageBuilder {
    fn vitals(&self) -> &dyn StageVitalsValues {
        self.as_vitals_values()
    }
}

impl StageVitalsValues for StageBuilder {
    fn with_target_body_temp(&self, value: f32) -> &dyn StageVitalsValues {
        self.target_body_temp.set(value);

        self.as_vitals_values()
    }

    fn with_target_heart_rate(&self, value: f32) -> &dyn StageVitalsValues {
        self.target_heart_rate.set(value);

        self.as_vitals_values()
    }

    fn with_target_blood_pressure(&self, top: f32, bottom: f32) -> &dyn StageVitalsValues {
        self.target_pressure_top.set(top);
        self.target_pressure_bottom.set(bottom);

        self.as_vitals_values()
    }

    fn will_reach_target_in(&self, hours: f32) -> &dyn StageVitalsValues {
        self.reaches_peak_in_hours.set(hours);

        self.as_vitals_values()
    }

    fn will_end(&self) -> &dyn StageDrainsNode {
        self.as_drains_node()
    }

    fn will_last_forever(&self) -> &dyn StageDrainsNode {
        self.is_endless.set(true);

        self.as_drains_node()
    }
}

impl StageDrainsNode for StageBuilder {
    fn drains(&self) -> &dyn StageDrainsValues {
        self.as_drains_values()
    }

    fn no_drains(&self) -> &dyn StageDeathChance {
        self.target_stamina_drain.set(0.00001);
        self.target_food_drain.set(0.00001);
        self.target_water_drain.set(0.00001);

        self.as_stage_death_chance()
    }
}

impl StageDrainsValues for StageBuilder {
    fn stamina(&self, value: f32) -> &dyn StageDrainsValues {
        self.target_stamina_drain.set(value);

        self.as_drains_values()
    }

    fn food_level(&self, value: f32) -> &dyn StageDrainsValues {
        self.target_food_drain.set(value);

        self.as_drains_values()
    }

    fn water_level(&self, value: f32) -> &dyn StageDrainsValues {
        self.target_water_drain.set(value);

        self.as_drains_values()
    }

    fn affects_fatigue(&self, target_delta: f32) -> &dyn StageDeathChance {
        self.target_fatigue_delta.set(target_delta);

        self.as_stage_death_chance()
    }

    fn no_fatigue_effect(&self) -> &dyn StageDeathChance {
        self.target_fatigue_delta.set(0.000001);

        self.as_stage_death_chance()
    }
}

impl StageDeathChance for StageBuilder {
    fn with_chance_of_death(&self, value: usize) -> &dyn StageEnd {
        self.chance_of_death.replace(Some(value));

        self.as_stage_end()
    }

    fn no_death_probability(&self) -> &dyn StageEnd {
        self.chance_of_death.replace(None);

        self.as_stage_end()
    }
}

impl StageEnd for StageBuilder {
    fn build(&self) -> StageDescription {
        let self_heal_chance = match self.self_heal_chance.borrow().as_ref() {
            Some(c) => Some(*c),
            None => None
        };
        let chance_of_death = match self.chance_of_death.borrow().as_ref() {
            Some(c) => Some(*c),
            None => None
        };

        StageDescription {
            level: *self.level.borrow(),
            self_heal_chance,
            chance_of_death,
            is_endless: self.is_endless.get(),
            reaches_peak_in_hours: self.reaches_peak_in_hours.get(),
            target_body_temp: self.target_body_temp.get(),
            target_heart_rate: self.target_heart_rate.get(),
            target_pressure_top: self.target_pressure_top.get(),
            target_pressure_bottom: self.target_pressure_bottom.get(),
            target_fatigue_delta: self.target_fatigue_delta.get(),
            target_stamina_drain: self.target_stamina_drain.get(),
            target_food_drain: self.target_food_drain.get(),
            target_water_drain: self.target_water_drain.get()
        }
    }
}