celeste_rs 0.5.1

Library for working with files related to Celeste and it's modding scene.
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

use std::{
    fmt::Display,
    ops::{Add, AddAssign, Sub, SubAssign},
    time::Duration,
};

use crate::saves::def::util::*;

impl FileTime {
    pub fn as_duration(&self) -> Duration {
        // We won't get any more precise than milliseconds because
        // ...
        // why
        Duration::from_millis(self.as_millis())
    }

    pub fn as_millis(&self) -> u64 {
        self.0 / 10000
    }

    /// Returns the [FileTime] separated into hours, minutes, seconds, and milliseconds
    pub fn as_parts(&self) -> (u64, u64, u64, u64) {
        let duration = self.as_millis();
        let hours = duration / 3600000;
        let mins = (duration / 60000) % 60;
        let secs = (duration / 1000) % 60;
        let millis = duration % 1000;

        (hours, mins, secs, millis)
    }

    pub fn from_duration(dur: Duration) -> Self {
        // Why does this not return u64??
        // The from_millis takes u64, but then returns u128???
        Self::from_millis(dur.as_millis() as u64)
    }

    pub fn from_millis(millis: u64) -> Self {
        FileTime(millis * 10000)
    }

    pub fn from_parts(hours: u64, minutes: u64, seconds: u64, millis: u64) -> Self {
        Self::from_millis(Self::parts_to_millis(hours, minutes, seconds, millis))
    }

    pub fn add_duration(&mut self, dur: Duration) {
        self.add_millis(dur.as_millis() as u64)
    }

    pub fn add_millis(&mut self, millis: u64) {
        self.0 += millis * 10000
    }

    pub fn add_parts(&mut self, hours: u64, minutes: u64, seconds: u64, millis: u64) {
        self.add_millis(Self::parts_to_millis(hours, minutes, seconds, millis))
    }

    fn parts_to_millis(hours: u64, minutes: u64, seconds: u64, millis: u64) -> u64 {
        ((hours * 60 + minutes) * 60 + seconds) * 1000 + millis
    }
}

impl Add for FileTime {
    type Output = FileTime;

    fn add(self, rhs: Self) -> Self::Output {
        FileTime(self.0 + rhs.0)
    }
}

impl Sub for FileTime {
    type Output = FileTime;

    fn sub(self, rhs: Self) -> Self::Output {
        FileTime(self.0 - rhs.0)
    }
}

impl AddAssign for FileTime {
    fn add_assign(&mut self, rhs: Self) {
        self.0 += rhs.0;
    }
}

impl SubAssign for FileTime {
    fn sub_assign(&mut self, rhs: Self) {
        self.0 -= rhs.0;
    }
}
impl Add for &FileTime {
    type Output = FileTime;

    fn add(self, rhs: Self) -> Self::Output {
        FileTime(self.0 + rhs.0)
    }
}

impl Sub for &FileTime {
    type Output = FileTime;

    fn sub(self, rhs: Self) -> Self::Output {
        FileTime(self.0 - rhs.0)
    }
}

impl Display for FileTime {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let (hours, mins, secs, millis) = self.as_parts();
        write!(f, "{hours:02}:{mins:02}:{secs:02}:{millis:03}")
    }
}