Support running two sims at once

src/emulator.rs

@@ -1,4 +1,5 @@
 use std::{
+    collections::HashMap,
     fs,
     path::{Path, PathBuf},
     sync::{
@@ -10,11 +11,11 @@ use std::{
 
 use anyhow::Result;
 
-use crate::{
-    audio::Audio,
-    renderer::GameRenderer,
-    shrooms_vb_core::{CoreVB, VBKey},
-};
+use crate::{audio::Audio, renderer::GameRenderer};
+use shrooms_vb_core::Sim;
+pub use shrooms_vb_core::VBKey;
+
+mod shrooms_vb_core;
 
 pub struct EmulatorBuilder {
     rom: Option<PathBuf>,
@@ -23,6 +24,20 @@ pub struct EmulatorBuilder {
     has_game: Arc<AtomicBool>,
 }
 
+#[derive(PartialEq, Eq, Hash, Clone, Copy, Debug)]
+pub enum SimId {
+    Player1,
+    Player2,
+}
+impl SimId {
+    pub fn to_index(self) -> usize {
+        match self {
+            Self::Player1 => 0,
+            Self::Player2 => 1,
+        }
+    }
+}
+
 impl EmulatorBuilder {
     pub fn new() -> (Self, EmulatorClient) {
         let (queue, commands) = mpsc::channel();
@@ -50,17 +65,17 @@ impl EmulatorBuilder {
     pub fn build(self) -> Result<Emulator> {
         let mut emulator = Emulator::new(self.commands, self.running, self.has_game)?;
         if let Some(path) = self.rom {
-            emulator.load_rom(&path)?;
+            emulator.load_rom_from_file(SimId::Player1, &path)?;
         }
         Ok(emulator)
     }
 }
 
 pub struct Emulator {
-    sim: CoreVB,
+    sims: Vec<Sim>,
     audio: Audio,
     commands: mpsc::Receiver<EmulatorCommand>,
-    renderer: Option<GameRenderer>,
+    renderers: HashMap<SimId, GameRenderer>,
     running: Arc<AtomicBool>,
     has_game: Arc<AtomicBool>,
 }
@@ -72,24 +87,50 @@ impl Emulator {
         has_game: Arc<AtomicBool>,
     ) -> Result<Self> {
         Ok(Self {
-            sim: CoreVB::new(),
+            sims: vec![],
             audio: Audio::init()?,
             commands,
-            renderer: None,
+            renderers: HashMap::new(),
             running,
             has_game,
         })
     }
 
-    pub fn load_rom(&mut self, path: &Path) -> Result<()> {
+    pub fn load_rom_from_file(&mut self, sim_id: SimId, path: &Path) -> Result<()> {
         let bytes = fs::read(path)?;
-        self.sim.reset();
-        self.sim.load_rom(bytes)?;
+        self.load_rom(sim_id, bytes)?;
+        Ok(())
+    }
+
+    pub fn start_second_sim(&mut self, rom: Option<PathBuf>) -> Result<()> {
+        let bytes = if let Some(path) = rom {
+            fs::read(path)?
+        } else if let Some(rom) = self.sims.first().and_then(|s| s.clone_rom()) {
+            rom
+        } else {
+            return Ok(());
+        };
+        self.load_rom(SimId::Player2, bytes)?;
+        Ok(())
+    }
+
+    fn load_rom(&mut self, sim_id: SimId, bytes: Vec<u8>) -> Result<()> {
+        while self.sims.len() <= sim_id.to_index() {
+            self.sims.push(Sim::new());
+        }
+        let sim = &mut self.sims[sim_id.to_index()];
+        sim.reset();
+        sim.load_rom(bytes)?;
         self.has_game.store(true, Ordering::Release);
         self.running.store(true, Ordering::Release);
         Ok(())
     }
 
+    pub fn stop_second_sim(&mut self) {
+        self.renderers.remove(&SimId::Player2);
+        self.sims.truncate(1);
+    }
+
     pub fn run(&mut self) {
         let mut eye_contents = vec![0u8; 384 * 224 * 2];
         let mut audio_samples = vec![];
@@ -97,15 +138,20 @@ impl Emulator {
             let mut idle = true;
             if self.running.load(Ordering::Acquire) {
                 idle = false;
-                self.sim.emulate_frame();
+                Sim::emulate_many(&mut self.sims);
             }
-            if let Some(renderer) = &mut self.renderer {
-                if self.sim.read_pixels(&mut eye_contents) {
-                    idle = false;
-                    renderer.render(&eye_contents);
+            for (sim_id, renderer) in self.renderers.iter_mut() {
+                if let Some(sim) = self.sims.get_mut(sim_id.to_index()) {
+                    if sim.read_pixels(&mut eye_contents) {
+                        idle = false;
+                        renderer.render(&eye_contents);
+                    }
                 }
             }
-            self.sim.read_samples(&mut audio_samples);
+            let weight = 1.0 / self.sims.len() as f32;
+            for sim in self.sims.iter_mut() {
+                sim.read_samples(&mut audio_samples, weight);
+            }
             if !audio_samples.is_empty() {
                 idle = false;
                 self.audio.update(&audio_samples);
@@ -137,14 +183,22 @@ impl Emulator {
 
     fn handle_command(&mut self, command: EmulatorCommand) {
         match command {
-            EmulatorCommand::SetRenderer(renderer) => {
-                self.renderer = Some(renderer);
+            EmulatorCommand::SetRenderer(sim_id, renderer) => {
+                self.renderers.insert(sim_id, renderer);
             }
-            EmulatorCommand::LoadGame(path) => {
-                if let Err(error) = self.load_rom(&path) {
+            EmulatorCommand::LoadGame(sim_id, path) => {
+                if let Err(error) = self.load_rom_from_file(sim_id, &path) {
                     eprintln!("error loading rom: {}", error);
                 }
             }
+            EmulatorCommand::StartSecondSim(path) => {
+                if let Err(error) = self.start_second_sim(path) {
+                    eprintln!("error starting second sim: {}", error);
+                }
+            }
+            EmulatorCommand::StopSecondSim => {
+                self.stop_second_sim();
+            }
             EmulatorCommand::Pause => {
                 self.running.store(false, Ordering::Release);
             }
@@ -154,11 +208,17 @@ impl Emulator {
                 }
             }
             EmulatorCommand::Reset => {
-                self.sim.reset();
-                self.running.store(true, Ordering::Release);
+                for sim in self.sims.iter_mut() {
+                    sim.reset();
+                }
+                if !self.sims.is_empty() {
+                    self.running.store(true, Ordering::Release);
+                }
             }
-            EmulatorCommand::SetKeys(keys) => {
-                self.sim.set_keys(keys);
+            EmulatorCommand::SetKeys(sim_id, keys) => {
+                if let Some(sim) = self.sims.get_mut(sim_id.to_index()) {
+                    sim.set_keys(keys);
+                }
             }
         }
     }
@@ -166,12 +226,14 @@ impl Emulator {
 
 #[derive(Debug)]
 pub enum EmulatorCommand {
-    SetRenderer(GameRenderer),
-    LoadGame(PathBuf),
+    SetRenderer(SimId, GameRenderer),
+    LoadGame(SimId, PathBuf),
+    StartSecondSim(Option<PathBuf>),
+    StopSecondSim,
     Pause,
     Resume,
     Reset,
-    SetKeys(VBKey),
+    SetKeys(SimId, VBKey),
 }
 
 #[derive(Clone)]