rotterna-lib 0.2.0

A library for parsing and converting StepMania files to osu! files
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

use crate::utils::parse_field;
#[derive(Debug, Clone)]
pub struct SmFile {
    pub metadata: Metadata,
    pub offset: f64, // Time in MILLISECONDS
    pub bpms: Vec<(f64, f64)>,  // (row, bpm) - row position and BPM value
    pub stops: Vec<(f64, f64)>, // (row, duration) - row position and duration in seconds
    pub charts: Vec<Chart>,
}

impl SmFile {
    pub fn new() -> SmFile {
        SmFile {
            metadata: Metadata::new(),
            offset: 0.0,
            bpms: Vec::new(),
            stops: Vec::new(),
            charts: Vec::new(),
        }
    }
}

#[derive(Debug, Clone)]
pub struct Metadata {
    pub title: String,
    pub subtitle: String,
    pub artist: String,
    pub title_translit: String,
    pub artist_translit: String,
    pub credit: String,
    pub music: String,
    pub banner: String,
    pub background: String,
}

impl Metadata {
    pub fn new() -> Metadata {
        Metadata {
            title: String::new(),
            subtitle: String::new(),
            artist: String::new(),
            title_translit: String::new(),
            artist_translit: String::new(),
            credit: String::new(),
            music: String::new(),
            banner: String::new(),
            background: String::new(),
        }
    }
    pub fn parse(&mut self, content: &str) {
        parse_field(content, r"#TITLE:(.*?);", &mut self.title);
        parse_field(content, r"#SUBTITLE:(.*?);", &mut self.subtitle);
        parse_field(content, r"#ARTIST:(.*?);", &mut self.artist);
        parse_field(content, r"#TITLETRANSLIT:(.*?);", &mut self.title_translit);
        parse_field(
            content,
            r"#ARTISTTRANSLIT:(.*?);",
            &mut self.artist_translit,
        );
        parse_field(content, r"#CREDIT:(.*?);", &mut self.credit);
        parse_field(content, r"#MUSIC:(.*?);", &mut self.music);
        parse_field(content, r"#BANNER:(.*?);", &mut self.banner);
        parse_field(content, r"#BACKGROUND:(.*?);", &mut self.background);
    }
}

#[derive(Debug, Clone)]
pub struct Chart {
    pub stepstype: String,
    pub description: String,
    pub difficulty: String,
    pub meter: u32,
    pub radar_values: Vec<f64>,
    pub column_count: u32,
    pub measures: Vec<Measure>,
}

impl Chart {
    pub fn new() -> Chart {
        Chart {
            stepstype: String::new(),
            description: String::new(),
            difficulty: String::new(),
            meter: 0,
            radar_values: Vec::new(),
            column_count: 0,
            measures: Vec::new(),
        }
    }
}

#[derive(Debug, Clone)]
pub struct Measure {
    pub beats: Vec<Beat>,
    pub start_time: f64, // Time in MILLISECONDS
}

impl Measure {
    pub fn new() -> Measure {
        Measure {
            beats: Vec::new(),
            start_time: 0.0,
        }
    }
}

#[derive(Debug, Clone)]
pub struct Beat {
    pub time: f64,        // Time in MILLISECONDS
    pub notes: Vec<bool>, // true = note, false = empty
}
impl Beat {
    pub fn new() -> Beat {
        Beat {
            time: 0.0,
            notes: Vec::new(),
        }
    }
}



pub struct OsuSettings
{
    pub od: f64, 
    pub hp: f64,
}