twgame 0.11.0

DDNet physics implementation
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

use super::Tees;
use crate::{
    entities::tee::Tee,
    ids::{PlayerUid, TeamId},
};
use twgame_core::twsnap::time::{Duration, Instant};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TeamKind {
    Team0,
    NonTeam0,
    // TODO: Solo,
}

#[derive(Debug)]
pub struct Globals {
    locked: bool,
    team_kind: TeamKind,
    team_id: TeamId,
    pub(super) start_time: Option<Instant>,
    pub(super) all_finished: bool,
}

impl Globals {
    pub(super) fn new(team_id: TeamId, team_kind: TeamKind) -> Self {
        Self {
            team_id,
            locked: false,
            team_kind,
            start_time: None,
            all_finished: false,
        }
    }
}

// accessible to Team struct
impl Globals {
    pub(super) fn toggle_lock(&mut self) {
        self.locked = !self.locked;
    }

    pub(super) fn set_lock(&mut self, locked: bool) {
        self.locked = locked;
    }
}

// accessible to team and entities
impl Globals {
    pub fn team_id(&self) -> TeamId {
        self.team_id
    }
    pub fn is_locked(&self) -> bool {
        self.team_kind == TeamKind::NonTeam0 && self.locked
    }

    pub fn kill_propagates(&self) -> bool {
        self.is_locked() && self.start_time.is_some()
    }

    pub fn killed_to_team0(&self) -> bool {
        self.team_kind == TeamKind::NonTeam0 && !self.is_locked()
    }

    pub fn team_kind(&self) -> TeamKind {
        self.team_kind
    }

    /// unlock team for the unlock team tile
    pub fn unlock_team(&mut self) {
        self.locked = false;
    }

    pub fn all_finished(&self) -> bool {
        self.all_finished
    }

    pub fn can_save(&self) -> bool {
        self.team_kind != TeamKind::Team0 && self.start_time.is_some() && !self.all_finished
    }

    pub fn can_load(&self) -> bool {
        self.team_kind != TeamKind::Team0 && self.start_time.is_none()
    }

    pub fn load(&mut self, locked: bool, start_time: Option<Instant>) {
        self.locked = locked;
        self.start_time = start_time;
    }

    pub fn race_time(
        &self,
        now: Instant,
        tees: &Tees<Tee>,
        player_uid: PlayerUid,
    ) -> Option<Duration> {
        if self.team_kind() == TeamKind::NonTeam0 {
            self.start_time
                .map(|past_time| now.duration_since(past_time).unwrap())
        } else {
            let tee = tees.get_tee(player_uid).unwrap();
            tee.race_time(now)
        }
    }
}