Use libc rand instead of rolling my own.

1 files changed, 18 insertions, 29 deletions

diff --git a/src/main.rs b/src/main.rs
index ffa6320..0d73c83 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,26 +4,8 @@ use std::io::{stderr, stdout, Read, Write};
 use std::sync::mpsc::{Receiver, SyncSender, TryRecvError};
 use std::time::{Duration, SystemTime};
 
-#[derive(Debug)]
-struct Gen {
-    state: u64,
-}
-
-impl Gen {
-    fn new() -> Gen {
-        Gen {
-            state: SystemTime::now()
-                .duration_since(SystemTime::UNIX_EPOCH)
-                .unwrap()
-                .as_nanos() as u64,
-        }
-    }
-
-    fn rand(&mut self, max: i32) -> i32 {
-        // https://en.wikipedia.org/wiki/Linear_congruential_generator
-        self.state = self.state.wrapping_mul(6364136223846793005).wrapping_add(1);
-        (self.state >> 33 & 0x7fffffff) as i32 % max
-    }
+fn rand(max: i32) -> i32 {
+    unsafe { libc::rand() % max }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -195,11 +177,11 @@ impl Snake {
         Ok(())
     }
 
-    fn print(&self, g: &mut Gen) -> Result<(), Box<dyn Error>> {
+    fn print(&self) -> Result<(), Box<dyn Error>> {
         let next = self.next();
         if (self.direction == Dir::Left || self.direction == Dir::Right)
             && in_bounds(next)
-            && g.rand(40) == 0
+            && rand(40) == 0
         {
             move_cursor(next)?;
             write!(stdout(), "~")?;
@@ -275,22 +257,21 @@ impl Fruit {
         Ok(())
     }
 
-    fn new_pos(&mut self, g: &mut Gen) {
-        self.pos.row = g.rand(i32::from(Screen::ROWS) - 4) as u16 + 2;
-        self.pos.col = g.rand(i32::from(Screen::COLS) - 4) as u16 + 2;
+    fn new_pos(&mut self) {
+        self.pos.row = rand(i32::from(Screen::ROWS) - 4) as u16 + 2;
+        self.pos.col = rand(i32::from(Screen::COLS) - 4) as u16 + 2;
     }
 }
 
 fn snake() -> Result<i64, Box<dyn Error>> {
     let screen = Screen::init()?;
-    let mut g = Gen::new();
     let mut snake = Snake {
         body: vec![pos(Screen::ROWS / 2, Screen::COLS / 2)],
         direction: Dir::Right,
         growing: 0,
     };
     let mut fruit = Fruit { pos: pos(0, 0) };
-    fruit.new_pos(&mut g);
+    fruit.new_pos();
     let mut score: i64 = 0;
     let mut real_score: i64 = 0;
     let mut delay = Duration::from_millis(200);
@@ -298,7 +279,7 @@ fn snake() -> Result<i64, Box<dyn Error>> {
     loop {
         move_cursor(pos(0, 3))?;
         write!(stdout(), " Score: {} ", score)?;
-        snake.print(&mut g)?;
+        snake.print()?;
         fruit.print()?;
 
         move_cursor(pos(Screen::ROWS - 1, Screen::COLS - 1))?;
@@ -316,7 +297,7 @@ fn snake() -> Result<i64, Box<dyn Error>> {
         if snake.body[0] == fruit.pos {
             snake.growing += 6;
             loop {
-                fruit.new_pos(&mut g);
+                fruit.new_pos();
                 if !snake.body.contains(&fruit.pos) {
                     break;
                 }
@@ -333,6 +314,14 @@ fn snake() -> Result<i64, Box<dyn Error>> {
 }
 
 fn main() {
+    unsafe {
+        libc::srand(
+            SystemTime::now()
+                .duration_since(SystemTime::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos() as u32,
+        );
+    }
     let score = match snake() {
         Ok(s) => s,
         Err(err) => {