Method execute_batch

ui/src/emu_thread.rs:530–634

Execute a batch of CPU cycles. Runs up to `CYCLES_PER_BATCH` cycles, then returns to check for commands. Frames and state are sent automatically when `VBlank` starts (natural frame boundary).

(&mut self)

                    let species_bytes = species.to_le_bytes();
                    let mut maps_patched = 0u32;
                    let mut i = 0;

                    loop {
                        let pos = table_offset as usize + i * 20;
                        if pos + 20 > rom.len() {
                            break;
                        }
                        let map_group = rom[pos];
                        let map_num = rom[pos + 1];
                        // Terminator
                        if map_group == 0xFF && map_num == 0xFF {
                            break;
                        }
                        // Grass pointer (little-endian u32 at offset +4)
                        let grass_ptr = u32::from_le_bytes([
                            rom[pos + 4],
                            rom[pos + 5],
                            rom[pos + 6],
                            rom[pos + 7],
                        ]);
                        // Valid ROM pointer
                        if (0x0800_0000..0x0A00_0000).contains(&grass_ptr) {
                            let info_offset = (grass_ptr - 0x0800_0000) as usize;
                            // WildPokemonInfo: { rate: u32, pokemon_ptr: u32 }
                            if info_offset + 8 <= rom.len() {
                                let pokemon_ptr = u32::from_le_bytes([
                                    rom[info_offset + 4],
                                    rom[info_offset + 5],
                                    rom[info_offset + 6],
                                    rom[info_offset + 7],
                                ]);
                                if (0x0800_0000..0x0A00_0000).contains(&pokemon_ptr) {
                                    let arr_offset = (pokemon_ptr - 0x0800_0000) as usize;
                                    // Patch 12 entries: {min_level: u8, max_level: u8, species: u16}
                                    for entry in 0..12usize {
                                        let e = arr_offset + entry * 4;
                                        if e + 4 <= rom.len() {
                                            rom[e] = level; // min_level
                                            rom[e + 1] = level; // max_level
                                            rom[e + 2] = species_bytes[0];
                                            rom[e + 3] = species_bytes[1];
                                        }
                                    }
                                    maps_patched += 1;
                                }
                            }
                        }
                        i += 1;
                    }

                    tracing::info!("Patched {maps_patched} maps: species={species}, level={level}");
                    self.send_event(EmuEvent::WildEncounterPatched {
                        maps_patched,
                        message: format!("Patched {maps_patched} maps: Lv.{level}"),
                    });
                }
                EmuCommand::SetDisasmEnabled(enabled) => {
                    // Gate the per-instruction push without tearing down the