100 lines
3.5 KiB
Python
100 lines
3.5 KiB
Python
#!/usr/bin/env python3
|
|
"""Extrahiert die Weltkarten-Daten (Pfadsegmente, Levelpunkte, Levelnamen)
|
|
aus dem Original-START.EXE und gibt sie als Python-Literal aus -- damit
|
|
wurde die eingebettete SEGMENTS/LEVEL_NAMES-Tabelle in game/worldmap.py
|
|
erzeugt (26.07.2026). Nur noetig, falls die Tabelle je neu generiert
|
|
werden muss; das Spiel selbst liest START.EXE nicht mehr.
|
|
|
|
Aufruf: python3 tools/worldmap_extract.py [pfad/zu/START.EXE]
|
|
|
|
Binary-Struktur (NE-Datensegment, Offsets ~145114..146760):
|
|
Header, dann pro Level ein Segment aus 0xffff-terminierten u16-Records:
|
|
[x y 0 25] Standpunkt (Wiederholung des vorigen Endpunkts)
|
|
[x y 1 25] ... Wegpunkte (die Kartenfigur laeuft sie ab)
|
|
[x y 0 25] Endpunkt = Standpunkt an diesem Level
|
|
[label_x label_y] Position des Levelpunkt-Markers
|
|
[0] (Flag/Reserve)
|
|
danach die 22 Levelnamen als Pascal-Strings (\x04W1L0...).
|
|
y-Achse ist geflippt (Screen-Basis = (x, 218 - y), siehe game/worldmap.py).
|
|
"""
|
|
import os
|
|
import struct
|
|
import sys
|
|
|
|
|
|
def parse_worldmap(exe_path):
|
|
'''Rueckgabe: (segments, names); segments = Liste von dicts
|
|
{waypoints: [(x,y)...], stand: (x,y), label: (x,y)}.'''
|
|
d = open(exe_path, 'rb').read()
|
|
anchor = struct.pack('<4H', 58, 40, 0, 25)
|
|
start = d.find(anchor)
|
|
if start < 0:
|
|
raise ValueError('Kartenpfad-Anker nicht gefunden')
|
|
names_at = d.find(b'\x04W1L0\x04W1L1')
|
|
if names_at < 0:
|
|
raise ValueError('Levelnamen nicht gefunden')
|
|
# Namen lesen (22 Pascal-Strings)
|
|
names = []
|
|
p = names_at
|
|
while len(names) < 22 and p < len(d) - 1:
|
|
ln = d[p]
|
|
if not (1 <= ln <= 8):
|
|
break
|
|
names.append(d[p + 1:p + 1 + ln].decode('ascii'))
|
|
p += 1 + ln
|
|
|
|
def read_list(p):
|
|
vals = []
|
|
while p <= names_at - 2:
|
|
v = struct.unpack('<H', d[p:p + 2])[0]
|
|
p += 2
|
|
if v == 0xffff:
|
|
return vals, p
|
|
vals.append(v)
|
|
if len(vals) > 8:
|
|
return None, p
|
|
return vals, p
|
|
|
|
segments = []
|
|
p = start
|
|
cur = {'waypoints': [], 'stand': None, 'label': None}
|
|
while p < names_at - 2:
|
|
vals, p = read_list(p)
|
|
if vals is None:
|
|
continue
|
|
if len(vals) == 4 and vals[3] == 25:
|
|
x, y, flag = vals[0], vals[1], vals[2]
|
|
if x > 320 or y > 200:
|
|
continue # Sonder-/Sprungrecords (Weltwechsel) ueberspringen
|
|
cur['waypoints'].append((x, y))
|
|
if flag == 0 and len(cur['waypoints']) > 1:
|
|
cur['stand'] = (x, y)
|
|
elif len(vals) == 2:
|
|
cur['label'] = (vals[0], vals[1])
|
|
if cur['stand'] is None and cur['waypoints']:
|
|
cur['stand'] = cur['waypoints'][-1]
|
|
segments.append(cur)
|
|
cur = {'waypoints': [], 'stand': None, 'label': None}
|
|
# len==1 ([0]-Flag) und leere Listen: ignorieren
|
|
return segments, names
|
|
|
|
|
|
def main():
|
|
default = os.path.join(os.path.dirname(__file__), '..',
|
|
'game', 'original', 'START.EXE')
|
|
exe = sys.argv[1] if len(sys.argv) > 1 else default
|
|
segments, names = parse_worldmap(exe)
|
|
print('LEVEL_NAMES = %r' % (names,))
|
|
print()
|
|
print('SEGMENTS = [')
|
|
for s in segments:
|
|
print(' dict(waypoints=%r,' % (s['waypoints'],))
|
|
print(' stand=%r, label=%r),' % (s['stand'], s['label']))
|
|
print(']')
|
|
print('# %d Segmente, %d Namen' % (len(segments), len(names)),
|
|
file=sys.stderr)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|