Initial commit

Author: NeryK

.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.pyc
+build/
+dist/
+*.egg-info/
+.vscode/

.pylintrc

@@ -0,0 +1,2 @@
+[FORMAT]
+max-line-length=120

LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2022, NeryK
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -0,0 +1,26 @@
+# snowrunner-uwp2steam
+
+Tool to migrate the save data of the game Snowrunner from Microsoft Store / Xbox Game pass (UWP) to Steam.
+The migration is basically just renaming a number of files which have obfuscated names in UWP storage, and then making Steam aware of them.
+
+## References
+
+- https://steamcommunity.com/sharedfiles/filedetails/?id=2530914231
+- https://blog.s505.su/2021/08/how-to-transfer-snowrunner-game-saves.html
+- https://steamcommunity.com/app/1465360/discussions/0/4811511685077534336/#c3111403360718313694
+  - (which is based on https://github.com/zarroboogs/p4g-saveconv/blob/master/remotecache.py)
+- https://github.com/goatfungus/NMSSaveEditor/issues/306#issue-679701707
+
+## Usage
+
+1. Have both Snowrunner UWP and Steam versions installed (ideally with the same DLC).
+2. Find Snowrunner UWP save location, somewhere like: `%LOCALAPPDATA%\Packages\FocusHomeInteractiveSA.SnowRunnerWindows10_4hny5m903y3g0\SystemAppData\wgs\<an identifier>\<another identifier>`.
+3. Make a copy of it to be safe, like `C:\Temp\<another identifier>`
+4. Disable cloud saves for Snowrunner in Steam.
+5. Restart Steam in offline mode.
+6. Run Snowrunner and start a new game. Ensure the game is saved.
+7. Run the tool on the copy of the UWP data and write Steam data to a temporary directory: `py -m sr_u2s -i "C:\Temp\<another identifier>" -o "C:\Temp\steam_snowrunner_save"`
+8. Find Steam saves location, somewhere like:`%ProgramFiles(x86)%\Steam\userdata\<your Steam id\`
+9. Copy the directory `1465360` from the Steam data output directory to the Steam saves location.
+10. Run Snowrunner. If all went according to plan, you have recovered your save.
+11. Re-enable cloud saves for the game and return online.

setup.py

@@ -0,0 +1,29 @@
+import setuptools
+import sr_u2s
+
+def get_long_description():
+    with open("README.md", "r") as readme_file:
+        readme = readme_file.read()
+        return readme[readme.find("# snowrunner-uwp2steam"):]
+
+if __name__ == '__main__':
+	setuptools.setup(
+		name=sr_u2s.__name__,
+		version=sr_u2s.__version__,
+		author="NeryK",
+		author_email="96932938+NeryK@users.noreply.github.com",
+		description=sr_u2s.__doc__,
+		long_description=get_long_description(),
+		long_description_content_type="text/markdown",
+		url="https://github.com/NeryK/snowrunner-uwp2steam",
+		python_requires=">=3",
+		packages=[sr_u2s.__package__],
+        license="License :: OSI Approved :: BSD License",
+        classifiers=[
+            "Development Status :: 4 - Beta",
+            "Programming Language :: Python :: 3",
+            "License :: OSI Approved :: BSD License",
+            "Operating System :: OS Independent",
+            "Topic :: Games/Entertainment"
+        ]
+    )

sr_u2s/__init__.py

@@ -0,0 +1,4 @@
+"""Migrate Snowrunner save from Windows Store (UWP) storage to Steam storage"""
+
+__version__ = "0.1.0"
+__author__ = "NeryK"

sr_u2s/__main__.py

@@ -0,0 +1,42 @@
+"""Module entry point"""
+import os
+import argparse
+import pathlib
+from sr_u2s import __doc__, __version__
+from sr_u2s import container, remotecache, transfer_save
+
+
+def locate_container(input_dir):
+    save_path = pathlib.Path(input_dir)
+    files = [f for f in save_path.glob("container.*") if f.is_file()]
+    if len(files) != 1:
+        raise FileNotFoundError(f"No single 'container.XYZ' file found in {input_dir}")
+    return str(files[0])
+
+def make_remotecache(output_subdir):
+    save_path = pathlib.Path(output_subdir)
+    remcache_path = pathlib.Path(os.path.join(save_path.parent, "remotecache.vdf"))
+    remotecache.write_remcache(remcache_path, save_path)
+    return str(remcache_path)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("-i", "--input-uwp-save-directory", help="Snowrunner Windows Store savegame directory", required=True)
+    parser.add_argument("-o", "--output-steam-save-directory", help="Snowrunner Steam savegame directory", required=True)
+    parser.add_argument("-v", "--version", action="version", version=__version__)
+    args = parser.parse_args()
+
+    print("Snowrunner save UWP -> Steam start.")
+    input_dir = args.input_uwp_save_directory
+    if not os.path.exists(input_dir) or not os.path.isdir(input_dir):
+        parser.error(f"Error accessing {input_dir}")
+    container_path = locate_container(input_dir)
+    save_list = container.load_container(locate_container(input_dir))
+    print(f"Container file {container_path} loaded.")
+    output_subdir = os.path.join(args.output_steam_save_directory, "1465360", "remote")
+    os.makedirs(output_subdir, exist_ok=True)
+    transfer_save.copy_rename_save(save_list, input_dir, output_subdir, False)
+    print(f"{len(save_list)} files copied.")
+    remcache_file = make_remotecache(output_subdir)
+    print(f"Steam remote cache generated ({remcache_file}).")
+    print("Snowrunner save UWP -> Steam end.")

sr_u2s/container.py

@@ -0,0 +1,40 @@
+"""Parse UWP container file"""
+import argparse
+import struct
+
+def decode_hash(hash_bytes):
+    new_hash_bytes = bytearray()
+    new_hash_bytes.append(hash_bytes[3])
+    new_hash_bytes.append(hash_bytes[2])
+    new_hash_bytes.append(hash_bytes[1])
+    new_hash_bytes.append(hash_bytes[0])
+    new_hash_bytes.append(hash_bytes[5])
+    new_hash_bytes.append(hash_bytes[4])
+    new_hash_bytes.append(hash_bytes[7])
+    new_hash_bytes.append(hash_bytes[6])
+    return new_hash_bytes.hex().upper() + hash_bytes[8:].hex().upper()
+
+def parse_file_bytes(bytes):
+    filepath = bytes[:-32].decode("utf-16").strip("\x00")
+    hash1 = decode_hash(bytes[-32:-16])
+    hash2 = decode_hash(bytes[-16:])
+    if hash1 != hash2:
+        raise ValueError(f"Inconsistent hash for {filepath}")
+    return filepath, hash1
+
+def load_container(container_path):
+    save_files = []
+    with open(container_path, "rb") as containerfile:
+        _header = struct.unpack("I", containerfile.read(4))[0]
+        numfiles = struct.unpack("I", containerfile.read(4))[0]
+        for i in range(numfiles):
+            save_files.append(parse_file_bytes(containerfile.read(160)))
+    return save_files
+
+if __name__=="__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input-container", help="UWP container.xyz file", required=True)
+    args = parser.parse_args()
+
+    save_list = load_container(args.input_container)
+    print(save_list)

sr_u2s/remotecache.py

@@ -0,0 +1,98 @@
+# Source: https://steamcommunity.com/app/1465360/discussions/0/4811511685077534336/#c3111403360718313694
+# Original : https://github.com/zarroboogs/p4g-saveconv/blob/master/remotecache.py
+
+import os
+import math
+import hashlib
+import argparse
+from pathlib import Path
+
+
+def sha1sum( stream, start=0 ):
+    sha1 = hashlib.sha1()
+    stream.seek( start, 0 )
+
+    while True:
+        data = stream.read( 1024 )
+        if not data:
+            break
+        sha1.update( data )
+
+    stream.seek( 0, 0 )
+    return sha1
+
+
+def vdf_write( vdf, level, key="", val=None ):
+    pad = '\t' * level
+    if key == None or key == "":
+        vdf.write( f'{pad}' + "}\n" )
+    elif val == None:
+        vdf.write( f'{pad}"{key}"\n{pad}' + "{\n" )
+    else:
+        vdf.write( f'{pad}"{key}"\t\t"{val}"\n' )
+
+
+def write_remcache_file( vdf, filepath ):
+    fstat = os.stat( filepath )
+    fsize = fstat.st_size
+    ftime = math.floor( fstat.st_mtime )
+
+    with open( filepath, "rb" ) as fs:
+        fsha = sha1sum( fs ).hexdigest()
+
+    vdf_write( vdf, 1, filepath.name )
+    vdf_write( vdf, 2, "root", 0 )
+    vdf_write( vdf, 2, "size", fsize )
+    vdf_write( vdf, 2, "localtime", ftime )
+    vdf_write( vdf, 2, "time", ftime )
+    vdf_write( vdf, 2, "remotetime", ftime )
+    vdf_write( vdf, 2, "sha", fsha )
+    vdf_write( vdf, 2, "syncstate", 4 )
+    vdf_write( vdf, 2, "persiststate", 0 )
+    vdf_write( vdf, 2, "platformstosync2", -1 )
+    vdf_write( vdf, 1 )
+
+
+def write_remcache( remcache_path, data_path ):
+    with open( remcache_path, "w", newline='\n' ) as vdf:
+        vdf_write( vdf, 0, "1465360" )
+
+        for f in data_path.glob( "*" ):
+            write_remcache_file( vdf, f )
+
+        # for f in data_path.glob( "system.bin" ):
+        #     write_remcache_file( vdf, f )
+        #     write_remcache_file( vdf, Path( f"{f}slot" ) )
+
+        # for f in data_path.glob( "data*.bin" ):
+        #     write_remcache_file( vdf, f )
+        #     write_remcache_file( vdf, Path( f"{f}slot" ) )
+
+        vdf_write( vdf, 0 )
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument( "save_dir", nargs=1, help="pc save dir" )
+    args = parser.parse_args()
+
+    save_path = Path( args.save_dir[ 0 ] )
+
+    if not save_path.is_dir():
+        raise Exception( "missing save dir or save dir doesn't exist" )
+
+    # files = [ f for f in save_path.glob( "data*.binslot" ) if f.is_file() ]
+    # if len( files ) == 0:
+    #     raise Exception( "input dir doesn't contain pc saves" )
+    files = [ f for f in save_path.glob( "*.cfg" ) if f.is_file() ]
+    if len( files ) == 0:
+        raise Exception( "input dir doesn't contain pc saves" )
+
+    print( "generating remotecache.vdf" )
+    remcache_path = Path ( save_path.parent / "remotecache.vdf" )
+    write_remcache( remcache_path, save_path )
+
+    print( "done!" )
+
+if __name__ == "__main__":
+    main()

sr_u2s/transfer_save.py

@@ -0,0 +1,34 @@
+"""Automate Snowrunner save file renaming described in https://blog.s505.su/2021/08/how-to-transfer-snowrunner-game-saves.html"""
+import argparse
+import struct
+import os
+import shutil
+from sr_u2s import container
+
+
+def copy_file(input_dir, input_name, output_dir, output_name, dry_run):
+    input = os.path.join(input_dir, input_name)
+    output = os.path.join(output_dir, f"{output_name}.cfg")
+    print(f"Copy {input} to {output}")
+    if not dry_run:
+        shutil.copy2(input, output)
+
+def copy_rename_save(save_list, input_dir, output_dir, dry_run):
+    for decoded_filename, hashed_filename in save_list:
+        copy_file(input_dir, hashed_filename, output_dir, decoded_filename, dry_run)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Rename Snowrunner save files from Windows Store to Steam convention")
+    parser.add_argument("--input-container", help="UWP container.xyz file", required=True)
+    parser.add_argument("--input-save-directory", help="Snowrunner Windows Store savegame directory", required=True)
+    parser.add_argument("--output-save-directory", help="Snowrunner Steam savegame directory", required=True)
+    parser.add_argument("--dry-run", action="store_true", default=False, help="Enable dry run, do not copy files")
+    args = parser.parse_args()
+
+    save_list = container.load_container(args.input_container)
+    #print(save_list)
+    if not os.path.exists(args.input_save_directory) or not os.path.isdir(args.input_save_directory):
+        parser.error(f"Error accessing {args.input_save_directory}")
+    if not args.dry_run:
+        os.makedirs(args.output_save_directory, exist_ok=True)
+    copy_rename_save(save_list, args.input_save_directory, args.output_save_directory, args.dry_run)