Gex64Decomp/genobjdiff.py at master · MatBourgon/Gex64Decomp · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
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 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)
            match subtype:
                case "c":
                    subsegments.extend(CreateSegmentDefinition(name, path, True, "game" if offset <= 0x56340 else "sdk"))
                case "asm" | "hasm":
                    subsegments.extend(CreateSegmentDefinition(name, path, False, "game" if offset <= 0x56340 else "sdk"))
    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"
            }
        ]
    }

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)