feat(runtime): implement shared transactional memcard with async saves
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
This commit is contained in:
@@ -61,6 +61,32 @@ impl Firmware {
|
||||
/// This method is called exactly once per Host frame (60Hz).
|
||||
/// It updates peripheral signals and delegates the logic to the current state.
|
||||
pub fn tick(&mut self, signals: &InputSignals, platform: &mut dyn RuntimePlatform) {
|
||||
self.os.poll_background_io(platform);
|
||||
if self.os.memcard().host_faulted() {
|
||||
// Keep the resident VM, snapshots, and worker-owned buffers alive. A
|
||||
// stuck host operation cannot be repaired by launching another worker.
|
||||
self.state = FirmwareState::MemoryIoFault;
|
||||
self.state_initialized = true;
|
||||
self.on_update(signals, platform);
|
||||
return;
|
||||
}
|
||||
if self.os.memcard().session.removal_pending()
|
||||
&& let Some(task) = self.os.lifecycle().resident_game_task()
|
||||
{
|
||||
if self.os.lifecycle().task_state(task)
|
||||
== Some(prometeu_system::task::TaskState::Suspended)
|
||||
{
|
||||
if !matches!(
|
||||
self.state,
|
||||
FirmwareState::MemoryCardRemoved(_) | FirmwareState::ConfirmDiscard(_)
|
||||
) {
|
||||
self.state = FirmwareState::MemoryCardRemoved(Default::default());
|
||||
self.state_initialized = true;
|
||||
}
|
||||
} else {
|
||||
self.request_home_from_host();
|
||||
}
|
||||
}
|
||||
let barriered_signals = InputSignals::default();
|
||||
let effective_signals = if self.game_input_barrier_frames > 0 {
|
||||
self.game_input_barrier_frames -= 1;
|
||||
@@ -167,8 +193,10 @@ impl Firmware {
|
||||
FirmwareState::SplashScreen(s) => s.on_enter(&mut req),
|
||||
FirmwareState::LaunchHub(s) => s.on_enter(&mut req),
|
||||
FirmwareState::HubHome(s) => s.on_enter(&mut req),
|
||||
FirmwareState::ConfirmDiscard(s) => s.on_enter(&mut req),
|
||||
FirmwareState::MemoryCardRemoved(s) => s.on_enter(&mut req),
|
||||
FirmwareState::LoadCartridge(s) => s.on_enter(&mut req),
|
||||
FirmwareState::ResumeResidentGame => {}
|
||||
FirmwareState::ResumeResidentGame | FirmwareState::MemoryIoFault => {}
|
||||
FirmwareState::GameRunning(s) => s.on_enter(&mut req),
|
||||
FirmwareState::ShellRunning(s) => s.on_enter(&mut req),
|
||||
FirmwareState::AppCrashes(s) => s.on_enter(&mut req),
|
||||
@@ -194,8 +222,32 @@ impl Firmware {
|
||||
FirmwareState::SplashScreen(s) => s.on_update(&mut req),
|
||||
FirmwareState::LaunchHub(s) => s.on_update(&mut req),
|
||||
FirmwareState::HubHome(s) => s.on_update(&mut req),
|
||||
FirmwareState::ConfirmDiscard(s) => s.on_update(&mut req),
|
||||
FirmwareState::MemoryCardRemoved(s) => s.on_update(&mut req),
|
||||
FirmwareState::LoadCartridge(s) => s.on_update(&mut req),
|
||||
FirmwareState::ResumeResidentGame => None,
|
||||
FirmwareState::MemoryIoFault => {
|
||||
use prometeu_hal::color::Color;
|
||||
use prometeu_hal::{FrameId, GfxUiCommand, RenderSubmission, ShellUiFramePacket};
|
||||
let lines = [
|
||||
"Memory-card IO did not stop in time.",
|
||||
"Save outcome may be unknown.",
|
||||
"Restart the host before using storage again.",
|
||||
];
|
||||
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: text.into(),
|
||||
color: Color::WHITE,
|
||||
}
|
||||
}));
|
||||
let _ = req.platform.render_submission_sink().submit_render_submission(
|
||||
RenderSubmission::shell_ui(FrameId::ZERO, ShellUiFramePacket::new(commands)),
|
||||
);
|
||||
None
|
||||
}
|
||||
FirmwareState::GameRunning(s) => s.on_update(&mut req),
|
||||
FirmwareState::ShellRunning(s) => s.on_update(&mut req),
|
||||
FirmwareState::AppCrashes(s) => s.on_update(&mut req),
|
||||
@@ -216,8 +268,10 @@ impl Firmware {
|
||||
FirmwareState::SplashScreen(s) => s.on_exit(&mut req),
|
||||
FirmwareState::LaunchHub(s) => s.on_exit(&mut req),
|
||||
FirmwareState::HubHome(s) => s.on_exit(&mut req),
|
||||
FirmwareState::ConfirmDiscard(s) => s.on_exit(&mut req),
|
||||
FirmwareState::MemoryCardRemoved(s) => s.on_exit(&mut req),
|
||||
FirmwareState::LoadCartridge(s) => s.on_exit(&mut req),
|
||||
FirmwareState::ResumeResidentGame => {}
|
||||
FirmwareState::ResumeResidentGame | FirmwareState::MemoryIoFault => {}
|
||||
FirmwareState::GameRunning(s) => s.on_exit(&mut req),
|
||||
FirmwareState::ShellRunning(s) => s.on_exit(&mut req),
|
||||
FirmwareState::AppCrashes(s) => s.on_exit(&mut req),
|
||||
@@ -410,6 +464,7 @@ mod tests {
|
||||
|
||||
fn invalid_game_cartridge() -> Cartridge {
|
||||
Cartridge {
|
||||
memcard_slots: None,
|
||||
app_id: 7,
|
||||
title: "Broken Cart".into(),
|
||||
app_version: "1.0.0".into(),
|
||||
@@ -451,6 +506,7 @@ mod tests {
|
||||
.serialize();
|
||||
|
||||
Cartridge {
|
||||
memcard_slots: None,
|
||||
app_id: 8,
|
||||
title: "Trap Cart".into(),
|
||||
app_version: "1.0.0".into(),
|
||||
@@ -469,6 +525,7 @@ mod tests {
|
||||
|
||||
fn valid_cartridge_with(app_mode: AppMode, app_id: u32, title: &str) -> Cartridge {
|
||||
Cartridge {
|
||||
memcard_slots: None,
|
||||
app_id,
|
||||
title: title.into(),
|
||||
app_version: "1.0.0".into(),
|
||||
@@ -533,6 +590,15 @@ mod tests {
|
||||
platform.local_hardware().gfx.front_buffer()[index]
|
||||
}
|
||||
|
||||
fn wait_for_cartridge_preload(firmware: &mut Firmware, platform: &mut TestPlatform) {
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(2);
|
||||
while matches!(firmware.state, FirmwareState::LoadCartridge(_)) {
|
||||
assert!(std::time::Instant::now() < deadline, "cartridge admission did not complete");
|
||||
firmware.tick(&InputSignals::default(), platform);
|
||||
std::thread::yield_now();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn load_cartridge_transitions_to_app_crashes_when_vm_init_fails() {
|
||||
let mut firmware = Firmware::new(None);
|
||||
@@ -919,6 +985,7 @@ mod tests {
|
||||
firmware.tick(&stress_click, &mut platform);
|
||||
firmware.tick(&InputSignals::default(), &mut platform);
|
||||
|
||||
wait_for_cartridge_preload(&mut firmware, &mut platform);
|
||||
let stress_task = match &firmware.state {
|
||||
FirmwareState::GameRunning(step) => step.task_id,
|
||||
other => panic!("expected Stress GameRunning state, got {:?}", other),
|
||||
@@ -1017,6 +1084,7 @@ mod tests {
|
||||
InputSignals { f_signal: true, x_pos: 72, y_pos: 118, ..Default::default() };
|
||||
firmware.tick(&stress_click, &mut platform);
|
||||
|
||||
wait_for_cartridge_preload(&mut firmware, &mut platform);
|
||||
assert_eq!(firmware.os.lifecycle().task_state(dummy_task), Some(TaskState::Closed));
|
||||
assert_eq!(
|
||||
firmware.os.lifecycle().process_state_for_task(dummy_task),
|
||||
@@ -1100,6 +1168,7 @@ mod tests {
|
||||
firmware.tick(&stress_click, &mut platform);
|
||||
firmware.tick(&InputSignals::default(), &mut platform);
|
||||
|
||||
wait_for_cartridge_preload(&mut firmware, &mut platform);
|
||||
let stress_task = match &firmware.state {
|
||||
FirmwareState::GameRunning(step) => step.task_id,
|
||||
other => panic!("expected Stress GameRunning state, got {:?}", other),
|
||||
@@ -1188,6 +1257,7 @@ mod tests {
|
||||
firmware.tick(&stress_click, &mut platform);
|
||||
firmware.tick(&InputSignals::default(), &mut platform);
|
||||
|
||||
wait_for_cartridge_preload(&mut firmware, &mut platform);
|
||||
let stress_task = match &firmware.state {
|
||||
FirmwareState::GameRunning(step) => step.task_id,
|
||||
other => panic!("expected Stress GameRunning state, got {:?}", other),
|
||||
@@ -1972,4 +2042,129 @@ mod tests {
|
||||
);
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn memory_only_admission_runs_typed_guest_boot_and_warns_before_discard() {
|
||||
for debug in [false, true] {
|
||||
use prometeu_bytecode::{
|
||||
load_limits::LoadBudget,
|
||||
model::{ConstantPoolEntry, SyscallDecl},
|
||||
registry::{
|
||||
LifecycleRole, NamedType, Registry, RegistryDeclarations, Signature, TypeDecl,
|
||||
TypeId, TypeKind,
|
||||
},
|
||||
registry_codec::PbxModule,
|
||||
};
|
||||
let boot = assemble("HOSTCALL 0\nPOP_N 1\nFRAME_SYNC\nJMP 12").unwrap();
|
||||
let hook=assemble("PUSH_I64 560\nARRAY_NEW 9\nSET_GLOBAL 0\nGET_LOCAL 0\nPUSH_CONST 0\nPUSH_I32 1\nPUSH_I32 1\nPUSH_I32 1\nGET_GLOBAL 0\nPUSH_I32 0\nPUSH_I32 560\nHOSTCALL 1\nPOP_N 1\nGET_LOCAL 0\nPUSH_I32 0\nPUSH_I32 0\nGET_GLOBAL 0\nPUSH_I32 0\nPUSH_I32 560\nHOSTCALL 2\nPOP_N 2\nGET_LOCAL 0\nPUSH_I32 0\nHOSTCALL 3\nPOP_N 2\nPUSH_I32 0\nRET").unwrap();
|
||||
let mut code = boot.clone();
|
||||
code.extend(&hook);
|
||||
let mut types = prometeu_test_support::program::scalar_catalog();
|
||||
types.push(TypeDecl { name: None, kind: TypeKind::Array(TypeId(1)) });
|
||||
let registry = Registry::resolve(
|
||||
RegistryDeclarations {
|
||||
types,
|
||||
functions: vec![
|
||||
FunctionDecl {
|
||||
code_len: boot.len() as u32,
|
||||
max_stack_slots: 16,
|
||||
..Default::default()
|
||||
},
|
||||
FunctionDecl {
|
||||
lifecycle_role: LifecycleRole::MemcardBoot,
|
||||
code_offset: boot.len() as u32,
|
||||
code_len: hook.len() as u32,
|
||||
max_stack_slots: 16,
|
||||
signature: Signature {
|
||||
parameters: vec![NamedType { type_id: TypeId(0), name: None }],
|
||||
results: vec![TypeId(1)],
|
||||
},
|
||||
..Default::default()
|
||||
},
|
||||
],
|
||||
implementations: vec![],
|
||||
},
|
||||
code.len(),
|
||||
&mut LoadBudget::new(Default::default()),
|
||||
)
|
||||
.unwrap();
|
||||
let syscalls = [
|
||||
("bootstrap", 0, 1),
|
||||
("presentation", 8, 1),
|
||||
("slot_write", 6, 2),
|
||||
("slot_commit", 2, 2),
|
||||
]
|
||||
.map(|(name, arg_slots, ret_slots)| SyscallDecl {
|
||||
module: "mem".into(),
|
||||
name: name.into(),
|
||||
version: 1,
|
||||
arg_slots,
|
||||
ret_slots,
|
||||
});
|
||||
let constants = [ConstantPoolEntry::String("Guest save".into())];
|
||||
let program = PbxModule {
|
||||
registry: ®istry,
|
||||
code: &code,
|
||||
constants: &constants,
|
||||
debug: None,
|
||||
exports: &[],
|
||||
syscalls: &syscalls,
|
||||
}
|
||||
.serialize(&mut LoadBudget::new(Default::default()))
|
||||
.unwrap();
|
||||
let mut cartridge = valid_cartridge(AppMode::Game);
|
||||
cartridge.program = program;
|
||||
cartridge.memcard_slots = Some(1);
|
||||
cartridge.capabilities = prometeu_hal::syscalls::caps::MEMCARD;
|
||||
let mut firmware = Firmware::new(None);
|
||||
let mut platform = TestPlatform::new();
|
||||
firmware.load_cartridge(cartridge);
|
||||
firmware.tick(&InputSignals::default(), &mut platform);
|
||||
assert!(matches!(firmware.state, FirmwareState::LoadCartridge(_)));
|
||||
firmware.tick(&InputSignals { x_signal: true, ..Default::default() }, &mut platform);
|
||||
wait_for_cartridge_preload(&mut firmware, &mut platform);
|
||||
if debug {
|
||||
firmware.os.vm().set_paused(true);
|
||||
for _ in 0..80 {
|
||||
assert!(firmware.os.vm().debug_step_active_session(&mut platform).is_none());
|
||||
if !firmware.os.memcard().session.is_boot_active() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert!(!firmware.os.memcard().session.is_boot_active());
|
||||
firmware.os.vm().set_paused(false);
|
||||
}
|
||||
for _ in 0..4 {
|
||||
firmware.tick(&InputSignals::default(), &mut platform);
|
||||
}
|
||||
assert!(matches!(firmware.state, FirmwareState::GameRunning(_)));
|
||||
let session = &mut firmware.os.memcard().session;
|
||||
let context = session.context();
|
||||
assert_eq!(session.mode(), Some(prometeu_system::memcard::session::Mode::MemoryOnly));
|
||||
assert_eq!(session.presentation(context).unwrap().unwrap().title, "Guest save");
|
||||
assert_eq!(session.descriptor(context, 0).unwrap().1, 560);
|
||||
assert!(session.unsaved());
|
||||
firmware.request_home_from_host();
|
||||
firmware.tick(&InputSignals::default(), &mut platform);
|
||||
firmware.change_state(
|
||||
FirmwareState::ConfirmDiscard(
|
||||
super::super::firmware_state::ConfirmDiscardStep::new(None),
|
||||
),
|
||||
&InputSignals::default(),
|
||||
&mut platform,
|
||||
);
|
||||
firmware.tick(&InputSignals::default(), &mut platform);
|
||||
firmware.tick(&InputSignals { b_signal: true, ..Default::default() }, &mut platform);
|
||||
assert!(firmware.os.memcard().session.unsaved());
|
||||
firmware.change_state(
|
||||
FirmwareState::ConfirmDiscard(
|
||||
super::super::firmware_state::ConfirmDiscardStep::new(None),
|
||||
),
|
||||
&InputSignals::default(),
|
||||
&mut platform,
|
||||
);
|
||||
firmware.tick(&InputSignals::default(), &mut platform);
|
||||
firmware.tick(&InputSignals { a_signal: true, ..Default::default() }, &mut platform);
|
||||
assert_eq!(firmware.os.memcard().session.mode(), None);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
pub use crate::firmware::firmware_step_confirm_discard::ConfirmDiscardStep;
|
||||
pub use crate::firmware::firmware_step_crash_screen::AppCrashesStep;
|
||||
pub use crate::firmware::firmware_step_game_running::GameRunningStep;
|
||||
pub use crate::firmware::firmware_step_hub_home::HubHomeStep;
|
||||
@@ -13,8 +14,11 @@ pub enum FirmwareState {
|
||||
SplashScreen(SplashScreenStep),
|
||||
LaunchHub(LaunchHubStep),
|
||||
HubHome(HubHomeStep),
|
||||
ConfirmDiscard(ConfirmDiscardStep),
|
||||
LoadCartridge(LoadCartridgeStep),
|
||||
ResumeResidentGame,
|
||||
MemoryIoFault,
|
||||
MemoryCardRemoved(super::firmware_step_confirm_discard::MemoryCardRemovedStep),
|
||||
GameRunning(GameRunningStep),
|
||||
ShellRunning(ShellRunningStep),
|
||||
AppCrashes(AppCrashesStep),
|
||||
|
||||
@@ -0,0 +1,101 @@
|
||||
use super::{
|
||||
firmware_state::{FirmwareState, HubHomeStep, LoadCartridgeStep},
|
||||
prometeu_context::PrometeuContext,
|
||||
resident_game_termination,
|
||||
};
|
||||
use prometeu_hal::{
|
||||
FrameId, GfxUiCommand, RenderSubmission, ShellUiFramePacket, cartridge::Cartridge, color::Color,
|
||||
};
|
||||
|
||||
/// Player-owned exit decision. It never starts a save implicitly.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct ConfirmDiscardStep {
|
||||
next: Option<Cartridge>,
|
||||
released: bool,
|
||||
}
|
||||
impl ConfirmDiscardStep {
|
||||
pub fn new(next: Option<Cartridge>) -> Self {
|
||||
Self { next, released: false }
|
||||
}
|
||||
pub fn on_enter(&mut self, _ctx: &mut PrometeuContext) {}
|
||||
pub fn on_exit(&mut self, _ctx: &mut PrometeuContext) {}
|
||||
pub fn on_update(&mut self, ctx: &mut PrometeuContext) -> Option<FirmwareState> {
|
||||
let lines = [
|
||||
"Unsaved progress",
|
||||
"Leaving this game will discard RAM saves.",
|
||||
"A: Discard and leave",
|
||||
"B: Return to Home without leaving the game",
|
||||
];
|
||||
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: text.into(),
|
||||
color: Color::WHITE,
|
||||
}));
|
||||
let _ = ctx.platform.render_submission_sink().submit_render_submission(
|
||||
RenderSubmission::shell_ui(FrameId::ZERO, ShellUiFramePacket::new(commands)),
|
||||
);
|
||||
if !ctx.signals.a_signal && !ctx.signals.b_signal {
|
||||
self.released = true;
|
||||
}
|
||||
if self.released && ctx.signals.b_signal {
|
||||
return Some(FirmwareState::HubHome(HubHomeStep));
|
||||
}
|
||||
if self.released && ctx.signals.a_signal {
|
||||
if resident_game_termination::terminate_resident_game(ctx.os, ctx.platform, true)
|
||||
.is_err()
|
||||
{
|
||||
return None;
|
||||
}
|
||||
return Some(match self.next.take() {
|
||||
Some(card) => {
|
||||
FirmwareState::LoadCartridge(LoadCartridgeStep::new_game_switch(card))
|
||||
}
|
||||
None => FirmwareState::HubHome(HubHomeStep),
|
||||
});
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Default)]
|
||||
pub struct MemoryCardRemovedStep {
|
||||
released: bool,
|
||||
}
|
||||
impl MemoryCardRemovedStep {
|
||||
pub fn on_enter(&mut self, _ctx: &mut PrometeuContext) {}
|
||||
pub fn on_exit(&mut self, _ctx: &mut PrometeuContext) {}
|
||||
pub fn on_update(&mut self, ctx: &mut PrometeuContext) -> Option<FirmwareState> {
|
||||
if !ctx.os.memcard().session.removal_pending() {
|
||||
return Some(FirmwareState::HubHome(HubHomeStep));
|
||||
}
|
||||
let lines = [
|
||||
"Memory card is unavailable.",
|
||||
"Progress remains in memory.",
|
||||
"Reinsert a card through the host, or choose:",
|
||||
"A: Continue without saving to disk",
|
||||
"B: Leave the game",
|
||||
];
|
||||
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: text.into(),
|
||||
color: Color::WHITE,
|
||||
}));
|
||||
let _ = ctx.platform.render_submission_sink().submit_render_submission(
|
||||
RenderSubmission::shell_ui(FrameId::ZERO, ShellUiFramePacket::new(commands)),
|
||||
);
|
||||
if !ctx.signals.a_signal && !ctx.signals.b_signal {
|
||||
self.released = true;
|
||||
}
|
||||
if self.released && ctx.signals.a_signal && ctx.os.detach_memcard().is_ok() {
|
||||
return Some(FirmwareState::ResumeResidentGame);
|
||||
}
|
||||
if self.released && ctx.signals.b_signal {
|
||||
return Some(FirmwareState::ConfirmDiscard(ConfirmDiscardStep::new(None)));
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
@@ -23,7 +23,21 @@ impl AppCrashesStep {
|
||||
// Update peripherals for input on the crash screen
|
||||
ctx.platform.input_mut().pad_mut().begin_frame(ctx.signals);
|
||||
|
||||
let packet = ShellUiFramePacket::new(vec![GfxUiCommand::Clear { color: Color::RED }]);
|
||||
let mut commands = vec![GfxUiCommand::Clear { color: Color::RED }];
|
||||
if let CrashReport::VmPanic { message, .. } = &self.report
|
||||
&& message.starts_with("Memcard")
|
||||
{
|
||||
let text: Vec<char> = message.chars().take(240).collect();
|
||||
commands.extend(text.chunks(48).enumerate().map(|(line, chars)| {
|
||||
GfxUiCommand::DrawText {
|
||||
x: 8,
|
||||
y: 8 + line as i32 * 20,
|
||||
text: chars.iter().collect(),
|
||||
color: Color::WHITE,
|
||||
}
|
||||
}));
|
||||
}
|
||||
let packet = ShellUiFramePacket::new(commands);
|
||||
ctx.platform
|
||||
.render_submission_sink()
|
||||
.submit_render_submission(RenderSubmission::shell_ui(FrameId::ZERO, packet))
|
||||
|
||||
@@ -56,6 +56,16 @@ impl HubHomeStep {
|
||||
Some(SystemProfileAction::LaunchGame { target }) => {
|
||||
match CartridgeLoader::load(&target.path) {
|
||||
Ok(cartridge) => {
|
||||
if ctx.os.lifecycle().resident_game_task().is_none()
|
||||
&& ctx.os.memcard().session.mode().is_some()
|
||||
{
|
||||
if ctx.os.memcard().session.unsaved() {
|
||||
return Some(FirmwareState::ConfirmDiscard(
|
||||
super::firmware_state::ConfirmDiscardStep::new(Some(cartridge)),
|
||||
));
|
||||
}
|
||||
ctx.os.memcard().session.end_session();
|
||||
}
|
||||
if cartridge.app_mode == AppMode::Game
|
||||
&& let Some(resident_task_id) = ctx.os.lifecycle().resident_game_task()
|
||||
{
|
||||
@@ -70,6 +80,11 @@ impl HubHomeStep {
|
||||
return Some(FirmwareState::ResumeResidentGame);
|
||||
}
|
||||
|
||||
if ctx.os.memcard().session.unsaved() {
|
||||
return Some(FirmwareState::ConfirmDiscard(
|
||||
super::firmware_state::ConfirmDiscardStep::new(Some(cartridge)),
|
||||
));
|
||||
}
|
||||
if let Err(error) = resident_game_termination::terminate_resident_game(
|
||||
ctx.os,
|
||||
ctx.platform,
|
||||
@@ -107,6 +122,12 @@ impl HubHomeStep {
|
||||
}
|
||||
}
|
||||
Some(SystemProfileAction::KillResidentGame) => {
|
||||
if ctx.os.memcard().session.unsaved() {
|
||||
return Some(FirmwareState::ConfirmDiscard(
|
||||
super::firmware_state::ConfirmDiscardStep::new(None),
|
||||
));
|
||||
}
|
||||
|
||||
if let Err(error) =
|
||||
resident_game_termination::terminate_resident_game(ctx.os, ctx.platform, true)
|
||||
{
|
||||
|
||||
@@ -15,6 +15,10 @@ use prometeu_system::windows::WindowOwner;
|
||||
pub struct LoadCartridgeStep {
|
||||
pub cartridge: Cartridge,
|
||||
init_error: Option<CrashReport>,
|
||||
awaiting_memcard: bool,
|
||||
preparing_memcard: bool,
|
||||
input_released: bool,
|
||||
memcard_message: String,
|
||||
loaded_task_id: Option<prometeu_system::task::TaskId>,
|
||||
loaded_app_mode: Option<AppMode>,
|
||||
failure_recovery: LoadCartridgeFailureRecovery,
|
||||
@@ -31,12 +35,20 @@ impl LoadCartridgeStep {
|
||||
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
|
||||
}
|
||||
|
||||
pub fn new_game_switch(cartridge: Cartridge) -> Self {
|
||||
Self { failure_recovery: LoadCartridgeFailureRecovery::ReturnToHub, ..Self::new(cartridge) }
|
||||
}
|
||||
@@ -51,6 +63,15 @@ impl LoadCartridgeStep {
|
||||
|
||||
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(),
|
||||
@@ -70,6 +91,58 @@ impl LoadCartridgeStep {
|
||||
}
|
||||
|
||||
pub fn on_update(&mut self, ctx: &mut PrometeuContext) -> Option<FirmwareState> {
|
||||
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 ctx.os.memcard().choose_for_game(
|
||||
self.cartridge.app_id,
|
||||
self.cartridge.memcard_slots.unwrap() as usize,
|
||||
choice,
|
||||
created_at,
|
||||
) {
|
||||
Ok(()) => self.preparing_memcard = true,
|
||||
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
|
||||
@@ -106,6 +179,18 @@ impl LoadCartridgeStep {
|
||||
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!(
|
||||
@@ -131,5 +216,67 @@ impl LoadCartridgeStep {
|
||||
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) {}
|
||||
}
|
||||
|
||||
@@ -18,3 +18,5 @@ pub use boot_target::BootTarget;
|
||||
pub use firmware::Firmware;
|
||||
pub use firmware_state::FirmwareState;
|
||||
pub use prometeu_context::PrometeuContext;
|
||||
|
||||
pub(crate) mod firmware_step_confirm_discard;
|
||||
|
||||
@@ -16,6 +16,7 @@ pub(crate) fn terminate_resident_game(
|
||||
log_manual_hub_kill: bool,
|
||||
) -> Result<ResidentGameTerminationOutcome, LifecycleError> {
|
||||
let Some(task_id) = os.lifecycle().resident_game_task() else {
|
||||
os.memcard().session.end_session();
|
||||
return Ok(ResidentGameTerminationOutcome::NoResidentGame);
|
||||
};
|
||||
|
||||
@@ -30,6 +31,7 @@ pub(crate) fn terminate_resident_game(
|
||||
return Ok(ResidentGameTerminationOutcome::NoResidentGame);
|
||||
};
|
||||
|
||||
os.memcard().session.end_session();
|
||||
os.vm().transition_render_owner(AppMode::Shell, 0);
|
||||
platform.game2d_frame_composer().unbind_scene();
|
||||
platform.assets_mut().shutdown();
|
||||
|
||||
Reference in New Issue
Block a user