clean up

crates/prometeu-core/src/firmware/firmware.rs

@@ -20,37 +20,58 @@ impl Firmware {
     }
 
     pub fn step_frame(&mut self, signals: &InputSignals, hw: &mut dyn HardwareBridge) {
-        match &mut self.state {
+        let next_state = match &mut self.state {
-            FirmwareState::Reset => {
+            FirmwareState::Reset => Self::step_reset(&mut self.os),
-                self.os.reset();
+            FirmwareState::SplashScreen => Self::step_splash_screen(),
-                self.state = FirmwareState::SplashScreen;
+            FirmwareState::LaunchHub => Self::step_launch_hub(&mut self.hub),
+            FirmwareState::HubHome => Self::step_hub_home(&mut self.hub, &mut self.os, hw),
+            FirmwareState::LoadApp(cartridge) => Self::step_init_app(&mut self.os, signals, hw, cartridge),
+            FirmwareState::AppRunning => Self::step_run_app(&mut self.os, signals, hw),
+            FirmwareState::AppCrashes(_error) => Self::step_crash_screen(signals, hw),
+        };
+
+        if let Some(new_state) = next_state {
+            self.state = new_state;
         }
-            FirmwareState::SplashScreen => {
-                // Splash logic opcional
-                self.state = FirmwareState::LaunchHubHome;
     }
-            FirmwareState::LaunchHubHome => {
+
-                self.hub.init();
+    fn step_reset(os: &mut PrometeuOS) -> Option<FirmwareState> {
-                self.state = FirmwareState::HubHome;
+        os.reset();
+        Some(FirmwareState::SplashScreen)
     }
-            FirmwareState::HubHome => {
+
+    fn step_splash_screen() -> Option<FirmwareState> {
+        Some(FirmwareState::LaunchHub)
+    }
+
+    fn step_launch_hub(hub: &mut PrometeuHub) -> Option<FirmwareState> {
+        hub.init();
+        Some(FirmwareState::HubHome)
+    }
+
+    fn step_hub_home(hub: &mut PrometeuHub, os: &mut PrometeuOS, hw: &mut dyn HardwareBridge) -> Option<FirmwareState> {
         hw.gfx_mut().clear(Color::INDIGO);
-                self.hub.gui_update(&mut self.os);
+        hub.gui_update(os);
         hw.gfx_mut().present();
+        None
     }
-            FirmwareState::PosRunGame(_cart) => {
+
-                if let Some(error) = self.os.step_frame(signals, hw) {
+    fn step_init_app(os: &mut PrometeuOS, _signals: &InputSignals, _hw: &mut dyn HardwareBridge, cartridge: &Cartridge) -> Option<FirmwareState> {
-                    self.state = FirmwareState::PosCrashScreen(error);
+        match cartridge.header.mode {
+            AppMode::Game => {
+            },
+            AppMode::System => {                
             }
         }
-            FirmwareState::PosRunSystem(_cart) => {
+        os.initialize_vm(cartridge);
-                // System Apps rodam "dentro" do Hub/Window System
+        Some(FirmwareState::AppRunning)
-                if let Some(error) = self.os.step_frame(signals, hw) {
-                    self.state = FirmwareState::PosCrashScreen(error);
     }
-                // TODO: Compor com a UI do Hub
+
+    fn step_run_app(os: &mut PrometeuOS, signals: &InputSignals, hw: &mut dyn HardwareBridge) -> Option<FirmwareState> {
+        os.step_frame(signals, hw).map(FirmwareState::AppCrashes)
     }
-            FirmwareState::PosCrashScreen(_error) => {
+
+    fn step_crash_screen(signals: &InputSignals, hw: &mut dyn HardwareBridge) -> Option<FirmwareState> {
         // Atualiza periféricos para input na tela de crash
         hw.pad_mut().begin_frame(signals);
 
@@ -62,17 +83,12 @@ impl Firmware {
 
         // Se apertar START, volta pro Hub
         if hw.pad().start.down {
-                    self.state = FirmwareState::LaunchHubHome;
+            return Some(FirmwareState::LaunchHub);
-                }
-            }
         }
+        None
     }
     
-    pub fn load_app(&mut self, cart: Cartridge, mode: AppMode) {
+    pub fn load_cartridge(&mut self, cart: Cartridge) {
-        self.os.load_cartridge(&cart);
+        self.state = FirmwareState::LoadApp(cart);        
-        match mode {
-            AppMode::Game => self.state = FirmwareState::PosRunGame(cart),
-            AppMode::System => self.state = FirmwareState::PosRunSystem(cart),
-        }
     }
 }

crates/prometeu-core/src/firmware/firmware_state.rs

@@ -4,9 +4,9 @@ use crate::model::Cartridge;
 pub enum FirmwareState {
     Reset,
     SplashScreen,
-    LaunchHubHome,
+    LaunchHub,
     HubHome,
-    PosRunGame(Cartridge),
+    LoadApp(Cartridge),
-    PosRunSystem(Cartridge),
+    AppRunning,
-    PosCrashScreen(String),
+    AppCrashes(String),
 }

crates/prometeu-core/src/prometeu_hub/prometeu_hub.rs

@@ -1,3 +1,4 @@
+use crate::hardware::HardwareBridge;
 use crate::model::Color;
 use crate::prometeu_os::PrometeuOS;
 
@@ -34,4 +35,7 @@ impl PrometeuHub {
     pub fn gui_update(&mut self, _os: &mut PrometeuOS) {
         // Atualiza a UI do Window System
     }
+
+    pub fn render(&mut self, _os: &mut PrometeuOS, _hw: &mut dyn HardwareBridge) {
+    }
 }

crates/prometeu-core/src/prometeu_os/prometeu_os.rs

@@ -49,15 +49,8 @@ impl PrometeuOS {
     }
 
     /// Carrega um cartucho na PVM e reseta o estado de execução.
-    pub fn load_cartridge(&mut self, cart: &Cartridge) {
+    pub fn initialize_vm(&mut self, cartridge: &Cartridge) {
-        // Na spec: "resetar PC/stack/heap ao iniciar app"
+        self.vm.initialize(cartridge.program.clone());
-        self.vm.program = cart.program.clone();
-        self.vm.pc = 0;
-        self.vm.operand_stack.clear();
-        self.vm.call_stack.clear();
-        self.vm.globals.clear();
-        self.vm.heap.clear();
-        self.vm.halted = false;
     }
 
     /// Executa um tick do host (60Hz).

crates/prometeu-core/src/vm/virtual_machine.rs

@@ -43,6 +43,16 @@ impl VirtualMachine {
             halted: false,
         }
     }
+
+    pub fn initialize(&mut self, program: Program) {
+        self.program = program;
+        self.pc = 0;
+        self.operand_stack.clear();
+        self.call_stack.clear();
+        self.globals.clear();
+        self.heap.clear();
+        self.halted = false;
+    }
 }
 
 impl Default for VirtualMachine {