我们要做的是一个像素块画的贪吃蛇小游戏，效果如下图。
image.png

需求设计

我们都玩过贪吃蛇，在屏幕上随机出现一个苹果，我们要操控蛇去吃到苹果，当蛇吃到苹果后蛇的长度会加一。随着蛇的长度的增加，当蛇碰到自己或者碰到墙游戏就算结束。

依赖

rand：我们需要使用rand的随机数包来设置苹果的位置。
piston_window：这个包是用来调用openGL的，通过这个包可以快速的创建游戏的内容。

项目目录

image.png四个文件分别为，snake.rs用来创建我们的蛇，draw.rs用来创建我们的绘画方法，game.rs用来写我们这个游戏的规则，main.rs用来运行游戏。马上开始写。

draw.rs

  1. use piston_window::{rectangle,Context,G2d};
  2. use piston_window::types::Color;
  4. const BLOCK_SIZE:f64 = 25.0;
  6. pub fn to_coord(game_coord:i32) -> f64 {//因为该游戏是由像素块组成的，所以每一个提供的数组都需要乘以像素块的宽高，以定位到具体位置
  7.     (game_coord as f64) * BLOCK_SIZE
  8. }
  10. pub fn to_coord_u32(game_coord:i32) -> u32 {
  11.     to_coord(game_coord) as u32
  12. }
  14. pub fn draw_block(color:Color,x:i32,y:i32,con:&Context,g: &mut G2d){ // 该方法是画像素块的方法
  15.     let gui_x = to_coord(x);
  16.     let gui_y = to_coord(y);
  18.     rectangle( //rectangle结构体有四个参数 颜色，[x坐标，y坐标,宽度，高度]，绘制方式，画布
  19.         color,
  20.         [gui_x,gui_y,BLOCK_SIZE,BLOCK_SIZE],
  21.         con.transform,
  22.         g,
  23.     );
  24. }
  26. pub fn draw_rectangle(color:Color,x:i32,y:i32,width:i32,height:i32,con:&Context,g:&mut G2d){ //该方法用来画游戏背景
  27.     let x = to_coord(x);
  28.     let y = to_coord(y);
  30.     rectangle(
  31.         color,
  32.         [
  33.             x,
  34.             y,
  35.             BLOCK_SIZE * (width as f64),
  36.             BLOCK_SIZE * (height as f64),
  37.         ],
  38.         con.transform,
  39.         g,
  40.     )
  41. }

