Files
zelda-1-prometeu-port/tools/prepare_inventory_screen.py
T

127 lines
12 KiB
Python

#!/usr/bin/env python3
"""Decode native submenu transfers/items and publish the final scene-bank slot."""
import hashlib,json,uuid
from PIL import Image
from extract_graphics import ROOT,decode,ROM_SHA256
from extract_start_room import RGB,write_json
from nes_object_graphics import P,item
def prepare():
assert hashlib.sha256((ROOT/'.tmp/zelda-1.nes').read_bytes()).hexdigest()==ROM_SHA256
out=ROOT/'extracted/inventory_screen';out.mkdir(exist_ok=True,parents=True)
directory=json.loads((ROOT/'extracted/game_flow/rom-data.json').read_text())['transfer_directory_prg_offset']
common=P.index(bytes.fromhex('3f00200f3000120f1627360f0c1c2c0f121c2c0f2927070f2227070f2627070f152730ff'))
ram=bytearray(65536);ram[0x67f0:0x687e]=P[common:common+142];ram[0x687e:0x6b7e]=P[99328:100096]
patch_sig=bytes.fromhex('000809010a0b121e1f172425131421132021151622162223');patch=P.index(patch_sig,5*16384,6*16384)
offsets=list(P[patch:patch+24]);replacements=list(P[patch+24:patch+48]);empty=list(P[patch+48:patch+72])
for i,o in enumerate(offsets):ram[0x6847+4+o]=empty[i]
memory=bytearray(0x4000);memory[0x2800:0x2bc0]=bytes([36])*960
records=[]
def transfer(selector):
ptr=int.from_bytes(P[directory+selector:directory+selector+2],'little')
source=ram if ptr<0x8000 else P;start=ptr if ptr<0x8000 else 6*16384+ptr-0x8000;pos=start;events=[]
while 0x20<=source[pos]<0x40:
address=source[pos]*256+source[pos+1];control=source[pos+2];count=control&63 or 64;pos+=3
for i in range(count):memory[address+i*(32 if control&128 else 1)]=source[pos if control&64 else pos+i]
events.append({'address':address,'control':control,'count':count});pos+=1 if control&64 else count
records.append({'selector':selector,'pointer_cpu':ptr,'source':'RAM' if ptr<0x8000 else 'PRG','source_offset':start,'events':events})
for selector in (0x30,0x32,0x34,0x38,0x3a,0x3c,0x48,0x4a,0x4c,0x50,0x52,0x54,0x56,0x58,0x5a,0x5c):transfer(selector)
patterns=bytearray(8192)
for pos,size,dest in [(32895,1792,0),(19892,2304,1792),(53595,1824,2272),(34687,1792,4096),(51515,2080,5888),(36479,224,7968)]:patterns[dest:dest+size]=P[pos:pos+size]
rgb=dict(RGB);rgb.update({2:(0,0,188),34:(104,136,252),41:(56,184,0),12:(0,64,88),28:(0,136,136),44:(88,248,216)})
rows=[list(P[103171+i*4:103175+i*4]) for i in range(8)]
cave_asset=json.loads((ROOT/'assets/tilesets/cave_start/asset.json').read_text());cv=cave_asset['output']['pipeline']['palettes'][0]['palette']['rgba8888'];cave_colors=[tuple((v&0xffffffff)>>s&255 for s in (24,16,8,0)) for v in cv]
canonical=[(*rgb[c],255) for c in rows[0]]
for c in cave_colors:
if c not in canonical:canonical.append(c)
while len(canonical)<16:
c=(len(canonical),0,1,255)
if c not in canonical:canonical.append(c)
assert len(canonical)==16
palettes=[]
for n,row in enumerate(rows):
colors=[(0,0,0,0) if i==0 and n>=4 else (*rgb[c],255) for i,c in enumerate(row)]
palettes.append(colors+[canonical[i] for i in range(4,16)])
palettes[0]=canonical
palettes.append(cave_colors+[(0,0,0,255)]*(16-len(cave_colors)))
regpath=ROOT/'assets/.prometeu/index.json';reg=json.loads(regpath.read_text())
def register(root):
u=str(uuid.uuid5(uuid.NAMESPACE_URL,'zelda1/'+root))
for a in reg['assets']:
if a['root']==root:assert a['asset_uuid']==u;return a['asset_id'],u
n=reg['next_asset_id'];reg['next_asset_id']+=1;reg['assets'].append({'asset_id':n,'asset_uuid':u,'root':root,'included_in_build':True});return n,u
bank_root='ui/inventory';bank=ROOT/'assets'/bank_root;bank.mkdir(exist_ok=True,parents=True);bank_id,bank_uuid=register(bank_root);arts=[];keys={};native={}
def glyph(indices,key):
indices=tuple(indices)
if key in keys:return keys[key]
im=Image.new('RGBA',(8,8));im.putdata([canonical[i] for i in indices]);n=len(arts);path=bank/(key+'.png');im.save(path);keys[key]=n;arts.append({'file':path.name,'index':n,'artifact_id':key,'fingerprint':hashlib.sha256(path.read_bytes()).hexdigest()});return n
def pattern(key):
if key not in native:native[key]=glyph(decode(patterns[key*16:(key+1)*16]),f'ppu_{key*16:04x}')
return native[key]
def pal(x,y):
attr=memory[0x2bc0+(y//4)*8+x//4];return (attr>>(((y%4)//2)*4+((x%4)//2)*2))&3
panel=[];image=Image.new('RGBA',(256,176))
for y in range(8,30):
for x in range(32):
t=memory[0x2800+y*32+x];pa=pal(x,y);g=pattern(256+t);panel.append({'active':True,'glyph_id':g,'palette_id':pa,'flip_x':False,'flip_y':False})
im=Image.new('RGBA',(8,8));im.putdata([palettes[pa][v] for v in decode(patterns[4096+t*16:4096+(t+1)*16])]);image.paste(im,(x*8,(y-8)*8))
image.crop((0,1,256,176)).save(out/'panel.png')
# Native item frame heaps/attributes; encode all grades without baking sprites.
for slot in range(32):
for phase in range(4 if slot==1 else 2):
info=item(slot,phase)
for t in info['tiles'][:info['sides']]:pattern((t&1)*256+(t&254));pattern((t&1)*256+(t&254)+1)
pattern(0x1e);pattern(0x1f)
for t in set(replacements+empty+[0xe5,0xe6,0xf5]):pattern(256+t)
# Frozen-room strips come from the generated catalog when available.
catalog_path=ROOT/'extracted/overworld/expansion/catalog.json'
if catalog_path.exists():
catalog=json.loads(catalog_path.read_text());strips=catalog['menu_strips'];world_palette=catalog['world_palette_to_native']
else:
roots=['overworld_start','cave_start','cave_start','cave_start','overworld_north','overworld_north','overworld_north','overworld_north']
strips=[{'root':root,'row':8+30*(i-4) if i>=5 else 8,'palette':'cave' if i in (1,2,3) else 'world' if i>=4 else 'start'} for i,root in enumerate(roots)];world_palette=[2,3,0,1]
scene_roots=[r['root'] for r in strips];world_tiles=[]
for variant,strip in enumerate(strips):
root=strip['root'];request=json.loads((ROOT/f'assets/scenes/{root}/scene-bank.pack-request.json').read_text());layer=request['layers'][0]
asset_row=next(a for a in reg['assets'] if a['asset_id']==layer['glyph_asset_id']);folder=ROOT/'assets'/asset_row['root'];doc=json.loads((folder/'asset.json').read_text());cols=doc['output']['pipeline']['palettes'][0]['palette']['rgba8888'];cols=[tuple((v&0xffffffff)>>s&255 for s in (24,16,8,0)) for v in cols];lut={c:i for i,c in enumerate(cols)};files={a['index']:a['file'] for a in doc['artifacts']};cached={}
blank={'active':False,'glyph_id':0,'palette_id':0,'flip_x':False,'flip_y':False}
world_tiles+=panel+[dict(blank) for _ in range(32*8)]
for cell in layer['tiles'][strip['row']*32:(strip['row']+22)*32]:
gid=cell['glyph_id']
if gid not in cached:
im=Image.open(folder/files[gid]).convert('RGBA');cached[gid]=glyph([lut[v] for v in im.getdata()],f'world_{variant}_{gid}')
palette=8 if strip['palette']=='cave' else 2 if strip['palette']=='start' else world_palette[cell['palette_id']]
world_tiles.append({'active':cell['active'],'glyph_id':cached[gid],'palette_id':palette,'flip_x':cell['flip_x'],'flip_y':cell['flip_y']})
write_json(bank/'asset.json',{'schema_version':1,'asset_uuid':bank_uuid,'name':'NES inventory and frozen-room strips','type':'glyph_bank','preload':{'enabled':True},'output':{'format':'GLYPH/indexed_v1','codec':'NONE','metadata':{'tile_size':'8x8'},'pipeline':{'palettes':[{'index':i,'palette':{'rgba8888':[int.from_bytes(bytes(c),'big',signed=True) for c in row]}} for i,row in enumerate(palettes)]}},'artifacts':arts});write_json(bank/'studio.asset.json',{'schema_version':1,'glyph_bank_specialization':'sprites'})
scene_root='scenes/inventory';scene_id,scene_uuid=register(scene_root);folder=ROOT/'assets'/scene_root;folder.mkdir(exist_ok=True,parents=True)
write_json(folder/'asset.json',{'schema_version':1,'asset_uuid':scene_uuid,'name':'NES inventory scroll strips','type':'scene_bank','preload':{'enabled':True},'output':{'format':'SCENE/tilemap_v1','codec':'NONE','pipeline':{}}})
def layer(active,w,h,tiles):return {'active':active,'glyph_asset_id':bank_id,'tile_size':8,'parallax_factor_x':1.0,'parallax_factor_y':1.0,'width':w,'height':h,'tiles':tiles}
write_json(folder/'scene-bank.pack-request.json',{'schema_version':1,'format':'SCENE/tilemap_v1','version':1,'layers':[layer(True,32,len(world_tiles)//32,world_tiles)]+[layer(False,1,1,[blank]) for _ in range(3)]})
if json.loads(regpath.read_text())!=reg:write_json(regpath,reg)
offsets_at=P.index(bytes.fromhex('0003070a0b0c0d0e0f11121314151617'));frames_at=P.index(bytes.fromhex('20823c3470727428863c2a262422404a'));attrs_at=P.index(bytes.fromhex('ff01ff00000202000100020000020201'))
xs_at=P.index(bytes.fromhex('8098acb4c88098b0c88094a0b0c0ccb0'),5*16384,6*16384);cursor_at=P.index(bytes.fromhex('8098b0b0c88098b0c8'),xs_at,6*16384)
top=[native.get((t&1)*256+(t&254),0) for t in range(256)];bottom=[native.get((t&1)*256+(t&254)+1,0) for t in range(256)]
# Item frame offsets can address tile heap through grade/animation.
lines=['// Generated from verified native menu/item tables.', 'declare global menu_top: array<int> = ['+', '.join(map(str,top))+'];','declare global menu_bottom: array<int> = ['+', '.join(map(str,bottom))+'];']
for name,vals in [('item_offsets',P[offsets_at:offsets_at+37]),('item_frames',P[frames_at:frames_at+48]),('item_attrs',P[attrs_at:attrs_at+32]),('item_xs',P[xs_at:xs_at+16]),('cursor_xs',P[cursor_at:cursor_at+16])]:lines.append(f'declare global menu_{name}: array<int> = ['+', '.join(map(str,vals))+'];')
# Map patched transfer-buffer bytes to nametable cells, preserving overlapping halves.
cells={}
for record in records:
if record['source']=='RAM':
ev=record['events'][0]
for i in range(ev['count']):cells[record['pointer_cpu']+3+i-0x684b]=ev['address']+i
positions=sorted(set(offsets)); states=[]
for mask in range(256):
buf={o:ram[0x684b+o] for o in positions}
for i,o in enumerate(offsets):
if mask&(1<<(i//3)):buf[o]=0xf5 if buf[o] in (0xe5,0xe6) else replacements[i]
states += [native[256+buf[o]] for o in positions]
for name,vals in [('triforce_tiles',states),('triforce_x',[(cells[o]-0x2800)%32*8 for o in positions]),('triforce_y',[(cells[o]-0x2800)//32*8-240 for o in positions]),('triforce_palette',[pal((cells[o]-0x2800)%32,(cells[o]-0x2800)//32) for o in positions])]:
lines.append(f'declare global menu_{name}: array<int> = ['+', '.join(map(str,vals))+'];')
lines += ['declare struct TriforceData() {',f' fn count() -> int {{ return {len(positions)}; }}',f' fn tile(mask: int, i: int) -> int {{ return menu_triforce_tiles[(mask%256)*{len(positions)}+i] else 0; }}',' fn x(i: int) -> int { return menu_triforce_x[i] else 0; }',' fn y(i: int) -> int { return menu_triforce_y[i] else 0; }',' fn palette(i: int) -> int { return menu_triforce_palette[i] else 0; }','}']
lines+=['declare struct MenuData() {',' fn top(tile: int) -> int { return menu_top[tile] else 0; }',' fn bottom(tile: int) -> int { return menu_bottom[tile] else 0; }',' fn tile(slot: int, frame: int) -> int { let base=menu_item_offsets[slot] else 0; return menu_item_frames[base+frame] else 0; }',' fn attributes(slot: int) -> int { return menu_item_attrs[slot] else 0; }',' fn x(slot: int) -> int { return menu_item_xs[slot] else 176; }',' fn cursor_x(slot: int) -> int { return menu_cursor_xs[slot] else 128; }','}','']
(ROOT/'src/screens/inventory/data.generated.pbs').write_text('\n'.join(lines))
write_json(out/'rom-data.json',{'rom_sha256':ROM_SHA256,'common_data_prg':common,'transfer_directory_prg':directory,'transfers':records,'menu_memory_hex':memory[0x2800:0x2c00].hex(),'triforce_offsets':offsets,'triforce_empty_tiles':empty,'triforce_replacements':replacements,'glyph_native':native,'item_offsets_prg':offsets_at,'item_frames_prg':frames_at,'item_attrs_prg':attrs_at,'item_xs_prg':xs_at,'cursor_xs_prg':cursor_at,'scene_variants':scene_roots,'strip_height':416,'palettes':rows,'scope':'Overworld/cave submenu. Static transfers and item tables from local ROM. No starting inventory is granted.'})
print('Published inventory:',len(arts),'glyphs,',len(strips),'strips in scene slot 15')
if __name__=='__main__':prepare()