cheahjs/README.md

## README.md

      
    Raw
  

              README.md
            
          
    These are Python scripts that are used in conjunction with https://github.com/trumank/uesave-rs to convert PalWorld .sav files into JSON files.
NOTE THAT A LOT OF DATA IS STILL STORED AS BINARY INSIDE OF THE FILES, NOT EVERYTHING IS EASILY EDITABLE IN THE JSON!

Converting Co-op to Dedicated Server saves:

Go over to https://github.com/xNul/palworld-host-save-fix
Windows Instructions


Install Python. You can search for Python in the Microsoft store (any Python 3 version should work)
Click "Download as zip" on the top-right
Extract the zip somewhere.
Download uesave-rs, and extract uesave.exe into the folder you extracted the first zip into.
Drag and drop your save file folder (%LOCALAPPDATA%\Pal\Saved\SaveGames\<SteamID>\<SaveID> onto convert-to-json.bat. This will generate .sav.json files in the folder.

This should be the entire folder, not just a single .sav file.


After making any changes, drag and drop the save file folder again onto convert-to-sav.bat to convert the JSON back into the sav files.


## convert-to-json.bat
@ECHO OFF

@REM Check if python is installed, error if not
python --version 2>NUL
IF %ERRORLEVEL% NEQ 0 (
    ECHO Python is not installed. Please install python and try again.
    PAUSE
    EXIT /B 1
)

@REM Switch to script directory
cd /D "%~dp0"

@REM Check if first argument is a directory
IF NOT EXIST "%~1" (
    ECHO You must specify a directory to convert.
    PAUSE
    EXIT /B 1
)

ECHO This will convert the save files in "%~1" to JSON format.
@REM Ask user if they want to continue
CHOICE /C YN /M "Continue?"
IF %ERRORLEVEL% NEQ 1 (
    EXIT /B 1
)

python convert-to-json.py "uesave.exe" "%~1"
PAUSE

@REM Ask user if they want to open the output directory
CHOICE /C YN /M "Open output directory?"
IF %ERRORLEVEL% EQU 1 (
    START "" "%~1"
)

## convert-to-json.py
#!/usr/bin/env python3

import subprocess
import sys
import glob
import zlib

UESAVE_TYPE_MAPS = [
    ".worldSaveData.CharacterSaveParameterMap.Key=Struct",
    ".worldSaveData.FoliageGridSaveDataMap.Key=Struct",
    ".worldSaveData.FoliageGridSaveDataMap.ModelMap.InstanceDataMap.Key=Struct",
    ".worldSaveData.MapObjectSpawnerInStageSaveData.Key=Struct",
    ".worldSaveData.ItemContainerSaveData.Key=Struct",
    ".worldSaveData.CharacterContainerSaveData.Key=Struct",
]

def main():
    # Check if argument exists
    if len(sys.argv) < 3:
        print('convert-to-json.py <uesave.exe> <save_path>')
        exit(1)
    # Take the first argument as the path to uesave.exe
    uesave_path = sys.argv[1]
    # Take the second argument as a path to the save directory
    save_path = sys.argv[2]
    print(f"Converting .sav files in {save_path} to JSON (using {uesave_path})")
    # Find all .sav files in the directory, ignore backup files
    files = glob.glob(save_path + '/*.sav') + glob.glob(save_path + '/Players/*.sav')
    # Loop through all files
    for file in files:
        # Open the file
        with open(file, 'rb') as f:
            # Read the file
            data = f.read()
            uncompressed_len = int.from_bytes(data[0:4], byteorder='little')
            compressed_len = int.from_bytes(data[4:8], byteorder='little')
            magic_bytes = data[8:11]
            save_type = data[11]
            # Check for magic bytes
            if magic_bytes != b'PlZ':
                print(f'File {file} is not a save file, found {magic_bytes} instead of P1Z')
                continue
            # Valid save types
            if save_type not in [0x30, 0x31, 0x32]:
                print(f'File {file} has an unknown save type: {save_type}')
                continue
            # We only have 0x31 (single zlib) and 0x32 (double zlib) saves
            if save_type not in [0x31, 0x32]:
                print(f'File {file} uses an unhandled compression type: {save_type}')
                continue
            if save_type == 0x31:
                # Check if the compressed length is correct
                if compressed_len != len(data) - 12:
                    print(f'File {file} has an incorrect compressed length: {compressed_len}')
                    continue
            # Decompress file
            uncompressed_data = zlib.decompress(data[12:])
            if save_type == 0x32:
                # Check if the compressed length is correct
                if compressed_len != len(uncompressed_data):
                    print(f'File {file} has an incorrect compressed length: {compressed_len}')
                    continue
                # Decompress file
                uncompressed_data = zlib.decompress(uncompressed_data)
            # Check if the uncompressed length is correct
            if uncompressed_len != len(uncompressed_data):
                print(f'File {file} has an incorrect uncompressed length: {uncompressed_len}')
                continue
            print(f'File {file} uncompressed successfully')
            # Convert to json with uesave
            # Run uesave.exe with the uncompressed file piped as stdin
            # Standard out will be the json string
            uesave_run = subprocess.run(uesave_params(uesave_path, file+'.json'), input=uncompressed_data, capture_output=True)
            # Check if the command was successful
            if uesave_run.returncode != 0:
                print(f'uesave.exe failed to convert {file} (return {uesave_run.returncode})')
                print(uesave_run.stdout.decode('utf-8'))
                print(uesave_run.stderr.decode('utf-8'))
                continue
            print(f'File {file} (type: {save_type}) converted to JSON successfully')

def uesave_params(uesave_path, out_path):
    args = [
        uesave_path,
        'to-json',
        '--output', out_path,
    ]
    for map_type in UESAVE_TYPE_MAPS:
        args.append('--type')
        args.append(f'{map_type}')
    return args

if __name__ == "__main__":
    main()

## convert-to-sav.bat
@ECHO OFF

@REM Check if python is installed, error if not
python --version 2>NUL
IF %ERRORLEVEL% NEQ 0 (
    ECHO Python is not installed. Please install python and try again.
    PAUSE
    EXIT /B 1
)

@REM Switch to script directory
cd /D "%~dp0"

@REM Check if first argument is a directory
IF NOT EXIST "%~1" (
    ECHO You must specify a directory to convert.
    PAUSE
    EXIT /B 1
)

ECHO This will convert the save files in JSON format in "%~1" back to .sav format.
ECHO This will overwrite your existing .sav files!
@REM Ask user if they want to continue
CHOICE /C YN /M "Continue?"
IF %ERRORLEVEL% NEQ 1 (
    EXIT /B 1
)

python convert-to-sav.py "uesave.exe" "%~1"
PAUSE

@REM Ask user if they want to open the output directory
CHOICE /C YN /M "Open output directory?"
IF %ERRORLEVEL% EQU 1 (
    START "" "%~1"
)

## convert-to-sav.py
#!/usr/bin/env python3

import os
import subprocess
import sys
import glob
import zlib

def main():
    # Check if argument exists
    if len(sys.argv) < 3:
        print('convert-to-sav.py <uesave.exe> <save_path>')
        exit(1)
    # Take the first argument as the path to uesave.exe
    uesave_path = sys.argv[1]
    # Take the second argument as a path to the save directory
    save_path = sys.argv[2]
    print(f"Converting .sav.json files in {save_path} back to .sav (using {uesave_path})")
    # Find all .sav.json files in the directory, ignore backup files
    files = glob.glob(save_path + '/*.sav.json') + glob.glob(save_path + '/Players/*.sav.json')
    # Loop through all files
    for file in files:
        # Convert the file back to binary
        gvas_file = file.replace('.sav.json', '.sav.gvas')
        sav_file = file.replace('.sav.json', '.sav')
        uesave_run = subprocess.run(uesave_params(uesave_path, file, gvas_file))
        if uesave_run.returncode != 0:
            print(f'uesave.exe failed to convert {file} (return {uesave_run.returncode})')
            continue
        # Open the old sav file to get type
        if os.path.exists(sav_file):
            with open(sav_file, 'rb') as f:
                data = f.read()
                save_type = data[11]
        # If the sav file doesn't exist, use known heuristics
        else:
            # Largest files use double compression
            if sav_file.endswith('LocalData.sav') or sav_file.endswith('Level.sav'):
                save_type = 0x32
            else:
                save_type = 0x31

        # Open the binary file
        with open(gvas_file, 'rb') as f:
            # Read the file
            data = f.read()
            uncompressed_len = len(data)
            compressed_data = zlib.compress(data)
            compressed_len = len(compressed_data)
            if save_type == 0x32:
                compressed_data = zlib.compress(compressed_data)
            with open(sav_file, 'wb') as f:
                f.write(uncompressed_len.to_bytes(4, byteorder='little'))
                f.write(compressed_len.to_bytes(4, byteorder='little'))
                f.write(b'PlZ')
                f.write(bytes([save_type]))
                f.write(bytes(compressed_data))
        print(f'Converted {file} to {sav_file}')

def uesave_params(uesave_path, input_file, output_file):
    args = [
        uesave_path,
        'from-json',
        '--input', input_file,
        '--output', output_file,
    ]
    return args

if __name__ == "__main__":
    main()
	@ECHO OFF

	@REM Check if python is installed, error if not
	python --version 2>NUL
	IF %ERRORLEVEL% NEQ 0 (
	ECHO Python is not installed. Please install python and try again.
	PAUSE
	EXIT /B 1
	)

	@REM Switch to script directory
	cd /D "%~dp0"

	@REM Check if first argument is a directory
	IF NOT EXIST "%~1" (
	ECHO You must specify a directory to convert.
	PAUSE
	EXIT /B 1
	)

	ECHO This will convert the save files in "%~1" to JSON format.
	@REM Ask user if they want to continue
	CHOICE /C YN /M "Continue?"
	IF %ERRORLEVEL% NEQ 1 (
	EXIT /B 1
	)

	python convert-to-json.py "uesave.exe" "%~1"
	PAUSE

	@REM Ask user if they want to open the output directory
	CHOICE /C YN /M "Open output directory?"
	IF %ERRORLEVEL% EQU 1 (
	START "" "%~1"
	)
	#!/usr/bin/env python3

	import subprocess
	import sys
	import glob
	import zlib

	UESAVE_TYPE_MAPS = [
	".worldSaveData.CharacterSaveParameterMap.Key=Struct",
	".worldSaveData.FoliageGridSaveDataMap.Key=Struct",
	".worldSaveData.FoliageGridSaveDataMap.ModelMap.InstanceDataMap.Key=Struct",
	".worldSaveData.MapObjectSpawnerInStageSaveData.Key=Struct",
	".worldSaveData.ItemContainerSaveData.Key=Struct",
	".worldSaveData.CharacterContainerSaveData.Key=Struct",
	]

	def main():
	# Check if argument exists
	if len(sys.argv) < 3:
	print('convert-to-json.py <uesave.exe> <save_path>')
	exit(1)
	# Take the first argument as the path to uesave.exe
	uesave_path = sys.argv[1]
	# Take the second argument as a path to the save directory
	save_path = sys.argv[2]
	print(f"Converting .sav files in {save_path} to JSON (using {uesave_path})")
	# Find all .sav files in the directory, ignore backup files
	files = glob.glob(save_path + '/.sav') + glob.glob(save_path + '/Players/.sav')
	# Loop through all files
	for file in files:
	# Open the file
	with open(file, 'rb') as f:
	# Read the file
	data = f.read()
	uncompressed_len = int.from_bytes(data[0:4], byteorder='little')
	compressed_len = int.from_bytes(data[4:8], byteorder='little')
	magic_bytes = data[8:11]
	save_type = data[11]
	# Check for magic bytes
	if magic_bytes != b'PlZ':
	print(f'File {file} is not a save file, found {magic_bytes} instead of P1Z')
	continue
	# Valid save types
	if save_type not in [0x30, 0x31, 0x32]:
	print(f'File {file} has an unknown save type: {save_type}')
	continue
	# We only have 0x31 (single zlib) and 0x32 (double zlib) saves
	if save_type not in [0x31, 0x32]:
	print(f'File {file} uses an unhandled compression type: {save_type}')
	continue
	if save_type == 0x31:
	# Check if the compressed length is correct
	if compressed_len != len(data) - 12:
	print(f'File {file} has an incorrect compressed length: {compressed_len}')
	continue
	# Decompress file
	uncompressed_data = zlib.decompress(data[12:])
	if save_type == 0x32:
	# Check if the compressed length is correct
	if compressed_len != len(uncompressed_data):
	print(f'File {file} has an incorrect compressed length: {compressed_len}')
	continue
	# Decompress file
	uncompressed_data = zlib.decompress(uncompressed_data)
	# Check if the uncompressed length is correct
	if uncompressed_len != len(uncompressed_data):
	print(f'File {file} has an incorrect uncompressed length: {uncompressed_len}')
	continue
	print(f'File {file} uncompressed successfully')
	# Convert to json with uesave
	# Run uesave.exe with the uncompressed file piped as stdin
	# Standard out will be the json string
	uesave_run = subprocess.run(uesave_params(uesave_path, file+'.json'), input=uncompressed_data, capture_output=True)
	# Check if the command was successful
	if uesave_run.returncode != 0:
	print(f'uesave.exe failed to convert {file} (return {uesave_run.returncode})')
	print(uesave_run.stdout.decode('utf-8'))
	print(uesave_run.stderr.decode('utf-8'))
	continue
	print(f'File {file} (type: {save_type}) converted to JSON successfully')

	def uesave_params(uesave_path, out_path):
	args = [
	uesave_path,
	'to-json',
	'--output', out_path,
	]
	for map_type in UESAVE_TYPE_MAPS:
	args.append('--type')
	args.append(f'{map_type}')
	return args

	if __name__ == "__main__":
	main()
	#!/usr/bin/env python3

	import os
	import subprocess
	import sys
	import glob
	import zlib

	def main():
	# Check if argument exists
	if len(sys.argv) < 3:
	print('convert-to-sav.py <uesave.exe> <save_path>')
	exit(1)
	# Take the first argument as the path to uesave.exe
	uesave_path = sys.argv[1]
	# Take the second argument as a path to the save directory
	save_path = sys.argv[2]
	print(f"Converting .sav.json files in {save_path} back to .sav (using {uesave_path})")
	# Find all .sav.json files in the directory, ignore backup files
	files = glob.glob(save_path + '/.sav.json') + glob.glob(save_path + '/Players/.sav.json')
	# Loop through all files
	for file in files:
	# Convert the file back to binary
	gvas_file = file.replace('.sav.json', '.sav.gvas')
	sav_file = file.replace('.sav.json', '.sav')
	uesave_run = subprocess.run(uesave_params(uesave_path, file, gvas_file))
	if uesave_run.returncode != 0:
	print(f'uesave.exe failed to convert {file} (return {uesave_run.returncode})')
	continue
	# Open the old sav file to get type
	if os.path.exists(sav_file):
	with open(sav_file, 'rb') as f:
	data = f.read()
	save_type = data[11]
	# If the sav file doesn't exist, use known heuristics
	else:
	# Largest files use double compression
	if sav_file.endswith('LocalData.sav') or sav_file.endswith('Level.sav'):
	save_type = 0x32
	else:
	save_type = 0x31

	# Open the binary file
	with open(gvas_file, 'rb') as f:
	# Read the file
	data = f.read()
	uncompressed_len = len(data)
	compressed_data = zlib.compress(data)
	compressed_len = len(compressed_data)
	if save_type == 0x32:
	compressed_data = zlib.compress(compressed_data)
	with open(sav_file, 'wb') as f:
	f.write(uncompressed_len.to_bytes(4, byteorder='little'))
	f.write(compressed_len.to_bytes(4, byteorder='little'))
	f.write(b'PlZ')
	f.write(bytes([save_type]))
	f.write(bytes(compressed_data))
	print(f'Converted {file} to {sav_file}')

	def uesave_params(uesave_path, input_file, output_file):
	args = [
	uesave_path,
	'from-json',
	'--input', input_file,
	'--output', output_file,
	]
	return args

	if __name__ == "__main__":
	main()