zara 1.0.0

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

use crate::health::side::builtin::{UnderwaterSideEffect, UnderwaterSideEffectStateContract};
use crate::health::side::{SideEffectsMonitor, SideEffectDeltasC};
use crate::utils::{FrameSummaryC, clamp_bottom};

use std::cell::Cell;
use std::any::Any;

impl UnderwaterSideEffect {
    /// Creates new `UnderwaterSideEffect` instance.
    ///
    /// # Parameters
    /// - `oxygen_drain`: oxygen drain speed when is under water, 0..100 percents per game second
    /// - `stamina_drain`: stamina drain speed when is under water, 0..100 percents per game second
    pub fn new(oxygen_drain: f32, stamina_drain: f32) -> Self {
        UnderwaterSideEffect {
            oxygen_drain_amount: Cell::new(oxygen_drain),
            stamina_drain_amount: Cell::new(stamina_drain),
            gained_fatigue: Cell::new(0.),
            sleeping_state: Cell::new(false),
            time_under_water: Cell::new(0.),
            underwater_state: Cell::new(false)
        }
    }
    pub fn get_state(&self) -> UnderwaterSideEffectStateContract {
        UnderwaterSideEffectStateContract {
            oxygen_drain_amount: self.oxygen_drain_amount.get(),
            stamina_drain_amount: self.stamina_drain_amount.get(),
            sleeping_state: self.sleeping_state.get(),
            gained_fatigue: self.gained_fatigue.get(),
            underwater_state: self.underwater_state.get(),
            time_under_water: self.time_under_water.get()
        }
    }
    pub fn restore_state(&self, state: &UnderwaterSideEffectStateContract) {
        self.oxygen_drain_amount.set(state.oxygen_drain_amount);
        self.stamina_drain_amount.set(state.stamina_drain_amount);
        self.sleeping_state.set(state.sleeping_state);
        self.gained_fatigue.set(state.gained_fatigue);
        self.underwater_state.set(state.underwater_state);
        self.time_under_water.set(state.time_under_water);
    }
}

impl SideEffectsMonitor for UnderwaterSideEffect {
    fn check(&self, frame_data: &FrameSummaryC) -> SideEffectDeltasC {
        const TIME_TO_REACH_UNDERWATER_TOPS: f32 = 60. * 5.; // game seconds
        const TIME_TO_REACH_FATIGUE_CAP: f32 = 3.*60.*60.; // game seconds
        const MAX_HEART_RATE_IMPACT: f32 = 79.;
        const MAX_TOP_PRESSURE_IMPACT: f32 = 35.;
        const MAX_BOTTOM_PRESSURE_IMPACT: f32 = 29.;

        if !frame_data.player.is_sleeping && self.sleeping_state.get() {
            // Woke up
            self.sleeping_state.set(false);
            self.gained_fatigue.set(0.);
        }
        if frame_data.player.is_sleeping && !self.sleeping_state.get() {
            // Went to bed
            self.sleeping_state.set(true);
        }

        if frame_data.player.is_underwater && !self.underwater_state.get() {
            self.underwater_state.set(true);
            self.time_under_water.set(0.);
        }
        if !frame_data.player.is_underwater && self.underwater_state.get() {
            self.underwater_state.set(false);
        }

        if frame_data.player.is_underwater {
            let underwater_time = self.time_under_water.get() + frame_data.game_time_delta;
            let underwater_time_capped = crate::utils::clamp_to(
                underwater_time,
                TIME_TO_REACH_UNDERWATER_TOPS);

            self.time_under_water.set(underwater_time);

            let p = crate::utils::clamp_01(underwater_time_capped / TIME_TO_REACH_UNDERWATER_TOPS);
            let p_fatigue = crate::utils::clamp_01(underwater_time / TIME_TO_REACH_FATIGUE_CAP);

            self.gained_fatigue.set(crate::utils::lerp(0., 100., p_fatigue));

            return SideEffectDeltasC {
                oxygen_level_bonus: -self.oxygen_drain_amount.get() * frame_data.game_time_delta,
                stamina_bonus: -self.stamina_drain_amount.get() * frame_data.game_time_delta,
                top_pressure_bonus: crate::utils::lerp(0., MAX_TOP_PRESSURE_IMPACT, p),
                bottom_pressure_bonus: crate::utils::lerp(0., MAX_BOTTOM_PRESSURE_IMPACT, p),
                heart_rate_bonus: crate::utils::lerp(0., MAX_HEART_RATE_IMPACT, p),
                fatigue_bonus: self.gained_fatigue.get(),

                ..Default::default()
            }
        } else {
            // Lerp back
            let underwater_time = clamp_bottom(self.time_under_water.get() - frame_data.game_time_delta, 0.);

            const EPS: f32 = 0.000001;

            if underwater_time > EPS {
                self.time_under_water.set(underwater_time);

                let p = crate::utils::clamp_01(underwater_time / TIME_TO_REACH_UNDERWATER_TOPS);

                return SideEffectDeltasC {
                    top_pressure_bonus: crate::utils::lerp(0., MAX_TOP_PRESSURE_IMPACT, p),
                    bottom_pressure_bonus: crate::utils::lerp(0., MAX_BOTTOM_PRESSURE_IMPACT, p),
                    heart_rate_bonus: crate::utils::lerp(0., MAX_HEART_RATE_IMPACT, p),
                    fatigue_bonus: self.gained_fatigue.get(),

                    ..Default::default()
                }
            }
        }

        SideEffectDeltasC {
            fatigue_bonus: self.gained_fatigue.get(),

            ..Default::default()
        }
    }

    fn as_any(&self) -> &dyn Any { self }
}