Clean up code a little

- Move duck blocks down, they were too high - Change timing on jump notes, 1/8th to allow user to jump over - Change timing on duck blocks, 1/16h to allow user to duck under on beat - Move jump note blocks down into the ground, so they're easy to jump over - Shorten song duration by 10 seconds, so you don't wait at the end for 10 seconds - Add more metadata to the files
2023-09-19 21:32:01 +01:00
parent ec87745859
commit 48f93de564
3287 changed files with 11316774 additions and 11287525 deletions
@@ -1,11 +1,8 @@
 from __future__ import annotations

 import argparse
-import json
 import os
 import shutil
-from copy import deepcopy
-from dataclasses import asdict

 from drsxml2json import ALL_TRACK_PATHS
 from drsxml2json import get_songdata_from_track_id
@@ -22,138 +19,112 @@ from model.dancedash import DDRoadBlockNode
 from model.dancedash import DDSphereNode
 from model.dancedash import DRS_TO_DDS_LINE_NOTE_TYPE
 from model.dancedash import DRS_TO_DDS_NOTE_TYPE
+from model.dancedash import ORDER_COUNT_PER_BEAT
 from model.dancedash import X_Y
-from model.dancedash import X_Y_Z
 from model.dancerush import DRS_DOWN
 from model.dancerush import DRS_JUMP
 from model.dancerush import DRSSongData
 from model.dancerush import DRSSongDifficulty
 from model.dancerush import DRSTrackPoint
-from model.dancerush import DRSTrackStep
+from util import create_valid_filename
 from util import get_ogg_and_duration
 from util import get_song_cover_path
-from util import ORDER_COUNT_PER_BEAT
+from util import yyyymmdd_to_ticks


 def map_sphere_nodes(
        difficulty: DRSSongDifficulty,
        total_time_seconds: float,
-        bpm: int,
+        bps: float,
+        ticks_per_second: float,
 ) -> list[DDSphereNode]:
    spheres = []
    for track_step in difficulty.track.sequence_data:
-        track_step: DRSTrackStep = track_step
-        # Long note get mapped elsewhere
-        if track_step.long_point or track_step.kind in (DRS_DOWN, DRS_JUMP):
+        if track_step.long_point or track_step.is_down_or_up:
            continue
-        bps = bpm / 60
+
        if track_step.tick_info.start_tick:
-            end_time_seconds = difficulty.track.clip.end_time / 1000
-            ticks_per_second = difficulty.track.info.end_tick / end_time_seconds
            seconds = track_step.tick_info.end_tick / ticks_per_second
        else:
            seconds = track_step.tick_info.stime_ms / 1000

