Files
RustRaptor/data/hd/jobs/derived-10521-water-only-quiet-band-complete1-20261019/context/historical-compositor.rs
T

57 lines
12 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Focused10521 water successor: literalH5647 three unchanged authentic Original windows, new10521 only, noWorld.
use std::{collections::{BTreeMap,BTreeSet},fs,io::Write,path::Path};
use raptor_replica::{assets::{Catalog,Sprite},content::Registry,hd::{HdAssets,OriginalDetailCells,OriginalPalette},render::{Canvas,upscale},terrain_hd::{logical_sprite,selected_art,TerrainHd,Replacement,RetainedOriginalPlacement,PaletteConstraintPlacement,OverlayResult}};
use serde_json::{Value,json};
#[derive(Clone)]struct Layer{image:Sprite,retained:Option<OriginalDetailCells>,domain:Option<OriginalPalette>,record:Value}
fn read(p:&Path)->Value{serde_json::from_slice(&fs::read(p).unwrap()).unwrap()}
fn id(v:&Value)->u32{u32::from_str_radix(v.as_str().unwrap(),16).unwrap()}
fn class(v:u16)->u8{match v{0..=239=>0,240..=244=>1,245..=249=>2,_=>v as u8}}
fn gz(b:&[u8])->Vec<u8>{let mut z=flate2::write::GzEncoder::new(Vec::new(),flate2::Compression::default());z.write_all(b).unwrap();z.finish().unwrap()}
fn emit(out:&Path,name:&str,image:&Sprite,pal:&[[u8;3];256])->Value{let mut b=Vec::new();let mut c=Vec::new();let mut ppm=format!("P6\n{} {}\n255\n",image.width,image.height).into_bytes();for &v in &image.pixels{assert!(v<256);b.extend(v.to_le_bytes());c.push(class(v));ppm.extend(pal[v as usize]);}let ip=format!("{name}.indices-u16le.gz");let cp=format!("{name}.classes-u8.gz");let rp=format!("{name}.ppm.gz");fs::write(out.join(&ip),gz(&b)).unwrap();fs::write(out.join(&cp),gz(&c)).unwrap();fs::write(out.join(&rp),gz(&ppm)).unwrap();json!({"width":image.width,"height":image.height,"indexed":ip,"classes":cp,"PPM":rp})}
// Exact public frame metadata is checked before accepting trusted details/domains.
fn metadata_stage(frame:&Value,retained:&Option<OriginalDetailCells>,domain:&Option<OriginalPalette>){
let expected:Vec<[u32;2]>=frame.get("original_detail_cells").and_then(|v|v.as_array()).map(|v|v.iter().map(|p|[p[0].as_u64().unwrap()as u32,p[1].as_u64().unwrap()as u32]).collect()).unwrap_or_default();
assert_eq!(retained.as_ref().map(|d|d.cells()).unwrap_or(&[]),expected.as_slice(),"trusted details match full native frame");
let opted=frame.get("palette_constraint").is_some_and(|v|!v.is_null());
assert_eq!(domain.is_some(),opted,"foreign/native palette domain must not be discarded");
if opted{assert_eq!(frame["palette_constraint"],"original-painted-ordinary-v1");}
}
fn bank_indices(bank:&Value,asset:u32,scale:usize)->Vec<u16>{
let row=bank.as_array().unwrap().iter().find(|r|id(&r["asset"])==asset).unwrap();
let rec=row["scales"].as_array().unwrap().iter().find(|r|r["scale"].as_u64()==Some(scale as u64)).unwrap();
assert_eq!([rec["width"].as_u64().unwrap(),rec["height"].as_u64().unwrap()],[(32*scale)as u64,(32*scale)as u64]);
rec["indices"].as_array().unwrap().iter().map(|v|v.as_u64().unwrap()as u16).collect()
}
fn support(ids:&[u32],own:&BTreeSet<u32>,active:&BTreeSet<u32>,cols:usize,rows:usize)->Vec<[usize;4]>{
let at=|x:i32,y:i32|->Option<usize>{if x<0||y<0||x>=cols as i32||y>=rows as i32{None}else{Some(y as usize*cols+x as usize)}};let mut r=BTreeSet::new();
for(t,v)in ids.iter().enumerate(){if !own.contains(v){continue}let tx=(t%cols)as i32;let ty=(t/cols)as i32;r.insert([t%cols*32,t/cols*32,(t%cols+1)*32,(t/cols+1)*32]);
for(dx,dy)in[(-1,0),(1,0),(0,-1),(0,1)]{let Some(q)=at(tx+dx,ty+dy)else{continue};if !active.contains(&ids[q])||own.contains(&ids[q]){continue}let x=q%cols*32;let y=q/cols*32;r.insert(match(dx,dy){(-1,0)=>[x+30,y+2,x+32,y+30],(1,0)=>[x,y+2,x+2,y+30],(0,-1)=>[x+2,y+30,x+30,y+32],_=>[x+2,y,x+30,y+2]});}
for vy in[ty,ty+1]{for vx in[tx,tx+1]{let pos=[(vx-1,vy-1),(vx,vy-1),(vx-1,vy),(vx,vy)];let slots:Option<Vec<_>>=pos.iter().map(|&(x,y)|at(x,y)).collect();let Some(slots)=slots else{continue};if !slots.iter().all(|q|active.contains(&ids[*q])){continue}for(&q,&(px,py))in slots.iter().zip(pos.iter()){if own.contains(&ids[q]){continue}let x=q%cols*32+if px==vx{0}else{30};let y=q/cols*32+if py==vy{0}else{30};r.insert([x,y,x+2,y+2]);}}}
}r.into_iter().collect()
}
fn compose(control:&Sprite,ids:&[u32],s:usize,layers:&BTreeMap<(u32,usize),Layer>,allowed:&BTreeSet<u32>,pal:&[[u8;3];256],cols:usize)->(Sprite,Value){
let(mut parts,mut retained,mut domains,mut used)=(Vec::new(),Vec::new(),Vec::new(),Vec::new());
for(t,&asset)in ids.iter().enumerate(){if !allowed.contains(&asset){continue}let l=&layers[&(asset,s)];let n=parts.len();if let Some(d)=&l.retained{retained.push(RetainedOriginalPlacement{replacement_index:n,details:d.clone()});}if let Some(p)=&l.domain{domains.push(PaletteConstraintPlacement{replacement_index:n,palette:p.clone()});}
parts.push(Replacement{image:l.image.clone(),position:[(t%cols*32)as i32,(t/cols*32)as i32],logical_size:[32,32]});used.push(json!({"slot":t,"asset":format!("{asset:05x}"),"position":[t%cols*32,t/cols*32],"component":l.record,"retained_cells":l.retained.as_ref().map(|d|d.cells()),"palette_domain":l.domain.as_ref().map(|d|d.indices())}));}
let composed=TerrainHd::default().compose_with_palette_constraints(control,&parts,&retained,&domains,s,pal);assert!(composed.results.iter().all(|r|*r==OverlayResult::Applied),"{:?}",composed.results);let mut rc=0;let mut dc=0;
for r in &retained{let p=&parts[r.replacement_index];for &[x,y]in r.details.cells(){for dy in 0..s{for dx in 0..s{let xx=(p.position[0]as usize+x as usize)*s+dx;let yy=(p.position[1]as usize+y as usize)*s+dy;assert_eq!(composed.image.pixels[yy*control.width+xx],control.pixels[yy*control.width+xx],"retained OriginalNx after every join");rc+=1;}}}}
for d in &domains{let p=&parts[d.replacement_index];for y in 0..32*s{for x in 0..32*s{let i=(p.position[1]as usize*s+y)*control.width+p.position[0]as usize*s+x;assert!(d.palette.contains(composed.image.pixels[i]),"joined owner escaped original palette domain");dc+=1;}}}
(composed.image,json!({"pre_blit":used,"retained_OriginalNx_samples":rc,"palette_domain_samples":dc}))
}
fn main(){
let a:Vec<String>=std::env::args().collect();assert_eq!(a.len(),7,"DATA BASE OWN BANK CASES FRESH_OUT");let contract=read(Path::new(&a[5]));let rows=contract["cases"].as_array().unwrap();assert_eq!(rows.len(),3);let own=BTreeSet::from([0x10521u32]);let cat=Catalog::open(&a[1]).unwrap();let pal=cat.palette().unwrap();let reg=Registry::base(&cat).unwrap();
for(case,row)in rows.iter().enumerate(){assert_eq!(row["case_index"],case);let mission:raptor_replica::content::ContentId=row["mission"].as_str().unwrap().into();let m=&reg.missions[&mission];assert_eq!(m.columns,9);let y0=row["window_row0"].as_u64().unwrap()as usize;let x0=row["window_column0"].as_u64().unwrap()as usize;let cols=row["width_tiles"].as_u64().unwrap()as usize;let height=row["height_tiles"].as_u64().unwrap()as usize;assert_eq!(height,3);assert_eq!(cols,if case==1{5}else{3});for slot in 0..cols*height{let t=&m.tiles[m.layout[(y0+slot/cols)*9+x0+slot%cols]];let d=&row["authentic_original_definitions"][slot];assert_eq!(t.art.asset,Some(id(&row["ordered_source_ids"][slot])));assert_eq!(t.art.asset,Some(id(&d["intact"])));assert_eq!(t.health as i64,d["health"].as_i64().unwrap());assert_eq!(t.reward as u64,d["reward"].as_u64().unwrap());}assert!(row["settled_changes"].as_array().is_none_or(|v|v.is_empty()));}
let literal=read(&Path::new(&a[2]).join("hd.json"));let mut native=BTreeMap::new();for s in literal["sequences"].as_array().unwrap(){for f in s["frames"].as_array().unwrap(){native.insert(s["base_asset"].as_u64().unwrap()as u32+f["frame"].as_u64().unwrap()as u32,f.clone());}}assert_eq!(native.len(),5647);assert!(!native.contains_key(&0x10521));let source:BTreeSet<u32>=rows.iter().flat_map(|r|r["ordered_source_ids"].as_array().unwrap()).map(id).collect();assert_eq!(source.len(),11);let foreign:BTreeSet<u32>=source.iter().copied().filter(|a|native.contains_key(a)).collect();assert_eq!(foreign.len(),10);let active:BTreeSet<u32>=foreign.union(&own).copied().collect();assert_eq!(source,active);
let pm=read(&Path::new(&a[3]).join("hd.json"));assert_eq!(pm["sequences"].as_array().unwrap().len(),1);assert_eq!(pm["sequences"][0]["base_asset"],0x10521);native.insert(0x10521,pm["sequences"][0]["frames"][0].clone());let bank=read(Path::new(&a[4]));assert_eq!(bank.as_array().unwrap().len(),1);let out=Path::new(&a[6]);assert!(!out.exists());fs::create_dir(out).unwrap();fs::create_dir(out.join("components")).unwrap();fs::create_dir(out.join("planes")).unwrap();fs::write(out.join("actual-palette-rgb.bin"),pal.iter().flat_map(|p|p.iter().copied()).collect::<Vec<_>>()).unwrap();let mut base=HdAssets::load_lazy(Path::new(&a[2]),&cat,None);let mut ownhd=HdAssets::load_lazy(Path::new(&a[3]),&cat,None);assert!(base.diagnostics.is_empty()&&ownhd.diagnostics.is_empty(),"{:?} {:?}",base.diagnostics,ownhd.diagnostics);let mut layers=BTreeMap::new();let mut components=Vec::new();let mut stages=Vec::new();for &asset in &active{let src=cat.sprite(asset).unwrap();for s in 1..5{let hd=if own.contains(&asset){&mut ownhd}else{&mut base};let(image,retained,domain)=hd.terrain_sprite_with_palette(asset,s,&pal).unwrap().unwrap();metadata_stage(&native[&asset],&retained,&domain);if own.contains(&asset){let original=upscale(&src,s).unwrap();let mut restored=image.clone();if let Some(d)=&retained{for &[x,y]in d.cells(){for dy in 0..s{let i=(y as usize*s+dy)*restored.width+x as usize*s;restored.pixels[i..i+s].copy_from_slice(&original.pixels[i..i+s]);}}}assert_eq!(restored.pixels,bank_indices(&bank,asset,s));assert_eq!(src.pixels,bank[0]["source"]["indices"].as_array().unwrap().iter().map(|v|v.as_u64().unwrap()as u16).collect::<Vec<_>>());stages.push(json!({"asset":"10521","scale":s,"retained_cells":retained.as_ref().map(|d|d.cells()),"restored_standalone_equals_new_G2_bank":true}));}let mut r=emit(&out.join("components"),&format!("{asset:05x}-s{s}"),&image,&pal);r["asset"]=json!(format!("{asset:05x}"));r["scale"]=json!(s);r["native_frame"]=native[&asset].clone();components.push(r.clone());layers.insert((asset,s),Layer{image,retained,domain,record:r});}}
let mut records=Vec::new();for row in rows{let case=row["case_index"].as_u64().unwrap();let cols=row["width_tiles"].as_u64().unwrap()as usize;let height=3;let ids:Vec<u32>=row["ordered_source_ids"].as_array().unwrap().iter().map(id).collect();let regions=support(&ids,&own,&active,cols,height);let mut c=Canvas{scale:1,image:Sprite{width:32*cols,height:96,pixels:vec![0;32*cols*96]}};for(slot,&asset)in ids.iter().enumerate(){c.blit(&cat.sprite(asset).unwrap(),(slot%cols*32)as i32,(slot/cols*32)as i32);}
for s in 1..5{let original=upscale(&c.image,s).unwrap();let(b,bi)=compose(&original,&ids,s,&layers,&foreign,&pal,cols);let(p,pi)=compose(&original,&ids,s,&layers,&active,&pal,cols);let(mut delta,mut outside,mut interior)=(0usize,0usize,0usize);for i in 0..original.pixels.len(){assert_eq!(class(original.pixels[i]),class(b.pixels[i]));assert_eq!(class(original.pixels[i]),class(p.pixels[i]));if original.pixels[i]>=250{assert_eq!(b.pixels[i],original.pixels[i]);assert_eq!(p.pixels[i],original.pixels[i]);}let x=i%original.width;let y=i/original.width;let asset=ids[y/(32*s)*cols+x/(32*s)];if own.contains(&asset){assert_eq!(b.pixels[i],original.pixels[i]);}let allowed=regions.iter().any(|r|x>=r[0]*s&&x<r[2]*s&&y>=r[1]*s&&y<r[3]*s);if !allowed{assert_eq!(b.pixels[i],p.pixels[i]);outside+=1;}if foreign.contains(&asset)&&x%(32*s)>=2*s&&x%(32*s)<30*s&&y%(32*s)>=2*s&&y%(32*s)<30*s{assert_eq!(b.pixels[i],p.pixels[i]);interior+=1;}if b.pixels[i]!=p.pixels[i]{assert!(allowed);delta+=1;}}
let mut planes=serde_json::Map::new();for(role,img)in[("Original_joined_SourceNx",&original),("immutable_H5647_baseline",&b),("10521_water_only_successor",&p)]{planes.insert(role.into(),emit(&out.join("planes"),&format!("case{case:02}-s{s}-{role}"),img,&pal));}records.push(json!({"case_index":case,"scale":s,"endpoint":row,"planes":planes,"baseline_inputs":bi,"proposal_inputs":pi,"support_rectangles":regions,"changed_samples":delta,"outside_support_samples_exact":outside,"foreign_interior_samples_exact":interior}));}}
assert!(base.diagnostics.is_empty()&&ownhd.diagnostics.is_empty());let r=json!({"status":"ACTUAL_FOCUSED10521_WATER_SUCCESSOR_THREE_OLD_AFFECTED_GENUINE_CASES_G2_H5647_ALL4","records":records,"components":components,"own_stage_checks":stages,"other6_unchanged_not_reprocessed":true,"World_calls":0,"diagnostics":[]});fs::write(out.join("ACTUAL-10521-FOCUSED-WATER-SUCCESSOR-THREE-CONTEXTS.json"),serde_json::to_vec_pretty(&r).unwrap()).unwrap();println!("Focused10521:3unchanged genuine cases×all4×3roles,4ownstagechecks,other6notreprocessed;World0");
}