Snake.rs

  1. use std::collections::LinkedList; //我们使用链表的数据结构来存储我们的蛇
  2. use piston_window::{Context,G2d};
  3. use piston_window::types::Color;
  4. use crate::draw::draw_block;
  6. const SNAKE_COLOR: Color = [0.00,0.80,0.00,1.0]; //定义蛇的颜色
  7. pub struct Snake {
  8.     direction:Direction, //我们需要蛇在移动的时候的方向
  9.     body:LinkedList<Block>,//用LinkedList来存储蛇的身体，其实就是一个x和y的坐标，我们用Block表示
  10.     tail:Option<Block>,//储存蛇的尾巴，因为吃到苹果后蛇的身体从尾部增加一个所以要记住尾部。因为目前的移动方式是加头去尾的方式开始移动之后就会有值存在这里
  11. }
  12. #[derive(Debug,Clone)]
  13. struct Block {
  14.     x:i32,
  15.     y:i32,
  16. }
  17. #[derive(Copy,Clone,PartialEq)]
  18. pub enum Direction { //我们用枚举来写出四个方向
  19.     Up,
  20.     Down,
  21.     Left,
  22.     Right,
  23. }
  24. impl Direction {
  25.     pub fn opposite(&self) -> Direction { //给方向设置一个方法，即当我们按的方向与当前蛇运行的方向相反时。我们不做任何操作
  26.         match *self {
  27.             Direction::Up => Direction::Down,
  28.             Direction::Down => Direction::Up,
  29.             Direction::Left => Direction::Right,
  30.             Direction::Right => Direction::Left,
  31.         }
  32.     }
  33. }
  35. impl Snake { //给蛇结构体定义方法
  36.     pub fn new(x:i32,y:i32)->Snake { //初始化 蛇的长度是三 
  37.         let mut body:LinkedList<Block> = LinkedList::new();
  38.         body.push_back(Block{ //push_back 向List后方添加元素 push_fornt 向List前方添加元素
  39.             x:x+2,
  40.             y
  41.         });
  42.         body.push_back(Block{
  43.             x:x+1,
  44.             y
  45.         });
  46.         body.push_back(Block{
  47.             x:x,
  48.             y
  49.         });
  51.         Snake{
  52.             direction:Direction::Right,
  53.             body,
  54.             tail:None,
  55.         }
  56.     }
  58.     pub fn draw(&self,con:&Context,g:&mut G2d){ //遍历List 把蛇的每一部分画出来
  59.         for block in &self.body {
  60.             draw_block(SNAKE_COLOR, block.x, block.y, con, g)
  61.         }
  62.     }
  64.     pub fn head_position(&self) -> (i32,i32) {
  65.         let head_block = self.body.front().unwrap(); //取List的头节点 放回一个Result 所以要用upwrap()
  66.         (head_block.x,head_block.y)
  67.     }
  69.     pub fn move_forward(&mut self,dir:Option<Direction>) { //蛇的移动
  70.         match dir { //判断是由调整了方向
  71.             Some(d) => self.direction = d,
  72.             None=>(),
  73.         }
  74.         //移动的策略是向链表的头节点新增一个节点，在尾节点处去除一个节点
  75.         let (head_x,head_y):(i32,i32) = self.head_position();
  76.         //根据移动方向调整新加节点的位置
  77.         let new_block = match self.direction {
  78.             Direction::Up => Block{
  79.                 x:head_x,
  80.                 y:head_y-1,
  81.             },
  82.             Direction::Down => Block{
  83.                 x:head_x,
  84.                 y:head_y+1,
  85.             },
  86.             Direction::Left => Block{
  87.                 x:head_x-1,
  88.                 y:head_y,
  89.             },
  90.             Direction::Right=> Block{
  91.                 x:head_x+1,
  92.                 y:head_y,
  93.             },
  94.         };
  95.         //把新节点添加到链表中
  96.         self.body.push_front(new_block);
  97.         //把尾节点吐出来
  98.         let removed_block = self.body.pop_back().unwrap();
  99.         self.tail = Some(removed_block);
  100.     }
  102.     pub fn head_direction(&self)->Direction {
  103.         self.direction
  104.     }
  105.     //判断蛇头的下一个位置
  106.     pub fn next_head(&self,dir:Option<Direction>) -> (i32,i32) {
  107.         let (head_x,head_y):(i32,i32) = self.head_position();
  109.         let mut moving_dir = self.direction;
  110.         match dir {
  111.             Some(d) => moving_dir =d,
  112.             None => {}
  113.         };
  115.         match moving_dir {
  116.             Direction::Up => (head_x,head_y-1),
  117.             Direction::Down => (head_x,head_y+1),
  118.             Direction::Left => (head_x-1,head_y),
  119.             Direction::Right => (head_x+1,head_y),
  120.         }
  121.     }
  123.     pub fn restore_tail(&mut self){ // 当吃到苹果的时候，把因为移动而去掉的尾巴加回来
  124.         let blk = self.tail.clone().unwrap();
  125.         self.body.push_back(blk);
  126.     }
  127.     //判断下一个位置的蛇头是不是会碰到蛇身体
  128.     pub fn overlap_tail(&self,x:i32,y:i32) -> bool {
  129.         let mut ch = 0;
  130.         for block in &self.body {
  131.             if x == block.x && y == block.y {
  132.                 return true
  133.             }
  135.             ch += 1;
  136.             if ch == self.body.len() -1 {
  137.                 break;
  138.             }
  139.         }
  140.         return false;
  141.     }
  142. }

