use crate::firmware::firmware_state::{ AppCrashesStep, FirmwareState, GameRunningStep, HubHomeStep, ShellRunningStep, }; use crate::firmware::prometeu_context::PrometeuContext; use crate::firmware::resident_game_termination; use prometeu_hal::app_mode::AppMode; use prometeu_hal::cartridge::Cartridge; use prometeu_hal::color::Color; use prometeu_hal::log::{LogLevel, LogSource}; use prometeu_hal::primitives::Rect; use prometeu_system::CrashReport; use prometeu_system::windows::WindowOwner; #[derive(Debug, Clone)] pub struct LoadCartridgeStep { pub cartridge: Cartridge, init_error: Option, awaiting_memcard: bool, preparing_memcard: bool, input_released: bool, memcard_message: String, loaded_task_id: Option, loaded_app_mode: Option, failure_recovery: LoadCartridgeFailureRecovery, } #[derive(Debug, Clone, Copy, PartialEq, Eq)] enum LoadCartridgeFailureRecovery { AppCrash, ReturnToHub, } impl LoadCartridgeStep { pub fn new(cartridge: Cartridge) -> Self { Self { cartridge, init_error: None, awaiting_memcard: false, preparing_memcard: false, input_released: false, memcard_message: String::new(), loaded_task_id: None, loaded_app_mode: None, failure_recovery: LoadCartridgeFailureRecovery::AppCrash, } } pub fn needs_memcard_choice(&self) -> bool { self.awaiting_memcard && !self.preparing_memcard } /// Typed host and UI admission share this single policy boundary. pub fn choose_memcard( &mut self, os: &mut prometeu_system::SystemOS, choice: prometeu_system::memcard::admission::Choice, created_at: u64, ) -> prometeu_system::memcard::image::Result<()> { if !self.needs_memcard_choice() { return Err(prometeu_system::memcard::image::Error::InvalidState); } os.memcard().choose_for_game( self.cartridge.app_id, self.cartridge.memcard_slots.unwrap() as usize, choice, created_at, )?; self.preparing_memcard = true; Ok(()) } pub fn new_game_switch(cartridge: Cartridge) -> Self { Self { failure_recovery: LoadCartridgeFailureRecovery::ReturnToHub, ..Self::new(cartridge) } } pub fn on_enter(&mut self, ctx: &mut PrometeuContext) { ctx.os.log( LogLevel::Info, LogSource::Pos, 0, format!("Loading cartridge: {}", self.cartridge.title), ); ctx.platform.game2d_frame_composer().unbind_scene(); if self.cartridge.app_mode == AppMode::Game && self.cartridge.memcard_slots.is_some() { self.awaiting_memcard = true; ctx.os.vm().transition_render_owner(AppMode::Shell, 0); return; } self.load(ctx); } fn load(&mut self, ctx: &mut PrometeuContext) { // Initialize Asset Manager ctx.platform.assets_mut().initialize_for_cartridge( self.cartridge.asset_table.clone(), self.cartridge.preload.clone(), self.cartridge.assets.clone(), ); match ctx.os.sessions().load_vm_cartridge(&self.cartridge) { Ok(loaded) => { self.loaded_task_id = Some(loaded.task_id); self.loaded_app_mode = Some(loaded.app_mode); } Err(report) => { self.init_error = Some(report.into_crash_report("load VM cartridge into session")); } } } pub fn on_update(&mut self, ctx: &mut PrometeuContext) -> Option { if self.awaiting_memcard { use prometeu_system::memcard::admission::{Choice, PreparationState}; if self.preparing_memcard { match ctx.os.memcard().admission.state { PreparationState::Ready => { self.awaiting_memcard = false; self.preparing_memcard = false; self.load(ctx); } PreparationState::Failed(error) => { self.memcard_message = Self::preparation_message(error); self.preparing_memcard = false; } _ => {} } } if self.awaiting_memcard { let pressed = ctx.signals.a_signal || ctx.signals.b_signal || ctx.signals.x_signal || ctx.signals.y_signal; if !pressed { self.input_released = true; } if self.input_released && pressed && !self.preparing_memcard { self.input_released = false; if ctx.signals.b_signal { return Some(FirmwareState::HubHome(HubHomeStep)); } let choice = if ctx.signals.a_signal { Choice::Persistent } else if ctx.signals.x_signal { Choice::MemoryFresh } else { Choice::MemoryExisting }; let created_at = ctx.platform.wall_clock().utc_unix_seconds(); match self.choose_memcard(ctx.os, choice, created_at) { Ok(()) => {} Err(error) => self.memcard_message = Self::preparation_message(error), } } self.draw_memcard(ctx); return None; } } if let Some(report) = self.init_error.take() { if self.failure_recovery == LoadCartridgeFailureRecovery::ReturnToHub { if self.cartridge.app_mode == AppMode::Game && let Some(task_id) = ctx.os.lifecycle().resident_game_task() { let is_partial_target = ctx .os .sessions() .vm_session_for_task(task_id) .map(|session| session.app_id == self.cartridge.app_id) .unwrap_or(false); if is_partial_target { let _ = resident_game_termination::terminate_resident_game( ctx.os, ctx.platform, false, ); } } ctx.os.log( LogLevel::Error, LogSource::Hub, 0, format!( "Failed to switch to game {} app_id {}; returning to Home: {:?}", self.cartridge.title, self.cartridge.app_id, report ), ); return Some(FirmwareState::HubHome(HubHomeStep)); } return Some(FirmwareState::AppCrashes(AppCrashesStep { report })); } match ctx.platform.assets().preloads_ready() { Ok(false) => return None, Err(error) => { return Some(FirmwareState::AppCrashes(AppCrashesStep { report: CrashReport::VmPanic { message: format!("Cartridge preload failed: {error:?}"), pc: None, }, })); } Ok(true) => {} } let Some(task_id) = self.loaded_task_id.take() else { let report = CrashReport::VmPanic { message: format!( "cartridge {} was not loaded into a VM session", self.cartridge.title ), pc: None, }; return Some(FirmwareState::AppCrashes(AppCrashesStep { report })); }; if self.loaded_app_mode == Some(AppMode::Shell) { let id = ctx.os.windows().add_window( self.cartridge.title.clone(), WindowOwner::Task(task_id), Rect { x: 40, y: 20, w: 240, h: 140 }, Color::WHITE, ); ctx.os.windows().set_focus(id); return Some(FirmwareState::ShellRunning(ShellRunningStep::new(task_id))); } Some(FirmwareState::GameRunning(GameRunningStep::new(task_id))) } fn preparation_message(error: prometeu_system::memcard::image::Error) -> String { use prometeu_system::memcard::image::Error; match error { Error::NoSpace => "This memory card has no room for this game.".into(), Error::Corrupt => "The memory card failed its integrity checks.".into(), Error::ReadOnly => "This memory card cannot accept saves.".into(), Error::OutOfMemory => "There is not enough memory to start this game.".into(), Error::Busy => "The memory card is still busy. Please wait.".into(), Error::InvalidState => "No usable memory card or existing save is available.".into(), _ => format!("Memory card unavailable: {error:?}"), } } fn draw_memcard(&self, ctx: &mut PrometeuContext) { use prometeu_hal::{FrameId, GfxUiCommand, RenderSubmission, ShellUiFramePacket}; let installed = ctx.os.memcard().card_installed(); let existing = ctx.os.memcard().card_has_game(self.cartridge.app_id); let mut lines = vec!["Save memory".to_string(), self.cartridge.title.clone()]; if let Some((recovered, degraded, blocked)) = ctx.os.memcard().installed_health() { if recovered { lines.push("Recovered an older save after an integrity failure.".into()); } if degraded { lines.push("Memory card degraded: some blocks are excluded.".into()); } if blocked { lines.push("Disk saving is unavailable on this card.".into()); } } if let prometeu_system::memcard::admission::PreparationState::Failed(error) = ctx.os.memcard().admission.state { lines.push(Self::preparation_message(error)); } if self.preparing_memcard { lines.push("Preparing save memory...".into()); } else { lines.push( if installed { "A: Use installed memory card" } else { "No memory card installed" } .into(), ); lines.push("X: Start fresh without saving to disk".into()); if existing { lines.push("Y: Load saves, then play without disk saving".into()); } lines.push("B: Return to Home".into()); } if !self.memcard_message.is_empty() { lines.push(self.memcard_message.clone()); } let mut commands = vec![GfxUiCommand::Clear { color: Color::BLACK }]; commands.extend(lines.into_iter().enumerate().map(|(i, text)| GfxUiCommand::DrawText { x: 8, y: 8 + i as i32 * 20, text, color: Color::WHITE, })); let _ = ctx.platform.render_submission_sink().submit_render_submission( RenderSubmission::shell_ui(FrameId::ZERO, ShellUiFramePacket::new(commands)), ); } pub fn on_exit(&mut self, _ctx: &mut PrometeuContext) {} }