Files

238 lines
14 KiB
Python

#!/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()