game.rs

  1. use piston_window::*;
  2. use piston_window::types::Color;
  3. use rand::{thread_rng,Rng};
  4. use crate::snake::{Direction,Snake};
  5. use crate::draw::{draw_block,draw_rectangle};
  6. //设置颜色
  7. const FOOD_COLOR:Color= [0.80,0.00,0.00,1.0];
  8. const BORDER_COLOR:Color= [0.00,0.00,0.00,1.0];
  9. const GAMEOVER_COLOR:Color= [0.90,0.00,0.00,1.0];
  10. //设置速度和重开时间
  11. const MOVING_PERIOD: f64 = 0.1;
  12. const RESTART_TIME:f64 = 1.0;
  13. //Game结构体 
  14. pub struct Game {
  15.     snake:Snake,
  16.     food_exists:bool,
  17.     food_x:i32,
  18.     food_y:i32,
  19.     width:i32,
  20.     height:i32,
  21.     game_over:bool,
  22.     waiting_time:f64,
  23. }
  25. impl Game {
  26.     //初始化Game
  27.     pub fn new(width:i32,height:i32) -> Game {
  28.         Game{
  29.             snake:Snake::new(2,2),
  30.             waiting_time:0.0,
  31.             food_exists:true,
  32.             food_x:6,
  33.             food_y:4,
  34.             width,
  35.             height,
  36.             game_over:false
  37.         }
  38.     }
  39.     //监听键盘 操作
  40.     pub fn key_press(&mut self,key:Key){
  41.         if self.game_over{
  42.             return
  43.         }
  45.         let dir = match key {
  46.             Key::Up => Some(Direction::Up),
  47.             Key::Down => Some(Direction::Down),
  48.             Key::Left => Some(Direction::Left),
  49.             Key::Right => Some(Direction::Right),
  50.             _ => None
  51.         };
  53.         if dir.unwrap() == self.snake.head_direction().opposite() {
  54.             return
  55.         }
  57.         self.update_snake(dir);
  58.     }
  59.     //将蛇 苹果 边框 GameOver都画出来
  60.     pub fn draw(&self,con:&Context,g:&mut G2d){
  61.         self.snake.draw(con, g);
  63.         if self.food_exists {
  64.             draw_block(FOOD_COLOR, self.food_x, self.food_y, con, g);
  65.         }
  66.         //四边边框
  67.         draw_rectangle(BORDER_COLOR,0,0, self.width, 1, con, g);
  68.         draw_rectangle(BORDER_COLOR,0,self.width-1, self.width, 1, con, g);
  69.         draw_rectangle(BORDER_COLOR,0,0, 1, self.height, con, g);
  70.         draw_rectangle(BORDER_COLOR,self.width-1,0, 1, self.height, con, g);
  71.         //GameOver
  72.         if self.game_over {
  73.             draw_rectangle(GAMEOVER_COLOR, 0, 0, self.width, self.height, con, g)
  74.         }
  75.     }
  76.     //检查是否gameover 吃到苹果 以及生么也不操作时候的如何更新
  77.     pub fn update(&mut self,delta_time:f64){
  78.         self.waiting_time += delta_time;
  79.         if self.game_over {
  80.             if self.waiting_time > RESTART_TIME {
  81.                 self.restart();
  82.             }
  83.             return
  84.         }
  86.         if !self.food_exists {
  87.             self.add_food();
  88.             self.update_snake(None);
  89.         }
  91.         if self.waiting_time > MOVING_PERIOD{
  92.             self.update_snake(None);
  93.         }
  94.     }
  96.     //检查是否吃到苹果了
  97.     fn check_eating(&mut self){
  98.         let (head_x,head_y):(i32,i32) = self.snake.head_position();
  99.         if self.food_exists && self.food_y == head_y && self.food_x == head_x {
  100.             self.food_exists = false;
  101.             self.snake.restore_tail();
  102.         }
  103.     }
  104.     //检查蛇是否活着
  105.     fn check_if_snake_alive(&self,dir:Option<Direction>) -> bool {
  106.         let (next_x,next_y) = self.snake.next_head(dir);
  108.         if self.snake.overlap_tail(next_x, next_y) {
  109.             return false;
  110.         }
  112.         next_x > 0 && next_y > 0 && next_x < self.width -1 && next_y < self.height -1 
  113.     }
  114.     //添加随机位置的苹果
  115.     fn add_food(&mut self) {
  116.         let mut rng = thread_rng();
  118.         let mut new_x = rng.gen_range(1..=(self.width - 1));
  119.         let mut new_y = rng.gen_range(1..=(self.height - 1));
  120.         while self.snake.overlap_tail(new_x,new_y) {
  121.             new_x = rng.gen_range(1..=(self.width - 1));
  122.             new_y = rng.gen_range(1..=(self.height - 1));
  123.         }
  125.         self.food_x = new_x;
  126.         self.food_y = new_y;
  127.         self.food_exists = true;
  128.     }
  129.     //更新蛇的位置 同时检查是否吃到苹果
  130.     fn update_snake(&mut self, dir:Option<Direction>) {
  131.         if self.check_if_snake_alive(dir) {
  132.             self.snake.move_forward(dir);
  133.             self.check_eating();
  134.         } else {
  135.             self.game_over = true;
  136.         }
  137.         self.waiting_time = 0.0;
  138.     }
  139.     //重开
  140.     fn restart (&mut self){
  141.         self.snake = Snake::new(2,2);
  142.         self.waiting_time = 0.0;
  143.         self.food_exists = true;
  144.         self.food_x = 6;
  145.         self.food_y = 4;
  146.         self.game_over = false;
  147.     }
  148. }

main.rs

extern crate rand;
extern crate piston_window;

mod draw;
mod snake;
mod game;

use piston_window::*;
use piston_window::types::Color;
use game::Game;
use draw::to_coord_u32;

const BACK_COLOR:Color = [0.5,0.5,0.5,1.0];

fn main() {
    let (width,height) = (30,30);
    //  https://docs.rs/piston_window/latest/piston_window/struct.PistonWindow.html 查看PistonWindow结构体的作用
    let mut window:PistonWindow = WindowSettings::new(
        "Snake",
        [to_coord_u32(width),to_coord_u32(height)],
    ).exit_on_esc(true)
        .build()
        .unwrap();

    let mut game = Game::new(width,height);
    //一直监听事件 一直根据arg.dt的时间更新 
    while let Some(event) = window.next() {
        if let Some(Button::Keyboard(key)) = event.press_args() {
            game.key_press(key);
        }
        window.draw_2d(&event, |c,g,_|{
            clear(BACK_COLOR, g);
            game.draw(&c, g);
        });

        event.update(|arg| {
            game.update(arg.dt)
        });
    }
}