changed processor functions that use for to a functional approach (#3)

* changed processor functions that use for to a functional approach

* changed the way a color is picked from a conditional to a simple lookup table

---------

Co-authored-by: cuds <[email protected]>

Author: Csatinapppple

src/drivers/display_driver.rs

@@ -38,14 +38,17 @@ impl DisplayDriver {
         DisplayDriver { canvas: canvas }
     }
 
+    const COLORS: [pixels::Color; 2] =
+        [pixels::Color::RGB(0, 0, 100), pixels::Color::RGB(0, 150, 0)];
+
     pub fn draw(&mut self, pixels: &[u64; CHIP8_HEIGHT]) {
-        pixels.iter().enumerate().for_each(|(y_index, y)| {
+        pixels.iter().enumerate().for_each(|(y_index, &row)| {
             (0usize..CHIP8_WIDTH).for_each(|x_index| {
                 let _x_start = (x_index as u32) * SCALE_FACTOR;
                 let _y_start = (y_index as u32) * SCALE_FACTOR;
 
                 self.canvas
-                    .set_draw_color(color((*y >> (63 - x_index)) & 1));
+                    .set_draw_color(Self::COLORS[((row >> (63 - x_index)) & 1) as usize]);
 
                 let _ = self.canvas.fill_rect(Rect::new(
                     _x_start as i32,
@@ -59,11 +62,3 @@ impl DisplayDriver {
         self.canvas.present();
     }
 }
-
-fn color(value: u64) -> pixels::Color {
-    if value == 0 {
-        pixels::Color::RGB(0, 0, 100)
-    } else {
-        pixels::Color::RGB(0, 150, 0)
-    }
-}

src/processor.rs

@@ -19,7 +19,6 @@ pub struct OutputState<'a> {
 
 enum ProgramCounter {
     Unknown(u16),
-    //Stay,
     Next,
     Skip,
     Jump(usize),
@@ -54,9 +53,10 @@ pub struct Processor {
 impl Processor {
     pub fn new() -> Self {
         let mut ram = [0u8; CHIP8_RAM];
-        for i in 0..FONT_SET.len() {
-            ram[i] = FONT_SET[i];
-        }
+
+        FONT_SET.iter().enumerate().for_each(|(i, &font)| {
+            ram[i] = font;
+        });
 
         Processor {
             vram: [0; CHIP8_HEIGHT],
@@ -76,18 +76,16 @@ impl Processor {
     }
 
     pub fn load(&mut self, data: &[u8]) {
-        for (i, &byte) in data.iter().enumerate() {
+        data.iter().enumerate().for_each(|(i, &byte)| {
             let addr = 0x200 + i;
-            if addr < 4096 {
-                self.ram[0x200 + i] = byte;
-            } else {
-                break;
+            if addr >= 4096 {
+                panic!("ROM Data is bigger than chip8 RAM");
             }
-        }
+            self.ram[addr] = byte;
+        });
     }
 
     pub fn tick(&mut self, keypad: u16) -> OutputState {
-        //self.vram_changed = false;
         self.keypad = keypad;
 
         if self.keypad_wait {
@@ -170,7 +168,6 @@ impl Processor {
                 println!("ERROR: OPCODE {:#06x} UNKNOWN", opcode);
                 self.pc += OPCODE_SIZE;
             }
-            //ProgramCounter::Stay => (),
             ProgramCounter::Next => self.pc += OPCODE_SIZE,
             ProgramCounter::Skip => self.pc += 2 * OPCODE_SIZE,
             ProgramCounter::Jump(addr) => self.pc = addr,
@@ -356,7 +353,8 @@ impl Processor {
 
     fn op_dxyn(&mut self, x: usize, y: usize, n: usize) -> ProgramCounter {
         self.v[0x0f] = 0;
-        for byte in 0..n {
+
+        (0..n).for_each(|byte| {
             let y = (self.v[y] as usize + byte) % CHIP8_HEIGHT;
             let x = self.v[x] as usize % CHIP8_WIDTH;
 
@@ -371,7 +369,7 @@ impl Processor {
             }
             self.v[0xf] |= if self.vram[y] & mask > 0 { 1 } else { 0 };
             self.vram[y] = self.vram[y] ^ mask;
-        }
+        });
         self.vram_changed = true;
         ProgramCounter::Next
     }
@@ -448,19 +446,15 @@ impl Processor {
     // The interpreter copies the values of registers V0 through Vx
     // into memory, starting at the address in I.
     fn op_fx55(&mut self, x: usize) -> ProgramCounter {
-        for i in 0..x + 1 {
-            self.ram[self.i + i] = self.v[i];
-        }
+        (0..x + 1).for_each(|i| self.ram[self.i + i] = self.v[i]);
         ProgramCounter::Next
     }
 
     // LD Vx, [I]
     // The interpreter reads values from memory starting at location
     // I into registers V0 through Vx.
     fn op_fx65(&mut self, x: usize) -> ProgramCounter {
-        for i in 0..x + 1 {
-            self.v[i] = self.ram[self.i + i];
-        }
+        (0..x + 1).for_each(|i| self.v[i] = self.ram[self.i + i]);
         ProgramCounter::Next
     }
 }