Beatsaber Rust Utilities: A Beatsaber V3 parsing library.
beatsaber
beatmap
Cleanup pass on FX event serialization.
+38
-38
+38
-38
src/difficulty/lightshow/group/fx.rs
+38
-38
src/difficulty/lightshow/group/fx.rs
···
71
71
let groups = raw_box
72
72
.groups
73
73
.into_iter()
74
-
.map(|g| {
75
-
let data = g
74
+
.map(|raw_group| {
75
+
let data = raw_group
76
76
.data_ids
77
77
.into_iter()
78
78
.map(|id| {
···
83
83
))
84
84
})
85
85
})
86
-
.collect::<Result<Vec<_>, _>>()?;
86
+
.collect::<Result<Vec<FxEventData>, _>>()?;
87
87
88
88
Ok(FxEventGroup {
89
-
filter: g.filter,
90
-
beat_dist_type: g.beat_dist_type,
91
-
beat_dist_value: g.beat_dist_value,
92
-
fx_dist_type: g.fx_dist_type,
93
-
fx_dist_value: g.fx_dist_value,
94
-
fx_dist_effect_first: g.fx_dist_effect_first,
95
-
fx_dist_easing: g.fx_dist_easing,
89
+
filter: raw_group.filter,
90
+
beat_dist_type: raw_group.beat_dist_type,
91
+
beat_dist_value: raw_group.beat_dist_value,
92
+
fx_dist_type: raw_group.fx_dist_type,
93
+
fx_dist_value: raw_group.fx_dist_value,
94
+
fx_dist_effect_first: raw_group.fx_dist_effect_first,
95
+
fx_dist_easing: raw_group.fx_dist_easing,
96
96
data,
97
97
})
98
98
})
99
-
.collect::<Result<Vec<_>, _>>()?;
99
+
.collect::<Result<Vec<FxEventGroup>, _>>()?;
100
100
101
101
Ok(FxEventBox {
102
102
beat: raw_box.beat,
···
104
104
groups,
105
105
})
106
106
})
107
-
.collect::<Result<Vec<_>, _>>()?;
107
+
.collect::<Result<Vec<FxEventBox>, _>>()?;
108
108
109
109
Ok(FxEventContainer { event_boxes })
110
110
}
···
119
119
let mut event_data: IndexSet<FxEventDataKey> = IndexSet::new();
120
120
121
121
// Todo Deduplicate.
122
-
let event_boxes_raw: Vec<_> = self
122
+
let raw_boxes = self
123
123
.event_boxes
124
124
.iter()
125
-
.map(|b| {
126
-
let groups_raw: Vec<_> = b
125
+
.map(|event_box| {
126
+
let groups_raw = event_box
127
127
.groups
128
128
.iter()
129
-
.map(|g| {
129
+
.map(|event_group| {
130
130
let mut ids = Vec::new();
131
-
for data in &g.data {
132
-
let data: FxEventDataKey = data.into();
133
-
let index = match event_data.get_index_of(&data) {
134
-
Some(index) => index,
135
-
None => {
136
-
let index = event_data.len();
137
-
event_data.insert(data);
138
-
index
139
-
}
140
-
};
131
+
132
+
for data in &event_group.data {
133
+
let data_key: FxEventDataKey = data.into();
134
+
135
+
let index = event_data.get_index_of(&data_key).unwrap_or_else(|| {
136
+
let index = event_data.len();
137
+
event_data.insert(data_key);
138
+
index
139
+
});
140
+
141
141
ids.push(index);
142
142
}
143
143
144
144
FxEventGroupRaw {
145
-
filter: g.filter.clone(),
146
-
beat_dist_type: g.beat_dist_type.clone(),
147
-
beat_dist_value: g.beat_dist_value,
148
-
fx_dist_type: g.fx_dist_type.clone(),
149
-
fx_dist_value: g.fx_dist_value,
150
-
fx_dist_effect_first: g.fx_dist_effect_first,
151
-
fx_dist_easing: g.fx_dist_easing.clone(),
145
+
filter: event_group.filter.clone(),
146
+
beat_dist_type: event_group.beat_dist_type.clone(),
147
+
beat_dist_value: event_group.beat_dist_value,
148
+
fx_dist_type: event_group.fx_dist_type.clone(),
149
+
fx_dist_value: event_group.fx_dist_value,
150
+
fx_dist_effect_first: event_group.fx_dist_effect_first,
151
+
fx_dist_easing: event_group.fx_dist_easing.clone(),
152
152
data_ids: ids,
153
153
}
154
154
})
155
-
.collect();
155
+
.collect::<Vec<FxEventGroupRaw>>();
156
156
157
157
FxEventBoxRaw {
158
-
beat: b.beat,
159
-
group_id: b.group_id,
158
+
beat: event_box.beat,
159
+
group_id: event_box.group_id,
160
160
groups: groups_raw,
161
161
}
162
162
})
163
-
.collect();
163
+
.collect::<Vec<FxEventBoxRaw>>();
164
164
165
165
let mut state = serializer.serialize_struct("FxEventContainer", 2)?;
166
-
state.serialize_field("vfxEventBoxGroups", &event_boxes_raw)?;
166
+
state.serialize_field("vfxEventBoxGroups", &raw_boxes)?;
167
167
state.serialize_field(
168
168
"_fxEventsCollection",
169
169
&FxEventArrays {