tcm 0.1.1

Rust library for parsing and serializing TCM (tcbot macro) format for Geometry Dash
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

//! Input types for TCM replays.

use crate::Frame;

#[repr(u8)]
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum PlayerButton {
    Jump = 1,
    Left = 2,
    Right = 3,
}

impl TryFrom<u8> for PlayerButton {
    type Error = ();

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            1 => Ok(PlayerButton::Jump),
            2 => Ok(PlayerButton::Left),
            3 => Ok(PlayerButton::Right),
            _ => Err(()),
        }
    }
}

#[repr(u8)]
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum RestartType {
    Restart = 0,
    RestartFull = 1,
    Death = 2,
}

impl TryFrom<u8> for RestartType {
    type Error = ();

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(RestartType::Restart),
            1 => Ok(RestartType::RestartFull),
            2 => Ok(RestartType::Death),
            _ => Err(()),
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub struct RestartInput {
    pub restart_type: RestartType,
    pub new_seed: Option<u64>,
}

#[derive(Debug, Clone, PartialEq)]
pub struct TpsInput {
    pub tps: f32,
}

#[derive(Debug, Clone, PartialEq)]
pub struct VanillaInput {
    pub button: PlayerButton,
    pub push: bool,
    pub player2: bool,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BugpointInput;

#[derive(Debug, Clone, PartialEq)]
pub enum Input {
    Vanilla(VanillaInput),
    Restart(RestartInput),
    Tps(TpsInput),
    Bugpoint(BugpointInput),
}

/// A single input command with its associated frame number.
#[derive(Debug, Clone, PartialEq)]
pub struct InputCommand {
    /// The frame number when this input occurs
    pub frame: Frame,
    /// The input data
    pub input: Input,
}

impl InputCommand {
    pub fn new(frame: Frame, input: Input) -> Self {
        Self { frame, input }
    }

    pub fn is_vanilla(&self) -> bool {
        matches!(self.input, Input::Vanilla(_))
    }

    pub fn is_custom(&self) -> bool {
        !self.is_vanilla()
    }

    pub fn adjusted_frame(&self) -> Frame {
        match self.input {
            Input::Restart(_) => 0,
            _ => self.frame,
        }
    }
}