moving a thing around the screen

src/main.rs

@@ -1,3 +1,124 @@
+extern crate sdl2;
+
+use sdl2::Sdl;
+use sdl2::video::{Window};
+use sdl2::image::LoadTexture;
+
+use sdl2::event::Event;
+use sdl2::keyboard::Keycode;
+
+use sdl2::rect::Rect;
+
+use std::path::Path;
+
+
+const WIDTH:u32  = 1280;
+const HEIGHT:u32 =  960;
+
+
+// it looks like returning the Canvas is still the best route to take
+fn init() -> (Sdl, Window) {
+    let context = match sdl2::init() {
+        Ok(context) => context,
+        Err(err)    => panic!("Could not initialize SDL2. Error: {}", err),
+    };
+
+    let video = match context.video() {
+        Ok(video) => video,
+        Err(err)  => panic!("Could not gain access to the SDL2 video subsystem. Error: {}", err),
+    };
+
+    let window = match video.window("Drop Game", WIDTH, HEIGHT)
+        .position_centered()
+        .opengl()
+        .build() {
+            Ok(window) => window,
+            Err(err)   => panic!("Could not create window. Error: {}", err),
+        };
+
+    return (context, window)
+}
+
+
 fn main() {
-    println!("Hello, world!");
+
+    let mut running: bool = true;
+    let mut blitx: i32 = 7;
+    let mut blity: i32 = 5;
+
+    let mut blitrect = Rect::new(blitx * 80, blity * 80, 80, 80);
+
+    let (context, window) = init();
+
+    let mut canvas = match window.into_canvas()
+        .build() {
+            Ok(canvas) => canvas,
+            Err(err)   => panic!("Could not create canvas from window. Error: {}", err),
+        };
+
+    let tc = canvas.texture_creator();
+
+    let texture = match tc.load_texture(&Path::new("assets/blip1.png")) {
+        Ok(texture) => texture,
+        Err(err)    => panic!("Could not load png: {}", err)
+    };
+
+
+
+
+    let mut pump = match context.event_pump() {
+        Ok(pump) => pump,
+        Err(err) => panic!("Could not start pumping: {}", err)
+    };
+
+
+
+    while running {
+        // pull all pending events
+        for event in pump.poll_iter() {
+            match event {
+                // apparently '{..}' means "with whatever fields"
+                Event::Quit {..} => {
+                    running = false
+                },
+
+                Event::KeyDown { keycode: k, .. } => match k {
+                    Some(Keycode::Escape) | Some(Keycode::Q) => {
+                        running = false
+                    },
+                    Some(Keycode::Up) => {
+                        if blity >= 1 { blity -= 1; }
+                    },
+                    Some(Keycode::Down) => {
+                        if blity < 11 { blity += 1; }
+                    },
+                    Some(Keycode::Left) => {
+                        if blitx >= 1 { blitx -= 1; }
+                    },
+                    Some(Keycode::Right) => {
+                        if blitx < 15 { blitx += 1; }
+                    },
+                    Some(_) => { },
+                    None => {}
+                },
+
+                _ => {}
+            }
+        }
+
+        blitrect.set_x(blitx * 80);
+        blitrect.set_y(blity * 80);
+
+        canvas.clear();
+        match canvas.copy(&texture, None, blitrect) {
+            Ok(())   => (), // no return value == success
+            Err(err) => panic!("Could not render texture: {}", err),
+        };
+
+        canvas.present();
+
+    }
+
 }
+
+