Simply Patrick Hopes can always go up, tears can only come down.

const NTSC_FRAME_SECS: f64 = 1.0 / 60.0988;

pub fn run_emulation_frame(
    mut nes: NonSendMut<NesSystem>,
    time: Res<Time>,
    audio_buf: Res<AudioBuffer>,
    // ...
) {
    if nes.paused {
        nes.accumulator = 0.0;
        return;
    }

    nes.accumulator += time.delta_secs_f64();
    // 防止 spiral of death：最多追趕 4 幀
    nes.accumulator = nes.accumulator.min(NTSC_FRAME_SECS * 4.0);

    let mut frames_run = 0;
    while nes.accumulator >= NTSC_FRAME_SECS {
        nes.sys.joypad1.borrow_mut().set_buttons(nes_input.0);
        nes.sys.run_until_frame();

        // 把 APU 產生的 sample 送到音訊 ring buffer
        let samples = nes.sys.apu.borrow_mut().drain_samples();
        if let Ok(mut buf) = audio_buf.buffer.lock() {
            if buf.len() < 8192 {
                buf.extend(samples.iter());
            }
        }

        nes.accumulator -= NTSC_FRAME_SECS;
        frames_run += 1;
    }

    if frames_run > 0 {
        // 把 PPU framebuffer 複製到 GPU 材質
        copy_framebuffer_to_texture(&nes, &mut images, &fb_handle);
    }
}

pub fn setup_emulation(world: &mut World) {
    // exclusive world access，只在初始化時呼叫一次
    let sys = System::new(rom, sample_rate);
    world.insert_non_send_resource(NesSystem {
        sys,
        paused: false,
        accumulator: 0.0,
    });
}

fn copy_framebuffer_to_texture(nes: &NesSystem, images: &mut Assets<Image>, handle: &FramebufferHandle) {
    let ppu = nes.sys.ppu.borrow();
    let fb = ppu.framebuffer();
    if let Some(image) = images.get_mut(&handle.0) {
        for (i, &color) in fb.iter().enumerate() {
            let (r, g, b) = PALETTE[color as usize];
            image.data[i * 4]     = r;
            image.data[i * 4 + 1] = g;
            image.data[i * 4 + 2] = b;
            image.data[i * 4 + 3] = 255;
        }
    }
}

fn barrel_distort(uv: vec2<f32>, curvature: f32) -> vec2<f32> {
    let centered = uv - 0.5;
    let dist = dot(centered, centered);
    let distorted = centered * (1.0 + dist * curvature);
    return distorted + 0.5;
}

let scanline = 1.0 - scanline_intensity * 0.5 * (1.0 - cos(uv.y * 240.0 * 3.14159));

let mask_pos = i32(uv.x * 768.0) % 3;
var mask = vec3<f32>(0.8, 0.8, 0.8);
if mask_pos == 0 { mask.r = 1.0; }
else if mask_pos == 1 { mask.g = 1.0; }
else { mask.b = 1.0; }

let vignette = 1.0 - vignette_intensity * dot(centered, centered) * 2.0;

pub fn setup_audio(mut commands: Commands) {
    let buffer = Arc::new(Mutex::new(VecDeque::with_capacity(4096)));
    let buf_clone = buffer.clone();

    let stream = device.build_output_stream(
        &config,
        move |data: &mut [f32], _| {
            let mut buf = buf_clone.lock().unwrap();
            for frame in data.chunks_mut(channels) {
                let sample = buf.pop_front().unwrap_or(0.0);
                for ch in frame.iter_mut() {
                    *ch = sample;
                }
            }
        },
        |err| eprintln!("Audio error: {err}"),
        None,
    ).unwrap();
    // ...
}

pub fn read_input(
    keyboard: Res<ButtonInput<KeyCode>>,
    gamepads: Query<&Gamepad>,
    mut nes_input: ResMut<NesInput>,
) {
    let mut state = 0u8;

    // 鍵盤
    if keyboard.pressed(KeyCode::ArrowUp)   { state |= 1 << 4; }
    if keyboard.pressed(KeyCode::ArrowDown) { state |= 1 << 5; }
    if keyboard.pressed(KeyCode::KeyZ)      { state |= 1 << 0; } // A
    if keyboard.pressed(KeyCode::KeyX)      { state |= 1 << 1; } // B

    // 手把（第一支）
    if let Some(gamepad) = gamepads.iter().next() {
        if gamepad.pressed(GamepadButton::DPadUp) { state |= 1 << 4; }
        // 類比搖桿 → 方向鍵（deadzone 0.5）
        if let Some(axis) = gamepad.get(GamepadAxis::LeftStickY) {
            if axis > 0.5 { state |= 1 << 4; }  // up
            if axis < -0.5 { state |= 1 << 5; }  // down
        }
        // ...
    }

    nes_input.0 = state;
}

pub fn save(nes: &NesSystem, path: &Path) -> Result<Vec<u8>> {
    let mut cpu_state = Vec::new();
    nes.sys.cpu.save_state(&mut cpu_state);

    let mut ppu_state = Vec::new();
    nes.sys.ppu.borrow().save_state(&mut ppu_state);

    let mut apu_state = Vec::new();
    nes.sys.apu.borrow().save_state(&mut apu_state);

    // ... mapper, joypad ...

    let state = NesState {
        version: 2,
        cpu: &cpu_state,
        ram: &ram_data,
        mapper: &mapper_state,
        ppu: &ppu_state,
        apu: &apu_state,
        // ...
    };

    let mut builder = planus::Builder::new();
    let offset = state.prepare(&mut builder);
    builder.finish(offset, None);
    Ok(builder.as_slice().to_vec())
}