A Blender-Python script to convert basic Age information from inside a PyPRP .blend into a functional Korman .blend.

convert_pyprp_to_korman.py

import bpy
import addon_utils

from PyHSPlasma import *
import korman.properties.modifiers.region as kor_region

# For reading all that alcscripty info
from ruamel.yaml import YAML

collision_bounds_translations = {
    "BOX": "box",
    "SPHERE": "sphere",
    "CONVEX_HULL": "hull",
    "TRIANGLE_MESH": "trimesh",
}


def findOrAddKormanPage(page_num, page_name):
    name = page_name
    suffix = page_num

    korAge = bpy.context.scene.world.plasma_age
    for page in korAge.pages:
        if page.seq_suffix == suffix:
            return page

    print("Adding page #{} named {}".format(suffix, name))
    korAge.pages.add()
    korPage = korAge.pages[-1]
    korPage.name = name
    korPage.seq_suffix = suffix

    return korPage


def checkFlag(value, bit):
    return bool(value & (1 << bit))


def readBook():
    korAge = bpy.context.scene.world.plasma_age

    book_yaml = YAML().load(bpy.data.texts["Book"].as_string().replace("\t","    "))
    if "age" in book_yaml:
        korAge.seq_prefix = book_yaml["age"]["sequenceprefix"]
        korAge.day_length = book_yaml["age"]["daylength"]
        korAge.start_time = book_yaml["age"]["starttime"]
        korAge.start_time = book_yaml["age"]["starttime"]

        if "pages" in book_yaml["age"]:
            pages = {entry["index"]: entry["name"] for entry in book_yaml["age"]["pages"]}

            for page_num in pages:
                korPage = findOrAddKormanPage(page_num, pages[page_num])

            valid_page_nums = [page.seq_suffix for page in korAge.pages]

            # Copy game properties into attributes for Plasma Objects
            for blObj in bpy.context.scene.objects:
                # Assign to a page, if provided and valid
                if "page_num" in blObj.game.properties:
                    page_num = int(blObj.game.properties["page_num"].value)
                    if page_num in valid_page_nums:
                        blObj.plasma_object.page = findOrAddKormanPage(page_num, None).name
                        blObj.plasma_object.enabled = True

                # Add modifiers analagous to PyPRP properties
                if "type" in blObj.game.properties:
                    obj_type = blObj.game.properties["type"].value

                    if obj_type == "swpoint":
                        blObj.plasma_modifiers.spawnpoint.display_order = blObj.plasma_modifiers.determine_next_id()

                    elif obj_type == "region":
                        if "regiontype" in blObj.game.properties:
                            regiontype = blObj.game.properties["regiontype"].value
                            if regiontype == "panic":
                                blObj.plasma_modifiers.paniclink.display_order = blObj.plasma_modifiers.determine_next_id()
                            if regiontype == "footstep":
                                blObj.plasma_modifiers.footstep.display_order = blObj.plasma_modifiers.determine_next_id()
                                if "surface" in blObj.game.properties and blObj.game.properties["surface"].value in kor_region.footstep_surface_ids.keys():
                                    blObj.plasma_modifiers.footstep.surface = blObj.game.properties["surface"].value
                        else:
                            # Logic-only Region
                            pass

                    elif obj_type == "collider":
                        blObj.plasma_modifiers.collision.display_order = blObj.plasma_modifiers.determine_next_id()
                        bounds_type = blObj.game.collision_bounds_type
                        if bounds_type in collision_bounds_translations.keys():
                            blObj.plasma_modifiers.collision.bounds = collision_bounds_translations[bounds_type]

                    elif obj_type == "sprite":
                        blObj.plasma_modifiers.viewfacemod.display_order = blObj.plasma_modifiers.determine_next_id()
                        if "sprite_flags" in blObj.game.properties:
                            sprite_flags = int(blObj.game.properties["sprite_flags"].value, base=16)

                            if checkFlag(sprite_flags, plViewFaceModifier.kFaceCam) and checkFlag(sprite_flags, plViewFaceModifier.kPivotY):
                                blObj.plasma_modifiers.viewfacemod.preset_options = "Billboard"
                            elif checkFlag(sprite_flags, plViewFaceModifier.kFaceCam) and checkFlag(sprite_flags, plViewFaceModifier.kPivotFace):
                                blObj.plasma_modifiers.viewfacemod.preset_options = "Sprite"
                            else:
                                blObj.plasma_modifiers.viewfacemod.preset_options = "Custom"
                                if checkFlag(sprite_flags, plViewFaceModifier.kFaceCam):
                                    blObj.plasma_modifiers.viewfacemod.target_type = "kFaceCam"
                                elif checkFlag(sprite_flags, plViewFaceModifier.kFaceCam):
                                    blObj.plasma_modifiers.viewfacemod.target_type = "kFaceList"
                                elif checkFlag(sprite_flags, plViewFaceModifier.kFaceCam):
                                    blObj.plasma_modifiers.viewfacemod.target_type = "kFacePlay"
                                elif checkFlag(sprite_flags, plViewFaceModifier.kFaceCam):
                                    blObj.plasma_modifiers.viewfacemod.target_type = "kFaceObj"

                                if checkFlag(sprite_flags, plViewFaceModifier.kPivotY):
                                    blObj.plasma_modifiers.viewfacemod.pivot_on_y = True

    if "config" in book_yaml:
        if "agesdlhook" in book_yaml["config"]:
            # We could enable this with `korAge.age_sdl = True`,
            # but that would start something we can't finish.
            # Best to leave this a manual step for now.
            pass


def readFNI():
    korFni = bpy.context.scene.world.plasma_fni

    options = {}

    fni = bpy.data.texts["init"]
    for lineItem in fni.lines:
        if lineItem.body:
            line = lineItem.body.strip()
            if line[0] == "#":
                continue
            command, *args = line.split(" ")
            options[command] = args

    for command in options.keys():
        if command == "Graphics.Renderer.SetClearColor":
            korFni.clear_color = tuple(map(float, options[command]))
        elif command == "Graphics.Renderer.SetYon":
            korFni.yon = int(options[command][0])
        elif command == "Graphics.Renderer.Fog.SetDefColor":
            korFni.fog_color = tuple(map(float, options[command]))
        elif command == "Graphics.Renderer.Fog.SetDefLinear":
            korFni.fog_method = "linear"
            korFni.fog_start = float(options[command][0])
            korFni.fog_end = float(options[command][1])
            korFni.fog_density = float(options[command][2])
        elif command == "Graphics.Renderer.Fog.SetDefExp2":
            korFni.fog_method = "exp2"
            korFni.fog_end = float(options[command][0])
            korFni.fog_density = float(options[command][1])


def import_from_pyprp():
    if "Book" in bpy.data.texts:
        print("Reading Age Book information...")
        readBook()

    if "init" in bpy.data.texts:
        print("Reading Age's Init information...")
        readFNI()


#  Check that Korman is installed and currently loaded
if all(addon_utils.check("korman")):
    import_from_pyprp()
else:
    print("Korman could not be found.  Converting PyPRP information to Korman cannot continue.")