chore: version Zelda 1 port and engineering records
This commit is contained in:
@@ -0,0 +1,237 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Build the starting cave and doorway masks from verified NES bytes."""
|
||||
import hashlib
|
||||
import json
|
||||
from PIL import Image
|
||||
from extract_graphics import ROOT, ROM_SHA256, decode
|
||||
from extract_start_room import RGB, write_json
|
||||
|
||||
TILES_UUID = 'dd893d16-0bd4-4569-a0c5-dcd67d504f39'
|
||||
SCENE_UUID = 'd692272f-18be-4db1-be6f-70b40145ae2c'
|
||||
DOOR_UUID = '5a67354c-de25-4c39-adfd-d0adac83f464'
|
||||
|
||||
|
||||
def prepare():
|
||||
rom = (ROOT / '.tmp/zelda-1.nes').read_bytes()
|
||||
assert hashlib.sha256(rom).hexdigest() == ROM_SHA256
|
||||
prg = rom[16:]
|
||||
source = json.loads((ROOT / 'extracted/overworld/start/room.json').read_text())
|
||||
primary_offset, secondary_offset = source['primary_table_prg_offset'], source['secondary_table_prg_offset']
|
||||
primary = prg[primary_offset:primary_offset + 56]
|
||||
secondary = prg[secondary_offset:secondary_offset + 64]
|
||||
directory_offset = source['column_directory_prg_offset']
|
||||
directory = [int.from_bytes(prg[directory_offset + i*2:directory_offset + i*2+2], 'little') for i in range(16)]
|
||||
# Confirm the room-specific coordinates and cave selector used by StageFlow.
|
||||
attrs77 = [prg[99328+i*128+0x77] for i in range(6)]
|
||||
assert attrs77[0] & 0xF0 == 64 and ((attrs77[5] & 7)*16+77) == 77
|
||||
assert attrs77[1] & 0xFC == 0x40
|
||||
assert source['tilemap'][11][8] == 0x24
|
||||
assert prg[99328+0x44] & 3 == 3 and prg[99328+128+0x44] & 3 == 2
|
||||
layout_offset = prg.index(bytes.fromhex('00009595959595c2c295959595950000'))
|
||||
descriptors = prg[layout_offset:layout_offset+16]
|
||||
tilemap = [[36]*32 for _ in range(30)]
|
||||
palette_map = [[0]*32 for _ in range(30)]
|
||||
columns = []
|
||||
for x, descriptor in enumerate(descriptors):
|
||||
cursor = 5*16384 + directory[descriptor >> 4] - 0x8000
|
||||
remaining = descriptor & 15
|
||||
while True:
|
||||
if prg[cursor] & 128:
|
||||
if remaining == 0: break
|
||||
remaining -= 1
|
||||
cursor += 1
|
||||
start, squares = cursor, []
|
||||
while len(squares) < 11:
|
||||
value = prg[cursor]
|
||||
squares.extend([value & 63] * (2 if value & 64 else 1))
|
||||
cursor += 1
|
||||
assert len(squares) == 11
|
||||
columns.append({'descriptor': descriptor, 'prg_offset': start, 'squares': squares})
|
||||
for y, index in enumerate(squares):
|
||||
base = primary[index]
|
||||
values = list(secondary[index*4:index*4+4]) if index < 16 else list(range(base,base+4))
|
||||
# InitModeB uses room $44's outer palette 3, inner palette 2.
|
||||
palette = 2 if 2 <= x <= 13 and 2 <= y <= 8 else 3
|
||||
for n,(dx,dy) in enumerate(((0,0),(0,1),(1,0),(1,1))):
|
||||
tilemap[8+y*2+dy][x*2+dx] = values[n]
|
||||
palette_map[8+y*2+dy][x*2+dx] = palette
|
||||
bg = bytearray(4096)
|
||||
bg[:1792] = prg[34687:34687+1792]
|
||||
bg[1792:0xF20] = prg[51515:51515+2080]
|
||||
bg[0xF20:] = prg[36479:36479+224]
|
||||
sprites = bytearray(4096)
|
||||
sprites[:1792] = prg[32895:32895+1792]
|
||||
sprites[0x8E0:0x1000] = prg[53595:53595+1824]
|
||||
palettes = [list(prg[103171+i*4:103175+i*4]) for i in range(8)]
|
||||
cave_palette_offset = prg.index(bytes.fromhex('3f08080f3000120f070f17'))
|
||||
palettes[2] = list(prg[cave_palette_offset+3:cave_palette_offset+7])
|
||||
palettes[3] = list(prg[cave_palette_offset+7:cave_palette_offset+11])
|
||||
rgb = dict(RGB)
|
||||
rgb.update({7:(136,20,0),0x29:(56,184,0),0x02:(0,0,188),0x22:(104,136,252),
|
||||
0x0C:(0,64,88),0x1C:(0,136,136),0x2C:(88,248,216)})
|
||||
def tile_image(tile, palette, transparent=False, patterns=bg):
|
||||
result = Image.new('RGBA',(8,8))
|
||||
result.putdata([(*rgb[palettes[palette][v]],255) if v or not transparent else (0,0,0,0)
|
||||
for v in decode(patterns[tile*16:(tile+1)*16])])
|
||||
return result
|
||||
terrain = Image.new('RGBA',(256,240),(0,0,0,255))
|
||||
for y in range(8,30):
|
||||
for x in range(32): terrain.paste(tile_image(tilemap[y][x],palette_map[y][x]),(x*8,y*8))
|
||||
canvas = terrain.copy()
|
||||
fires = terrain.copy()
|
||||
# Independent reference composites; gameplay renders these objects as sprites.
|
||||
animations = prg.index(bytes.fromhex('00080b0f13175c60'))
|
||||
heap = prg.index(bytes.fromhex('0004080c101014185c9e44ce'))
|
||||
attr_signature = bytes.fromhex('00000000000000000200000101010102')
|
||||
attr_heap = prg.index(attr_signature, heap)
|
||||
decorations = []
|
||||
overlays = []
|
||||
for obj,x in ((0x6A,120),(0x40,72),(0x40,168)):
|
||||
index = prg[animations+obj+1]
|
||||
tile = prg[heap+index]
|
||||
palette = 4 + (prg[attr_heap+index] & 3)
|
||||
left = Image.new('RGBA',(8,16))
|
||||
left.paste(tile_image(tile,palette,True,sprites),(0,0))
|
||||
left.paste(tile_image(tile+1,palette,True,sprites),(0,8))
|
||||
canvas.alpha_composite(left,(x,129))
|
||||
canvas.alpha_composite(left.transpose(Image.Transpose.FLIP_LEFT_RIGHT),(x+8,129))
|
||||
if obj == 0x40:
|
||||
fires.alpha_composite(left,(x,129))
|
||||
fires.alpha_composite(left.transpose(Image.Transpose.FLIP_LEFT_RIGHT),(x+8,129))
|
||||
whole=Image.new('RGBA',(16,16));whole.alpha_composite(left,(0,0));whole.alpha_composite(left.transpose(Image.Transpose.FLIP_LEFT_RIGHT),(8,0))
|
||||
overlays.append((1 if obj==0x6A else 0,x,129,whole))
|
||||
decorations.append({'object_type':obj,'tile':tile,'palette':palette,'x':x,'y':129})
|
||||
person_only = canvas.copy()
|
||||
canvas.alpha_composite(tile_image(32,4,True,sprites),(124,153))
|
||||
canvas.alpha_composite(tile_image(33,4,True,sprites),(124,161))
|
||||
sword=Image.new('RGBA',(8,16));sword.alpha_composite(tile_image(32,4,True,sprites),(0,0));sword.alpha_composite(tile_image(33,4,True,sprites),(0,8));overlays.append((2,124,153,sword))
|
||||
text_offset = 16384 + int.from_bytes(prg[16384:16386],'little') - 0x8000
|
||||
cursor, address, text_tiles = text_offset, 0x21A4, []
|
||||
while True:
|
||||
encoded = prg[cursor];cursor+=1
|
||||
tile = encoded & 63
|
||||
if tile != 0x25:
|
||||
px,py = ((address-0x2000)%32)*8,((address-0x2000)//32)*8
|
||||
canvas.paste(tile_image(tile,2),(px,py))
|
||||
overlays.append((2,px,py,tile_image(tile,2,True)))
|
||||
text_tiles.append({'tile':tile,'x':px,'y':py})
|
||||
address += 1
|
||||
control = encoded & 0xC0
|
||||
if control == 0xC0: break
|
||||
if control: address = 0x21C4 if control == 0x80 else 0x21E4
|
||||
out = ROOT / 'extracted/cave/start';out.mkdir(parents=True,exist_ok=True)
|
||||
terrain.save(out/'terrain.png');canvas.save(out/'room.png')
|
||||
person_only.save(out/'room_taken_person.png');fires.save(out/'room_taken.png')
|
||||
canvas.resize((768,720),Image.Resampling.NEAREST).save(out/'room@3x.png')
|
||||
registry_path=ROOT/'assets/.prometeu/index.json';registry=json.loads(registry_path.read_text())
|
||||
def register(root,uuid):
|
||||
matches=[a for a in registry['assets'] if a['root']==root or a['asset_uuid']==uuid]
|
||||
if matches:
|
||||
assert len(matches)==1 and matches[0]['asset_uuid']==uuid and matches[0]['root']==root
|
||||
matches[0]['included_in_build']=True
|
||||
return matches[0]['asset_id']
|
||||
index=registry['next_asset_id'];registry['next_asset_id']+=1
|
||||
registry['assets'].append({'asset_id':index,'asset_uuid':uuid,'root':root,'included_in_build':True})
|
||||
return index
|
||||
tiles_id=register('tilesets/cave_start',TILES_UUID)
|
||||
register('scenes/cave_start',SCENE_UUID)
|
||||
register('characters/link_door',DOOR_UUID)
|
||||
bank=ROOT/'assets/tilesets/cave_start';bank.mkdir(parents=True,exist_ok=True)
|
||||
colors=sorted(set(canvas.getdata())|{(0,0,0,0)});assert len(colors)<=16
|
||||
artifacts=[];glyphs={};variant_tiles=[]
|
||||
for visual in (canvas, person_only, fires, terrain):
|
||||
map_tiles=[]
|
||||
for y in range(30):
|
||||
for x in range(32):
|
||||
crop=visual.crop((x*8,y*8,x*8+8,y*8+8));key=crop.tobytes()
|
||||
if key not in glyphs:
|
||||
index=len(glyphs);glyphs[key]=index
|
||||
path=bank/f'tile_{index:03d}.png';crop.save(path)
|
||||
artifacts.append({'file':path.name,'index':index,'artifact_id':f'cave-tile-{index:03d}',
|
||||
'fingerprint':hashlib.sha256(path.read_bytes()).hexdigest()})
|
||||
map_tiles.append({'active':y>=8,'glyph_id':glyphs[key],'palette_id':0,'flip_x':False,'flip_y':False})
|
||||
variant_tiles.append(map_tiles)
|
||||
placements=[]
|
||||
for kind,x,y,image in overlays:
|
||||
for yy in range(0,image.height,8):
|
||||
for xx in range(0,image.width,8):
|
||||
crop=image.crop((xx,yy,xx+8,yy+8));key=crop.tobytes()
|
||||
if not crop.getbbox():continue
|
||||
if key not in glyphs:
|
||||
index=len(glyphs);glyphs[key]=index;path=bank/f'tile_{index:03d}.png';crop.save(path)
|
||||
artifacts.append({'file':path.name,'index':index,'artifact_id':f'cave-tile-{index:03d}','fingerprint':hashlib.sha256(path.read_bytes()).hexdigest()})
|
||||
placements.append((kind,x+xx,y+yy,glyphs[key]))
|
||||
module=ROOT/'src/stages/cave_start'
|
||||
flat=[v for row in placements for v in row]
|
||||
code='// Generated independent sprites: kind (fire/person/ware+text), x, y, glyph.\n'
|
||||
code+='import { Scene } from @zelda1:scene;\n'
|
||||
code+='declare global cave_parts: array<int> = ['+','.join(map(str,flat))+'];\n'
|
||||
code+='declare struct CaveArt() {\n fn draw(variant: int,offset: int) -> void {\n'
|
||||
code+=f' for i: int from 0 until {len(placements)} {{\n'
|
||||
code+=' let kind=cave_parts[i*4] else 0;\n'
|
||||
code+=' if kind==0 || (kind==1 && variant!=2) || (kind==2 && variant==0) {\n'
|
||||
code+=' let x=cave_parts[i*4+1] else 0; let y=cave_parts[i*4+2] else 0; let glyph=cave_parts[i*4+3] else 0;\n'
|
||||
code+=' Scene.emit_sprite(glyph,0,x,y+offset,3,0);\n }\n }\n }\n}\n'
|
||||
(module/'art.generated.pbs').write_text(code)
|
||||
write_json(out/'composition.json',{'bank':3,'terrain_scene':1,'parts':[{'kind':k,'x':x,'y':y,'glyph':g} for k,x,y,g in placements],'legacy_scenes_reserved':[2,3]})
|
||||
write_json(bank/'asset.json',{'schema_version':1,'asset_uuid':TILES_UUID,'name':'Starting cave NES',
|
||||
'type':'glyph_bank','output':{'format':'GLYPH/indexed_v1','codec':'NONE','metadata':{'tile_size':'8x8'},
|
||||
'pipeline':{'palettes':[{'index':0,'palette':{'rgba8888':[int.from_bytes(bytes(c),'big',signed=True) for c in colors]}}]}},
|
||||
'preload':{'enabled':True},'artifacts':artifacts})
|
||||
write_json(bank/'studio.asset.json',{'schema_version':1,'glyph_bank_specialization':'tileset'})
|
||||
def layer(active,w,h,values):return {'active':active,'glyph_asset_id':tiles_id,'tile_size':8,
|
||||
'parallax_factor_x':1.0,'parallax_factor_y':1.0,'width':w,'height':h,'tiles':values}
|
||||
empty={'active':False,'glyph_id':0,'palette_id':0,'flip_x':False,'flip_y':False}
|
||||
scene_variants=[('cave_start',SCENE_UUID),
|
||||
('cave_taken_person','787f596f-a349-43f2-9e1a-028331ed5bea'),
|
||||
('cave_taken','edc6ec17-3963-47c4-afab-d390541f4a37')]
|
||||
for i,(name,uuid) in enumerate(scene_variants):
|
||||
register('scenes/'+name,uuid)
|
||||
scene=ROOT/'assets/scenes'/name;scene.mkdir(parents=True,exist_ok=True)
|
||||
write_json(scene/'asset.json',{'schema_version':1,'asset_uuid':uuid,'name':name,
|
||||
'type':'scene_bank','output':{'format':'SCENE/tilemap_v1','codec':'NONE','pipeline':{}},'preload':{'enabled':True}})
|
||||
write_json(scene/'scene-bank.pack-request.json',{'schema_version':1,'format':'SCENE/tilemap_v1','version':1,
|
||||
'layers':[layer(True,32,30,variant_tiles[3])]+[layer(False,1,1,[empty]) for _ in range(3)]})
|
||||
# Terrain collision stays independent from dynamic text and actors.
|
||||
values=[tile for row in tilemap[8:] for tile in row]
|
||||
module=ROOT/'src/stages/cave_start';module.mkdir(parents=True,exist_ok=True)
|
||||
lines=['// Generated from RoomLayoutOWCave0; decorative art is not collision data.',
|
||||
'declare global terrain: array<int> = [']
|
||||
lines += [' '+', '.join(map(str,values[r*32:(r+1)*32]))+(',' if r<21 else '') for r in range(22)]
|
||||
lines += ['];','','declare struct CaveData() {',' fn tile_at(column: int, row: int) -> int {',
|
||||
' if column < 0 || column >= 32 || row < 0 || row >= 22 { return 255; }',
|
||||
' return terrain[row * 32 + column] else 255;',' }','}','']
|
||||
(module/'room.generated.pbs').write_text('\n'.join(lines))
|
||||
# Reproduce NES behind-background sprite priority at this doorway, using
|
||||
# original pattern indices (not RGB: a black background pixel may be solid).
|
||||
door=ROOT/'assets/characters/link_door';door.mkdir(parents=True,exist_ok=True)
|
||||
door_artifacts=[]
|
||||
for step in range(17):
|
||||
for direction in ('up','down'):
|
||||
for phase in range(2):
|
||||
image=Image.open(ROOT/f'assets/characters/link/walk_{direction}_{phase}.png').convert('RGBA')
|
||||
for yy in range(16):
|
||||
for xx in range(16):
|
||||
sx,sy=64+xx,77+step+3+yy
|
||||
tile=source['tilemap'][sy//8][sx//8]
|
||||
index=decode(bg[tile*16:(tile+1)*16])[(sy%8)*8+sx%8]
|
||||
if index: image.putpixel((xx,yy),(0,0,0,0))
|
||||
index=len(door_artifacts);path=door/f'door_{step:02d}_{direction}_{phase}.png';image.save(path)
|
||||
door_artifacts.append({'file':path.name,'index':index,'artifact_id':f'door-{step}-{direction}-{phase}',
|
||||
'fingerprint':hashlib.sha256(path.read_bytes()).hexdigest()})
|
||||
link=json.loads((ROOT/'assets/characters/link/asset.json').read_text())
|
||||
write_json(door/'asset.json',{'schema_version':1,'asset_uuid':DOOR_UUID,'name':'Link NES doorway priority',
|
||||
'type':'glyph_bank','output':link['output'],'preload':{'enabled':True},'artifacts':door_artifacts})
|
||||
write_json(door/'studio.asset.json',{'schema_version':1,'glyph_bank_specialization':'sprites'})
|
||||
if json.loads(registry_path.read_text())!=registry: write_json(registry_path,registry)
|
||||
write_json(out/'room.json',{'rom_sha256':ROM_SHA256,'layout_prg_offset':layout_offset,'columns':columns,
|
||||
'tilemap':tilemap,'palette_map':palette_map,'nes_palettes':palettes,'palette_prg_offset':cave_palette_offset,
|
||||
'decorations':decorations,'text_prg_offset':text_offset,'text_tiles':text_tiles,
|
||||
'entrance':{'overworld_x':64,'overworld_y':77,'cave_x':112,'cave_y':221,'walk_pixels':48},
|
||||
'scope':'Terrain scene plus independent sprites for fires, person, sword and text. Runtime inventory and room flags control visibility without scene rebinding.'})
|
||||
print(f'Cave: {len(artifacts)} glyphs, {len(colors)} colors; doorway: {len(door_artifacts)} masked Link poses')
|
||||
|
||||
from prepare_real_secret import prepare as prepare_secret
|
||||
prepare_secret()
|
||||
|
||||
if __name__=='__main__':prepare()
|
||||
Reference in New Issue
Block a user