vconvert 0.1.1

A simple vulnus to soundspace converter (or vice versa)
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

use std::{time::Duration, str::FromStr};

use serde::{Deserialize, Serialize};

use crate::{DefaultMapNote, vulnus};

#[derive(Debug)]
pub struct Map {
    pub(crate) song_id: u64,
    pub(crate) notes : Vec<MapNote>
}

pub enum ParseSoundSpaceMapErr {
    InvalidSyntax,
    UnknownFailure
}

impl FromStr for Map {
    type Err = ParseSoundSpaceMapErr;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let mut each_note = s.split(',');
        let song_id = each_note.next().unwrap().parse::<u64>().or(Err(ParseSoundSpaceMapErr::InvalidSyntax))?;
        let notes : Vec<MapNote> = each_note.map(|n| -> Result<MapNote,ParseSoundSpaceMapErr> {
            let nn = n.split('|');
            let mut take_3 = nn.take(3);
            let x = take_3.next().ok_or(ParseSoundSpaceMapErr::InvalidSyntax)?.parse::<f32>().or(Err(ParseSoundSpaceMapErr::InvalidSyntax))?;
            let y = take_3.next().ok_or(ParseSoundSpaceMapErr::InvalidSyntax)?.parse::<f32>().or(Err(ParseSoundSpaceMapErr::InvalidSyntax))?;
            let t = take_3.next().ok_or(ParseSoundSpaceMapErr::InvalidSyntax)?.parse::<f64>().or(Err(ParseSoundSpaceMapErr::InvalidSyntax))?;
            Ok(MapNote {
                x,
                y,
                time:t
            })
        } )
        .flatten() // unwrap
        .collect();

        Ok(Map {
            song_id,
            notes
        })

        // Err(ParseSoundSpaceMapErr::UnknownFailure)
    }
}
impl From<vulnus::Map> for Map {
    fn from(m: vulnus::Map) -> Self {
        Map {
            song_id: 0,
            notes: m.notes.into_iter().map(|n| MapNote::from(n)).collect()
        }
    }
}

impl Map {

    pub fn set_offset(&mut self, offset: Duration) {
        self.notes.iter_mut().for_each(|note| note.set_offset(offset));
    }
    pub fn resize(&mut self, by: i32) {
        self.notes.iter_mut().for_each(|note| note.resize(by));
    }
    pub fn set_song_id(&mut self, song_id: u64) {
        self.song_id = song_id;
    }
    pub fn get_song_id(&self) -> u64 {
        self.song_id
    }
    pub fn get_notes(&self) -> &Vec<MapNote> {
        &self.notes
    }
    
}
impl ToString for Map {
    fn to_string(&self) -> String {
        let mut s = String::new();
        s.push_str(&self.song_id.to_string());
        s.push(',');
        s.push_str(&self.notes.iter().map(|n| n.to_string()).collect::<Vec<String>>().join(","));
        s
    }
}

#[derive(Debug)]

pub struct MapNote {
    pub(crate) time: f64,
    pub(crate) x:f32,
    pub(crate) y:f32
}

impl From<vulnus::MapNote> for MapNote {
    fn from(n: vulnus::MapNote) -> Self {
        MapNote {
            time: n.time,
            x: n.x,
            y: n.y
        }
    }
}
impl ToString for MapNote {
    fn to_string(&self) -> String {
        format!("{:.2}|{:.2}|{:.2}", self.x, self.y, self.time)
    }
}

impl DefaultMapNote for MapNote {
    fn y_as_ref(&self) -> &f32 {
        &self.y
    }
    fn x_as_ref(&self) -> &f32 {
        &self.x
    }
    fn time_as_ref(&self) -> &f64 {
        &self.time
    }
    fn y_as_mut(&mut self) -> &mut f32 {
        &mut self.y
    }
    fn x_as_mut(&mut self) -> &mut f32 {
        &mut self.x
    }
    fn time_as_mut(&mut self) -> &mut f64 {
        &mut self.time
    }
}