From 4b08430cf4407dec7e4fd71e1757dc9134de14c1 Mon Sep 17 00:00:00 2001
From: UnitedAirforce <i5904503668i@gmail.com>
Date: Tue, 9 Jun 2026 22:45:46 +0800
Subject: [PATCH] Added osu/osz converter and importer

---
 server/importer.py                            | 368 ++++++++++
 .../.gitignore                                |   2 +
 tools/osuosz to bms (modified om2bms)/LICENSE | 674 ++++++++++++++++++
 .../osuosz to bms (modified om2bms)/README.md | 117 +++
 .../commandUI.py                              | 148 ++++
 .../default_outdir.ini                        |   1 +
 .../om2bms/__init__.py                        |   1 +
 .../om2bms/allerregular.ttf                   | Bin 0 -> 96396 bytes
 .../om2bms/data_structures.py                 | 351 +++++++++
 .../om2bms/exceptions.py                      |  23 +
 .../om2bms/extra_file_processing.py           | 107 +++
 .../om2bms/om_to_bms.py                       | 534 ++++++++++++++
 .../om2bms/osu.py                             | 399 +++++++++++
 tools/osuosz to bms (modified om2bms)/osu.py  |  55 ++
 tools/osuosz to bms (modified om2bms)/osz.py  | 233 ++++++
 .../output/placeholder                        |   1 +
 .../requirements.txt                          |   2 +
 .../settings.json                             |   1 +
 18 files changed, 3017 insertions(+)
 create mode 100644 server/importer.py
 create mode 100644 tools/osuosz to bms (modified om2bms)/.gitignore
 create mode 100644 tools/osuosz to bms (modified om2bms)/LICENSE
 create mode 100644 tools/osuosz to bms (modified om2bms)/README.md
 create mode 100644 tools/osuosz to bms (modified om2bms)/commandUI.py
 create mode 100644 tools/osuosz to bms (modified om2bms)/default_outdir.ini
 create mode 100644 tools/osuosz to bms (modified om2bms)/om2bms/__init__.py
 create mode 100644 tools/osuosz to bms (modified om2bms)/om2bms/allerregular.ttf
 create mode 100644 tools/osuosz to bms (modified om2bms)/om2bms/data_structures.py
 create mode 100644 tools/osuosz to bms (modified om2bms)/om2bms/exceptions.py
 create mode 100644 tools/osuosz to bms (modified om2bms)/om2bms/extra_file_processing.py
 create mode 100644 tools/osuosz to bms (modified om2bms)/om2bms/om_to_bms.py
 create mode 100644 tools/osuosz to bms (modified om2bms)/om2bms/osu.py
 create mode 100644 tools/osuosz to bms (modified om2bms)/osu.py
 create mode 100644 tools/osuosz to bms (modified om2bms)/osz.py
 create mode 100644 tools/osuosz to bms (modified om2bms)/output/placeholder
 create mode 100644 tools/osuosz to bms (modified om2bms)/requirements.txt
 create mode 100644 tools/osuosz to bms (modified om2bms)/settings.json

