1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

extern crate piston;
extern crate graphics;
extern crate glutin_window;
extern crate opengl_graphics;

use piston::window::WindowSettings;
use piston::event_loop::*;
use piston::input::*;
use glutin_window::GlutinWindow;
use opengl_graphics::{ GlGraphics, OpenGL };

struct Game{
    gl:GlGraphics,
    snek: Snek,
}

impl Game{
    fn render(&mut self, arg: &RenderArgs){
        use graphics;

        let blue: [f32; 4] = [0.0, 0.0, 1.0, 1.0];

        self.gl.draw(arg.viewport(), |_c, gl|{
            graphics::clear(blue, gl);
        });

        self.snek.render(&mut self.gl, arg);
    }
}

struct Snek{
    x: i32,
    y: i32,
}

impl Snek{
    fn render(&self, gl: &mut GlGraphics, args: &RenderArgs){
        use graphics;

        let red: [f32; 4] = [1.0, 0.0, 0.0, 1.0];

        let square = graphics::rectangle::square(self.x as f64, self.y as f64, 20_f64);

        gl.draw(args.viewport(), |c, gl|{
            let transform = c.transform;

            graphics::rectangle(red, square, transform, gl);
    });
    }
}

fn main() {
    let opengl = OpenGL::V3_2;

    let mut window: GlutinWindow = WindowSettings::new(
        "Rusty Snek Gaem",
        [512, 512]
    ).opengl(opengl)
        .exit_on_esc(true)
        .build()
        .unwrap();

    let mut game = Game{
        gl: GlGraphics::new(opengl),
        snek: Snek {x: 50, y: 50},
    };

    let mut events = Events::new(EventSettings::new());
    while let Some(e) = events.next(&mut window) {
        if let Some(r) = e.render_args() {
            game.render(&r);
        }
    }
}