functional

1 files changed, 142 insertions, 29 deletions

diff --git a/src/lib.rs b/src/lib.rs
index 5b4bbb0..6d7cd75 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,56 +1,169 @@
-pub mod input;
 mod tetris;
-mod display;
 
 use crate::tetris::piece;
-use std::io::stdin;
-use crate::input::Input;
+
+use std::time::{Instant, Duration};
+
+// SFML
+use sfml::window::{Style, Event, ContextSettings, Key};
+use sfml::graphics::{self, *};
+use sfml::system::{Vector2f, Vector2u};
 
 pub struct Game {
-    tickrate: u8, // How many times things are checked a second
-    maxfps: u8, // Between 1 and 240
-    gamespeed: u8, // How quickly r#move(down) is called in ms
+    tickrate: Duration, // How many times things are checked a second
+    maxfps: u64,
+    window_geometry: (u32, u32),
+    window: RenderWindow,
 }
 impl Game {
     pub fn new() -> Game {
+        let maxfps = 30;
+        let geometry = (480, 480);
+
+        // Window setup
+        let mut context_settings: ContextSettings = Default::default();
+        context_settings.antialiasing_level = 0;
+
+        let mut window = graphics::RenderWindow::new(
+            geometry,
+            "Test",
+            Style::DEFAULT,
+            &context_settings);
+
+        window.set_framerate_limit(maxfps);
+        window.clear(Color::rgb(250, 250, 250));
+
+        // View
+        let view_geometry = (geometry.0 as f32, geometry.1 as f32);
+        let view = View::new(
+            Vector2f::from(view_geometry) / 2.0,
+            Vector2f::from(view_geometry));
+        window.set_view(&view);
+
         Game{
-            tickrate: 20,
+            tickrate: Duration::from_secs(1),
             maxfps: 30,
-            gamespeed: 250,
+            window_geometry: geometry,
+            window: window,
         }
     }
 
+    pub fn set_geometry(&mut self, geometry: (u32, u32)) {
+        self.window_geometry = geometry;
+        self.window.set_size(Vector2u::from(geometry));
+    }
+
+    fn pause(&mut self) {
+        println!("paused");
+        loop {
+            match self.window.wait_event() {
+                Some(Event::GainedFocus) => break,
+                 _ => ()
+            }
+        }
+        println!("resumed");
+    }
+
     // The actual game loop
-    pub fn game_loop(&self, input: &Input) {
+    pub fn game_loop(&mut self) {
+
+        // Textures
+        let background = Texture::from_file("assets/background.png").expect("Cannot load texture");
+        let bit = Texture::from_file("assets/bit.png").expect("Cannot load texture");
+
+        // Objects
+        let mut background = RectangleShape::with_texture(&background);
+        background.set_size(Vector2f::new(480.0, 480.0));
+
+        let mut bit = RectangleShape::with_texture(&bit);
+        bit.set_size(Vector2f::new(24.0, 24.0));
+
+        // Initialize the background
+        self.window.draw(&background);
+
+        // Timing
+        let mut tick = Instant::now();
+        let mut fpscap = Instant::now();
+
+        // Game setup
         let mut tetris = tetris::Tetris::new();
-        let mut piece = piece::Piece::random(piece::Pos(0,0));
+        let mut piece = piece::Piece::random(piece::Pos(-2,3));
         loop {
-            tetris.check_lines();
-            piece.r#move(piece::Dir::Down, &tetris);
+            // Process events
+            let mut key: Option<Key> = None;
+            match self.window.poll_event() {
+                Some(n) => match n {
+                    Event::Closed => break,
+                    Event::Resized {width: w, height: h} => self.set_geometry((w, h)),
+                    Event::LostFocus => self.pause(),
+                    Event::KeyPressed {code: c, ctrl: _, alt: _, shift: _, system: _} => key = Some(c),
+                    Event::KeyReleased {code: _, ctrl: _, alt: _, shift: _, system: _} => key = None,
+                    _ => (),
+                },
+                None => (),
+            }
+
+            // Process keys
+            use tetris::piece::{Dir, Rotate};
+            match key {
+                Some(Key::A) => piece.r#move(Dir::Left, &tetris),
+                Some(Key::S) => piece.r#move(Dir::Down, &tetris),
+                Some(Key::D) => piece.r#move(Dir::Right, &tetris),
+                Some(Key::Q) => piece.rotate(Rotate::Left, &tetris),
+                Some(Key::E) => piece.rotate(Rotate::Right, &tetris),
+                _ => ()
+            }
 
             // Check if piece is dead
             if piece.is_alive() == false {
                 piece.apply_to_grid(&mut tetris);
-                piece = piece::Piece::random(piece::Pos(0,0));
+                piece = piece::Piece::random(piece::Pos(-2,3));
                 // piece = piece::Piece::new(piece::Pieces::Cube, piece::Pos(0,0));
             }
-            
-            let grid = tetris.return_grid();
-            display::display(&grid, &piece);
-
-            let mut input = String::new();
-
-            stdin().read_line(&mut input).expect("Could not read line");
-            let input = input.get(0..1).expect("Nothing to get");
-            match input {
-                "a" => piece.r#move(piece::Dir::Left, &tetris),
-                "d" => piece.r#move(piece::Dir::Right, &tetris),
-                "e" => piece.rotate(piece::Rotate::Right, &tetris),
-                "q" => piece.rotate(piece::Rotate::Left, &tetris),
-                " " => break,
-                _ => (),
+
+            // Check if there are full lines
+            tetris.check_lines();
+
+            // Execute on tick
+            if tick.elapsed() >= self.tickrate {
+                // Reset the clock
+                tick = Instant::now();
+
+                // Timed logic
+                piece.r#move(piece::Dir::Down, &tetris)
+            }
+
+            if fpscap.elapsed() >= Duration::from_millis(1 / self.maxfps) {
+                // Reset the clock
+                fpscap = Instant::now();
+
+                // Draw the background
+                self.window.draw(&background);
+
+                // Start drawing everything
+                let grid = tetris.return_grid();
+    
+                // Draw all the bits
+                for y in (0..grid.len()).rev() {
+                    for x in 0..grid.len() {
+                        if *grid.get(y).unwrap_or(&vec![0]).get(x).unwrap_or(&0) == 1 {
+                            bit.set_position(((x * 24) as f32, (y * 24) as f32));
+                            self.window.draw(&bit); 
+                        }
+                    }
+                }
+                for piece_bit in piece.get_bits_pos() {
+                    if !(piece_bit.0 < 0 || piece_bit.1 < 0) {
+                        bit.set_position(((piece_bit.1 as f32) * 24.0, (piece_bit.0 as f32) * 24.0));
+                        self.window.draw(&bit); 
+                    }
+                }
+        
+                self.window.display();
             }
         }
+
+        self.window.close();
     }
 }