-        time = seconds / total_time_seconds
-        sphere = DDSphereNode(
-            noteOrder=round(bps * seconds * ORDER_COUNT_PER_BEAT),
-            time=time,
-            position=X_Y(x=track_step.position_info.to_dance_dash_x, y=0),
-            position2D=X_Y(x=0, y=0),
-            size=X_Y_Z(x=1, y=1, z=1),
-            noteType=DRS_TO_DDS_NOTE_TYPE[track_step.kind],
-            postionOffset=None,
-            isPlayAudio=False,
+        spheres.append(
+            DDSphereNode(
+                noteOrder=round(bps * seconds * ORDER_COUNT_PER_BEAT),
+                time=seconds / total_time_seconds,
+                position=X_Y(x=track_step.position_info.to_dance_dash_x, y=0),
+                noteType=DRS_TO_DDS_NOTE_TYPE[track_step.kind],
+            ),
        )
-        spheres.append(sphere)
-
    return spheres


 def map_line_nodes(
        difficulty: DRSSongDifficulty,
        total_time_seconds: float,
-        bpm: int,
+        bps: float,
+        ticks_per_second: float,
 ) -> list[DDLineNode]:
    lines = []
    for line_group_id, track_step in enumerate(difficulty.track.sequence_data, start=1):
-        track_step: DRSTrackStep = track_step
-        if not track_step.long_point or track_step.kind in (DRS_DOWN, DRS_JUMP):
+        if not track_step.long_point or track_step.is_down_or_up:
            continue

-        bps = bpm / 60
-
-        # DANCERUSH defines the first line step as a point, with the first point being the start of the line.
-        # So we need to add a point at the start of the line for Dance Dash.
-        initial_track_point = DRSTrackPoint(
-            tick=track_step.tick_info.start_tick,
-            left_pos=track_step.position_info.left_pos,
-            right_pos=track_step.position_info.right_pos,
-            point_time=track_step.tick_info.stime_ms,
+        track_step.long_point.insert(
+            0, DRSTrackPoint(
+                tick=track_step.tick_info.start_tick,
+                left_pos=track_step.position_info.left_pos,
+                right_pos=track_step.position_info.right_pos,
+                point_time=track_step.tick_info.stime_ms,
+            ),
        )
-        track_step.long_point.insert(0, initial_track_point)

-        index_in_line = 0
        last_was_shuffle_end = False
+        index_in_line = 0
        for drs_track_point in track_step.long_point:
            last_was_shuffle_end = False
            index_in_line += 1
-            drs_track_point: DRSTrackPoint = drs_track_point

-            if drs_track_point.tick is not None:
-                end_time_seconds = difficulty.track.clip.end_time / 1000
-                ticks_per_second = difficulty.track.info.end_tick / end_time_seconds
+            if drs_track_point.tick:
                seconds = drs_track_point.tick / ticks_per_second
            else:
                seconds = drs_track_point.point_time / 1000

-            line = DDLineNode(
-                lineGroupId=line_group_id,
-                indexInLine=index_in_line,
-                isSliding=False,
-                noteOrder=round(bps * seconds * ORDER_COUNT_PER_BEAT),
-                time=seconds / total_time_seconds,
-                position=X_Y(x=drs_track_point.to_dance_dash_x, y=0),
-                position2D=X_Y(x=0, y=0),
-                size=X_Y_Z(x=1, y=1, z=1),
-                noteType=DRS_TO_DDS_LINE_NOTE_TYPE[track_step.kind],
-                postionOffset=None,
-                isPlayAudio=False,
+            lines.append(
+                DDLineNode(
+                    lineGroupId=line_group_id,
+                    indexInLine=index_in_line,
+                    noteOrder=round(bps * seconds * ORDER_COUNT_PER_BEAT),
+                    time=seconds / total_time_seconds,
+                    position=X_Y(x=drs_track_point.to_dance_dash_x, y=0),
+                    noteType=DRS_TO_DDS_LINE_NOTE_TYPE[track_step.kind],
+                ),
            )
-            lines.append(line)

            if drs_track_point.left_end_pos and drs_track_point.right_end_pos:
                index_in_line += 1
-                end_line = deepcopy(line)
-                end_line.position.x = drs_track_point.to_dance_dash_end_x
-                end_line.indexInLine = index_in_line
-                lines.append(end_line)
+                lines.append(
+                    lines[-1].line_end(drs_track_point, index_in_line),
+                )
                last_was_shuffle_end = True

        if last_was_shuffle_end:
-            last_line = lines[-1]
-            tail_line = deepcopy(last_line)
-            tail_line.noteOrder += ORDER_COUNT_PER_BEAT / 4
-            tail_line.indexInLine += 1
-            lines.append(tail_line)
-
+            lines.append(lines[-1].tail)
    return lines


 def map_down_and_jump_notes(
        difficulty: DRSSongDifficulty,
        total_time_seconds: float,
-        bpm: int,
+        bps: float,
+        ticks_per_second: float,
 ) -> list[DDRoadBlockNode]:
    road_blocks = []
    for track_step in difficulty.track.sequence_data:
-        if track_step.kind not in (DRS_DOWN, DRS_JUMP):
+        if not track_step.is_down_or_up:
            continue

-        bps = bpm / 60
        if track_step.tick_info.start_tick:
-            end_time_seconds = difficulty.track.clip.end_time / 1000
-            ticks_per_second = difficulty.track.info.end_tick / end_time_seconds
            seconds = track_step.tick_info.end_tick / ticks_per_second
        else:
            seconds = track_step.tick_info.stime_ms / 1000
@@ -161,133 +132,112 @@ def map_down_and_jump_notes(
        note_order = round(bps * seconds * ORDER_COUNT_PER_BEAT)
        if track_step.kind == DRS_JUMP:
            # user jumps OVER in DD, not ON like in DRS
-            note_order += ORDER_COUNT_PER_BEAT / 4
+            note_order += ORDER_COUNT_PER_BEAT / 8
+        elif track_step.kind == DRS_DOWN:
+            # user needs to duck UNDER in DD, not go down ON like in DRS
+            note_order += ORDER_COUNT_PER_BEAT / 16

-        road_block = DDRoadBlockNode(
-            noteOrder=note_order,
-            time=seconds / total_time_seconds,
-            position=DDJumpPos if track_step.kind == DRS_JUMP else DDDownPos,
-            position2D=DDJumpPos2D if track_step.kind == DRS_JUMP else DDDownPos2D,
+        road_blocks.append(
+            DDRoadBlockNode(
+                noteOrder=note_order,
+                time=seconds / total_time_seconds,
+                position=DDJumpPos if track_step.kind == DRS_JUMP else DDDownPos,
+                position2D=DDJumpPos2D if track_step.kind == DRS_JUMP else DDDownPos2D,
+            ),
        )
-        road_blocks.append(road_block)
-
    return road_blocks


-def create_dd_tracks_from_DRSSongData(
-        drs_song_data: DRSSongData, target_dir: str,
-) -> bool:
+def create_dd_tracks_from_DRSSongData(drs_song_data: DRSSongData, target_dir: str = None) -> bool:
+    if not target_dir:
+        target_dir = f'tracks/{create_valid_filename(song_data.info.title_name)}/'
+
    dd_bmp = int(drs_song_data.info.bpm_max / 100)
+    dd_bps = dd_bmp / 60
+
    folder_path = TRACK_ID_TO_PATH.get(drs_song_data.song_id)
    song_path, song_length = get_ogg_and_duration(folder_path)
-
    if not song_path or not song_length:
        print(
-            f'Could not find song path or song length for {drs_song_data.info.title_name}',
+            f'No song found for {drs_song_data.info.title_name} ({drs_song_data.song_id})',
        )
        return False

    if not os.path.exists(target_dir):
        os.makedirs(target_dir)
-        print(f'Created directory: {target_dir}')
-
-    if song_path and song_length:
-        shutil.copy(song_path, target_dir)

+    new_song_path = os.path.join(target_dir, drs_song_data.ogg)
+    shutil.copy(song_path, new_song_path)
+    song_path = new_song_path
    if song_cover_path := get_song_cover_path(folder_path):
-        shutil.copy(song_cover_path, target_dir)
+        new_song_cover_path = os.path.join(target_dir, drs_song_data.png)
+        shutil.copy(song_cover_path, new_song_cover_path)
+        song_cover_path = new_song_cover_path

    song_paths = []
    for attr, difficulty in drs_song_data.difficulties.with_attrs_as_str.items():
-
        if attr in ('difficulty_2a', 'difficulty_2b'):  # 2 player difficulties
            continue

+        ticks_per_second = None
+        if difficulty.track.clip and difficulty.track.clip.end_time:
+            end_time_seconds = difficulty.track.clip.end_time / 1000
+            ticks_per_second = difficulty.track.info.end_tick / end_time_seconds
+
+        song_length_f = float(song_length)
        sphere_notes = map_sphere_nodes(
-            difficulty,
-            float(song_length),
-            dd_bmp,
+            difficulty, song_length_f, dd_bps, ticks_per_second,
        )
        line_notes = map_line_nodes(
-            difficulty,
-            float(song_length),
-            dd_bmp,
+            difficulty, song_length_f, dd_bps, ticks_per_second,
        )
        road_block_notes = map_down_and_jump_notes(
-            difficulty,
-            float(song_length),
-            dd_bmp,
+            difficulty, song_length_f, dd_bps, ticks_per_second,
        )
-        total_note_count = len(sphere_notes) + \
-            len(line_notes) + len(road_block_notes)
+
+        total_note_count = len(sphere_notes + line_notes + road_block_notes)  # noqa
        drs_beat_map = DDBeatMap(
            data=DDBeatMapData(
                name=f'{drs_song_data.info.title_name} {attr}',
-                intervalPerSecond=0.0,
-                gridSize=X_Y(x=0, y=0),
-                planeSize=X_Y(x=0, y=0),
-                orderCountPerBeat=ORDER_COUNT_PER_BEAT,
                sphereNodes=sphere_notes,
                lineNodes=line_notes,
-                effectNodes=[],
                roadBlockNodes=road_block_notes,
-                trapNodes=[],
            ),
-            beatSubs=1,
            BPM=dd_bmp,
-            songStartOffset=0.0,
-            NPS=str(round(total_note_count / float(song_length), 2)),
-            developerMode=False,
-            noteSpeed=1.0,
-            noteJumpOffset=0.0,
-            interval=1.0,
-            info='',
+            NPS=str(round(total_note_count / song_length_f, 2)),
        )
-        target_difficulty_path = os.path.join(
-            target_dir, f'{drs_song_data.song_id}_{attr}.json',
-        )
-        song_paths.append(target_difficulty_path)
-        with open(target_difficulty_path, 'w') as f:
-            json.dump(asdict(drs_beat_map), f, indent=4)
-            print(f'Created file: {target_difficulty_path}')

-        drs_beat_map_no_blocks = deepcopy(drs_beat_map)
-        drs_beat_map_no_blocks.data.roadBlockNodes = []
-        target_difficulty_path_no_blocks = os.path.join(
-            target_dir, f'{drs_song_data.song_id}_{attr}_no_blocks.json',
+        song_paths.append(
+            drs_beat_map.save_to_file(
+                target_dir, f'{attr}.json',
+            ),
+        )
+        song_paths.append(
+            drs_beat_map.block_less.save_to_file(
+                target_dir, f'{attr}_blockless.json',
+            ),
        )
-        song_paths.append(target_difficulty_path_no_blocks)
-        with open(target_difficulty_path_no_blocks, 'w') as f:
-            json.dump(asdict(drs_beat_map_no_blocks), f, indent=4)
-            print(f'Created file: {target_difficulty_path_no_blocks}')

    normal, normal_no_blocks, easy, easy_no_blocks = song_paths
+    create_ticks = yyyymmdd_to_ticks(str(drs_song_data.info.distribution_date))
    drs_song_info_json = DDBeatMapInfoFile(
-        EditorVersion='1.3.2',
+        CreateTicks=create_ticks,
+        CreateTime=str(create_ticks),
        BeatMapId=drs_song_data.song_id,
-        OstId=0,
-        CreateTicks=0,
-        CreateTime='',
        SongName=drs_song_data.info.title_name,
        SongLength=song_length,
        SongAuthorName=drs_song_data.info.artist_name,
-        LevelAuthorName='https://github.com/thomasasfk/drs2dd',
-        SongPreviewSection=0,
        Bpm=str(dd_bmp),
-        SongPath=os.path.basename(song_path or '') or None,
-        OstName=None,
+        SongPath=os.path.basename(song_path),
        CoverPath=os.path.basename(song_cover_path or '') or None,
        DRS_Easy=os.path.basename(easy_no_blocks),
        DRS_Normal=os.path.basename(normal_no_blocks),
        DRS_Hard=os.path.basename(easy),
        DRS_Expert=os.path.basename(normal),
    )
+    drs_song_info_json.save_to_file(target_dir)

-    info_file_path = os.path.join(target_dir, 'info.json')
-    with open(info_file_path, 'w') as f:
-        json.dump(asdict(drs_song_info_json), f, indent=4)
-        print(f'Created file: {info_file_path}')
-
+    print(f'Created {drs_song_data.info.title_name} ({drs_song_data.song_id})')
    return True


@@ -296,32 +246,30 @@ if __name__ == '__main__':
        description='Create DD tracks from DRS Song Data',
    )
    parser.add_argument(
-        '--song-id', type=int,
+        '--song-id',
+        type=int,
        help='ID of the song to process (number of folder)',
    )

    args = parser.parse_args()
-
    if args.song_id:
        song_data = get_songdata_from_track_id(args.song_id)
        if not song_data:
            print(f'No song data found for song id {args.song_id}')
            raise SystemExit(1)

+        target_directory = create_valid_filename(song_data.info.title_name)
        created = create_dd_tracks_from_DRSSongData(
-            song_data, song_data.info.title_name,
+            song_data, target_directory,
        )
-
        print(f'Song {args.song_id} created?: {created}')
        raise SystemExit(0)

    for song_id in ALL_TRACK_PATHS:
        if song_data := get_songdata_from_track_id(int(song_id)):
            try:
-                created = create_dd_tracks_from_DRSSongData(
-                    song_data, f'tracks/{song_data.info.title_name}',
-                )
+                create_dd_tracks_from_DRSSongData(song_data)
            except Exception as e:
                print(f'Error creating song {song_id}: {e}')
-                created = False
-            print(f'Song {song_id} created?: {created}')
+
+    raise SystemExit(0)
@@ -1,10 +1,15 @@
 from __future__ import annotations

+import json
+import os
+from copy import deepcopy
+from dataclasses import asdict
 from dataclasses import dataclass
 from dataclasses import field

 from model.dancerush import DRS_LEFT
 from model.dancerush import DRS_RIGHT
+from model.dancerush import DRSTrackPoint

 DD_LEFT = 8
 DD_RIGHT = 9
@@ -14,6 +19,8 @@ DD_LINE_RIGHT = 13

 DD_ROAD_BLOCK = 14

+ORDER_COUNT_PER_BEAT = 24
+
 DRS_TO_DDS_NOTE_TYPE = {
    DRS_LEFT: DD_LEFT,
    DRS_RIGHT: DD_RIGHT,
@@ -40,15 +47,28 @@ class X_Y_Z(X_Y):
 class DDLineNode:
    lineGroupId: int
    indexInLine: int
-    isSliding: bool
    noteOrder: int
    time: float
    position: X_Y
-    position2D: X_Y
-    size: X_Y_Z
    noteType: int
-    postionOffset: X_Y_Z | None  # Yes, postionOffset - not positionOffset.
-    isPlayAudio: bool
+    position2D: X_Y = X_Y(x=0, y=0)
+    size: X_Y_Z = X_Y_Z(x=1, y=1, z=1)
+    isPlayAudio: bool = False
+    postionOffset: X_Y_Z | None = None
+    isSliding: bool = False
+
+    def line_end(self, track_point: DRSTrackPoint, index: int):
+        line = deepcopy(self)
+        line.position.x = track_point.to_dance_dash_end_x
+        line.indexInLine = index
+        return line
+
+    @property
+    def tail(self):
+        line = deepcopy(self)
+        line.noteOrder += ORDER_COUNT_PER_BEAT / 4
+        line.indexInLine += 1
+        return line


@dataclass
@@ -56,18 +76,18 @@ class DDSphereNode:
    noteOrder: int
    time: float
    position: X_Y
-    position2D: X_Y
-    size: X_Y_Z
    noteType: DD_LEFT | DD_RIGHT
-    postionOffset: dict | None
-    isPlayAudio: bool
+    position2D: X_Y = X_Y(x=0, y=0)
+    size: X_Y_Z = X_Y_Z(x=1, y=1, z=1)
+    postionOffset: dict | None = None
+    isPlayAudio: bool = False


-DDJumpPos2D = X_Y(x=1.49, y=4.33)
-DDDownPos2D = X_Y(x=1.49, y=-3.932)
+DDJumpPos2D = X_Y(x=0.0, y=0.0)
+DDDownPos2D = X_Y(x=0.0, y=0.0)

-DDJumpPos = X_Y(x=5, y=0)
-DDDownPos = X_Y(x=5, y=12)
+DDJumpPos = X_Y(x=5, y=-1)
+DDDownPos = X_Y(x=5, y=10)


@dataclass
@@ -77,9 +97,9 @@ class DDRoadBlockNode:
    position: X_Y
    position2D: X_Y
    length: int = 1
-    noteType: DD_ROAD_BLOCK = DD_ROAD_BLOCK
    postionOffset: X_Y_Z = X_Y_Z(x=0, y=0, z=0)
    size: X_Y_Z = X_Y_Z(x=1, y=1, z=1)
+    noteType: DD_ROAD_BLOCK = DD_ROAD_BLOCK
    isPlayAudio: bool = False
    startPosSelctOrder: int = -1
    endPosSelctOrder: int = -1
@@ -89,45 +109,58 @@ class DDRoadBlockNode:
@dataclass
 class DDBeatMapData:
    name: str
-    intervalPerSecond: float
-    gridSize: X_Y
-    planeSize: X_Y
-    orderCountPerBeat: int
-    sphereNodes: list[DDSphereNode] = field(default_factory=list)
-    lineNodes: list[DDLineNode] = field(default_factory=list)
+    sphereNodes: list[DDSphereNode]
+    lineNodes: list[DDLineNode]
+    roadBlockNodes: list[DDRoadBlockNode]
+    intervalPerSecond: float = 0.0
+    gridSize: X_Y = X_Y(x=0, y=0)
+    planeSize: X_Y = X_Y(x=0, y=0)
+    orderCountPerBeat: int = ORDER_COUNT_PER_BEAT
    effectNodes: list = field(default_factory=list)
-    roadBlockNodes: list = field(default_factory=list)
    trapNodes: list = field(default_factory=list)


@dataclass
 class DDBeatMap:
    data: DDBeatMapData
-    beatSubs: int
    BPM: int
-    songStartOffset: float
    NPS: str
-    developerMode: bool
-    noteSpeed: float
-    noteJumpOffset: float
-    interval: float
-    info: str
+    beatSubs: int = 1
+    songStartOffset: float = 0.0
+    developerMode: bool = False
+    noteSpeed: float = 1.0
+    noteJumpOffset: float = 0.0
+    interval: float = 1.0
+    info: str = ''
+
+    def save_to_file(self, target_dir: str, filename: str) -> str:
+        target_difficulty_path = os.path.join(target_dir, filename)
+        with open(target_difficulty_path, 'w') as f:
+            json.dump(asdict(self), f, indent=4)
+        return target_difficulty_path
+
+    @property
+    def block_less(self):
+        beat_map = deepcopy(self)
+        beat_map.data.name = f'{beat_map.data.name} (Blockless)'
+        beat_map.data.roadBlockNodes = []
+        return beat_map


@dataclass
 class DDBeatMapInfoFile:
-    EditorVersion: str
    BeatMapId: int
-    OstId: int
-    CreateTicks: int
-    CreateTime: str
    SongName: str
    SongLength: str
    SongAuthorName: str
-    LevelAuthorName: str
-    SongPreviewSection: int
    Bpm: str
    SongPath: str
+    CreateTicks: int
+    CreateTime: str
+    EditorVersion: str = '1.3.2'
+    OstId: int = 0
+    LevelAuthorName: str = 'https://github.com/thomasasfk/drs2dd'
+    SongPreviewSection: int = 0
    OstName: str | None = None
    CoverPath: str | None = None
    DDVR_Easy: str | None = None
@@ -141,3 +174,9 @@ class DDBeatMapInfoFile:
    DRS_ACE: str | None = None
    DDVR_Env: str | None = None
    DRS_Env: str | None = None
+
+    def save_to_file(self, target_dir: str) -> str:
+        info_file_path = os.path.join(target_dir, 'info.json')
+        with open(info_file_path, 'w') as f:
+            json.dump(asdict(self), f, indent=4)
+        return info_file_path
@@ -58,6 +58,14 @@ class DRSSongData:
    difficulties: DRSSongDifficulties | None = None
    info: DRSSongInfo | None = None

+    @property
+    def ogg(self) -> str:
+        return f'{str(self.song_id)}.ogg'
+
+    @property
+    def png(self) -> str:
+        return f'{str(self.song_id)}.png'
+
    @classmethod
    def from_xml_dict(cls, data: dict, difficulties: DRSSongDifficulties) -> DRSSongData:
        return cls(
@@ -337,6 +345,10 @@ class DRSTrackStep:
    player_info: DRSTrackStepPlayerInfo
    long_point: list[DRSTrackPoint] = field(default_factory=list)

+    @property
+    def is_down_or_up(self):
+        return self.kind in (DRS_DOWN, DRS_JUMP)
+
    @classmethod
    def from_xml_dict(cls, data: dict):

@@ -35,10 +35,5 @@ find . -type f -name "*.m4a" -exec sh -c 'ffmpeg -y -i "$1" "${1%.m4a}.ogg"' sh

 ```bash
 # remove 10 seconds from all ogg files
-find . -type f -name "*.ogg" -exec sh -c 'DURATION=$(ffprobe -i "$0" -show_entries format=duration -v quiet -of csv="p=0"); TRIM_TIME=$(awk "BEGIN {print $DURATION - 10}"); ffmpeg -ss 0 -t $TRIM_TIME -i "$0" "${0%.mp3}-fixed.ogg"' {} \;
-```
-
-```bash
-# move the fixed ogg files to the original file name
-find . -type f -name '*-fixed.ogg' -exec sh -c 'mv "$0" "${0%-fixed.mp3}.ogg"' {} \;
+find . -type f -name "*.m4a" -exec sh -c 'DURATION=$(ffprobe -i "$0" -show_entries format=duration -v quiet -of csv="p=0"); TRIM_TIME=$(awk "BEGIN {print $DURATION - 10}"); ffmpeg -ss 0 -t $TRIM_TIME -i "$0" "${0%.m4a}.ogg"' {} \;
 ```
@@ -1,27 +0,0 @@
-{
-    "EditorVersion": "1.3.2",
-    "BeatMapId": 287,
-    "OstId": 0,
-    "CreateTicks": 0,
-    "CreateTime": "",
-    "SongName": "1-2-3 Jump!",
-    "SongLength": "124.017778",
-    "SongAuthorName": "\u307e\u308d\u3093 (IOSYS) ft. Renko",
-    "LevelAuthorName": "https://github.com/thomasasfk/drs2dd",
-    "SongPreviewSection": 0,
-    "Bpm": "110",
-    "SongPath": "00287clip1.ogg",
-    "OstName": null,
-    "CoverPath": "jk_00287_b.png",
-    "DDVR_Easy": null,
-    "DDVR_Normal": null,
-    "DDVR_Hard": null,
-    "DRS_Easy": "287_difficulty_1b_no_blocks.json",
-    "DRS_Normal": "287_difficulty_1a_no_blocks.json",
-    "DRS_Hard": "287_difficulty_1b.json",
-    "DRS_Expert": "287_difficulty_1a.json",
-    "DRS_Master": null,
-    "DRS_ACE": null,
-    "DDVR_Env": null,
-    "DRS_Env": null
-}
@@ -0,0 +1,27 @@
+{
+    "BeatMapId": 287,
+    "SongName": "1-2-3 Jump!",
+    "SongLength": "114.003469",
+    "SongAuthorName": "\u307e\u308d\u3093 (IOSYS) ft. Renko",
+    "Bpm": "110",
+    "SongPath": "287.ogg",
+    "CreateTicks": 637822944000000000,
+    "CreateTime": "637822944000000000",
+    "EditorVersion": "1.3.2",
+    "OstId": 0,
+    "LevelAuthorName": "https://github.com/thomasasfk/drs2dd",
+    "SongPreviewSection": 0,
+    "OstName": null,
+    "CoverPath": "287.png",
+    "DDVR_Easy": null,
+    "DDVR_Normal": null,
+    "DDVR_Hard": null,
+    "DRS_Easy": "difficulty_1b_blockless.json",
+    "DRS_Normal": "difficulty_1a_blockless.json",
+    "DRS_Hard": "difficulty_1b.json",
+    "DRS_Expert": "difficulty_1a.json",
+    "DRS_Master": null,
+    "DRS_ACE": null,
+    "DDVR_Env": null,
+    "DRS_Env": null
+}
@@ -1,25 +1,25 @@
 {
-    "EditorVersion": "1.3.2",
    "BeatMapId": 121,
-    "OstId": 0,
-    "CreateTicks": 0,
-    "CreateTime": "",
    "SongName": "41 Days",
-    "SongLength": "101.889161",
+    "SongLength": "91.878458",
    "SongAuthorName": "Merk & Kremont",
+    "Bpm": "128",
+    "SongPath": "121.ogg",
+    "CreateTicks": 637140384000000000,
+    "CreateTime": "637140384000000000",
+    "EditorVersion": "1.3.2",
+    "OstId": 0,
    "LevelAuthorName": "https://github.com/thomasasfk/drs2dd",
    "SongPreviewSection": 0,
-    "Bpm": "128",
-    "SongPath": "00121clip1.ogg",
    "OstName": null,
-    "CoverPath": "jk_00121_b.png",
+    "CoverPath": "121.png",
    "DDVR_Easy": null,
    "DDVR_Normal": null,
    "DDVR_Hard": null,
-    "DRS_Easy": "121_difficulty_1b_no_blocks.json",
-    "DRS_Normal": "121_difficulty_1a_no_blocks.json",
-    "DRS_Hard": "121_difficulty_1b.json",
-    "DRS_Expert": "121_difficulty_1a.json",
+    "DRS_Easy": "difficulty_1b_blockless.json",
+    "DRS_Normal": "difficulty_1a_blockless.json",
+    "DRS_Hard": "difficulty_1b.json",
+    "DRS_Expert": "difficulty_1a.json",
    "DRS_Master": null,
    "DRS_ACE": null,
    "DDVR_Env": null,
@@ -1,25 +1,25 @@
 {
-    "EditorVersion": "1.3.2",
    "BeatMapId": 132,
-    "OstId": 0,
-    "CreateTicks": 0,
-    "CreateTime": "",
    "SongName": "50th Memorial Songs -Beginning Story-",
-    "SongLength": "138.019410",
+    "SongLength": "128.003469",
    "SongAuthorName": "BEMANI Sound Team",
+    "Bpm": "135",
+    "SongPath": "132.ogg",
+    "CreateTicks": 636887232000000000,
+    "CreateTime": "636887232000000000",
+    "EditorVersion": "1.3.2",
+    "OstId": 0,
    "LevelAuthorName": "https://github.com/thomasasfk/drs2dd",
    "SongPreviewSection": 0,
-    "Bpm": "135",
-    "SongPath": "00132clip1.ogg",
    "OstName": null,
-    "CoverPath": "jk_00132_b.png",
+    "CoverPath": "132.png",
    "DDVR_Easy": null,
    "DDVR_Normal": null,
    "DDVR_Hard": null,
-    "DRS_Easy": "132_difficulty_1b_no_blocks.json",
-    "DRS_Normal": "132_difficulty_1a_no_blocks.json",
-    "DRS_Hard": "132_difficulty_1b.json",
-    "DRS_Expert": "132_difficulty_1a.json",
+    "DRS_Easy": "difficulty_1b_blockless.json",
+    "DRS_Normal": "difficulty_1a_blockless.json",
+    "DRS_Hard": "difficulty_1b.json",
+    "DRS_Expert": "difficulty_1a.json",
    "DRS_Master": null,
    "DRS_ACE": null,
    "DDVR_Env": null,
@@ -1,25 +1,25 @@
 {
-    "EditorVersion": "1.3.2",
    "BeatMapId": 133,
-    "OstId": 0,
-    "CreateTicks": 0,
-    "CreateTime": "",
    "SongName": "50th Memorial Songs -Flagship medley-",
-    "SongLength": "122.345941",
+    "SongLength": "112.335465",
    "SongAuthorName": "BEMANI Sound Team",
+    "Bpm": "135",
+    "SongPath": "133.ogg",
+    "CreateTicks": 636917472000000000,
+    "CreateTime": "636917472000000000",
+    "EditorVersion": "1.3.2",
+    "OstId": 0,
    "LevelAuthorName": "https://github.com/thomasasfk/drs2dd",
    "SongPreviewSection": 0,
-    "Bpm": "135",
-    "SongPath": "00133clip1.ogg",
    "OstName": null,
-    "CoverPath": "jk_00133_b.png",
+    "CoverPath": "133.png",
    "DDVR_Easy": null,
    "DDVR_Normal": null,
    "DDVR_Hard": null,
-    "DRS_Easy": "133_difficulty_1b_no_blocks.json",
-    "DRS_Normal": "133_difficulty_1a_no_blocks.json",
-    "DRS_Hard": "133_difficulty_1b.json",
-    "DRS_Expert": "133_difficulty_1a.json",
+    "DRS_Easy": "difficulty_1b_blockless.json",
+    "DRS_Normal": "difficulty_1a_blockless.json",
+    "DRS_Hard": "difficulty_1b.json",
+    "DRS_Expert": "difficulty_1a.json",
    "DRS_Master": null,
    "DRS_ACE": null,
    "DDVR_Env": null,
@@ -1,25 +1,25 @@
 {
-    "EditorVersion": "1.3.2",
    "BeatMapId": 131,
-    "OstId": 0,
-    "CreateTicks": 0,
-    "CreateTime": "",
    "SongName": "50th Memorial Songs -The BEMANI History-",
-    "SongLength": "130.008526",
+    "SongLength": "120.003469",
    "SongAuthorName": "BEMANI Sound Team",
+    "Bpm": "136",
+    "SongPath": "131.ogg",
+    "CreateTicks": 636917472000000000,
+    "CreateTime": "636917472000000000",
+    "EditorVersion": "1.3.2",
+    "OstId": 0,
    "LevelAuthorName": "https://github.com/thomasasfk/drs2dd",
    "SongPreviewSection": 0,
-    "Bpm": "136",
-    "SongPath": "00131clip1.ogg",
    "OstName": null,
-    "CoverPath": "jk_00131_b.png",
+    "CoverPath": "131.png",
    "DDVR_Easy": null,
    "DDVR_Normal": null,
    "DDVR_Hard": null,
-    "DRS_Easy": "131_difficulty_1b_no_blocks.json",
-    "DRS_Normal": "131_difficulty_1a_no_blocks.json",
-    "DRS_Hard": "131_difficulty_1b.json",
-    "DRS_Expert": "131_difficulty_1a.json",
+    "DRS_Easy": "difficulty_1b_blockless.json",
+    "DRS_Normal": "difficulty_1a_blockless.json",
+    "DRS_Hard": "difficulty_1b.json",
+    "DRS_Expert": "difficulty_1a.json",
    "DRS_Master": null,
    "DRS_ACE": null,
    "DDVR_Env": null,
@@ -0,0 +1,27 @@
+{
+    "BeatMapId": 134,
+    "SongName": "50th Memorial Songs -\u4e8c\u4eba\u306e\u6642 \uff5eunder the cherry blossoms\uff5e-",
+    "SongLength": "124.503469",
+    "SongAuthorName": "BEMANI Sound Team",
+    "Bpm": "160",
+    "SongPath": "134.ogg",
+    "CreateTicks": 636917472000000000,
+    "CreateTime": "636917472000000000",
+    "EditorVersion": "1.3.2",
+    "OstId": 0,
+    "LevelAuthorName": "https://github.com/thomasasfk/drs2dd",
+    "SongPreviewSection": 0,
+    "OstName": null,
+    "CoverPath": "134.png",
+    "DDVR_Easy": null,
+    "DDVR_Normal": null,
+    "DDVR_Hard": null,
+    "DRS_Easy": "difficulty_1b_blockless.json",
+    "DRS_Normal": "difficulty_1a_blockless.json",
+    "DRS_Hard": "difficulty_1b.json",
+    "DRS_Expert": "difficulty_1a.json",
+    "DRS_Master": null,
+    "DRS_ACE": null,
+    "DDVR_Env": null,
+    "DRS_Env": null
+}
@@ -1,27 +0,0 @@
-{
-    "EditorVersion": "1.3.2",
-    "BeatMapId": 134,
-    "OstId": 0,
-    "CreateTicks": 0,
-    "CreateTime": "",
-    "SongName": "50th Memorial Songs -\u4e8c\u4eba\u306e\u6642 \uff5eunder the cherry blossoms\uff5e-",
-    "SongLength": "134.513197",
-    "SongAuthorName": "BEMANI Sound Team",
-    "LevelAuthorName": "https://github.com/thomasasfk/drs2dd",
-    "SongPreviewSection": 0,
-    "Bpm": "160",
-    "SongPath": "00134clip1.ogg",
-    "OstName": null,
-    "CoverPath": "jk_00134_b.png",
-    "DDVR_Easy": null,
-    "DDVR_Normal": null,
-    "DDVR_Hard": null,
-    "DRS_Easy": "134_difficulty_1b_no_blocks.json",
-    "DRS_Normal": "134_difficulty_1a_no_blocks.json",
-    "DRS_Hard": "134_difficulty_1b.json",
-    "DRS_Expert": "134_difficulty_1a.json",
-    "DRS_Master": null,
-    "DRS_ACE": null,
-    "DDVR_Env": null,
-    "DRS_Env": null
-}
@@ -1,25 +1,25 @@
 {
-    "EditorVersion": "1.3.2",
    "BeatMapId": 272,
-    "OstId": 0,
-    "CreateTicks": 0,
-    "CreateTime": "",
    "SongName": "7 to Smoke",
-    "SongLength": "120.627664",
+    "SongLength": "110.628458",
    "SongAuthorName": "lapix",
+    "Bpm": "120",
+    "SongPath": "272.ogg",
+    "CreateTicks": 637631136000000000,
+    "CreateTime": "637631136000000000",
+    "EditorVersion": "1.3.2",
+    "OstId": 0,
    "LevelAuthorName": "https://github.com/thomasasfk/drs2dd",
    "SongPreviewSection": 0,
-    "Bpm": "120",
-    "SongPath": "00272clip1.ogg",
    "OstName": null,
-    "CoverPath": "jk_00272_b.png",
+    "CoverPath": "272.png",
    "DDVR_Easy": null,
    "DDVR_Normal": null,
    "DDVR_Hard": null,
-    "DRS_Easy": "272_difficulty_1b_no_blocks.json",
-    "DRS_Normal": "272_difficulty_1a_no_blocks.json",
-    "DRS_Hard": "272_difficulty_1b.json",
-    "DRS_Expert": "272_difficulty_1a.json",
+    "DRS_Easy": "difficulty_1b_blockless.json",
+    "DRS_Normal": "difficulty_1a_blockless.json",
+    "DRS_Hard": "difficulty_1b.json",
+    "DRS_Expert": "difficulty_1a.json",
    "DRS_Master": null,
    "DRS_ACE": null,
    "DDVR_Env": null,
@@ -1,25 +1,25 @@
 {
-    "EditorVersion": "1.3.2",
    "BeatMapId": 278,
-    "OstId": 0,
-    "CreateTicks": 0,
-    "CreateTime": "",
    "SongName": "8347",
-    "SongLength": "114.311837",
+    "SongLength": "104.311474",
    "SongAuthorName": "Zekk",
+    "Bpm": "130",
+    "SongPath": "278.ogg",
+    "CreateTicks": 637636320000000000,
+    "CreateTime": "637636320000000000",
+    "EditorVersion": "1.3.2",
+    "OstId": 0,
    "LevelAuthorName": "https://github.com/thomasasfk/drs2dd",
    "SongPreviewSection": 0,
-    "Bpm": "130",
-    "SongPath": "00278clip1.ogg",
    "OstName": null,
-    "CoverPath": "jk_00278_b.png",
+    "CoverPath": "278.png",
    "DDVR_Easy": null,
    "DDVR_Normal": null,
    "DDVR_Hard": null,
-    "DRS_Easy": "278_difficulty_1b_no_blocks.json",
-    "DRS_Normal": "278_difficulty_1a_no_blocks.json",
-    "DRS_Hard": "278_difficulty_1b.json",
-    "DRS_Expert": "278_difficulty_1a.json",
+    "DRS_Easy": "difficulty_1b_blockless.json",
+    "DRS_Normal": "difficulty_1a_blockless.json",
+    "DRS_Hard": "difficulty_1b.json",
+    "DRS_Expert": "difficulty_1a.json",
    "DRS_Master": null,
    "DRS_ACE": null,
    "DDVR_Env": null,
@@ -1,25 +1,25 @@
 {
-    "EditorVersion": "1.3.2",
    "BeatMapId": 236,
-    "OstId": 0,
-    "CreateTicks": 0,
-    "CreateTime": "",
    "SongName": "A Legend Is Born",
-    "SongLength": "126.804172",
+    "SongLength": "116.803469",
    "SongAuthorName": "RoughSketch",
+    "Bpm": "150",
+    "SongPath": "236.ogg",
+    "CreateTicks": 637394400000000000,
+    "CreateTime": "637394400000000000",
+    "EditorVersion": "1.3.2",
+    "OstId": 0,
    "LevelAuthorName": "https://github.com/thomasasfk/drs2dd",
    "SongPreviewSection": 0,
-    "Bpm": "150",
-    "SongPath": "00236clip1.ogg",
    "OstName": null,
-    "CoverPath": "jk_00236_b.png",
+    "CoverPath": "236.png",
    "DDVR_Easy": null,
    "DDVR_Normal": null,
    "DDVR_Hard": null,
-    "DRS_Easy": "236_difficulty_1b_no_blocks.json",
-    "DRS_Normal": "236_difficulty_1a_no_blocks.json",
-    "DRS_Hard": "236_difficulty_1b.json",
-    "DRS_Expert": "236_difficulty_1a.json",
+    "DRS_Easy": "difficulty_1b_blockless.json",
+    "DRS_Normal": "difficulty_1a_blockless.json",
+    "DRS_Hard": "difficulty_1b.json",
+    "DRS_Expert": "difficulty_1a.json",
    "DRS_Master": null,
    "DRS_ACE": null,
    "DDVR_Env": null,
@@ -1,25 +1,25 @@
 {
-    "EditorVersion": "1.3.2",
    "BeatMapId": 316,
-    "OstId": 0,
-    "CreateTicks": 0,
-    "CreateTime": "",
    "SongName": "A Vague Idea",
-    "SongLength": "124.644717",
+    "SongLength": "114.630454",
    "SongAuthorName": "BEMANI Sound Team \"PHQUASE\"",
+    "Bpm": "134",
+    "SongPath": "316.ogg",
+    "CreateTicks": 637848000000000000,
+    "CreateTime": "637848000000000000",
+    "EditorVersion": "1.3.2",
+    "OstId": 0,
    "LevelAuthorName": "https://github.com/thomasasfk/drs2dd",
    "SongPreviewSection": 0,
-    "Bpm": "134",
-    "SongPath": "00316clip1.ogg",
    "OstName": null,
-    "CoverPath": "jk_00316_b.png",
+    "CoverPath": "316.png",
    "DDVR_Easy": null,
    "DDVR_Normal": null,
    "DDVR_Hard": null,
-    "DRS_Easy": "316_difficulty_1b_no_blocks.json",
-    "DRS_Normal": "316_difficulty_1a_no_blocks.json",
-    "DRS_Hard": "316_difficulty_1b.json",
-    "DRS_Expert": "316_difficulty_1a.json",
+    "DRS_Easy": "difficulty_1b_blockless.json",
+    "DRS_Normal": "difficulty_1a_blockless.json",
+    "DRS_Hard": "difficulty_1b.json",
+    "DRS_Expert": "difficulty_1a.json",
    "DRS_Master": null,
    "DRS_ACE": null,
    "DDVR_Env": null,
--- a/Show More
+++ b/Show More