Upgraded to latest Piston and Rust 1.0.0

removed use of unstabel features
Gl => GlGraphics

src/board.rs

@@ -1,10 +1,10 @@
 
 use std::collections::HashSet;
-use std::iter::range_step_inclusive;
+// use std::iter::range_step_inclusive;
 use rand::random;
 use graphics::*;
 use opengl_graphics::{
-    Gl,
+    GlGraphics,
 };
 use number_renderer::NumberRenderer;
 use settings::Settings;
@@ -18,7 +18,6 @@ fn rgb2rgba(c: [f32; 3]) -> [f32; 4] { [c[0], c[1], c[2], 1.0] }
 pub struct Board<'a> {
     tiles: Vec<Tile<'a>>,
     score: i32,
-
     settings: &'a Settings,
 }
 
@@ -88,13 +87,16 @@ impl<'a> Board<'a> {
                     tiles.push(self.tiles[i].clone());
                 }
             }
-            tiles.append(&mut tiles_need_added);
+            // 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);
         }
     }
 
-    pub fn render(&self, number_renderer: &NumberRenderer, c: &Context, gl: &mut Gl) {
+    pub fn render(&self, number_renderer: &NumberRenderer, c: &Context, gl: &mut GlGraphics) {
         number_renderer.render(
         self.score as u32,
         self.settings.best_rect[0] + self.settings.best_rect[2] / 2.0,
@@ -118,14 +120,22 @@ impl<'a> Board<'a> {
 
     fn merge_col(&mut self, y_start: i32, y_end: i32, y_step: i32) {
         if self.is_locking() {
+            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 }
+        } 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 {
+            for col in 0 .. self.settings.tile_width {
-                for row in range_step_inclusive(y_start, y_end, y_step) {
+                // TODO: replace steps by (y_start .. y_end).step_by(y_step) if step_by becomes stable
+                for row  in steps.to_vec() {
                     match self.get_mut_tile(col, row) {
                         None => {
                             match self.get_mut_next_tile(col, row, 0, y_step) {
@@ -150,7 +160,7 @@ impl<'a> Board<'a> {
                 let mut sy = 0;
                 let mut dx = 0;
                 let mut dy = 0;
-                for row in range_step_inclusive(y_start, y_end, y_step) {
+                for row  in steps.to_vec() {
                     match self.get_tile(col, row) {
                         Some(ref d_tile) => {
                             match self.get_next_tile(col, row, 0, y_step) {
@@ -206,10 +216,18 @@ 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 }
+        } 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 range_step_inclusive(x_start, x_end, x_step) {
+                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) {
@@ -234,7 +252,7 @@ impl<'a> Board<'a> {
                 let mut sy = 0;
                 let mut dx = 0;
                 let mut dy = 0;
-                for col in range_step_inclusive(x_start, x_end, x_step) {
+                for col in steps.to_vec() {
                     match self.get_tile(col, row) {
                         Some(ref d_tile) => {
                             match self.get_next_tile(col, row, x_step, 0) {
@@ -350,7 +368,7 @@ impl<'a> Board<'a> {
         count
     }
 
-    fn render_board(&self, c: &Context, gl: &mut Gl) {
+    fn render_board(&self, c: &Context, gl: &mut GlGraphics) {
         Rectangle::new(rgb2rgba(self.settings.label_color))
         .draw([self.settings.board_padding,
         self.settings.board_padding + self.settings.board_offset_y,
@@ -377,7 +395,7 @@ impl<'a> Board<'a> {
         }
     }
 
-    fn render_tiles(&self, number_renderer: &NumberRenderer, c: &Context, gl: &mut Gl) {
+    fn render_tiles(&self, number_renderer: &NumberRenderer, c: &Context, gl: &mut GlGraphics) {
         for tile in self.tiles.iter() {
             tile.render(number_renderer, c, gl);
         }

src/main.rs

@@ -1,6 +1,3 @@
-
-#![feature(core,collections,path_ext)]
-
 extern crate rustc_serialize;
 extern crate rand;
 
@@ -45,19 +42,19 @@ fn main() {
 
     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() {
+           // 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) {