genobjdiff.py

import yaml
import json

try:
    from yaml import CLoader as Loader, CDumper as Dumper
except:
    from yaml import Loader, Dumper

def CreateSegmentDefinition(name, path, hasBasePath, category):
    return [{
        "name": name,
        "target_path": f"build/asm{path}{name}.o",
        "base_path": f"build/src{path}{name}.o" if hasBasePath else None,
        "metadata": {
            "progress_categories": [
                category
            ]
        }
    }]

def ParseSubsegmentLabel(label, offset):
    if label is None:
        return ("/", hex(offset)[2:].upper())
    elif label.rfind("/") == -1:
        return ("/", label)
    else:
        return ("/" + label[:label.rfind("/") + 1], label[label.rfind("/") + 1:])

def GetOffsetName(offset):
    if offset < 0x53BD0:
        return "game"
    if offset < 0x57220:
        return "libmus"
    if offset < 0x6AC60:
        return "sdk"
    if offset < 0x6B6F0:
        return "libkmc"
    return "unknown"

def ParseMainSegment(segment):
    subsegments = []
    for subsegment in segment["subsegments"]:
        if isinstance(subsegment, list):
            offset = subsegment[0] if len(subsegment) > 0 else None
            subtype = subsegment[1] if len(subsegment) > 1 else None
            label = subsegment[2] if len(subsegment) > 2 else None
            (path, name) = ParseSubsegmentLabel(label, offset)
            offsetName = GetOffsetName(offset)
            match subtype:
                case "c":
                    subsegments.extend(CreateSegmentDefinition(name, path, True, offsetName))
                case "asm":
                    subsegments.extend(CreateSegmentDefinition(name, path, False, offsetName))
                case "hasm":
                    subsegments.extend(CreateSegmentDefinition(name, path, True, offsetName))
    return subsegments

def ParseLevelSegment(segment):
    levelId = segment["subsegments"][0][2]
    levelId = levelId[levelId.find("/") + 1:]
    return CreateSegmentDefinition(levelId, "/level/", True, "level")

def ParseSegment(segment):
    try:
        match segment["type"]:
            case "code":
                match segment["name"]:
                    case "entry":
                        return None
                    case "main":
                        return ParseMainSegment(segment)
                    case "zlib":
                        return CreateSegmentDefinition("zlib", "/", True, "sdk")
                    case _:
                        return ParseLevelSegment(segment)
            case _:
                return None
    except Exception as e:
        return None

def CreateObjJSON(segments):
    return {
        "$schema": "https://raw.githubusercontent.com/encounter/objdiff/main/config.schema.json",
        "units": segments,
        "progress_categories": [
            {
                "id": "game",
                "name": "Game"
            },
            {
                "id": "sdk",
                "name": "SDK"
            },
            {
                "id": "level",
                "name": "Level"
            },
            {
                "id": "libmus",
                "name": "Libmus"
            },
            {
                "id": "libkmc",
                "name": "LibKMC"
            }
        ]
    }

def ApplyOverrides(j):
    with open("objdiff.overrides.txt", "r") as f:
        s = f.read()
        s = s.replace("\r\n", "\n")
        keys = s.split("\n")
        for k in keys:
            n = FindObj(j["units"], k)
            if n is None:
                print(f"Unknown objdiff override: \"{k}\"")
            else:
                n["metadata"]["complete"] = True

    return j

try:
    with open("gexenterthegecko.yaml", "r") as f:
        y = yaml.load(f.read(), Loader=Loader)
        segments = []
        for segment in y["segments"]:
            segmentData = ParseSegment(segment)
            if segmentData is not None:
                segments.extend(segmentData)
        if len(segments) == 0:
            print("Error: No segments detected")
            exit(1)

        objdiffjson = CreateObjJSON(segments)
        
        with open("objdiff.json", "w") as fo:
            json.dump(objdiffjson, fo)
except:
    exit(1)