Upgraded to latest Piston

src/app.rs

@@ -14,6 +14,8 @@ pub struct App<'a> {
     logo: Option<Texture>,
     comment1: Option<Texture>,
     comment2: Option<Texture>,
+
+    gl: Gl,
 }
 
 impl<'a> App<'a> {
@@ -26,19 +28,21 @@ impl<'a> App<'a> {
             logo: None,
             comment1: None,
             comment2: None,
+
+            gl: Gl::new(),
         }
     }
 }
 
 impl<'a> App<'a> {
-    fn render_ui(&self, c: &Context, gl: &mut Gl) {
+    fn render_ui(&mut self, c: &Context) {
         // logo
         c.trans(self.settings.board_padding, self.settings.board_padding)
          .image(self.logo.get_ref())
          .rgb(self.settings.text_dark_color[0],
               self.settings.text_dark_color[1],
               self.settings.text_dark_color[2])
-         .draw(gl);
+         .draw(&mut self.gl);
 
         c.view()
          .rect(self.settings.best_rect[0],
@@ -49,13 +53,16 @@ impl<'a> App<'a> {
                self.settings.label_color[1],
                self.settings.label_color[2],
                1.0)
-         .fill(gl);
+         .fill(&mut self.gl);
 
-        self.render_comment(self.comment1.get_ref(), self.settings.comment1_offset_y, c, gl);
+        //let comment1_offset_y = self.settings.comment1_offset_y;
-        self.render_comment(self.comment2.get_ref(), self.settings.comment2_offset_y, c, gl);
+        //let comment1 = self.comment1.as_ref().unwrap();
+        //self.render_comment(comment1, comment1_offset_y, c);
+
+        //self.render_comment(self.comment2.get_ref(), self.settings.comment2_offset_y, c);
     }
 
-    fn render_comment(&self, comment: &Texture, y: f64, c: &Context, gl: &mut Gl) {
+    fn render_comment(&mut self, comment: &Texture, y: f64, c: &Context) {
         let (width, height) = comment.get_size();
         let w = self.settings.window_size[0] as f64 - 2.0 * self.settings.board_padding;
         let h = height as f64 * w / width as f64;
@@ -64,22 +71,24 @@ impl<'a> App<'a> {
          .rgb(self.settings.text_dark_color[0],
               self.settings.text_dark_color[1],
               self.settings.text_dark_color[2])
-         .draw(gl);
+         .draw(&mut self.gl);
     }
 }
 
 impl<'a> Game for App<'a> {
-    fn load(&mut self, asset_store: &mut AssetStore) {
+    fn load(&mut self) {
-        self.number_renderer = Some(NumberRenderer::new(asset_store));
+        let asset_store = AssetStore::from_folder(self.settings.asset_folder.as_slice());
+        self.number_renderer = Some(NumberRenderer::new(&asset_store));
 
         self.logo = Some(Texture::from_path(&asset_store.path("logo.png").unwrap()).unwrap());
         self.comment1 = Some(Texture::from_path(&asset_store.path("comment1.png").unwrap()).unwrap());
         self.comment2 = Some(Texture::from_path(&asset_store.path("comment2.png").unwrap()).unwrap());
     }
 
-    fn render(&self, c: &Context, args: &mut RenderArgs) {
+    fn render(&mut self, args: &mut RenderArgs) {
-        self.render_ui(c, args.gl);
+        let ref c = Context::abs(args.width as f64, args.height as f64);
-        self.board.render(self.number_renderer.get_ref(), c, args.gl);
+        self.render_ui(c);
+        self.board.render(self.number_renderer.get_ref(), c, &mut self.gl);
     }
 
     fn update(&mut self, args: &mut UpdateArgs) {

src/board.rs

@@ -89,7 +89,7 @@ impl<'a> Board<'a> {
         }
     }
 
-    pub fn render(&self, number_renderer: &NumberRenderer, c: &Context, gl: &mut Gl) {
+    pub fn render(&mut self, number_renderer: &NumberRenderer, c: &Context, gl: &mut Gl) {
         number_renderer.render(
             self.score as u32,
             self.settings.best_rect[0] + self.settings.best_rect[2] / 2.0,

src/main.rs

@@ -14,30 +14,23 @@ mod number_renderer;
 mod settings;
 mod tile;
 
-type GameWindowBackEnd = GameWindowSDL2;
-
 fn main() {
     let settings = settings::Settings::load();
 
-    let mut game_window: GameWindowBackEnd = GameWindow::new(
+    let mut game_window = GameWindowSDL2::new(
         GameWindowSettings {
             title: "Rust-2048".to_string(),
             size: settings.window_size,
             fullscreen: false,
             exit_on_esc: true,
-            background_color: [
-                settings.window_background_color[0],
-                settings.window_background_color[1],
-                settings.window_background_color[2],
-                1.0,
-            ],
         }
     );
 
-    let mut asset_store = AssetStore::from_folder(settings.asset_folder.as_slice());
-
     let mut app = app::App::new(&settings);
-
+    let game_iter_settings = GameIteratorSettings {
-    app.run(&mut game_window, &mut asset_store);
+        updates_per_second: 120,
+        max_frames_per_second: 60,
+    };
+    app.run(&mut game_window, &game_iter_settings);
 }
 

src/number_renderer.rs

@@ -2,8 +2,6 @@
 use graphics::*;
 use piston::{
     AssetStore,
-    Gl,
-    Texture,
 };
 
 static DIGITS_WIDTH: f64 = 20.0;
@@ -14,7 +12,7 @@ pub struct NumberRenderer {
 }
 
 impl NumberRenderer {
-    pub fn new(asset_store: &mut AssetStore) -> NumberRenderer {
+    pub fn new(asset_store: &AssetStore) -> NumberRenderer {
         NumberRenderer {
             image: Texture::from_path(&asset_store.path("digits.png").unwrap()).unwrap(),
         }
@@ -37,7 +35,7 @@ impl NumberRenderer {
         for digit in digits.iter() {
             c.rect(x, y, width, height)
              .image(&self.image)
-             .src_rect(*digit * DIGITS_WIDTH as u32, 0, DIGITS_WIDTH as u32, DIGITS_HEIGHT as u32)
+             .src_rect((*digit * DIGITS_WIDTH as u32) as i32, 0, DIGITS_WIDTH as i32, DIGITS_HEIGHT as i32)
              .rgba(color[0], color[1], color[2], 1.0)
              .draw(gl);
             x += width;