diff --git a/server/importer.py b/server/importer.py
new file mode 100644
index 0000000..21dc396
--- /dev/null
+++ b/server/importer.py
@@ -0,0 +1,368 @@
+import os
+import zipfile
+import json
+import shutil
+import hashlib
+from PIL import Image
+
+def calculate_md5_and_size(file_path):
+    md5_hash = hashlib.md5()
+    file_size = 0
+
+    with open(file_path, "rb") as file:
+        for byte_block in iter(lambda: file.read(4096), b""):
+            md5_hash.update(byte_block)
+            file_size += len(byte_block)
+
+    return md5_hash.hexdigest(), file_size
+
+def process_folder(folder_path):
+    md5_checksum_dict = {}
+    size_dict = {}
+
+    for root, dirs, files in os.walk(folder_path):
+        for file_name in files:
+            file_path = os.path.join(root, file_name)
+            relative_path = os.path.relpath(file_path, folder_path)
+            
+            md5_checksum, file_size = calculate_md5_and_size(file_path)
+            
+            md5_checksum_dict[relative_path.replace("\\", "/")] = md5_checksum
+            size_dict[relative_path.replace("\\", "/")] = file_size
+
+    return md5_checksum_dict, size_dict
+
+def write_to_file(file_name, data):
+    with open(file_name, "w") as file:
+        file.write(json.dumps(data, separators=(',', ':')))
+
+def get_unique_song_file(existing_songs, song_file):
+    counter = 1
+    unique_song_file = song_file
+    while unique_song_file in existing_songs:
+        unique_song_file = f"{song_file}{counter}"
+        counter += 1
+    return unique_song_file
+
+def get_chart_list(dir, manifest):
+    chart_6k = manifest.get("diff_6k").split('/')
+    chart_4k = manifest.get("diff_4k").split('/')
+    dir_list = []
+    all_chart = chart_6k + chart_4k
+    diff_table = ["_EL.bms", "_EX.bms", "_LPR.bms", "_PR.bms", "_EL4.bms", "_EX4.bms", "_PR4.bms"]
+    for i in range(len(all_chart)):
+        if all_chart[i] != "0":
+            path = os.path.join(dir, "note", manifest.get("mp3") + diff_table[i])
+            dir_list.append(path)
+    return dir_list
+
+def deleteChart(song_id):
+
+    # Find the song manifest to remove.
+
+    playmanifest_path = "OverRide/playmanifest.json"
+    with open(playmanifest_path, 'r', encoding="utf-8") as f:
+        playmanifest = json.load(f)
+
+    manifest_to_remove = None
+    for manifest in playmanifest:
+        if manifest[0].get("id") == song_id:
+            manifest_to_remove = manifest
+            break
+
+    # We now have the manifest to remove, which is aquired after looping through the main manifest.
+
+    if manifest_to_remove is None:
+        print("That song ID not found. 没有找到此歌曲ID。")
+        return
+    
+    # Confirm with the user one last time by printing out some useful data.
+
+    song_title = manifest_to_remove[0].get("title")
+    diff_str = manifest_to_remove[0].get("diff_6k") + "/" + manifest_to_remove[0].get("diff_4k")
+    charter = manifest_to_remove[0].get("charter_6k") + "/" + manifest_to_remove[0].get("charter_4k")
+    print(f"Are you sure you want to delete the song '{song_title}', difficulty '{diff_str}', charted by '{charter}'?")
+    print(f"你确定要删除这首歌吗？名为 '{song_title}'，难度 '{diff_str}'，谱师为 '{charter}'?")
+    confirm = input("(y/n): ")
+    if confirm.lower() != 'y':
+        print("Deletion cancelled. 删除终止。")
+        return
+
+    song_name = manifest_to_remove[0].get("mp3")
+
+    # Remove everything but the chart.
+
+    paths_to_check = [
+        (os.path.join("OverRide", "bga", f"{song_name}.zip"), False),
+        (os.path.join("OverRide", "music", f"{song_name}"), False),
+        (os.path.join("Resources", "data_fm", f"{song_name}.jpg"), False),
+        (os.path.join("Resources", "data_fm", f"255{song_name}.jpg"), False),
+    ]
+
+    for path, _ in paths_to_check:
+        if os.path.exists(path):
+            os.remove(path)
+
+    # Remove charts
+
+    charts = get_chart_list(os.path.join("OverRide"), manifest_to_remove[0])
+
+    for chart in charts:
+        chart = chart.replace(".bms", "")
+        if os.path.exists(chart):
+            os.remove(chart)
+
+    # Remove the charts from the zip.
+
+    note_zip_path = os.path.join("OverRide", "Note.zip")
+    if os.path.exists(note_zip_path):
+        temp_zip_path = os.path.join("OverRide", "temp_Note.zip")
+        with zipfile.ZipFile(note_zip_path, 'r') as note_zip:
+            with zipfile.ZipFile(temp_zip_path, 'w') as temp_zip:
+                for item in note_zip.infolist():
+                    check_name = "offlineNote_" + song_name + "_"
+                    file_name = item.filename
+                    if not file_name.startswith(check_name):
+                        # write file
+                        temp_zip.writestr(item, note_zip.read(item.filename))
+
+        os.remove(note_zip_path)
+        os.rename(temp_zip_path, note_zip_path)
+
+    # Remove the manifest, and refresh the metadata.
+
+    playmanifest.remove(manifest_to_remove)
+    with open(playmanifest_path, 'w', encoding="utf-8") as f:
+        json.dump(playmanifest, f, indent=4)
+
+    # Correct the main sync and metadata.
+    update_metadata()
+    print("Song has been deleted from the server. 歌曲已从服务器删除。")
+
+def importChart(name):
+
+    # Create a temp directory for unzipping the provided zip file.
+
+    extract_to = "_temp"
+    if os.path.exists(extract_to):
+        shutil.rmtree(extract_to)
+    os.makedirs(extract_to)
+
+    if not os.path.isfile(name):
+        print(f"Error: The file '{name}' does not exist.")
+        return
+
+    # Safely opens the zip file.
+
+    try:
+        with zipfile.ZipFile(name, 'r') as zip_ref:
+            zip_ref.extractall(extract_to)
+    except zipfile.BadZipFile:
+        print(f"Error: '{name}' is not a valid zip file.")
+        return
+    except PermissionError:
+        print(f"Error: Permission denied. Check your permissions for '{extract_to}'.")
+        return
+    except Exception as e:
+        print(f"An unexpected error occurred when unzipping: {e}")
+        return
+
+    # Safely read the song manifest
+
+    manifest_path = os.path.join(extract_to, "manifest.json")
+
+    if not os.path.isfile(manifest_path):
+        print(f"Error: The file '{manifest_path}' does not exist.")
+        return
+    try:
+        with open(manifest_path, 'r', encoding='utf-8') as f:
+            manifest = json.load(f)
+    except Exception as e:
+        print(f"JSON parse failed for manifest failed: {e}")
+        return
+    
+    for song in manifest:
+        song_file = song.get("mp3")
+
+        # get list of charts
+
+        charts = get_chart_list(extract_to, song)
+
+        # Sanity check everything
+        # (0): at least one chart should be present in the config.
+
+        standard_check = True
+        reason_fail = ""
+
+        if charts == []:
+            standard_check = False
+            reason_fail += "\nNo charts found in the chart config this song (all zeroes). "
+
+        bga_data = song.get("bga")
+
+        # (1): either the jpg and png version of the thumbnail should exist. 
+
+        img1_path = os.path.join(os.path.join(extract_to, "thumbs"), f"{song_file}.jpg")
+        img2_path = os.path.join(os.path.join(extract_to, "thumbs"), f"{song_file}.png")
+        is_png = False
+
+        if os.path.exists(img1_path) == False:
+            if os.path.exists(img2_path) == False:
+                standard_check = False
+                reason_fail += "\nSong thumbnail (music_name.jpg or music_name.png) is missing from the thumbs folder. "
+            else:
+                is_png = True
+
+        # (2): The correct mp3 file should be there.
+
+        song_path = os.path.join(os.path.join(extract_to, "music"), f"{song_file}.mp3")
+
+        if os.path.exists(song_path) == False:
+            standard_check = False
+            reason_fail += "\nMusic file (music_name.mp3) is missing from the Music folder. "
+
+        # (3): If bga data is present, bga file should be there.
+
+        bga_path = os.path.join(os.path.join(extract_to, "bga"), f"{song_file}.zip")
+
+        if bga_data != None and os.path.exists(bga_path) == False:
+            standard_check = False
+            reason_fail += "\nSince manifest specified BGA, there should be a music_name.zip in the bga folder. "
+
+        # (4): If bga data is not present but there is a song_name.zip in bga folder.
+
+        if bga_data == None and os.path.exists(bga_path):
+            standard_check = False
+            reason_fail += "\nManifest did not specify BGA, but there is a music_name.zip in the bga folder. While this is not a breaking issue, if you wish to use the BGA please specify it in the manifest. "
+
+        # (5): All the charts specified in the manifest should exist
+
+        for chart in charts:
+            if os.path.exists(chart) == False:
+                standard_check = False
+                reason_fail += "\nA chart that is specified in manifest is missing from the note folder: " + chart + ". "
+
+        # That is it!
+
+        if standard_check == False:
+            print("The song contains issues and is not imported. 此曲目存在问题，没有导入。")
+            print("The reasons are as follows. 原因如下。")
+            print(reason_fail)
+            shutil.rmtree(extract_to)
+            continue
+        
+        playmanifest_path = "OverRide/playmanifest.json"
+        with open(playmanifest_path, 'r', encoding="utf-8") as f:
+            playmanifest = json.load(f)
+        
+        existing_song_files = [item[0].get("mp3") for item in playmanifest]
+        unique_song_file = get_unique_song_file(existing_song_files, song_file)
+
+        # Copy bga zip file if bga is specified
+
+        if bga_data != None:
+            new_bga_name = unique_song_file + ".zip"
+            new_bga_path = os.path.join("OverRide", "bga", new_bga_name)
+            os.makedirs(os.path.dirname(new_bga_path), exist_ok=True)
+            shutil.move(bga_path, new_bga_path)
+
+        # Copy music file
+
+        new_song_name = unique_song_file
+        new_song_path = os.path.join("OverRide", "Music", new_song_name)
+        os.makedirs(os.path.dirname(new_song_path), exist_ok=True)
+        shutil.move(song_path, new_song_path)
+
+        # Copy the thumbnails
+
+        new_img_name = unique_song_file + ".jpg"
+        new_img_path = os.path.join("Resources", "data_fm", new_img_name)
+        os.makedirs(os.path.dirname(new_img_path), exist_ok=True)
+
+        if is_png:
+            with Image.open(img2_path) as img:
+                rgb_img = img.convert("RGB")
+                rgb_img.save(new_img_path, "JPEG")
+        else:
+            shutil.move(img1_path, new_img_path)
+
+        # Save a resized 255x255 version of the image
+        resized_img_name = "255" + unique_song_file + ".jpg"
+        resized_img_path = os.path.join("Resources", "data_fm", resized_img_name)
+
+        with Image.open(new_img_path) as img:
+            img = img.resize((255, 255), Image.Resampling.LANCZOS)
+            img.save(resized_img_path, "JPEG")
+
+        # Copy all the charts
+
+        for chart in charts:
+            new_chart_name = os.path.basename(chart).replace(".bms", "")
+            new_chart_name = new_chart_name.replace(song_file, unique_song_file)
+            new_chart_path = os.path.join("OverRide", "Note", new_chart_name)
+            os.makedirs(os.path.dirname(new_chart_path), exist_ok=True)
+            shutil.copy(chart, new_chart_path)
+
+        # Add charts to zip
+
+        note_zip_path = os.path.join("OverRide", "Note.zip")
+        new_charts = []
+        for chart in charts:
+            new_chart_name = chart.replace(song_file, f"offlineNote_{unique_song_file}")
+            new_chart_name = new_chart_name.replace(".bms", "")
+            os.rename(chart, new_chart_name)
+            new_charts.append(new_chart_name)
+
+        with zipfile.ZipFile(note_zip_path, 'a') as note_zip:
+            for chart in new_charts:
+                note_zip.write(chart, arcname=os.path.basename(chart))
+
+        # Merge the manifest
+
+        if playmanifest:
+            last_id = playmanifest[-1][0].get("id", 0)
+        else:
+            last_id = 0
+
+        song["id"] = last_id + 1
+        song["mp3"] = unique_song_file
+
+        playmanifest.append([song])
+        with open(playmanifest_path, 'w', encoding="utf-8") as f:
+            json.dump(playmanifest, f, indent=4)
+
+        print(f"Song added: 歌曲已添加：{unique_song_file}")
+
+    # Refresh the metadata and we are done!
+    update_metadata()
+    shutil.rmtree(extract_to)
+        
+
+def update_metadata():
+    resources_folder = "Resources"
+    
+    md5_checksum_dict, size_dict = process_folder(resources_folder)
+    
+    md5_file_name = "OverRapid/Md5ListChecksum.json"
+    size_file_name = "OverRapid/SizeList.json"
+    
+    write_to_file(md5_file_name, md5_checksum_dict)
+    write_to_file(size_file_name, size_dict)
+
+    print(f"MD5 and size checksums saved.")
+
+def main():
+    print("Override Concierge - 您的Override管家")
+    print("For music import, simply enter the zip file's path. For music deletion, simply enter its SID as displayed in-game.")
+    print("曲目导入请输入zip文件的目录。曲目删除请输入游戏内显示的SID。")
+    user_input = input("Input 输入: ")
+
+    if user_input.isdigit():
+        deleteChart(int(user_input))
+    elif not user_input.endswith(".zip"):
+        print("The file is not zip. 文件不是zip。")
+    else:
+        importChart(user_input)
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/tools/osuosz to bms (modified om2bms)/.gitignore b/tools/osuosz to bms (modified om2bms)/.gitignore
new file mode 100644
index 0000000..389fb36
--- /dev/null
+++ b/tools/osuosz to bms (modified om2bms)/.gitignore	
@@ -0,0 +1,2 @@
+**/__pycache__/
+**/input/
\ No newline at end of file
diff --git a/tools/osuosz to bms (modified om2bms)/LICENSE b/tools/osuosz to bms (modified om2bms)/LICENSE
new file mode 100644
index 0000000..f288702
--- /dev/null
+++ b/tools/osuosz to bms (modified om2bms)/LICENSE	
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.
diff --git a/tools/osuosz to bms (modified om2bms)/README.md b/tools/osuosz to bms (modified om2bms)/README.md
new file mode 100644
index 0000000..5a7a5ef
--- /dev/null
+++ b/tools/osuosz to bms (modified om2bms)/README.md	
@@ -0,0 +1,117 @@
+# o!m2bms
+
+[Original Repo](https://github.com/mashimycota/om2bms)
+
+Program that converts osu!mania maps to BMS maps. (**currently only supports 2k to 8k**)
+
+Supports fully keysounded maps and bpm changes.
+
+**If you come across any Errors, please report them in the issues!**
+
+## Installation
+
+Written on Python 3.6+.
+You can download the required libraries by running:
+```
+pip install -r requirements.txt
+```
+
+Requires an instance of ffmpeg in your system PATH. Here's an [ffmpeg installtion tutorial](https://phoenixnap.com/kb/ffmpeg-windows) if you don't have it already. (To check it if works, type `ffmpeg` in your terminal, and it should not return an error)
+
+
+Set the default output directory by running,
+
+```
+python om2bms_osz.py -sdo [OUTPUT DIRECTORY]
+```
+
+or go to `default_outdir.ini` and paste the path to a subdirectory in a BMS songfolder directory.
+
+## Running
+Run
+
+```
+python om2bms_osz.py -i sample_osz_file.osz
+```
+
+to convert all 2k-8k files in `sample_osz_file.osz` and output them to `[OUTPUT DIRECTORY]/sample_osz_file`
+
+To convert individual .osu files run
+
+```
+python om2bms_osu.py -i sample_osu_file.osu
+```
+
+#### Batch Converting
+
+Run
+```
+python commandUI.py
+```
+To access the Command Line User Interface that allows some settings customisation and batch conversion of `.osz` files that are in the input folder (not compatible with single `.osu` files for now) 
+
+(I personally think always converting `.osz` files is best anyway)
+
+
+### To view help, run
+
+```
+python om2bms_osz.py -h
+```
+
+```
+python om2bms_osu.py -h
+```
+
+## Key Mapping
+(note: I will make images for this section in the future | will also make the layouts customizable)
+
+
+Lets define the columns like this = `|1|2|3|4|5|6|7|8|`.
+
+If a column is used for the key count in question, it will have it's corresponding number inside it.
+
+### 2k
+`|1| | | |5| | | |` (so 1k + scratch with controller)
+
+### 3k
+`| | | |4|5|6| | |`
+
+### 4k
+`| | |3|4| |6|7| |`
+
+### 5k
+`| |2|3|4|5|6| | |`
+
+### 6k
+`|1|2|3|4|5|6| | |` (so 5k + scratch if controller)
+
+## To-do List
+
+- [ ] Slider Velocity
+- [ ] Difficulty calculation when converting 
+- [x] *Background Videos* **(Needs to find fix for offset)**
+- [x] Persistent settings file for UI
+- [x] Support other keycounts then just 7k and 8k **(Supports 2k - 8k)**
+- [ ] Improved background image resize/processing when converting
+- [x] Adapt to be used without command line, aka a general run function for the arguments (necessary for GUI and improving command line UI)
+- [ ] Make GUI
+- [ ] Drag-and-drop for GUI
+- [ ] Change output file format from `.bms` to `.bmson` (will allow easier feature implementation). Not to be done for a while. Will require big rewrite.
+
+## Notes
+
+- Tested with LR2
+- Does not currently support SV changes
+- Uses first timing point to estimate the first measure
+- Assumes timing points are always the start of a new measure
+- If there are >1 hitsounds played in one note, only plays the hitsound with the highest bit
+
+[.osu file documentation](https://osu.ppy.sh/help/wiki/osu!_File_Formats/Osu_(file_format)).
+
+[BMS file documentation](https://hitkey.nekokan.dyndns.info/cmds.htm).
+
+## License
+
+This project is licensed under the GPLv3 license, refer to LICENSE for details.
+
diff --git a/tools/osuosz to bms (modified om2bms)/commandUI.py b/tools/osuosz to bms (modified om2bms)/commandUI.py
new file mode 100644
index 0000000..b1b503f
--- /dev/null
+++ b/tools/osuosz to bms (modified om2bms)/commandUI.py	
@@ -0,0 +1,148 @@
+import om2bms_osz
+import os
+import json
+
+
+if __name__ == "__main__":
+
+    clear = lambda: os.system("cls")
+
+    end = False
+    curr_page = "main"
+
+    # curr_opts = {
+    #     "in_file": "input", 
+    #     "set_default_out": open("./default_outdir.ini", "r").read().strip(),
+    #     "hitsound": None, 
+    #     "bg": True, 
+    #     "video": True, 
+    #     "offset": -235, 
+    #     "judge": 2
+    # }
+    if not os.path.exists("./settings.json"):
+        # incase someone for some reason deletes the settings file
+        default_settings = {
+            "in_file": "input", 
+            "set_default_out": "output",
+            "hitsound": None, 
+            "bg": True, 
+            "video": True, 
+            "offset": -235, 
+            "judge": 2
+            }
+        json.dump({"custom":default_settings, "default": default_settings}, open("./settings.json", "w"))
+
+    curr_opts = json.load(open("./settings.json", "r"))["custom"]
+    
+
+    if not os.path.isdir(curr_opts["in_file"]):
+        os.mkdir(curr_opts["in_file"])
+        print(f"The missing input directory \"{curr_opts['in_file']}\" has been created. You can put your .osz files in there to convert.")
+        input("Press ENTER to continue...")
+
+
+    while not end:
+        # updates options with whatever changes were made in previous iteration
+        settings_file = json.load(open("./settings.json", "r"))
+        settings_file["custom"] = curr_opts
+        json.dump(settings_file, open("./settings.json", "w"))  
+
+        # ugly format that shows the value of every setting at the beginning of each loop
+        main_page_options = """Input Folder: {}\t\t Output Folder: {}\t\t\t Use Hitsounds: {}
+Background Image: {}\t\t Default Map Offset: {}ms\t\t Judgement: {}
+Background Video: {}""".format(curr_opts["in_file"], curr_opts["set_default_out"], "False" if curr_opts["hitsound"] is None else curr_opts["hitsound"],
+                                                                                curr_opts["bg"], curr_opts["offset"], curr_opts["judge"], curr_opts["video"])
+
+
+        clear()
+        print("\n")
+        print(main_page_options)
+        print()
+
+        # initial page display
+        print("="*20 + "OPTIONS" + "="*20)
+        if curr_page == "main":
+            print("(1) Run Converter")
+            print("(2) Edit Settings")
+            print("(3) List Files To Convert")
+            print("(4) Exit Program")
+        elif curr_page == "settings":
+            print("(1) Change Input Folder \t\t (2) Change Output Folder")
+            print("(3) Toggle hitsounds \t\t\t (4) Toggle Convert Background Image")
+            print("(5) Change Offset\t\t\t (6) Change Map Judgement")
+            print("(7) Toggle Convert Background Video")
+            print("\n(RESET): Reset these settings back to the system defaults")
+            print("\n(0) Back to main page")
+            
+
+
+
+
+        print("")
+        option = input("Choose option number: ").lower().strip()
+
+        if curr_page == "main": # functionality for each option of main page
+            if option == "1":
+                # input_dir_scan = list(os.scandir(curr_opts["in_file"]))
+                
+                for file in os.scandir(curr_opts["in_file"]): # we loop across the path of every .osz file and convert them
+                    if file.is_file() and file.path.endswith(".osz"):
+                        curr_opts["in_file"] = file.path
+                        om2bms_osz.convert(**curr_opts)
+
+                print("\nConversion Complete\n")
+                end = True
+            elif option == "2":
+                curr_page = "settings"
+                clear()
+            elif option == "3": # we just iterate over and display the filename of all .osz files in input file
+                for file in os.scandir(curr_opts["in_file"]):
+                    if file.is_file() and file.path.endswith(".osz"):
+                        print(os.path.basename(file.path))
+                    input("(Enter to clear)")
+            elif option == "4":
+                end = True
+            else:
+                input("ERROR: That option number does not exist!")
+                
+        elif curr_page == "settings": # functionality for each  option of settings page
+            if option == "1":
+                new_input = input("Enter new input folder: ").strip()
+                if new_input:
+                    curr_opts["in_file"] = new_input
+                else:
+                    input("ERROR: the input folder must be a none empty name.")
+            elif option == "2":
+                new_output = input("Enter new output folder: ").strip()
+                if new_output:
+                    curr_opts["set_default_out"] = new_output
+                else:
+                    input("ERROR: the output folder must be a none empty name.")
+            elif option == "3":
+                curr_opts["hitsound"] = not curr_opts["hitsound"]
+            elif option == "4":
+                curr_opts["bg"] = not curr_opts["bg"]
+            elif option == "5":
+                new_offset = input("Enter a new Offset (ms): ").strip()
+                if all([num in map(str, range(10)) for num in (new_offset[1:] if new_offset[0] == "-" else new_offset)]):
+                    curr_opts["offset"] = int(new_offset)
+                else:
+                    input("ERROR: you must enter a whole number for the offset!")
+            elif option == "6":
+                new_judgement = input("Enter a number for the map judgement: ").strip()
+                if all([num in map(str, range(10)) for num in new_judgement]):
+                    curr_opts["judge"] = int(new_judgement) 
+                else:
+                    input("ERROR: Judgement number must be a positive whole number!")
+            elif option == "7":
+                curr_opts["video"] = not curr_opts["video"]
+            elif option == "reset":
+                settings_file = json.load(open("./settings.json", "r"))
+                curr_opts = settings_file["default"]
+                # will update the "settings.json" on next iteration of the while loop
+                
+            elif option == "0":
+                curr_page = "main"
+            else:
+                input("ERROR: That option number does not exist!")
+
diff --git a/tools/osuosz to bms (modified om2bms)/default_outdir.ini b/tools/osuosz to bms (modified om2bms)/default_outdir.ini
new file mode 100644
index 0000000..6caf68a
--- /dev/null
+++ b/tools/osuosz to bms (modified om2bms)/default_outdir.ini	
@@ -0,0 +1 @@
+output
\ No newline at end of file
diff --git a/tools/osuosz to bms (modified om2bms)/om2bms/__init__.py b/tools/osuosz to bms (modified om2bms)/om2bms/__init__.py
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/tools/osuosz to bms (modified om2bms)/om2bms/__init__.py	
@@ -0,0 +1 @@
+
diff --git a/tools/osuosz to bms (modified om2bms)/om2bms/allerregular.ttf b/tools/osuosz to bms (modified om2bms)/om2bms/allerregular.ttf
new file mode 100644
index 0000000000000000000000000000000000000000..8f384ee43d61d8d60f36bd157ae622c98be75a5e
GIT binary patch
literal 96396
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
M=eFjyF`DO$0D01e^#A|>

literal 0
HcmV?d00001

diff --git a/tools/osuosz to bms (modified om2bms)/om2bms/data_structures.py b/tools/osuosz to bms (modified om2bms)/om2bms/data_structures.py
new file mode 100644
index 0000000..ae59d02
--- /dev/null
+++ b/tools/osuosz to bms (modified om2bms)/om2bms/data_structures.py	
@@ -0,0 +1,351 @@
+from typing import Union, List, Tuple, Dict
+
+from om2bms.exceptions import BMSHitSoundException
+
+
+class OsuMania:
+    """Class containing information from .osu file"""
+
+    def __init__(self):
+        # general
+        self.audio_filename = None
+        self.audio_lead_in = None
+        self.video_filename = None
+        self.video_start_time = None
+        self.special_style = None  # o!m scrollkey y/n
+        self.sample_set = None
+        # metadata
+        self.title = None
+        self.title_unicode = None
+        self.artist = None
+        self.artist_unicode = None
+        self.creator = None
+        self.version = None
+        self.source = None
+        self.beatmap_id = None
+        self.stagebg = None
+
+        self.key_count = None  # originally circle size
+        self.od = None
+
+        self.float_bpm = []
+        self.timing_points = []
+        self.hit_objects = []
+        self.sample_objects = []
+        self.objects = []
+        self.sample_filenames = []
+        self.filename_to_sample = {}
+
+        self.noninherited_tp = []
+
+        self.hitsounds = {}
+        self.hitsound_names = []
+
+    def parse_float_bpm(self, bpm: float):
+        """
+        Parse float bpm into (INDEX, BPM)
+        """
+        for e in self.float_bpm:
+            if e[1] == bpm:
+                return
+        self.float_bpm.append((get_current_hs_count(len(self.float_bpm) + 1), bpm))
+
+
+class OsuTimingPoint:
+    """Contains information for a particular timing point"""
+    def __init__(self):
+        self.time = None
+        self.ms_per_beat = None
+        self.meter = None
+        self.sample_set = None
+        self.sample_index = None
+        self.volume = None  # not supported in lr2
+        self.inherited = None
+        self.kiai_mode = None  # not needed
+
+        self.ms_per_measure = None
+
+        self.sort_type = 0  # for sorting
+
+    def __repr__(self):
+        return str(self.time) + "ms at " + str(self.ms_per_beat) + "ms_per_beat"
+
+    def __eq__(self, other):
+        return self.ms_per_beat == other.ms_per_beat and self.meter == other.meter and \
+               self.sample_set == other.sample_set and self.sample_index == other.sample_index
+
+
+class SoundEvent:
+    """Just to contain build_filename"""
+    _hit_sound_key = {
+        0: "none",
+        1: "normal",
+        2: "whistle",
+        4: "finish",
+        8: "clap"}
+    _sample_set_key = {
+        1: "normal",
+        2: "soft",
+        3: "drum"}
+
+    def __init__(self):
+        self.index = None
+
+        self.sort_type = 1  # for sorting
+
+    def build_filename(self, custom_index: int, sample_set: int, hitsound: int) -> str:
+        """
+        filename = {sample set}-hit{sound}{index}.wav
+        """
+        index = "" if custom_index == 1 else str(custom_index)
+        return str(HitSound._sample_set_key[sample_set]) + "-hit" + str(HitSound._hit_sound_key[hitsound]) \
+            + index + ".wav"
+
+    def get_info(self):
+        """
+        For list iterating purposes
+        """
+        return (self.index, self)
+
+
+class OsuBGSoundEvent(SoundEvent):
+    """
+    For when sample plays in the background that is not the audiofile
+    """
+    def __init__(self, time, filename, sample_num):
+        super().__init__()
+        self.time = time
+        self.filename = filename
+        self.index = get_current_hs_count(sample_num)
+
+    def __str__(self):
+        return self.filename
+
+
+class HitSound(SoundEvent):
+    """
+    hit_sound key
+    """
+    def __init__(self, hitsound: int, tp: Union[OsuTimingPoint, None], sample_set: int, custom_index:
+                 int, filename: str, sample_num: int):
+        super().__init__()
+        self.timing_point = tp
+        self.hitsound = hitsound
+        self.sample_set = sample_set
+        self.custom_index = custom_index if custom_index != 0 else self.timing_point.sample_index
+        self.filename = filename if filename != "" else self.build_filename(self.custom_index, self.sample_set,
+                                                                            self.hitsound)
+        self.addition_set = self.sample_set  # needed?
+        self.index = get_current_hs_count(sample_num)
+
+    def __str__(self):
+        return self.filename
+
+
+class OsuHitObject:
+    """
+    Hitobject class
+
+    mania_column:
+    scroll = 0
+    key1 = 1
+    key2 = 2
+    ...
+    key7 = 7
+    """
+    def __init__(self):
+        self.time = None
+        self.time_value = None
+        self.new_combo = False
+
+        self.hit_sound = None
+        self.mania_column = None
+
+        self.timing_point = None
+
+        self.sort_type = 1  # for sorting
+
+
+class OsuManiaNote(OsuHitObject):
+    """Single o!m note"""
+    def __init__(self):
+        super().__init__()
+
+    def get_type_value(self):
+        """
+        Returns type value of note
+        """
+        return 5 if self.new_combo else 1
+
+    def __str__(self):
+        return "NOTE: t=" + str(self.time) + "|c=" + str(self.mania_column)
+
+    def __repr__(self):
+        return "NOTE: t=" + str(self.time) + "|c=" + str(self.mania_column)
+
+
+class OsuManiaLongNote(OsuHitObject):
+    """o!m noodle"""
+    def __init__(self, end_time=None):
+        super().__init__()
+        self.end_time = end_time
+
+    def get_type_value(self):
+        """
+        Returns type value of note
+        """
+        return 132 if self.new_combo else 128
+
+    def __str__(self):
+        return "LN: t=" + str(self.time) + "|t2=" + str(self.end_time) + "|c=" + str(self.mania_column)
+
+    def __repr__(self):
+        return "LN: t=" + str(self.time) + "|t2=" + str(self.end_time) + "|c=" + str(self.mania_column)
+
+
+class BMSMeasure:
+    """
+    Contains info for all lines in the same measure
+    """
+    _hit_sounds = True
+
+    def __init__(self, measure_number: str):
+        self.measure_number = measure_number
+        self.lines = []
+
+    def __str__(self):
+        """
+        Returns in format XXXYY:NN
+        """
+        ret = ""
+        for line in self.lines:
+            ret += ("#" + str(self.measure_number) + str(line.channel) + ":" + str(line.data) + "\n")
+        return str(ret)
+
+    def create_data_line(self, channel: str, bits: int,
+                         locations: List[Tuple[List[int], Union[OsuHitObject, OsuBGSoundEvent, str]]]):
+        """
+        Wrapper for creating data_line
+        """
+        chars = {}
+        locations_ = []
+        for e in locations:
+            locations_.append(e[0])
+            if isinstance(e[1], OsuHitObject):
+                if e[1].hit_sound is not None and BMSMeasure._hit_sounds:
+                    chars[e[0]] = e[1].hit_sound.index
+                    if chars[e[0]] == "":
+                        chars[e[0]] = "ZZ"
+                else:
+                    chars[e[0]] = "ZZ"
+            elif isinstance(e[1], OsuBGSoundEvent):
+                chars[e[0]] = e[1].index
+            else:
+                chars[e[0]] = e[1]
+        self.lines.append(BMSMainDataLine(channel, bits, chars, locations_, self.measure_number))
+
+    def create_measure_length_change(self, num_of_beats):
+        """
+        Channel 2 measure length change
+        """
+        # beats_over_four = float(num_of_beats / 4)
+        self.lines.append(BMSMainDataLine("02", 1, {0: str(num_of_beats)}, [0], self.measure_number))
+
+    def create_bpm_change_line(self, bpm: int):
+        """
+        Channel 3 bpm change (ints only), 01 - FF(255)
+        """
+        self.lines.append(BMSMainDataLine("03", 1, {0: str(hex(bpm))[2:4].upper().zfill(2)}, [0], self.measure_number))
+
+    def create_bpm_extended_change_line(self, bpm: Union[int, float], float_bpm_arr):
+        """
+        Channel 8 bpm change. Takes real number.
+        """
+        tup = (None, None)
+        for e in float_bpm_arr:
+            if e[1] == bpm:
+                tup = e
+        self.lines.append(BMSMainDataLine("08", 1, {0: str(tup[0])}, [0], self.measure_number))
+
+
+class BMSMainDataLine:
+    """
+    Single line within the
+    """
+    def __init__(self, channel: str, bits: int, chars: Dict[int, str], locations: List[int], measure_number: str):
+        self.channel = channel
+        self.data = self._build_data(bits, chars, locations)
+        self.measure_number = measure_number
+
+    def _build_data(self, bits: int, chars: Dict[int, str], locations: List[int]) -> str:
+        """
+        Builds the components of line
+        """
+        ret = ""
+        location_index = 0
+        for i in range(bits):
+            if i == locations[location_index]:
+                ret += chars[i]
+                if not location_index >= len(locations) - 1:
+                    location_index += 1
+            else:
+                ret += "00"
+        return ret
+
+    def __str__(self):
+        """
+        Returns in format XXXYY:NN
+        """
+        ret = "#" + str(self.measure_number) + str(self.channel) + ":" + str(self.data) + "\n"
+        return str(ret)
+
+
+def get_current_hs_count(sample_num: int) -> str:
+    """
+    Returns the HitSound instance's base36 hitsound identifier.
+    """
+    def base36encode(number, alphabet='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ') -> str:
+        """Converts an integer to a base36 string.
+        Adapted from Wikipedia.
+        """
+        base36 = ''
+        if 0 <= number < len(alphabet):
+            return alphabet[number]
+        while number != 0:
+            number, i = divmod(number, len(alphabet))
+            base36 = alphabet[i] + base36
+        return base36
+
+    ret = base36encode(sample_num)
+    if len(ret) == 1:
+        ret = "0" + ret
+    elif len(ret) > 2 or ret == "ZZ":
+        # raise BMSHitSoundException("Too many hitsounds.")
+        print("Too many hitsounds - continuing")
+        return ""
+    return ret
+
+
+def calculate_bpm(timing_point: OsuTimingPoint) -> Union[int, float]:
+    """
+    Calculates bpm and rounds if decimals 1-4 are 0 or 9
+    """
+    def get_nth_decimal(number, n):
+        """
+        Returns nth decimal of number
+        """
+        return int(number * (10 ** n)) % 10
+
+    bpm_float = 1 / ((timing_point.ms_per_beat / 1000) / 60)
+    ncount = count = 0
+    for i in range(1, 5):
+        if get_nth_decimal(bpm_float, i) == 0:
+            count += 1
+        elif get_nth_decimal(bpm_float, i) == 9:
+            ncount += 1
+    if count == 4:
+        return int(bpm_float)
+    elif ncount == 4:
+        return round(bpm_float)
+    else:
+        return int(bpm_float * (10 ** 4)) / 10000
diff --git a/tools/osuosz to bms (modified om2bms)/om2bms/exceptions.py b/tools/osuosz to bms (modified om2bms)/om2bms/exceptions.py
new file mode 100644
index 0000000..693eb06
--- /dev/null
+++ b/tools/osuosz to bms (modified om2bms)/om2bms/exceptions.py	
@@ -0,0 +1,23 @@
+"""
+For exceptions
+"""
+
+
+class OsuParseException(Exception):
+    """Excpetion class for osu parsing excpetions"""
+    pass
+
+
+class OsuGameTypeException(Exception):
+    """For non-osumania maps """
+    pass
+
+
+class BMSHitSoundException(Exception):
+    """When there are too many sound files (~1293)"""
+    pass
+
+
+class BMSMaxMeasuresException(Exception):
+    """BMS files only support up to 999 measures."""
+    pass
diff --git a/tools/osuosz to bms (modified om2bms)/om2bms/extra_file_processing.py b/tools/osuosz to bms (modified om2bms)/om2bms/extra_file_processing.py
new file mode 100644
index 0000000..4d98d7a
--- /dev/null
+++ b/tools/osuosz to bms (modified om2bms)/om2bms/extra_file_processing.py	
@@ -0,0 +1,107 @@
+from PIL import Image, ImageFilter, ImageEnhance, ImageOps, ImageFont, ImageDraw
+import os
+from pydub import AudioSegment
+from om2bms.data_structures import OsuTimingPoint
+
+def appratio(t: int,b: int, val: float) -> int:
+    """
+    calculates a fixed ratio with t and b to then convert val according to that ratio.
+    """
+    return int((t/b)*val)
+
+def cut_save_preview_audio(path_to_audio: str, preview_time: int, timing_points: list[OsuTimingPoint]) -> None:
+    """
+    Retrives a segment of an audio file and saves as preview_{filename}.mp3
+    """
+    
+    filename = os.path.basename(path_to_audio)
+    extention = filename.split(".")[-1]
+    file_dir = os.path.dirname(path_to_audio)
+    audio = AudioSegment.from_file(path_to_audio, format=extention)
+    segment_length = 20000 # in milliseconds
+    interval = [0,0]
+
+    if preview_time >= 0: # if there was already a preview starting point defined in the osu map
+        preview_time_end = preview_time + segment_length
+
+        if len(audio) < preview_time_end:
+            interval = [preview_time, len(audio)]
+        else:
+            interval = [preview_time, preview_time_end]
+
+    elif timing_points != [] and any([tp.kiai_mode for tp in timing_points]): # if no defined preview point, take first kiai section
+        i = 0
+        while not timing_points[i].kiai_mode:
+            i += 1
+
+        start = timing_points[i].time
+        end = start + segment_length
+
+        if end > len(audio):
+            end = len(audio)
+
+        interval = [start, end]
+
+    else: # if neither of the above, take default preview point that starts at 40% of the song
+        start = int(len(audio)*0.4) 
+        end = len(audio) if (start+segment_length) > len(audio) else start + segment_length
+        interval = [start, end]
+
+    preview_audio = audio[interval[0]:interval[1]] 
+    new_filename = "preview_"+filename
+
+    preview_audio.export(os.path.join(file_dir, new_filename), format=extention)
+
+
+def size_bg_thumbnail(path_to_image: str, creator: str, beatmapid: str, thumbnail_size = (1000, 750)) -> None:
+    """
+    Resizes image to 700x700. Add black borders if image is widescreen.
+    """
+    
+    source_image = Image.open(path_to_image).convert("RGB")
+    background = source_image
+    (sw, sh) = source_image.size
+    thumbnail_w, thumbnail_h = thumbnail_size
+
+    thumbnail_aspect = round(thumbnail_w/thumbnail_h, 3)
+    source_aspect = round(sw/sh, 3)
+    # print(thumbnail_aspect, source_aspect)
+
+    if thumbnail_aspect == source_aspect or source_aspect < 1.333: 
+        # if it's already the desired aspect, we'll only resize it and do no more processing on it.
+        background.thumbnail((thumbnail_w, thumbnail_h))
+        # background.show()
+        background.save(path_to_image)
+        background.close()
+    else:
+        # if it's not the desired aspect ratio, we fit it to an image with that aspect ratio (we also add text to the image in this case)
+
+        zoomed_w, zoomed_h = round((sw/sh)*thumbnail_w), thumbnail_h
+        # print(w, zoomed_w, h, zoomed_h)
+        background.resize((zoomed_h, zoomed_w)) # resizes to h=700 aspect ratio
+        background = ImageEnhance.Brightness(background).enhance(0.5) # dims image to 40% brightness
+        background = background.filter(ImageFilter.GaussianBlur(6)) # blurs image
+        background = ImageOps.fit(background, thumbnail_size) # fits/crops background image to the desired size
+
+        source_image.thumbnail(thumbnail_size) # resizes source image
+        paste_start_y = (thumbnail_h-source_image.height) // 2
+        background.paste(source_image, (0, paste_start_y)) # places source image centered into the background
+
+        curr_path = os.path.dirname(__file__) #because of some weird fucking path issue that the code is too dumb to understand (I spent an hour finding out this was the issue)
+        font = ImageFont.truetype(os.path.join(curr_path, "allerregular.ttf"), appratio(22,700,thumbnail_w))
+        draw = ImageDraw.Draw(background)
+
+        # mapper
+        text_offset = appratio(10,700, thumbnail_w)
+        draw.text((text_offset ,paste_start_y-text_offset), "mapped by "+creator, (255,255,255), anchor="lb", font=font)
+        # map uid
+        draw.text((thumbnail_w-text_offset, paste_start_y + source_image.height + text_offset), "uid: /"+str(beatmapid), anchor="rt", font=font)
+        
+
+
+        # background.show()
+
+        background.save(path_to_image)
+        background.close()
+
+# black_background_thumbnail("./lol.jpg", "Thor", "236", (700, 525))
\ No newline at end of file
diff --git a/tools/osuosz to bms (modified om2bms)/om2bms/om_to_bms.py b/tools/osuosz to bms (modified om2bms)/om2bms/om_to_bms.py
new file mode 100644
index 0000000..06ee3ad
--- /dev/null
+++ b/tools/osuosz to bms (modified om2bms)/om2bms/om_to_bms.py	
@@ -0,0 +1,534 @@
+import codecs
+import os
+import re
+
+from typing import Union, List, Tuple, Dict
+from fractions import Fraction
+from math import gcd
+from functools import reduce
+
+# import om2bms.image_resizer
+from om2bms.data_structures import OsuMania
+from om2bms.data_structures import OsuTimingPoint
+from om2bms.data_structures import OsuManiaNote
+from om2bms.data_structures import OsuManiaLongNote
+from om2bms.data_structures import OsuBGSoundEvent
+from om2bms.data_structures import BMSMeasure
+from om2bms.data_structures import calculate_bpm
+from om2bms.osu import OsuBeatmapReader
+from om2bms.exceptions import OsuGameTypeException
+from om2bms.exceptions import OsuParseException
+from om2bms.exceptions import BMSMaxMeasuresException
+
+
+class OsuManiaToBMSParser:
+    """
+    in_file: path to osu file to convert
+    out_dir: directory to output the converted bms file
+    filename: the name to print to console when converting
+    """
+    _ms_to_inverse_note_values = {}
+    _mania_note_to_channel = {
+        0: 16,
+        1: 11,
+        2: 12,
+        3: 13,
+        4: 14,
+        5: 15,
+        6: 18,
+        7: 19
+    }
+    _mania_ln_to_channel = {
+        0: 56,
+        1: 51,
+        2: 52,
+        3: 53,
+        4: 54,
+        5: 55,
+        6: 58,
+        7: 59
+    }
+    _convertion_options = {}
+    _out_file = None
+
+    def __init__(self, in_file, out_dir, filename):
+        self.reset()
+        self.bg_filename = None
+        self.audio_filepath = None
+        self.failed = False
+        try:
+            self.beatmap = OsuBeatmapReader(in_file)
+        except OsuGameTypeException:
+            self.failed = True
+            return
+        except OsuParseException as e:
+            self.failed = True
+            print(e)
+            return
+        print("\tConverting " + filename)
+
+        self.beatmap = self.beatmap.get_parsed_beatmap()
+
+        bms_filename = self.beatmap.title + " " + self.beatmap.version + ".bms"
+        bms_filename = re.sub('[\\/:"*?<>|]+', "", bms_filename)
+        output = os.path.join(out_dir, bms_filename)
+        OsuManiaToBMSParser._out_file = codecs.open(output, "w", "shiftjis", errors="replace")
+
+        self.write_buffer(self.create_header())
+        music_start_param = self.music_start_time(self.beatmap)
+        self.get_next_measure(music_start_param[0], music_start_param[1], self.beatmap)
+
+        OsuManiaToBMSParser._out_file.close()
+
+        file = os.path.dirname(in_file)
+        if OsuManiaToBMSParser._convertion_options["BG"] and self.beatmap.stagebg is not None and \
+                os.path.isfile(os.path.join(file, self.beatmap.stagebg)):
+            # om2bms.image_resizer.black_background_thumbnail(os.path.join(file, self.beatmap.stagebg))
+            self.bg_filename = os.path.join(file, self.beatmap.stagebg)
+        
+        if self.beatmap.audio_filename is not None and os.path.isfile(os.path.join(file, self.beatmap.audio_filename)):
+            self.audio_filepath = os.path.join(file, self.beatmap.audio_filename)
+        
+        if self.beatmap.video_filename is not None and os.path.isfile(os.path.join(file, self.beatmap.video_filename)):
+            self.video_filename = os.path.join(file, self.beatmap.video_filename)
+
+    def get_bg(self):
+        """
+        Returns bg filename
+        """
+        return self.bg_filename
+    
+    def get_audio_path(self):
+        """
+        Returns path to map audio
+        """
+        return self.audio_filepath
+    
+    def get_video_name(self):
+        """
+        Returns filename to map video
+        """
+        return self.video_filename
+
+    def reset(self):
+        """
+        Resets class variables
+        """
+        OsuManiaToBMSParser._out_file = None
+        OsuBeatmapReader._latest_tp_index = 0
+        OsuBeatmapReader._latest_noninherited_tp_index = 0
+        OsuBeatmapReader._sample_index = 1
+        BMSMeasure._hit_sounds = OsuManiaToBMSParser._convertion_options["HITSOUND"]
+
+    def write_buffer(self, buffer: Union[BMSMeasure, List[str]]):
+        """
+        Writes to file. \n between each element in buffer if list
+        """
+        if buffer is None:
+            return
+        elif isinstance(buffer, BMSMeasure):
+            for line in buffer.lines:
+                OsuManiaToBMSParser._out_file.write(str(line))
+        else:
+            for line in buffer:
+                OsuManiaToBMSParser._out_file.write(line)
+                OsuManiaToBMSParser._out_file.write("\n")
+        OsuManiaToBMSParser._out_file.write("\n")
+
+    def expansion_wrapper(self, n, ms_per_measure) -> Fraction:
+        """
+        Approximates n, where 0 < n < 1, to p/q where q=2^i or 3 * 2^i up to q=192.
+        """
+        def expander(n, ms_per_measure, meter, end):
+            """
+            Generalized expander for non upper number of 3 or 4 measures.
+            """
+            def within_offset(num, sum__, offset):
+                """
+                return true if within
+                """
+                return int(ms_per_measure * num) - 1 < ms_per_measure * (sum__ + offset) < int(ms_per_measure * num) + 2
+            done = False
+            denominator = meter
+            sum_ = Fraction(1, meter)
+            while sum_ + Fraction(1, denominator) < n:
+                sum_ += Fraction(1, denominator)
+            iterations = 0
+            while iterations < 6:
+                if within_offset(n, sum_, 0) or round(n, 5) == round(float(sum_), 5):
+                    done = True
+                    break
+                if float(sum_) > n:
+                    sum_ -= Fraction(1, denominator)
+                    denominator *= 2
+                elif float(sum_) < n:
+                    sum_ += Fraction(1, denominator)
+                    denominator *= 2
+                iterations += 1
+            # pad with maxs
+            while not done:
+                if within_offset(n, sum_, 0):
+                    break
+                prev_error = abs(n - sum_)
+                if sum_ > n:
+                    if within_offset(n, sum_, -Fraction(1, end)):
+                        sum_ -= Fraction(1, end)
+                        break
+                    elif abs(n - (prev_error - Fraction(1, end))) > sum_ - Fraction(1, end):
+                        break
+                    sum_ -= Fraction(1, end)
+                elif sum_ < n:
+                    if within_offset(n, sum_, Fraction(1, end)):
+                        sum_ += Fraction(1, end)
+                        break
+                    elif abs(n - (prev_error + Fraction(1, end))) < sum_ - Fraction(1, end):
+                        break
+                    sum_ += Fraction(1, end)
+            return (abs(n - sum_), sum_)
+
+        error2 = expander(n, ms_per_measure, 4, 128)
+        error3 = expander(n, ms_per_measure, 3, 192)
+        error = error2 if error2[0] < error3[0] else error3
+        time_value = error[1]
+        if time_value == 1:
+            return Fraction(0, 1)
+        if time_value != 0:
+            self.add_to_mtnv(time_value * ms_per_measure, time_value)
+        return error[1]
+
+    def music_start_time(self, beatmap: OsuMania):
+        """
+        Returns the measure offset and ms of first measure. Calls BMSMeasure and BMSMainDataLine on the BGM start line.
+        """
+        first_object = beatmap.objects[0]
+        first_timing = beatmap.timing_points[0]
+        ms_per_measure = first_timing.meter * first_timing.ms_per_beat
+        use_obj = False
+        if first_object.time < first_timing.time:
+            start_time = first_object.time
+            use_obj = True
+        else:
+            start_time = first_timing.time
+        # find first obj on down beat
+        if use_obj:
+            i = 0
+            while beatmap.objects[i].time < first_timing.time:
+                i += 1
+            start_time = beatmap.objects[i].time
+        while start_time - ms_per_measure > 0:
+            start_time -= ms_per_measure
+        # start_time_offset is the time from 0 ms to the first obj
+        start_time_offset = ms_per_measure - start_time if start_time > 0 else abs(start_time)
+
+        start_time_offset += OsuManiaToBMSParser._convertion_options["OFFSET"]
+
+        mus_start_at_001 = True if first_object.time + ms_per_measure < ms_per_measure else False
+
+        sto_fraction = start_time_offset / ms_per_measure
+        time_value_ratio = self.expansion_wrapper(sto_fraction, ms_per_measure)
+        if time_value_ratio == 0 and mus_start_at_001:
+            bms_measure = BMSMeasure("001")
+            measure_start = 1
+            bms_measure.create_data_line("01", time_value_ratio.denominator, [(time_value_ratio.numerator, "01")])
+        else:
+            if mus_start_at_001:
+                bms_measure = BMSMeasure("001")
+                measure_start = 1
+            else:
+                bms_measure = BMSMeasure("000")
+                if time_value_ratio == 0:
+                    measure_start = 0
+                else:
+                    measure_start = 1
+            bms_measure.create_data_line("01", time_value_ratio.denominator, [(time_value_ratio.numerator, "01")])
+
+        measure_offset = measure_start
+        if beatmap.objects[0].time > start_time:
+            while not start_time >= beatmap.objects[0].time:
+                start_time += ms_per_measure
+                measure_offset += 1
+        else:
+            measure_offset = 0 if measure_start == 0 else 1
+
+        if first_timing.meter != 4:
+            if bms_measure.measure_number == "000":
+                bms_measure.create_measure_length_change(first_timing.meter / 4)
+            elif bms_measure.measure_number == "001":
+                bms_measure0 = BMSMeasure("000")
+                bms_measure0.create_measure_length_change(first_timing.meter / 4)
+                self.write_buffer(bms_measure0)
+                bms_measure.create_measure_length_change(first_timing.meter / 4)
+        self.write_buffer(bms_measure)
+        if first_timing.meter != 4:
+            for i in range(1, measure_offset):
+                bms_measure = BMSMeasure(str(i).zfill(3))
+                bms_measure.create_measure_length_change(first_timing.meter / 4)
+                self.write_buffer(bms_measure)
+
+        first_measure_time = int(start_time)
+        if first_object.time < first_measure_time - 1:
+            measure_offset -= 1
+            first_measure_time -= ms_per_measure
+        if time_value_ratio == 0 and not mus_start_at_001:
+            while not self.within_2_ms(start_time, measure_offset * ms_per_measure):
+                measure_offset += 1
+
+        self.initialize_mtnv()
+        return (measure_offset, first_measure_time)
+
+    def get_next_measure(self, starting_measure: int, starting_ms: int, beatmap: OsuMania):
+        """
+        Retrieves information for each measure.
+        """
+        def add_to_measure(current_measure_, hitobjj_):
+            """
+            Adds hitobj to measure
+            """
+            if isinstance(hitobjj_, OsuManiaNote):
+                column = hitobjj_.mania_column
+                bmscolumn = OsuManiaToBMSParser._mania_note_to_channel[column]
+                if bmscolumn not in current_measure_:
+                    current_measure_[OsuManiaToBMSParser._mania_note_to_channel[column]] = [hitobjj_]
+                else:
+                    current_measure_[OsuManiaToBMSParser._mania_note_to_channel[column]].append(hitobjj_)
+            elif isinstance(hitobjj_, OsuManiaLongNote):
+                column = hitobjj_.mania_column
+                bmscolumn = OsuManiaToBMSParser._mania_ln_to_channel[column]
+                if bmscolumn not in current_measure_:
+                    current_measure_[OsuManiaToBMSParser._mania_ln_to_channel[column]] = [hitobjj_]
+                else:
+                    current_measure_[OsuManiaToBMSParser._mania_ln_to_channel[column]].append(hitobjj_)
+            elif isinstance(hitobjj_, OsuBGSoundEvent):
+                column = 1
+                if column not in current_measure_:
+                    current_measure_[column] = [hitobjj_]
+                else:
+                    current_measure_[column].append(hitobjj_)
+            elif isinstance(hitobjj_, OsuTimingPoint):
+                if 0 not in current_measure_:
+                    current_measure_[0] = [hitobjj_]
+                else:
+                    current_measure_[0] = [hitobjj_]
+
+        current_measure = {}
+
+        current_time_in_ms = starting_ms
+        truncate_measure = False
+        first_timing = beatmap.noninherited_tp[0]
+        ms_per_measure = first_timing.ms_per_beat * first_timing.meter
+        measure_number = starting_measure
+        most_recent_tp = first_timing
+        i = 0
+        while i < len(beatmap.objects):
+            hitobj = beatmap.objects[i]
+
+            if hitobj.time < int(current_time_in_ms + ms_per_measure) - 1 and not truncate_measure:
+                if not isinstance(hitobj, OsuTimingPoint):
+                    add_to_measure(current_measure, hitobj)
+                elif isinstance(hitobj, OsuTimingPoint) and self.within_2_ms(current_time_in_ms, hitobj.time):
+                    most_recent_tp = hitobj
+                    ms_per_measure = hitobj.ms_per_beat * hitobj.meter
+                    current_time_in_ms = hitobj.time
+                    add_to_measure(current_measure, hitobj)
+                else:
+                    truncate_measure = True
+            else:  # hitobj.starttime >= current_time_in_ms + ms_per_measure:
+                if truncate_measure:
+                    if hitobj.time - current_time_in_ms < 0:
+                        truncation_frac = (hitobj.time - (current_time_in_ms - ms_per_measure)) / ms_per_measure
+                    else:
+                        truncation_frac = (hitobj.time - current_time_in_ms) / ms_per_measure
+                    truncation_float = float(self.expansion_wrapper(truncation_frac, ms_per_measure))
+                    bmsmeasure = self.create_measure(current_measure, most_recent_tp, current_time_in_ms,
+                                                     str(measure_number).zfill(3),
+                                                     truncation_float)
+                    truncate_measure = False
+                    self.write_buffer(bmsmeasure)
+                    self.initialize_mtnv()
+                    measure_number += 1
+                    most_recent_tp = hitobj
+                    ms_per_measure = hitobj.ms_per_beat * hitobj.meter
+                    current_time_in_ms = hitobj.time
+                    current_measure = {}
+                    add_to_measure(current_measure, hitobj)
+
+                    i += 1
+                    continue
+                else:
+                    bmsmeasure = self.create_measure(current_measure, most_recent_tp, current_time_in_ms,
+                                                     str(measure_number).zfill(3), 0)
+
+                self.write_buffer(bmsmeasure)
+
+                # move to next measure with hitnotes
+                while not self.within_2_ms(current_time_in_ms, hitobj.time):
+                    measure_number += 1
+                    current_time_in_ms += ms_per_measure
+
+                    if hitobj.time < int(current_time_in_ms + ms_per_measure) - 1:
+                        if isinstance(hitobj, OsuTimingPoint) and not self.within_2_ms(current_time_in_ms, hitobj.time):
+                            truncate_measure = True
+                        elif isinstance(hitobj, OsuTimingPoint) and self.within_2_ms(current_time_in_ms, hitobj.time):
+                            most_recent_tp = hitobj
+                            self.initialize_mtnv()
+                            ms_per_measure = hitobj.ms_per_beat * hitobj.meter
+                            current_time_in_ms = hitobj.time
+                        current_measure = {}
+                        add_to_measure(current_measure, hitobj)
+                        break
+
+                if measure_number > 999:
+                    raise BMSMaxMeasuresException("Exceeded 999 measures")
+
+            if not truncate_measure:
+                i += 1
+
+        # for the last measure (outside loop)
+        bmsmeasure = self.create_measure(current_measure, most_recent_tp, current_time_in_ms,
+                                         str(measure_number).zfill(3), 0)
+        self.write_buffer(bmsmeasure)
+
+    def initialize_mtnv(self) -> None:
+        """
+        Reset _ms_to_inverse_note_values (bpm changes)
+        """
+        OsuManiaToBMSParser._ms_to_inverse_note_values = {}
+
+    def add_to_mtnv(self, key: int, value: Fraction):
+        """
+        Wrapper to add into mtnv
+        """
+        OsuManiaToBMSParser._ms_to_inverse_note_values[key] = value
+        OsuManiaToBMSParser._ms_to_inverse_note_values[key - 1] = value
+        OsuManiaToBMSParser._ms_to_inverse_note_values[key + 1] = value
+
+    def within_2_ms(self, base, n) -> bool:
+        """
+        True if n is close enough to base
+        """
+        return base - 2 <= n <= base + 2
+
+    def create_measure(self, current_measure, timing_point: OsuTimingPoint, measure_start: float,
+                       measure_number: str, measure_truncation: float):
+        """
+        Creates a BMSMeasure containing linedata
+        """
+        def get_numerator_with_gcd(fraction, gcd_) -> int:
+            """
+            Returns numerator of fraction with denom of gcd
+            """
+            if fraction[1] == gcd_:
+                return fraction[0]
+            elif fraction[1] < gcd_:
+                fraction[0] *= 2
+                fraction[1] *= 2
+                return get_numerator_with_gcd(fraction, gcd_)
+            else:  # fraction[1] > gcd: (switch from
+                if fraction[1] % 3 == 0:
+                    fraction[0] //= 3
+                    fraction[1] //= 3
+                else:
+                    fraction[0] //= 4
+                    fraction[0] *= 3
+                    fraction[1] //= 4
+                    fraction[1] *= 3
+                return get_numerator_with_gcd(fraction, gcd_)
+
+        #  if the measure is empty skip
+        if len(current_measure) == 0:
+            return
+
+        bms_measure = BMSMeasure(measure_number)
+        if timing_point.meter != 4:
+            bms_measure.create_measure_length_change(timing_point.meter / 4)
+            self.initialize_mtnv()
+        elif measure_truncation != 0:
+            bms_measure.create_measure_length_change(measure_truncation)
+        ms_per_measure = timing_point.meter * timing_point.ms_per_beat
+
+        if len(current_measure) != 0:
+            for key in sorted(current_measure.keys()):
+                # get notes from column/key and put them into a line
+                denoms = []
+                locations = []  # temp
+                locations_ = []  # to be passed into bmsmaindataline
+                for note in current_measure[key]:
+                    # if first_note:
+                    time_value_ms = round(abs(measure_start - note.time), 5)
+                    if self.within_2_ms(time_value_ms, 0):
+                        time_value_ratio = Fraction(0, 1)
+                    elif int(time_value_ms) in OsuManiaToBMSParser._ms_to_inverse_note_values:
+                        time_value_ratio = OsuManiaToBMSParser._ms_to_inverse_note_values[int(time_value_ms)]
+                    else:
+                        time_value_ratio = self.expansion_wrapper(time_value_ms / ms_per_measure, ms_per_measure)
+                    denoms.append(time_value_ratio.denominator)
+                    locations.append(([time_value_ratio.numerator, time_value_ratio.denominator], note))
+
+                if key == 0 and not current_measure[key][0].inherited:
+                    new_bpm = calculate_bpm(current_measure[key][0])
+                    if new_bpm <= 255 and isinstance(new_bpm, int):
+                        bms_measure.create_bpm_change_line(new_bpm)
+                    else:
+                        bms_measure.create_bpm_extended_change_line(new_bpm, self.beatmap.float_bpm)
+                elif key == 1:
+                    locations_ = sorted(locations, key=lambda x: x[0])
+                    for i in range(len(locations)):
+                        bms_measure.create_data_line(str(key).zfill(2), locations_[i][0][1],
+                                                     [(locations_[i][0][0], locations_[i][1])])
+                else:
+                    # make all denomaintors = to gcd
+                    gcd_ = reduce(lambda a, b: a * b // gcd(a, b), denoms)
+                    for list_ in locations:
+                        locations_.append((get_numerator_with_gcd(list_[0], gcd_), list_[1]))
+                    bms_measure.create_data_line(str(key).zfill(2), gcd_, sorted(locations_, key=lambda x: x[0]))
+
+            return bms_measure
+
+    def create_header(self) -> List[str]:
+        """
+        Makes everything before maindata field
+        """
+        # HEADER FIELD
+        buffer = list([""])
+        buffer.append("*---------------------- HEADER FIELD")
+        buffer.append("")
+        buffer.append("#PLAYER 1")
+        buffer.append("#GENRE " + self.beatmap.creator)
+        buffer.append("#TITLE " + self.beatmap.title_unicode)
+        if str(self.beatmap.key_count) + "k" not in self.beatmap.version.lower(): # addes [nk] prefix to the diff name
+            diff_key_count = "[" + str(self.beatmap.key_count) + "K] "
+            buffer.append("#SUBTITLE " + diff_key_count + self.beatmap.version)
+        else:
+            buffer.append("#SUBTITLE " + self.beatmap.version)
+        buffer.append("#ARTIST " + self.beatmap.artist_unicode)
+        # buffer.append("#SUBARTIST " + beatmap.artist)
+        buffer.append("#BPM " + str(int(calculate_bpm(self.beatmap.timing_points[0]))))
+        buffer.append("#PLAYLEVEL " + "0") # initially 5
+        buffer.append("#RANK " + str(OsuManiaToBMSParser._convertion_options["JUDGE"]))
+        buffer.append("")
+        for hs in self.beatmap.hitsound_names:
+            buffer.append("#WAV" + hs[0] + " " + str(hs[1]))
+        buffer.append("")
+        if self.beatmap.audio_filename is not None: # is for preview audio
+            buffer.append("#PREVIEW " + "preview_" + self.beatmap.audio_filename)
+        if self.beatmap.video_filename is not None and OsuManiaToBMSParser._convertion_options["VIDEO"]: #TODO add to _conversion_options so that it isn't added by default => adding to cmd UI also
+            buffer.append("#VIDEOFILE " + self.beatmap.video_filename)
+        if self.beatmap.stagebg is not None and OsuManiaToBMSParser._convertion_options["BG"]:
+            buffer.append("#BMP01 " + self.beatmap.stagebg)
+            buffer.append("#STAGEFILE " + self.beatmap.stagebg) # allows you to preview the map bg in song select
+            buffer.append("")
+        if len(self.beatmap.float_bpm) > 0:
+            for e in self.beatmap.float_bpm:
+                buffer.append("#BPM" + str(e[0]) + " " + str(e[1]))
+            buffer.append("")
+        # BGM FIELD
+        buffer.append("*---------------------- EXPANSION FIELD")
+        buffer.append("")
+
+        buffer.append("*---------------------- MAIN DATA FIELD")
+        buffer.append("")
+        buffer.append("")
+        if self.beatmap.stagebg is not None and OsuManiaToBMSParser._convertion_options["BG"]:
+            buffer.append("#00004:01")
+
+        return buffer
diff --git a/tools/osuosz to bms (modified om2bms)/om2bms/osu.py b/tools/osuosz to bms (modified om2bms)/om2bms/osu.py
new file mode 100644
index 0000000..30f8977
--- /dev/null
+++ b/tools/osuosz to bms (modified om2bms)/om2bms/osu.py	
@@ -0,0 +1,399 @@
+import copy
+import codecs
+
+from om2bms.data_structures import OsuMania
+from om2bms.data_structures import OsuTimingPoint
+from om2bms.data_structures import OsuBGSoundEvent
+from om2bms.data_structures import HitSound
+from om2bms.data_structures import OsuManiaNote
+from om2bms.data_structures import OsuManiaLongNote
+from om2bms.data_structures import calculate_bpm
+from om2bms.exceptions import OsuGameTypeException
+from om2bms.exceptions import OsuParseException
+
+
+class OsuBeatmapReader:
+    """Parses information from .osu file to OsuMania class. """
+    _latest_tp_index = 0
+    _latest_noninherited_tp_index = 0
+    _sample_index = 1
+
+    def __init__(self, input_file):
+        self.osumania_beatmap = OsuMania()
+        self.parse(input_file, self.osumania_beatmap)
+
+    def get_parsed_beatmap(self):
+        """
+        Returns the parsed beatmap.
+        """
+        return self.osumania_beatmap
+
+    def parse(self, input_file, osumania_beatmap):
+        """
+        Parses beatmap
+        """
+        def header_hitobjects(line, beatmap):
+            """
+            Parses header HitObjects
+            """
+            def decode_bits(num: int) -> int:
+                """
+                For when sample_set plays > 1 hitsound at the same time. Take only the largest
+                """
+                if num > 8:
+                    return 8
+                elif num > 4:
+                    return 4
+                elif num > 2:
+                    return 2
+                else:
+                    return 1
+            ln_buffer = None
+            type_ln = False
+            line_separated = parse_symbol_separated(line, ',')
+            if len(line_separated) < 4:
+                OsuParseException("HitObject Error: Invalid Syntax")
+            hit_object_type = line_separated[3]
+            hit_object_arg = parse_symbol_separated(line_separated[-1], ':')
+
+            hit_object = None
+            if hit_object_type == "1" or hit_object_type == "5":  # single note
+                hit_object = OsuManiaNote()
+                if hit_object_type == "5":
+                    hit_object.new_combo = True
+            elif hit_object_type == "2" or hit_object_type == "6":  # o!std slider
+                return
+            elif hit_object_type == "8" or hit_object_type == "12":  # o!std spinner
+                return
+            elif hit_object_type == "132" or hit_object_type == "128":  # o!m longnote
+                type_ln = True
+                hit_object = OsuManiaLongNote(int(hit_object_arg[0]))
+                ln_buffer = OsuManiaLongNote(int(hit_object_arg[0]))
+                if hit_object_type == "128":
+                    hit_object.new_combo = True
+            else:
+                raise OsuParseException("HitObject Error: type " + hit_object_type + " not found in " + line)
+
+            #! This is where the column conversion will be done for lower key counts. 
+            # column index = floor(x*y/512) = floor(x/512/y)
+            # x = index * 512/y
+            lt7keys = {
+                6: {0:0, 1:1, 2:2, 
+                    3:3, 4:4, 5:5},
+
+                5: {0:1, 1:2, 2:3,
+                    3:4, 4:5},
+
+                4: {0:2, 1:3, 
+                    2:5, 3:6},
+
+                3: {0:3, 1:4, 2:5},
+                2: {0:0, 2:4},
+            }
+            if beatmap.key_count == 7:
+                hit_object.mania_column = (int(line_separated[0]) // (512 // beatmap.key_count)) + 1 \
+                    if line_separated[0] != "0" else 0
+            elif beatmap.key_count in range(2, 9):
+                hit_object.mania_column = (int(line_separated[0]) // (512 // beatmap.key_count))
+                if beatmap.key_count != 8:
+                    # uses dictionary to redefine which column it's in depending on keycount
+                    hit_object.mania_column = lt7keys[beatmap.key_count][hit_object.mania_column] 
+
+            hit_object.hit_sound = int(line_separated[4])
+            hit_object.time = int(line_separated[2])
+
+            if OsuBeatmapReader._latest_tp_index < len(beatmap.timing_points) - 1 and \
+                    beatmap.timing_points[OsuBeatmapReader._latest_tp_index + 1].time <= hit_object.time:
+                OsuBeatmapReader._latest_tp_index += 1
+
+            hitsound_int = int(line_separated[4]) if int(line_separated[4]) in [0, 1, 2, 4, 8] else \
+                decode_bits(int(line_separated[4]))
+            timing_point = beatmap.timing_points[OsuBeatmapReader._latest_tp_index]
+            if type_ln:
+                filename = "" if len(hit_object_arg) < 5 else hit_object_arg[5].strip()
+                sample_set = int(hit_object_arg[1])
+            else:
+                filename = "" if len(hit_object_arg) < 4 else hit_object_arg[4].strip()
+                sample_set = int(hit_object_arg[0])
+
+            if filename == "" and hitsound_int == 0:
+                hitsound = None
+            else:
+                if sample_set == 0:
+                    sample_set = timing_point.sample_set
+                custom_index = int(hit_object_arg[3]) if type_ln else int(hit_object_arg[2])
+                hs_id = (hitsound_int, sample_set, custom_index, filename)
+                if hs_id not in beatmap.hitsounds:
+                    hitsound = HitSound(hitsound_int, timing_point, sample_set, custom_index, filename, OsuBeatmapReader._sample_index)
+                    OsuBeatmapReader._sample_index += 1
+                    beatmap.hitsounds[hs_id] = hitsound
+                    beatmap.hitsound_names.append(hitsound.get_info())
+                else:
+                    hitsound = beatmap.hitsounds[hs_id]
+
+            hit_object.hit_sound = hitsound
+            hit_object.timing_point = timing_point
+            beatmap.hit_objects.append(hit_object)
+            if ln_buffer is not None:
+                ln_buffer.time = hit_object.end_time
+                ln_buffer.end_time = hit_object.end_time
+                ln_buffer.mania_column = hit_object.mania_column
+                beatmap.hit_objects.append(ln_buffer)
+
+        def header_timingpoints(line, beatmap):
+            """
+            Parses header TimingPoints:
+            """
+            def get_ms_per_beat(ms, _beatmap):
+                """
+                Takes care of negative values found in Timing Points
+                """
+                if ms >= 0:
+                    return ms
+                else:
+                    for _tp in reversed(_beatmap.timing_points):
+                        if not _tp.inherited:
+                            return (abs(ms) / 100) * _tp.ms_per_beat
+                    raise OsuParseException("Non inherited BPM not found. Timing points are broken")
+
+            line_separated = parse_symbol_separated(line, ',')
+            if len(line_separated) != 8:
+                raise OsuParseException("TimingPoint Error: Invalid Syntax")
+            tp = OsuTimingPoint()
+            tp.time = int(float(line_separated[0]))
+            tp.inherited = True if int(line_separated[6]) == 0 else False
+            tp.meter = int(line_separated[2])
+            tp.sample_set = int(line_separated[3])
+            tp.sample_index = int(line_separated[4])
+            tp.volume = int(line_separated[5])
+            tp.kiai_mode = False if line_separated[7] == 0 else True
+            # delete previous tp if new tp causes old tp to last only a few ms
+            if len(beatmap.timing_points) > 0 and tp.time <= beatmap.timing_points[-1].time + 2 and not tp.inherited:
+                del beatmap.timing_points[-1]
+            if tp.inherited:
+                tp.ms_per_beat = get_ms_per_beat(float(line_separated[1]), beatmap)
+                prev_tp = beatmap.timing_points[-1]
+                if len(beatmap.timing_points) > 0 and tp.time <= prev_tp.time + 1 and \
+                        tp.sample_set != prev_tp.sample_set and tp.sample_index != prev_tp.sample_index:
+                    del beatmap.timing_points[-1]
+            else:
+                tp.ms_per_beat = float(line_separated[1])
+                bpm = calculate_bpm(tp)
+                if isinstance(bpm, float) or bpm > 255:
+                    beatmap.parse_float_bpm(bpm)
+                if len(beatmap.timing_points) > 0 and tp.time <= beatmap.noninherited_tp[-1].time + 1:
+                    del beatmap.noninherited_tp[-1]
+                beatmap.noninherited_tp.append(tp)
+            beatmap.timing_points.append(tp)
+
+        def header_events(line, beatmap):
+            """
+            Parses header Events
+            """
+            line_separated = parse_symbol_separated(line, ',')
+            if len(line_separated) < 1:
+                OsuParseException("Events Error: Invalid Syntax")
+            event = {}
+            if line_separated[0] == "Sample":
+                if len(line_separated) != 5:
+                    raise OsuParseException("Events Error: Invalid Syntax")
+                time = int(line_separated[1])
+                filename = str(line_separated[3][1:-1])
+                if filename not in beatmap.filename_to_sample.keys():
+                    beatmap.sample_filenames.append(filename)
+                    sample = OsuBGSoundEvent(time, filename, OsuBeatmapReader._sample_index)
+                    OsuBeatmapReader._sample_index += 1
+                    beatmap.filename_to_sample[filename] = sample
+                    beatmap.sample_objects.append(sample)
+                    beatmap.hitsound_names.append(sample.get_info())
+                else:
+                    sample = beatmap.filename_to_sample[filename]
+                    new_sample = copy.deepcopy(sample)
+                    new_sample.time = time
+                    beatmap.sample_objects.append(new_sample)
+
+            elif line_separated[0] == "Video":
+                if len(line_separated) != 3:
+                    OsuParseException("Events Error: Invalid Syntax")
+                else:
+                    beatmap.video_start_time = int(line_separated[1])
+                    beatmap.video_filename = line_separated[2].strip("\n").strip("\r")[1:-1]
+
+            elif len(line_separated) <= 5 and line_separated[0] == "0":
+                temp = line_separated[2]
+                temp = temp.replace('"', '').strip()
+                sep = temp.split('.')
+                if len(sep) == 2:
+                    beatmap.stagebg = sep[0] + "." + sep[1]
+
+        def header_difficulty(line, beatmap):
+            """
+            Parses the header Difficulty
+            """
+            line_property = get_line_property(line)
+            if line_property[0] == "CircleSize":
+                keycount = int(line_property[1])
+                if keycount in range(2,9):
+                    beatmap.key_count = keycount
+                else:
+                    raise OsuParseException("Only 2k-8k files are supported!")
+            elif line_property[0] == "HPDrainRate":
+                pass
+            elif line_property[0] == "OverallDifficulty":
+                beatmap.od = float(line_property[1])
+            elif line_property[0] == "ApproachRate":
+                pass
+            else:
+                OsuParseException("Attribute Error: " + line_property[0] + " not found")
+
+        def header_general(line, beatmap):
+            """
+            Parses the header General
+            """
+            line_property = get_line_property(line)
+            if line_property[0] == "AudioFilename":
+                audio_filename = line_property[1].strip()
+                beatmap.audio_filename = audio_filename
+                audio = HitSound(0, None, 0, 1, audio_filename, OsuBeatmapReader._sample_index)
+                OsuBeatmapReader._sample_index += 1
+                beatmap.hitsound_names.append(audio.get_info())
+            elif line_property[0] == "AudioLeadIn":
+                beatmap.audio_lead_in = int(line_property[1])
+            elif line_property[0] == "PreviewTime":
+                beatmap.preview_time = int(line_property[1])
+            elif line_property[0] == "Countdown":
+                pass
+            elif line_property[0] == "SampleSet":
+                beatmap.sample_set = str(line_property[1])
+                pass
+            elif line_property[0] == "StackLeniency":
+                pass
+            elif line_property[0] == "Mode":
+                if not int(line_property[1]) == 3:
+                    raise OsuGameTypeException("Beatmap is not an o!m beatmap!")
+            elif line_property[0] == "LetterboxInBreaks":
+                pass
+            elif line_property[0] == "SpecialStyle":
+                if line_property[1] == 1:
+                    beatmap.special_style = True
+            elif line_property[0] == "WidescreenStoryboard":
+                pass
+
+        def header_metadata(line, beatmap):
+            """
+            Parses the header Metadata
+            """
+            line_property = get_line_property(line)
+            if line_property[0] == "Title":
+                beatmap.title = line_property[1].strip().replace("/", "").replace("\\", "")
+            elif line_property[0] == "TitleUnicode":
+                try:
+                    beatmap.title_unicode = line_property[1].strip().encode("shiftjis")
+                    beatmap.title_unicode = line_property[1].strip()
+                except UnicodeEncodeError:
+                    beatmap.title_unicode = beatmap.title
+            elif line_property[0] == "Artist":
+                beatmap.artist = line_property[1].strip()
+            elif line_property[0] == "ArtistUnicode":
+                try:
+                    beatmap.artist_unicode = line_property[1].strip().encode("shiftjis")
+                    beatmap.artist_unicode = line_property[1].strip()
+                except UnicodeEncodeError:
+                    beatmap.artist_unicode = beatmap.artist
+            elif line_property[0] == "Creator":
+                beatmap.creator = line_property[1].strip()
+            elif line_property[0] == "Version":
+                beatmap.version = line_property[1].strip()
+            elif line_property[0] == "Source":
+                beatmap.source = line_property[1].strip()
+            elif line_property[0] == "Tags":
+                pass
+            elif line_property[0] == "BeatmapID":
+                beatmap.beatmap_id = line_property[1].strip()
+            elif line_property[0] == "BeatmapSetID":
+                pass
+
+        def is_empty(line):
+            """
+            Returns True iff line is empty
+            """
+            return len(line.strip()) == 0
+
+        def is_comment(line):
+            """
+            Returns True iff line is a comment line
+            """
+            return len(line) >= 2 and line[0:1] == "//"
+
+        def is_section_header(line):
+            """
+            Return True iff line is section header.
+            """
+            return len(line) >= 2 and line[0] == '[' and line[-2] == ']'
+
+        def get_section(line):
+            """
+            Return section header
+            """
+            return line[1:-2]
+
+        def get_line_property(line):
+            """
+            Returns tuple of (Attribute, Value)
+            """
+            split = line.split(":")
+            return (split[0], split[1])
+
+        def parse_symbol_separated(line, symbol):
+            """
+            Returns list of elements in line separated by symbol.
+            """
+            return line.split(symbol)
+
+        file = codecs.open(input_file, 'r', "utf-8")
+        section = "FileFormat"
+        for line in file.readlines():
+            if is_empty(line) or is_comment(line):
+                continue
+            elif is_section_header(line):
+                section = get_section(line)
+                continue
+            if line[0] == '[':
+                section = line[1:-3]
+                continue
+            if section == "FileFormat":
+                continue
+            elif section == "General":
+                header_general(line, osumania_beatmap)
+            elif section == "Editor":
+                continue
+            elif section == "Metadata":
+                header_metadata(line, osumania_beatmap)
+            elif section == "Difficulty":
+                header_difficulty(line, osumania_beatmap)
+            elif section == "Events":
+                header_events(line, osumania_beatmap)
+            elif section == "TimingPoints":
+                header_timingpoints(line, osumania_beatmap)
+            elif section == "Colours":
+                continue
+            elif section == "HitObjects":
+                header_hitobjects(line, osumania_beatmap)
+            else:
+                OsuParseException("Header Error: " + section + " not found")
+
+        osumania_beatmap.objects = sorted(osumania_beatmap.hit_objects +
+                                          osumania_beatmap.sample_objects +
+                                          osumania_beatmap.noninherited_tp,
+                                          key=lambda x: (x.time, x.sort_type))
+
+        # for i in range(len(osumania_beatmap.objects)):
+        #     if isinstance(osumania_beatmap.objects[i], OsuTimingPoint):
+        #         j = i
+        #         while osumania_beatmap.objects[j].time == osumania_beatmap.objects[i].time:
+        #             j -= 1
+        #         j += 1
+        #         osumania_beatmap.objects[j], osumania_beatmap.objects[i], = \
+        #             osumania_beatmap.objects[i], osumania_beatmap.objects[j]
+
+        file.close()
diff --git a/tools/osuosz to bms (modified om2bms)/osu.py b/tools/osuosz to bms (modified om2bms)/osu.py
new file mode 100644
index 0000000..98b0876
--- /dev/null
+++ b/tools/osuosz to bms (modified om2bms)/osu.py	
@@ -0,0 +1,55 @@
+import os
+
+from argparse import ArgumentParser
+
+import om2bms.om_to_bms
+
+
+if __name__ == '__main__':
+
+    parser = ArgumentParser(description='Convert a .osu osu!mania file to a BMS file. '
+                                        'Outputs to directory of om2bms.py',
+                            add_help=True,
+                            allow_abbrev=True)
+
+    parser.add_argument('-i', '--in_file',
+                        action='store',
+                        help='Path to file to be converted.',
+                        type=str)
+
+    parser.add_argument('-hs', '--hitsound',
+                        action='store_false',
+                        default=False,
+                        help='Disables hitsounds.')
+
+    parser.add_argument('-b', '--bg',
+                        action='store_false',
+                        default=True,
+                        help='Disables background conversion.')
+
+    parser.add_argument('-o', '--offset',
+                        default=0,
+                        type=int,
+                        help="Adjusts music start time by [offset] ms.")
+
+    parser.add_argument('-j', '--judge',
+                        default=2,
+                        type=int,
+                        help="Judge difficulty. Defaults to EASY. "
+                        "(3: EASY), (2: NORMAL), (1: HARD), (0: VERY HARD)")
+
+    args = parser.parse_args()
+
+    cwd = os.getcwd()
+
+    om2bms.om_to_bms.OsuManiaToBMSParser._convertion_options = {
+        "HITSOUND": args.hitsound,
+        "VIDEO": False,
+        "BG": args.bg,
+        "OFFSET": args.offset,
+        "JUDGE": args.judge
+    }
+    convert = om2bms.om_to_bms.OsuManiaToBMSParser(
+        args.in_file, os.getcwd(), args.in_file)
+    print("Done")
+    exit(0)
diff --git a/tools/osuosz to bms (modified om2bms)/osz.py b/tools/osuosz to bms (modified om2bms)/osz.py
new file mode 100644
index 0000000..ba4baf7
--- /dev/null
+++ b/tools/osuosz to bms (modified om2bms)/osz.py	
@@ -0,0 +1,233 @@
+import zipfile
+import os
+import json
+import shutil
+
+from argparse import ArgumentParser
+from om2bms.exceptions import BMSMaxMeasuresException
+from om2bms.extra_file_processing import size_bg_thumbnail, cut_save_preview_audio
+from types import SimpleNamespace
+
+import om2bms.om_to_bms
+import multiprocessing
+
+def convert(in_file: str, set_default_out: str = None, hitsound: bool = None, bg: bool = True, video: bool = True, foldername: str = None, offset: int = -235, judge: int = 2):
+
+    args = SimpleNamespace(**{ # Allows simpler use of the paramaters
+        "in_file": in_file, 
+        "set_default_out": set_default_out,
+        "hitsound": hitsound,
+        "bg": bg,
+        "video": video,
+        "foldername": foldername,
+        "offset": offset,
+        "judge": judge
+    })
+
+    cwd = os.getcwd()
+
+    cfg_file = os.path.join(cwd, 'settings.json')
+    if not os.path.exists(cfg_file):
+        default_settings = {
+            "in_file": "input", 
+            "set_default_out": "output",
+            "hitsound": None, 
+            "bg": True, 
+            "video": True, 
+            "offset": -235, 
+            "judge": 2
+            }
+        json.dump({"custom":default_settings, "default": default_settings}, open(cfg_file, "w"))
+
+    # I know this whole if statement is weird, but I don't want to risk breaking anything any more
+    if args.set_default_out is not None and args.set_default_out:
+        # modifies output dir in json settings
+        settings_obj = json.load(open(cfg_file, "r"))
+        settings_obj["custom"]["set_default_out"] = args.set_default_out.strip()
+        json.dump(settings_obj, open(cfg_file, "w"))
+
+        outdir = args.set_default_out.strip()
+    else:
+        outdir = json.load(open(cfg_file, "r"))["custom"]["set_default_out"]
+
+    if args.in_file is None:
+        exit(0)
+
+    if args.foldername is None:
+        foldername = os.path.basename(args.in_file)[:-4]
+        out_foldername = foldername
+    else:
+        out_foldername = args.foldername
+        
+    unzip_dir = os.path.join(cwd, "unzip_dir")
+    if not os.path.isdir(unzip_dir):
+        os.makedirs(unzip_dir)
+    try:
+        if not os.path.isdir(unzip_dir):
+            os.makedirs(unzip_dir)
+
+        filename = os.path.basename(args.in_file)
+        shutil.copy2(args.in_file, unzip_dir)
+
+        osz_dir = os.path.join(unzip_dir, filename)
+
+        base = os.path.splitext(osz_dir)[0]
+        os.rename(osz_dir, base + ".zip")
+        osz_file_dir = base + ".zip"
+
+        print("Unzipping...")
+        with zipfile.ZipFile(osz_file_dir, 'r') as zipf:
+            zipf.extractall(unzip_dir)
+
+        output_file_dir = os.path.join(outdir, out_foldername)
+        print("Output directory is " + output_file_dir)
+
+        if not os.path.isdir(output_file_dir):
+            os.makedirs(output_file_dir)
+
+        processes = []
+        manager = multiprocessing.Manager()
+        bg_list = manager.list()
+        audio_list = manager.list()
+        for file in os.listdir(unzip_dir):
+            if file.endswith(".osu"):
+                filedir = os.path.join(unzip_dir, file)
+                p = multiprocessing.Process(target=start_convertion,
+                                            args=(filedir, output_file_dir, file, args, bg_list, audio_list))
+                processes.append(p)
+
+
+        for p in processes:
+            p.start()
+
+        for p in processes:
+            p.join()
+
+        if args.bg:
+            print("Converting BG...")
+            convert_bg_list(bg_list)
+        
+        print("Snipping preview audio...")
+        make_preview_audio(audio_list)
+
+        # move files to output directory
+        for f in os.listdir(unzip_dir):
+            if not os.path.isdir(os.path.join(unzip_dir, f)):
+                if not f.split(".")[-1] == "zip" and not f.split(".")[-1] == "osu":
+                    full_path = os.path.join(unzip_dir, f)
+                    try:
+                        shutil.copy2(full_path, output_file_dir)
+                    except PermissionError as e:
+                        print(e)
+                        continue
+
+        print("Done")
+        # exit(0)
+    except Exception as e:
+        print(e)
+        exit(1)
+    finally:
+        shutil.rmtree(unzip_dir)
+
+def start_convertion(filedir_, output_file_dir_, file_, args, bg_list_, audio_list_):
+    """
+    Returns bg filename
+    """
+    try:
+        om2bms.om_to_bms.OsuManiaToBMSParser._convertion_options = {
+            "HITSOUND": None if args.hitsound == False else args.hitsound,
+            "BG": args.bg,
+            "VIDEO": args.video,
+            "OFFSET": args.offset,
+            "JUDGE": args.judge
+        }
+        
+        converted_file = om2bms.om_to_bms.OsuManiaToBMSParser(filedir_, output_file_dir_, file_)
+        if not converted_file.failed:
+            if args.bg:
+                bg_list_.append((converted_file.get_bg(), converted_file.beatmap.creator, converted_file.beatmap.beatmap_id))
+            
+            audio_list_.append((converted_file.get_audio_path(), converted_file.beatmap.preview_time, converted_file.beatmap.timing_points))
+        
+
+    except BMSMaxMeasuresException as e:
+        print(e)
+
+def make_preview_audio(audio_list_) -> None:
+    """
+    Creates a second audio file that we will use in the om2bms preview section
+    (From osu map, uses either PreviewTime + 20s, first kiai section + 20s, 40% song + 20s)
+    """
+
+    seen = []
+    for audio_info in audio_list_:
+        audio_path, map_preview_time, map_timing_poins = audio_info
+        if audio_path is not None and audio_path not in seen:
+            cut_save_preview_audio(audio_path, map_preview_time, map_timing_poins)
+            seen.append(audio_path)
+
+def convert_bg_list(bg_list_) -> None:
+    """
+    Converts all images in img_list
+    """
+    seen = []
+    for bg_info in bg_list_:
+        bg, creator, beatmapid = bg_info
+        if bg is not None and bg not in seen:
+            size_bg_thumbnail(bg, creator, beatmapid)
+            seen.append(bg)
+
+
+if __name__ == "__main__":
+
+    parser = ArgumentParser(description='Convert all .osu osu!mania files in a .osz to BMS files',
+                            add_help=True,
+                            allow_abbrev=True)
+
+    parser.add_argument('-i', '--in_file',
+                        action='store',
+                        default=None,
+                        help='Path to .osz to be converted.',
+                        type=str)
+
+    parser.add_argument('-sdo', '--set_default_out',
+                        action='store',
+                        default=None,
+                        help='Sets the default output directory',
+                        type=str)
+
+    parser.add_argument('-hs', '--hitsound',
+                        action='store_false',
+                        default=None,
+                        help='Disables hitsounds.')
+
+    parser.add_argument('-b', '--bg',
+                        action='store_false',
+                        default=True,
+                        help='Disables background image conversion.')
+    
+    parser.add_argument("-v", "--video",
+                        action="store_false",
+                        default=True,
+                        help="Disables video conversion.")
+
+    parser.add_argument('-f', '--foldername',
+                        action='store',
+                        default=None,
+                        help='Directory name to store output files in output path. '
+                             'Default value is the .osz filename')
+
+    parser.add_argument('-o', '--offset',
+                        default=-235,
+                        type=int,
+                        help="Adjusts music start time by [offset] ms.")
+
+    parser.add_argument('-j', '--judge',
+                        default=2,
+                        type=int,
+                        help="Judge difficulty. Defaults to EASY. "
+                        "(3: EASY), (2: NORMAL), (1: HARD), (0: VERY HARD)")
+
+    args = parser.parse_args()
+
+    convert(**vars(args)) # because this function takes actual arguments instead of kwargs
\ No newline at end of file
diff --git a/tools/osuosz to bms (modified om2bms)/output/placeholder b/tools/osuosz to bms (modified om2bms)/output/placeholder
new file mode 100644
index 0000000..22c4d27
--- /dev/null
+++ b/tools/osuosz to bms (modified om2bms)/output/placeholder	
@@ -0,0 +1 @@
+holds no info, it's just so that ./output/ uploads to github
\ No newline at end of file
diff --git a/tools/osuosz to bms (modified om2bms)/requirements.txt b/tools/osuosz to bms (modified om2bms)/requirements.txt
new file mode 100644
index 0000000..91b0332
--- /dev/null
+++ b/tools/osuosz to bms (modified om2bms)/requirements.txt	
@@ -0,0 +1,2 @@
+pillow
+pydub
\ No newline at end of file
diff --git a/tools/osuosz to bms (modified om2bms)/settings.json b/tools/osuosz to bms (modified om2bms)/settings.json
new file mode 100644
index 0000000..cfce453
--- /dev/null
+++ b/tools/osuosz to bms (modified om2bms)/settings.json	
@@ -0,0 +1 @@
+{"custom": {"in_file": "input", "set_default_out": "output", "hitsound": null, "bg": true, "video": true, "offset": -235, "judge": 2}, "default": {"in_file": "input", "set_default_out": "output", "hitsound": null, "bg": true, "video": true, "offset": -235, "judge": 2}}
\ No newline at end of file