@@ 93,7 93,7 @@ fn main() {
             unreachable!()
         })
     } else {
-        maxy as usize
+        maxy as usize - 1
     };
     let cols = if matches.opt_present(ARG_COLS) {
         matches.opt_str(ARG_COLS).unwrap().parse::<usize>().unwrap_or_else(|_| {

          
@@ 159,48 159,57 @@ fn main() {
         Border::Single
     };
 
-    let game_window = newwin(rows as i32, cols as i32, maxy / 2 - rows as i32 / 2, maxx / 2 - cols as i32 / 2);
     let mut cells = vec![vec![false; cols]; rows];
     for row in &mut cells[..] {
         for col in &mut row[..] {
             *col = rand::random::<bool>();
         }
     }
-    let mut game = Game { cells: cells, dead: dead, alive: alive, border: border, window: game_window };
+    let mut game = Game { cells: cells, dead: dead, alive: alive, border: border, window: newwin(rows as i32, cols as i32, maxy / 2 - rows as i32 / 2, maxx / 2 - cols as i32 / 2) };
 
-    let mut quit = false;
     let mut paused = false;
-    let mut last_time = time::precise_time_s();
-    let mut render = |delta| {
-        game.render(delta);
+    'game_loop: loop {
+        let before_render = time::precise_time_s();
+
+        game.render();
+        let mut game_window_beg = (0i32, 0i32);
+        getbegyx(game.window, &mut game_window_beg.0, &mut game_window_beg.1);
+        game_window_beg.0 += rows as i32;
+        mv(game_window_beg.0, game_window_beg.1);
+        clrtoeol();
+        addstr(&format!(
+            "exit (q)    {paused} (p){next}",
+            paused = if paused { "resume" } else { "pause" },
+            next = if paused { "  next (n)" } else { "" })
+        );
         refresh();
         wrefresh(game.window);
-    };
-    while !quit {
-        let time = time::precise_time_s();
-        let delta = time - last_time;
 
-        if !paused {
-            render(delta);
+        loop {
+            match getch() as u8 as char {
+                'q' => break 'game_loop,
+                'p' => {
+                    paused = !paused;
+                    nodelay(stdscr, !paused);
+                    continue 'game_loop;
+                },
+                'n' => break,
+                _ => if paused { continue } else { break }
+            }
         }
 
-        last_time = time::precise_time_s();
-        let render_duration = last_time - time;
+        game.update();
+
+        let after_render = time::precise_time_s();
+        let render_duration = after_render - before_render;
 
         let sleep = frame_duration - f64::min(render_duration, frame_duration);
         if sleep > 0. {
             std::thread::sleep_ms((sleep * 1000.) as u32);
         }
-
-        match getch() as u8 as char {
-            'q' => quit = true,
-            'p' => paused = !paused,
-            'n' if paused => render(delta),
-            _ => {}
-        }
     }
 
-    delwin(game_window);
+    delwin(game.window);
     end_ncurses();
 }
 

          
@@ 214,8 223,7 @@ struct Game {
 
 impl Game {
 
-    #[allow(unused_variables)]
-    fn render(&mut self, delta: f64) {
+    fn update(&mut self) {
         let count_neighbors = |cells: &Vec<Vec<bool>>, row, col| {
             let mut neighbors = 0;
             for row_off in -1..2 {

          
@@ 261,7 269,9 @@ impl Game {
                 }
             }
         }
+    }
 
+    fn render(&self) {
         for row in 0..self.cells.len() {
             for col in 0..self.cells[row].len() {
                 let cell_char = if self.cells[row][col] { self.alive } else { self.dead } as u64;