Merge pull request #13 from PifyZ/master

Format code

src/app.rs

@@ -1,4 +1,4 @@
-use std::path::{Path, PathBuf};
+use std::path::{ Path, PathBuf };
 
 use graphics::*;
 use piston::input::Button;
@@ -7,11 +7,7 @@ use piston::event::*;
 use board::Board;
 use number_renderer::NumberRenderer;
 use settings::Settings;
-use opengl_graphics::{
+use opengl_graphics::{ GlGraphics, Texture };
-    GlGraphics,
-    Texture,
-};
-
 
 pub struct App<'a> {
     board: Board<'a>,
@@ -94,7 +90,6 @@ impl<'a> App<'a> {
     }
 
     pub fn render(&mut self, args: &RenderArgs, gl: &mut GlGraphics) {
-
         let ref c = Context::abs(args.width as f64, args.height as f64);
 
         let w_bg_col = self.window_background_color;

src/board.rs

@@ -1,17 +1,10 @@
-
 use std::collections::HashSet;
-// use std::iter::range_step_inclusive;
 use rand::random;
 use graphics::*;
-use opengl_graphics::{
+use opengl_graphics::{ GlGraphics };
-    GlGraphics,
-};
 use number_renderer::NumberRenderer;
 use settings::Settings;
-use tile::{
+use tile::{ Tile, TileState };
-    Tile,
-    TileState,
-};
 
 fn rgb2rgba(c: [f32; 3]) -> [f32; 4] { [c[0], c[1], c[2], 1.0] }
 
@@ -41,6 +34,7 @@ impl<'a> Board<'a> {
         loop {
             let x = (random::<u32>() % self.settings.tile_width as u32) as i32;
             let y = (random::<u32>() % self.settings.tile_height as u32) as i32;
+
             if self.get_tile(x, y).is_none() {
                 self.tiles.push(Tile::new(self.settings, 2, x, y));
                 break;
@@ -52,20 +46,25 @@ impl<'a> Board<'a> {
         for tile in self.tiles.iter_mut() {
             tile.update(dt);
         }
-        
+
         if self.is_locking() {
             return;
         }
+
         let mut score_to_added = 0;
         let mut tiles_need_removed = HashSet::<usize>::new();
         let mut tiles_need_added = Vec::<Tile>::new();
+
         for i in 0..self.tiles.len() {
             let tile1 = &self.tiles[i];
+
             if tile1.status != TileState::TileStatic {
                 continue;
             }
+
             for j in i+1..self.tiles.len() {
                 let tile2 = &self.tiles[j];
+
                 if tile2.status != TileState::TileStatic
                   || tile1.tile_x != tile2.tile_x
                   || tile1.tile_y != tile2.tile_y {
@@ -82,15 +81,18 @@ impl<'a> Board<'a> {
 
         if tiles_need_removed.len() > 0 {
             let mut tiles = Vec::<Tile>::new();
+
             for i in 0..self.tiles.len() {
                 if !tiles_need_removed.contains(&i) {
                     tiles.push(self.tiles[i].clone());
                 }
             }
+
             // better but unstable:          tiles.append(&mut tiles_need_added);
             while let Some(tile_to_add) = tiles_need_added.pop() {
                 tiles.push(tile_to_add);
             }
+
             self.tiles = tiles;
             self.add_score(score_to_added);
         }
@@ -98,11 +100,11 @@ impl<'a> Board<'a> {
 
     pub fn render(&self, number_renderer: &NumberRenderer, c: &Context, gl: &mut GlGraphics) {
         number_renderer.render(
-        self.score as u32,
+            self.score as u32,
-        self.settings.best_rect[0] + self.settings.best_rect[2] / 2.0,
+            self.settings.best_rect[0] + self.settings.best_rect[2] / 2.0,
-        self.settings.best_rect[1] + self.settings.best_rect[3] / 2.0,
+            self.settings.best_rect[1] + self.settings.best_rect[3] / 2.0,
-        self.settings.best_rect[2],
+            self.settings.best_rect[2],
-        self.settings.text_light_color, c, gl);
+            self.settings.text_light_color, c, gl);
 
         self.render_board(c, gl);
         self.render_tiles(number_renderer, c, gl);
@@ -123,14 +125,22 @@ impl<'a> Board<'a> {
             println!("return");
             return;
         }
+
         let mut need_generate = false;
         let mut steps: Vec<i32> = Vec::with_capacity(self.settings.tile_height as usize);
+
         let mut next_step = y_start;
+
         if y_step < 0 {
-            while next_step > y_end { steps.push(next_step); next_step += y_step }
+            while next_step > y_end {
-        } else { 
+                steps.push(next_step); next_step += y_step
-            while next_step < y_end { steps.push(next_step); next_step += y_step }
+            }
-        };
+        } else {
+            while next_step < y_end {
+                steps.push(next_step); next_step += y_step
+            }
+        }
+
         loop {
             // move all tiles to right place
             for col in 0 .. self.settings.tile_width {
@@ -182,6 +192,7 @@ impl<'a> Board<'a> {
                         }
                     }
                 }
+
                 if found {
                     need_generate = true;
                     did_merged = true;
@@ -195,6 +206,7 @@ impl<'a> Board<'a> {
                 break;
             }
         }
+
         if need_generate {
             self.generate_tile();
         }
@@ -218,16 +230,21 @@ impl<'a> Board<'a> {
         let mut need_generate = false;
         let mut steps: Vec<i32> = Vec::with_capacity(self.settings.tile_width as usize);
         let mut next_step = x_start;
+
         if x_step < 0 {
-            while next_step > x_end { steps.push(next_step); next_step += x_step }
+            while next_step > x_end {
-        } else { 
+                steps.push(next_step); next_step += x_step
-            while next_step < x_end { steps.push(next_step); next_step += x_step }
+            }
-        };
+        } else {
+            while next_step < x_end {
+                steps.push(next_step); next_step += x_step
+            }
+        }
+
         loop {
             // move all tiles to right place
             for row in 0..self.settings.tile_height {
                 for col  in steps.to_vec() {
-                    
                     match self.get_mut_tile(col, row) {
                         None => {
                             match self.get_mut_next_tile(col, row, x_step, 0) {
@@ -274,6 +291,7 @@ impl<'a> Board<'a> {
                         }
                     }
                 }
+
                 if found {
                     need_generate = true;
                     did_merged = true;
@@ -325,6 +343,7 @@ impl<'a> Board<'a> {
         while x >= 0 && x < self.settings.tile_width
         && y >= 0 && y < self.settings.tile_height {
             let tile = self.get_tile(x, y);
+
             if tile.is_some() {
                 found = true;
                 break;
@@ -334,7 +353,7 @@ impl<'a> Board<'a> {
         }
 
         if found {
-        self.get_mut_tile(x, y)
+            self.get_mut_tile(x, y)
         } else {
             None
         }
@@ -346,6 +365,7 @@ impl<'a> Board<'a> {
                 return Some(tile);
             }
         }
+
         None
     }
 
@@ -355,6 +375,7 @@ impl<'a> Board<'a> {
                 return Some(tile);
             }
         }
+
         None
     }
 
@@ -365,31 +386,36 @@ impl<'a> Board<'a> {
                 count += 1;
             }
         }
+
         count
     }
 
     fn render_board(&self, c: &Context, gl: &mut GlGraphics) {
         Rectangle::new(rgb2rgba(self.settings.label_color))
-        .draw([self.settings.board_padding,
+        .draw(
-        self.settings.board_padding + self.settings.board_offset_y,
+            [self.settings.board_padding,
-        self.settings.board_size[0],
+            self.settings.board_padding + self.settings.board_offset_y,
-        self.settings.board_size[1]],
+            self.settings.board_size[0],
-        default_draw_state(),
+            self.settings.board_size[1]],
-        c.transform,
+            default_draw_state(),
-        gl);
+            c.transform,
-        
+            gl);
+
         let mut x = self.settings.board_padding + self.settings.tile_padding;
         let mut y = self.settings.board_padding + self.settings.board_offset_y + self.settings.tile_padding;
+
         for _ in 0..self.settings.tile_height {
             for _ in 0..self.settings.tile_width {
-                Rectangle::new(rgb2rgba(self.settings.tiles_colors[0]))
+                Rectangle::new(
-                  .draw([x, y, self.settings.tile_size, self.settings.tile_size],
+                    rgb2rgba(self.settings.tiles_colors[0]))
-                  default_draw_state(),
+                    .draw([x, y, self.settings.tile_size, self.settings.tile_size],
-                  c.transform,
+                    default_draw_state(),
-                  gl);
+                    c.transform,
+                    gl);
 
                 x += self.settings.tile_padding + self.settings.tile_size;
             }
+
             x = self.settings.board_padding + self.settings.tile_padding;
             y += self.settings.tile_padding + self.settings.tile_size;
         }

src/main.rs

@@ -7,9 +7,9 @@ extern crate opengl_graphics;
 extern crate sdl2_window;
 
 use piston::event::*;
-use piston::window::{WindowSettings, Size};
+use piston::window::{ WindowSettings, Size };
 use sdl2_window::Sdl2Window;
-use opengl_graphics::{GlGraphics,OpenGL};
+use opengl_graphics::{ GlGraphics, OpenGL };
 
 mod app;
 mod board;
@@ -32,45 +32,23 @@ fn main() {
 
     app.load();
 
-		/*
-    let game_iter_settings = GameIteratorSettings {
-            updates_per_second: 120,
-            max_frames_per_second: 60,
-    };
-    */
     let mut gl = GlGraphics::new(OpenGL::_3_2);
 
     for e in window.events() {
         use piston::event::{ RenderEvent, PressEvent };
+
         if let Some(ref args) = e.render_args() {
             app.render(args, &mut gl);
         }
 
-       if let Some(ref args) = e.update_args() {
+        if let Some(ref args) = e.update_args() {
            // TODO: only update if necessary
            // println!("update");
            app.update(args);
         }
+
         if let Some(ref args) = e.press_args() {
             app.key_press(args);
         }
-}
-
-		/*
-    for e in GameIterator::new(&mut window, &game_iter_settings) {
-
-        match e {
-            Render(ref args) => {
-                app.render(args);
-            },
-            Update(ref args) => {
-                app.update(args);
-            },
-            KeyPress(ref args) => {
-                app.key_press(args);
-            },
-            _ => {},
-        }
     }
-    */
 }

src/number_renderer.rs

@@ -1,10 +1,6 @@
-
 use std::path::Path;
 use graphics::*;
-use opengl_graphics::{
+use opengl_graphics::{ GlGraphics, Texture };
-    GlGraphics,
-    Texture,
-};
 
 static DIGITS_WIDTH: f64 = 20.0;
 static DIGITS_HEIGHT: f64 = 26.0;
@@ -42,6 +38,7 @@ impl NumberRenderer {
                       default_draw_state(),
                       c.transform,
                       gl);
+
             x += width;
         }
     }
@@ -49,15 +46,18 @@ impl NumberRenderer {
 
 fn number_to_digits(number: u32) -> Vec<u32> {
     let mut digits = Vec::<u32>::new();
+
     if number == 0 {
         digits.push(0);
         return digits;
     }
 
     let mut n = number;
+
     while n != 0 {
         digits.insert(0, n % 10);
         n /= 10;
     }
+
     digits
 }

src/settings.rs

@@ -3,11 +3,7 @@ use std::env::current_exe;
 use std::io::{BufWriter, BufReader, Write};
 use std::fs::{File};
 use std::path::Path;
-use rustc_serialize::{
+use rustc_serialize::{ json, Encodable, Decodable };
-    json,
-    Encodable,
-    Decodable,
-};
 
 static SETTING_FILENAME: &'static str = "settings.json";
 
@@ -47,10 +43,10 @@ impl Settings {
         let board_size = [
             s.tile_size * s.tile_width as f64 + s.tile_padding * (s.tile_width + 1) as f64,
             s.tile_size * s.tile_height as f64 + s.tile_padding * (s.tile_height + 1) as f64,
-
         ];
 
         let mut tiles_colors = Vec::<[f32; 3]>::new();
+
         for color in s.tiles_colors.iter() {
             tiles_colors.push([
                 color[0] / 255.0,
@@ -58,6 +54,7 @@ impl Settings {
                 color[2] / 255.0,
             ]);
         }
+
         Settings {
             asset_folder: s.asset_folder.clone(),
             comment1_offset_y: s.comment1_offset_y,
@@ -213,44 +210,52 @@ impl SettingsInJson {
 
     pub fn load() -> SettingsInJson {
         let exe_path = current_exe();
+
         if exe_path.is_err() {
             return SettingsInJson::default_settings();
         }
+
         let mut exe_path = exe_path.unwrap();
         exe_path.pop();
         let path = exe_path.join(Path::new(SETTING_FILENAME));
-// FIXME: use this if possible  (.exists() is unstable in Rust 1.0.0)
+
-/*      if !path.as_path().exists() || !path.is_file() {
+        // FIXME: use this if possible  (.exists() is unstable in Rust 1.0.0)
-            println!("Configuration file not found. Generating a default one.");
+        /*      if !path.as_path().exists() || !path.is_file() {
-            let default = SettingsInJson::default_settings();
+                    println!("Configuration file not found. Generating a default one.");
-            default.save();
+                    let default = SettingsInJson::default_settings();
-            return default;
+                    default.save();
-        }
+                    return default;
-        let file = File::open(&path).unwrap();
+                }
-        let mut reader = BufReader::new(file);
+                let file = File::open(&path).unwrap();
-*/
+                let mut reader = BufReader::new(file);
-        let file = File::open(&path);
+        */
-        match file {
+            let file = File::open(&path);
-            Err(e) => {
+
-                println!("Configuration file can't be open ({}). Try to generate a default one.", e);
+            match file {
-                let default = SettingsInJson::default_settings();
+                Err(e) => {
-                default.save();
+                    println!("Configuration file can't be open ({}). Try to generate a default one.", e);
-                return default;
+                    let default = SettingsInJson::default_settings();
-            },
+                    default.save();
-            _ => {}
+                    return default;
-        }
+                },
-        let mut reader = BufReader::new(file.unwrap());
+                _ => {}
-// End FIXME
+            }
+
+            let mut reader = BufReader::new(file.unwrap());
+        // End FIXME
+
         let mut decoder = json::Decoder::new(json::Json::from_reader(&mut reader).unwrap());
         Decodable::decode(&mut decoder).unwrap()
     }
 
     pub fn save(&self) {
         let exe_path = current_exe();
+
         if exe_path.is_err() {
             println!("WARNING: Failed to save settings: can't find exe path.");
             return;
         }
+
         let path = exe_path.unwrap();
         let file = File::create(&path.with_file_name(SETTING_FILENAME)).unwrap();
         let mut writer = BufWriter::new(file);
@@ -260,14 +265,10 @@ impl SettingsInJson {
                 if let Err(e) = writer.write(encoded.as_bytes()) {
                     println!("WARNING: Failed to save settings: {}", e);
                 }
-            }, Err(e) => {
+            },
+            Err(e) => {
                 println!("WARNING: Failed to save settings: {}", e);
             }
         }
-
-        // match self.encode(&mut encoder) {
-        //     Ok(()) => (),
-        //     Err(e) => { println!("WARNING: Failed to save settings: {}", e); },
-        // }
     }
 }

src/tile.rs

@@ -1,4 +1,3 @@
-
 use graphics::*;
 use opengl_graphics::GlGraphics;
 use number_renderer::NumberRenderer;
@@ -106,6 +105,7 @@ impl<'a> Tile<'a> {
     pub fn render(&self, number_renderer: &NumberRenderer, c: &Context, gl: &mut GlGraphics) {
         let mut pos = self.tile_to_pos(self.tile_x, self.tile_y);
         let mut size = (self.settings.tile_size, self.settings.tile_size);
+
         match self.status {
             TileState::TileMoving(_, x, y, _, _) => {
                 pos = (x, y);
@@ -118,6 +118,7 @@ impl<'a> Tile<'a> {
             },
             _ => {},
         }
+
         let (x, y) = pos;
         let (w, h) = size;
         let color = self.get_color();
@@ -135,6 +136,7 @@ impl<'a> Tile<'a> {
         } else {
             self.settings.text_dark_color
         };
+
         number_renderer.render(self.score as u32, x + self.settings.tile_size / 2.0, y + self.settings.tile_size / 2.0, self.settings.tile_size, color, c, gl);
     }