Rust fmt

src/app/editor.rs

@@ -1,3 +1 @@
-fn main() {
+fn main() {}
-
-}

src/app/game.rs

@@ -1,26 +1,18 @@
 #[macro_use]
 extern crate clap;
-extern crate sfml;
 extern crate rusty;
+extern crate sfml;
 
 use std::time::Instant;
 
-use clap::{
+use clap::{App, Arg};
-    Arg,
-    App,
-};
 
-use sfml::window::{
+use sfml::window::{joystick, Event, Key};
-    Event,
-    Key,
-    joystick,
-};
 
-
-use rusty::engine::scene::Scene;
 use rusty::engine::character::Character;
 use rusty::engine::controls::Controls;
 use rusty::engine::renderer::Renderer;
+use rusty::engine::scene::Scene;
 
 fn parse_resolution(res: &str) -> Result<(u32, u32), String> {
     let split = res.split('x').collect::<Vec<_>>();
@@ -43,21 +35,22 @@ fn parse_resolution(res: &str) -> Result<(u32, u32), String> {
 }
 
 fn main() {
-
     let matches = App::new("Rusty Maker")
         .version(crate_version!())
-        .arg(Arg::with_name("resolution")
+        .arg(
+            Arg::with_name("resolution")
                 .short("r")
                 .long("resolution")
                 .value_name("WIDTHxHEIGHT")
                 .takes_value(true)
                 .default_value("800x450")
-             .validator(|x| parse_resolution(&x).map(|_| ())))
+                .validator(|x| parse_resolution(&x).map(|_| ())),
-        .arg(Arg::with_name("fullscreen")
+        ).arg(
+            Arg::with_name("fullscreen")
                 .short("f")
                 .long("fullscreen")
-             .takes_value(false))
+                .takes_value(false),
-        .get_matches();
+        ).get_matches();
 
     let resolution = parse_resolution(matches.value_of("resolution").unwrap()).unwrap();
     let fullscreen = matches.is_present("fullscreen");
@@ -83,10 +76,8 @@ fn main() {
     let mut running = true;
 
     loop {
-
         // Manage the events
         while let Some(event) = renderer.poll_event() {
-
             match event {
                 // Quit the game if window is closed
                 Event::Closed => running = false,
@@ -120,10 +111,8 @@ fn main() {
         // Display and manage the frame rate
         renderer.display();
 
-        if ! running {
+        if !running {
             break;
         }
-
     }
-
 }

src/engine/character/mod.rs

@@ -1,30 +1,16 @@
-use std::time::{
+use std::time::{Duration, Instant};
-    Instant,
-    Duration,
-};
 
+use sfml::graphics::{FloatRect, IntRect, View};
 use sfml::system::Vector2;
 use sfml::window::Event;
-use sfml::graphics::{
-    IntRect,
-    FloatRect,
-    View,
-};
 
+use engine::controls::{Action, Controls};
 use engine::scene::Updatable;
-use engine::controls::{
-    Controls,
-    Action,
-};
 
+use engine::math::{clamp, duration_as_f32, duration_as_frame};
+use engine::physics;
 use engine::renderer::Drawable;
 use engine::texture::Texture;
-use engine::physics;
-use engine::math::{
-    duration_as_f32,
-    duration_as_frame,
-    clamp,
-};
 
 /// The different sides a character can face.
 pub enum Side {
@@ -60,7 +46,6 @@ impl Side {
 
 /// A character, enemy or controllable.
 pub struct Character {
-
     /// The position of the character.
     pub position: Vector2<f32>,
 
@@ -91,7 +76,6 @@ pub struct Character {
 }
 
 impl Character {
-
     /// Creates a character in (0, 0).
     fn generic(controls: Option<Controls>) -> Character {
         Character {
@@ -159,7 +143,6 @@ impl Character {
 
 impl Updatable for Character {
     fn update(&mut self, duration: &Duration) {
-
         let mut force: Vector2<f32> = Vector2::new(0.0, 0.0);
 
         if let Some(ref controls) = self.controls {
@@ -167,17 +150,13 @@ impl Updatable for Character {
         }
 
         if let Some(side) = Side::from_force(force) {
-
             self.side = side;
 
             if self.animation_timer.is_none() {
                 self.animation_timer = Some(Instant::now());
             }
-
         } else {
-
             self.animation_timer = None;
-
         }
 
         let duration = duration_as_f32(duration);
@@ -202,7 +181,6 @@ impl Updatable for Character {
 
         // Compute position
         self.position += self.speed * duration;
-
     }
 
     fn manage_event(&mut self, event: &Event) {
@@ -216,7 +194,7 @@ impl Updatable for Character {
             Some(Action::Jump(true)) => {
                 self.jump();
                 self.can_jump = false;
-            },
+            }
 
             Some(Action::Jump(false)) => {
                 self.can_jump = true;
@@ -224,7 +202,6 @@ impl Updatable for Character {
 
             _ => (),
         }
-
     }
 }
 

src/engine/controls/mod.rs

@@ -1,16 +1,7 @@
 use sfml::system::Vector2;
-use sfml::window::joystick::{
+use sfml::window::joystick::{axis_position, is_button_pressed, is_connected, Axis, COUNT};
-    Axis,
-    axis_position,
-    is_connected,
-    is_button_pressed,
-    COUNT,
-};
 
-use sfml::window::{
+use sfml::window::{Event, Key};
-    Key,
-    Event,
-};
 
 /// The different actions that a user can do.
 pub enum Action {
@@ -32,7 +23,6 @@ pub enum Controls {
 }
 
 impl Controls {
-
     /// Returns the default keyboard controls.
     pub fn default_keyboard() -> Controls {
         Controls::Keyboard(KeyboardMap::default())
@@ -81,13 +71,11 @@ impl Controls {
             Controls::Gamepad(ref map) => map.is_running(),
         }
     }
-
 }
 
 /// A map between keyboard keys and actions.
 #[derive(Copy, Clone)]
 pub struct KeyboardMap {
-
     /// The key corresponding to the jump button.
     jump_key: Key,
 
@@ -99,11 +87,9 @@ pub struct KeyboardMap {
 
     /// The key corresponding to the right button.
     right_key: Key,
-
 }
 
 impl KeyboardMap {
-
     /// Creates the default keyboard config.
     pub fn default() -> KeyboardMap {
         KeyboardMap {
@@ -116,22 +102,17 @@ impl KeyboardMap {
 
     /// Converts an event and depending on the config, returns the corresponding action.
     pub fn convert(&self, event: &Event) -> Option<Action> {
-
         match event {
-            Event::KeyPressed { code, ..  } if *code == self.jump_key =>
+            Event::KeyPressed { code, .. } if *code == self.jump_key => Some(Action::Jump(true)),
-                Some(Action::Jump(true)),
 
-            Event::KeyReleased { code, ..  } if *code == self.jump_key =>
+            Event::KeyReleased { code, .. } if *code == self.jump_key => Some(Action::Jump(false)),
-                Some(Action::Jump(false)),
 
             _ => None,
         }
-
     }
 
     /// Returns the direction of the keys.
     pub fn direction(&self) -> Vector2<f32> {
-
         let mut ret = Vector2::new(0.0, 0.0);
 
         const RIGHT: Vector2<f32> = Vector2 { x: 1.0, y: 0.0 };
@@ -145,20 +126,17 @@ impl KeyboardMap {
         }
 
         ret
-
     }
 
     /// Returns whether the running button is held down.
     pub fn is_running(&self) -> bool {
         self.run_key.is_pressed()
     }
-
 }
 
 /// A map between gamepad buttons and actions.
 #[derive(Copy, Clone)]
 pub struct GamepadMap {
-
     /// Id of the gamepad.
     id: u32,
 
@@ -170,17 +148,14 @@ pub struct GamepadMap {
 
     /// Left / Right axis.
     left_right_axis: Axis,
-
 }
 
 impl GamepadMap {
-
     /// Creates the default gamepad from an id.
     ///
     /// Returns None if the gamepad corresponding to the id is not connected.
     pub fn from_id(id: u32) -> Option<GamepadMap> {
-
+        if !is_connected(id) {
-        if ! is_connected(id){
             return None;
         }
 
@@ -196,7 +171,7 @@ impl GamepadMap {
     pub fn all() -> Vec<GamepadMap> {
         let mut gamepads = vec![];
 
-        for id in 0 .. COUNT {
+        for id in 0..COUNT {
             if let Some(gamepad) = GamepadMap::from_id(id) {
                 gamepads.push(gamepad);
             }
@@ -207,21 +182,18 @@ impl GamepadMap {
 
     /// Converts an event and depending on the config, returns the corresponding action.
     pub fn convert(&self, event: &Event) -> Option<Action> {
-
         match event {
-            Event::JoystickButtonPressed { joystickid, button } if
+            Event::JoystickButtonPressed { joystickid, button }
-                *joystickid == self.id && *button == self.jump_button => {
+                if *joystickid == self.id && *button == self.jump_button =>
-
+            {
                 Some(Action::Jump(true))
+            }
 
-            },
+            Event::JoystickButtonReleased { joystickid, button }
-
+                if *joystickid == self.id && *button == self.jump_button =>
-            Event::JoystickButtonReleased { joystickid, button } if
+            {
-                *joystickid == self.id && *button == self.jump_button => {
-
                 Some(Action::Jump(false))
-
+            }
-            },
 
             _ => None,
         }
@@ -229,10 +201,7 @@ impl GamepadMap {
 
     /// Returns the direction of the directionnal buttons of the gamepad.
     pub fn direction(&self) -> Vector2<f32> {
-        Vector2::new(
+        Vector2::new(axis_position(self.id, self.left_right_axis) / 100.0, 0.0)
-            axis_position(self.id, self.left_right_axis) / 100.0,
-            0.0
-        )
     }
 
     /// Returns whether the run button is held down.

src/engine/map/mod.rs

@@ -1,15 +1,9 @@
+use sfml::graphics::{FloatRect, IntRect};
 use sfml::system::Vector2;
-use sfml::graphics::{
-    IntRect,
-    FloatRect
-};
 
-use engine::texture::Texture;
+use engine::math::{clamp, Matrix};
 use engine::renderer::Drawable;
-use engine::math::{
+use engine::texture::Texture;
-    Matrix,
-    clamp,
-};
 
 /// This enum represents if the collision happens on the X axis or the Y axis.
 #[derive(Copy, Clone)]
@@ -42,11 +36,9 @@ impl CollisionAxis {
     }
 }
 
-
 /// This struct represents the different sides from which a collision can occur.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub struct CollisionTile {
-
     /// If the character comes from the top, it will collide if this bool is true.
     pub from_top: bool,
 
@@ -58,7 +50,6 @@ pub struct CollisionTile {
 
     /// If the character comes from the bottom, it will collide if this bool is true.
     pub from_bottom: bool,
-
 }
 
 impl CollisionTile {
@@ -118,7 +109,6 @@ pub enum GraphicTile {
 }
 
 impl GraphicTile {
-
     /// Checks if a graphic tile has a top border.
     pub fn is_top(self) -> bool {
         match self {
@@ -151,8 +141,6 @@ impl GraphicTile {
         }
     }
 
-
-
     /// Creates a vec containing all the non hidden graphic tiles.
     pub fn all() -> Vec<GraphicTile> {
         vec![
@@ -175,8 +163,8 @@ impl GraphicTile {
         top: Option<CollisionTile>,
         left: Option<CollisionTile>,
         right: Option<CollisionTile>,
-        bottom: Option<CollisionTile>) -> GraphicTile {
+        bottom: Option<CollisionTile>,
-
+    ) -> GraphicTile {
         GraphicTile::from_neighbours(
             top.unwrap_or_else(CollisionTile::full),
             left.unwrap_or_else(CollisionTile::full),
@@ -190,15 +178,14 @@ impl GraphicTile {
         top: CollisionTile,
         left: CollisionTile,
         right: CollisionTile,
-        bottom: CollisionTile) -> GraphicTile {
+        bottom: CollisionTile,
-
+    ) -> GraphicTile {
         let mut all = GraphicTile::all()
             .into_iter()
             .map(|x| (x, true))
             .collect::<Vec<_>>();
 
         for (ref mut tile, ref mut possible) in &mut all {
-
             if tile.is_top() == (top == CollisionTile::full()) {
                 *possible = false;
             }
@@ -214,7 +201,6 @@ impl GraphicTile {
             if tile.is_bottom() == (bottom == CollisionTile::full()) {
                 *possible = false;
             }
-
         }
 
         for (tile, possible) in all {
@@ -276,24 +262,20 @@ impl Drawable for PositionedTile {
 
 /// The map represents the tiles contained in a level.
 pub struct Map {
-
     /// The entrace point of the character in the map.
     entrance: (usize, usize),
 
     /// The tiles contained in the level.
     tiles: Matrix<(CollisionTile, GraphicTile)>,
-
 }
 
 impl Map {
-
     /// Creates a map full of nothing, with a ground at the bottom.
     pub fn new(rows: usize, cols: usize) -> Map {
-
         let mut tiles = Matrix::from_size(rows, cols, CollisionTile::empty());
         let rows = tiles.rows();
 
-        for i in 0 .. tiles.cols() {
+        for i in 0..tiles.cols() {
             tiles[(rows - 1, i)] = CollisionTile::full();
         }
 
@@ -303,7 +285,6 @@ impl Map {
         tiles[(25, 15)] = CollisionTile::full();
 
         Map::from_collision_tiles(tiles)
-
     }
 
     /// Creates a map from a txt file.
@@ -337,24 +318,21 @@ impl Map {
         let rows = tiles.rows();
         let cols = tiles.cols();
 
-        let mut matrix = Matrix::from_size(rows, cols,
+        let mut matrix =
-            (CollisionTile::empty(), GraphicTile::Hidden)
+            Matrix::from_size(rows, cols, (CollisionTile::empty(), GraphicTile::Hidden));
-        );
-
-        for i in 0 .. rows {
-            for j in 0 .. cols {
 
+        for i in 0..rows {
+            for j in 0..cols {
                 let graphic = if tiles[(i, j)] == CollisionTile::full() {
-
                     // TODO This is uggly
                     // If there is an overflow, we should give None instead
                     let (i, j) = (i as isize, j as isize);
 
                     GraphicTile::from_neighbour_options(
-                        tiles.get(((i  ) as usize, (j-1) as usize)).cloned(),
+                        tiles.get(((i) as usize, (j - 1) as usize)).cloned(),
-                        tiles.get(((i-1) as usize, (j  ) as usize)).cloned(),
+                        tiles.get(((i - 1) as usize, (j) as usize)).cloned(),
-                        tiles.get(((i+1) as usize, (j  ) as usize)).cloned(),
+                        tiles.get(((i + 1) as usize, (j) as usize)).cloned(),
-                        tiles.get(((i  ) as usize, (j+1) as usize)).cloned(),
+                        tiles.get(((i) as usize, (j + 1) as usize)).cloned(),
                     )
                 } else {
                     GraphicTile::Hidden
@@ -402,9 +380,11 @@ impl Map {
     /// Checks whether the bounding box collides with elements of the map.
     ///
     /// Returns the new correct position.
-    pub fn collides_bbox(&self, old: FloatRect, new: FloatRect)
+    pub fn collides_bbox(
-        -> Option<(CollisionAxis, Vector2<f32>)> {
+        &self,
-
+        old: FloatRect,
+        new: FloatRect,
+    ) -> Option<(CollisionAxis, Vector2<f32>)> {
         let cols = self.tiles.cols() - 1;
         let rows = self.tiles.rows() - 1;
 
@@ -418,67 +398,64 @@ impl Map {
         let mut collision_y = false;
         let mut new = new;
 
-
+        for col in min_col..=max_col {
-        for col in min_col ..= max_col {
+            for row in min_row..=max_row {
-            for row in min_row ..= max_row {
-
                 let tile_left = col as f32 * 16.0;
                 let tile_top = row as f32 * 16.0;
 
                 let tile = FloatRect::new(tile_left, tile_top, 16.0, 16.0);
 
-                if ! overlap(new, tile) {
+                if !overlap(new, tile) {
                     continue;
                 }
 
                 // Collisions between feet and ground
-                if self.tiles[(row, col)].0.from_top &&
+                if self.tiles[(row, col)].0.from_top
-                   old.top + old.height <= tile_top &&
+                    && old.top + old.height <= tile_top
-                   new.top + new.height >= tile_top {
+                    && new.top + new.height >= tile_top
-
+                {
                     collision_y = true;
                     new.top = tile_top - new.height;
                 }
 
-                if ! overlap(new, tile) {
+                if !overlap(new, tile) {
                     continue;
                 }
 
                 // Collisions between right and right wall
-                if self.tiles[(row, col)].0.from_left  &&
+                if self.tiles[(row, col)].0.from_left
-                   old.left + old.width <= tile_left &&
+                    && old.left + old.width <= tile_left
-                   new.left + new.width >= tile_left {
+                    && new.left + new.width >= tile_left
-
+                {
                     collision_x = true;
                     new.left = tile_left - new.width;
                 }
 
-                if ! overlap(new, tile) {
+                if !overlap(new, tile) {
                     continue;
                 }
 
                 // Collisions between left and left wall
-                if self.tiles[(row, col)].0.from_right &&
+                if self.tiles[(row, col)].0.from_right
-                   old.left >= tile_left + 16.0 &&
+                    && old.left >= tile_left + 16.0
-                   new.left <= tile_left + 16.0 {
+                    && new.left <= tile_left + 16.0
-
+                {
                     collision_x = true;
                     new.left = tile_left + 16.0;
                 }
 
-                if ! overlap(new, tile) {
+                if !overlap(new, tile) {
                     continue;
                 }
 
                 // Collisions between head and roof
-                if self.tiles[(row, col)].0.from_bottom &&
+                if self.tiles[(row, col)].0.from_bottom
-                   old.top >= tile_top + 16.0 &&
+                    && old.top >= tile_top + 16.0
-                   new.top <= tile_top + 16.0 {
+                    && new.top <= tile_top + 16.0
-
+                {
                     collision_y = true;
                     new.top = tile_top + 16.0;
                 }
-
             }
         }
 
@@ -494,10 +471,8 @@ impl Map {
 
 /// Checks if two boxes overlap.
 pub fn overlap(box1: FloatRect, box2: FloatRect) -> bool {
-    box2.left < box1.left + box1.width &&
+    box2.left < box1.left + box1.width
-    box2.left + box2.width > box1.left &&
+        && box2.left + box2.width > box1.left
-    box2.top  < box1.top + box1.height &&
+        && box2.top < box1.top + box1.height
-    box2.top  + box2.height > box1.top
+        && box2.top + box2.height > box1.top
 }
-
-

src/engine/math/mod.rs

@@ -1,9 +1,6 @@
 use std::time::Duration;
 
-use std::ops::{
+use std::ops::{Index, IndexMut};
-    Index,
-    IndexMut
-};
 
 /// Clamp a number between two boundaries.
 pub fn clamp(number: f32, min: f32, max: f32) -> f32 {
@@ -30,7 +27,6 @@ pub fn duration_as_f32(duration: &Duration) -> f32 {
 
 /// A generic matrix type, useful for levels.
 pub struct Matrix<T> {
-
     /// The number of rows of the matrix.
     rows: usize,
 
@@ -39,10 +35,12 @@ pub struct Matrix<T> {
 
     /// The contained data in the matrix.
     data: Vec<T>,
-
 }
 
-impl<T> Matrix<T> where T: Clone {
+impl<T> Matrix<T>
+where
+    T: Clone,
+{
     /// Creates a matrix from an element and duplicates it.
     pub fn from_size(rows: usize, cols: usize, element: T) -> Matrix<T> {
         Matrix {

src/engine/mod.rs

@@ -1,4 +1,3 @@
-
 /// This module contains the struct Scene.
 pub mod scene;
 

src/engine/physics/mod.rs

@@ -1,13 +1,19 @@
 use sfml::system::Vector2;
 
 /// The gravity force.
-pub const G: Vector2<f32> = Vector2 { x: 0.0, y: 25.0 * 32.0 };
+pub const G: Vector2<f32> = Vector2 {
+    x: 0.0,
+    y: 25.0 * 32.0,
+};
 
 /// The friction with the ground.
 pub const GROUND_FRICTION: Vector2<f32> = Vector2 { x: 0.5, y: 1.0 };
 
 /// The speed of a jump.
-pub const JUMP_SPEED: Vector2<f32> = Vector2 { x: 0.0, y: -12.5 * 32.0 };
+pub const JUMP_SPEED: Vector2<f32> = Vector2 {
+    x: 0.0,
+    y: -12.5 * 32.0,
+};
 
 /// The maximum vertical speed.
 pub const MAXIMUM_VERTICAL_SPEED: f32 = 10.0 * 32.0;

src/engine/renderer/mod.rs

@@ -1,26 +1,14 @@
 use std::time::Instant;
 
-use sfml::graphics::{
+use sfml::graphics::{Color, IntRect, RenderTarget, RenderWindow, Sprite, View};
-    RenderWindow,
-    RenderTarget,
-    Sprite,
-    Color,
-    IntRect,
-    View,
-};
 
-use sfml::window::{
+use sfml::window::{Event, Style};
-    Style,
-    Event,
-};
 
-use sfml::system::{
+use sfml::system::Vector2;
-    Vector2,
-};
 
-use engine::texture::{Texture, TextureManager};
-use engine::scene::Scene;
 use engine::map::GraphicTile;
+use engine::scene::Scene;
+use engine::texture::{Texture, TextureManager};
 
 /// Our custom drawable trait.
 pub trait Drawable {
@@ -36,7 +24,6 @@ pub trait Drawable {
 
 /// The game window.
 pub struct Renderer {
-
     /// The window on which the rendering will be done.
     window: RenderWindow,
 
@@ -45,17 +32,19 @@ pub struct Renderer {
 
     /// The global timer of the renderer.
     started: Instant,
-
 }
 
 impl Renderer {
     /// Creates a new renderer.
     pub fn new(width: u32, height: u32, fullscreen: bool) -> Renderer {
-
         let mut window = RenderWindow::new(
             (width, height),
             "Free Rusty Maker",
-            if fullscreen { Style::FULLSCREEN } else { Style::CLOSE },
+            if fullscreen {
+                Style::FULLSCREEN
+            } else {
+                Style::CLOSE
+            },
             &Default::default(),
         );
         window.set_vertical_sync_enabled(true);
@@ -104,9 +93,9 @@ impl Renderer {
         let rows = map.rows();
         let cols = map.cols();
 
-        for i in 0 .. rows {
+        for i in 0..rows {
-            for j in 0 .. cols {
+            for j in 0..cols {
-                let tile = map.at(i,j);
+                let tile = map.at(i, j);
                 if tile.graphic != GraphicTile::Hidden {
                     self.draw(&tile);
                 }

src/engine/scene/mod.rs

@@ -1,25 +1,22 @@
 use std::time::Duration;
 
+use sfml::graphics::View;
 use sfml::system::Vector2;
 use sfml::window::Event;
-use sfml::graphics::View;
 
 use engine::character::Character;
 use engine::map::Map;
 
 /// Contains everything needed to play.
 pub struct Scene {
-
     /// The characters contained in the scene.
     characters: Vec<Character>,
 
     /// The map of the scene.
     map: Map,
-
 }
 
 impl Scene {
-
     /// Creates an empty scene.
     pub fn new() -> Scene {
         Scene {
@@ -41,7 +38,7 @@ impl Scene {
     fn controlable(&self) -> Option<&Character> {
         for character in &self.characters {
             if character.controls().is_some() {
-                return Some(&character)
+                return Some(&character);
             }
         }
         None
@@ -78,7 +75,6 @@ impl Scene {
 
     /// Updates the whole scene.
     pub fn update(&mut self, duration: &Duration) {
-
         for c in &mut self.characters {
             let old = c.bbox();
 
@@ -118,7 +114,6 @@ impl Scene {
     pub fn map(&self) -> &Map {
         &self.map
     }
-
 }
 
 /// Trait that needs to be implemented for everything that can be updatable.

src/engine/texture/mod.rs

@@ -57,8 +57,14 @@ macro_rules! make_textures {
 }
 
 make_textures!(
-    Mario, mario, make_mario_texture, "../../../assets/textures/mario.png",
+    Mario,
-    Overworld, overworld, make_overworld_texture, "../../../assets/textures/overworld.png",
+    mario,
+    make_mario_texture,
+    "../../../assets/textures/mario.png",
+    Overworld,
+    overworld,
+    make_overworld_texture,
+    "../../../assets/textures/overworld.png",
 );
 
 impl TextureManager {