Flutter随机迷宫生成和解迷宫小游戏功能的源码

此博客旨在帮助大家更好的了解图的遍历算法，通过flutter移动端平台将图的遍历算法运用在迷宫生成和解迷宫上，让算法变成可视化且可以进行交互，最终做成一个可进行随机迷宫生成和解迷宫的app小游戏。本人是应届毕业生，希望能与大家一起讨论和学习～

注：由于这是本人第一次写博客，难免排版或用词上有所欠缺，请大家多多包涵。
注：如需转载文章，请注明出处，谢谢。

一、项目介绍：

1.概述
项目名：方块迷宫
作者：沫小亮。
编程框架与语言：flutter&dart
开发环境：android studio 3.6.2
学习参考：慕课网-看得见的算法
项目完整源码地址：（待更新）
游戏截图：

2.迷宫生成原理
1.采用图的遍历进行迷宫生成，其本质就是生成一棵树，树中每个节点只能访问一次，且每个节点之间没有环路（迷宫的正确路径只有一条）。
2.初始化：设置起点和终点位置，并给所有行坐标为奇数且列坐标为奇数的位置设置为路。其余位置设置为墙。（坐标从0…开始算）

（如下图，蓝色位置为墙，橙色位置为路，橙色线条为可能即将打通的路，此图来源于慕课网-看得见的算法）

3.在遍历过程中，不断遍历每个位置，同时遍历过的位置设为已访问位置，结合迷宫生成算法（见迷宫特点第6点）让相邻某个墙变成路，使之路径联通。直至所有位置都遍历完成则迷宫生成结束（每个节点只能遍历一次）。

（如下图，蓝色位置为墙，橙色位置为路，橙色线条为可能即将打通的路，此图来源于慕课网-看得见的算法）

3.迷宫特点（可根据需求自行扩展）
1.迷宫只有一个起点、一个终点，且起点和终点的位置固定。
2.迷宫的正确路径只有一条。
3.迷宫的正确路径是连续的。
4.迷宫地图是正方形，且方块行数和列数都为奇数。
5.迷宫中每个方块占用一个单元格。
6.迷宫生成算法：图的深度优先遍历和广度优先遍历相结合 + 随机队列（入队和出队随机在队头或队尾）+ 随机方向遍历顺序（提高迷宫的随机性）。
7.迷宫自动求解算法：图的深度优先遍历（递归方法）。

4.玩法介绍（可根据需求自行扩展）
1.游戏共设置有10个关卡，到达终点可以进入下一关，随着关卡数的增加，迷宫地图大小（方块数）增加，但限定时间也会增加。
2.点击方向键可对玩家角色的位置进行控制。
2.每个关卡都有限定时间，超过限定时间仍未到达终点则闯关失败，可从本关继续挑战。
3.每个关卡都可以使用一次提示功能，可展示2秒的正确路径，便于小白玩家入门。
4. 颜色对应：
蓝灰色方块->墙（不可经过）
蓝色方块->玩家角色（可控制移动）
白色方块->路（可经过）
深橘色->终点（通关）
橙色->正确路径（提示功能）

二、项目源码（主要部分）：

pubspec.yaml //flutter配置清单

dependencies:
 flutter:
 sdk: flutter
 //toast库
 fluttertoast: ^3.1.3
 //cupertino主题图标集
 cupertino_icons: ^0.1.2

maze_game_model.dart //迷宫游戏数据层

class mazegamemodel {
 int _rowsum; //迷宫行数
 int _columnsum; //迷宫列数
 int _startx, _starty; //迷宫入口坐标（[startx,starty]）
 int _endx, _endy; //迷宫出口坐标（[endx,endy]）
 static final int map_road = 1; //1代表路
 static final int map_wall = 0; //0代表墙
 list<list<int>> mazemap; //迷宫地形（1代表路，0代表墙）
 list<list<bool>> visited; //是否已经访问过
 list<list<bool>> path; //是否是正确解的路径
 list<list<int>> direction = [
 [-1, 0],
 [0, 1],
 [1, 0],
 [0, -1]
 ]; //迷宫遍历的方向顺序（迷宫趋势）
 int spendstepsum = 0; //求解的总步数
 int successsteplength = 0; //正确路径长度
 int playerx, playery; //当前玩家坐标

 mazegamemodel(int rowsum, int columnsum) {
 if (rowsum % 2 == 0 || columnsum % 2 == 0) {
 throw "model_this->迷宫行数和列数不能为偶数";
 }
 this._rowsum = rowsum;
 this._columnsum = columnsum;
 mazemap = new list<list<int>>();
 visited = new list<list<bool>>();
 path = new list<list<bool>>();

 //初始化迷宫起点与终点坐标
 _startx = 1;
 _starty = 0;
 _endx = rowsum - 2;
 _endy = columnsum - 1;

 //初始化玩家坐标
 playerx = _startx;
 playery = _starty;

 //初始化迷宫遍历的方向（上、左、右、下）顺序（迷宫趋势）
 //随机遍历顺序，提高迷宫生成的随机性（共12种可能性）
 for (int i = 0; i < direction.length; i++) {
 int random = random().nextint(direction.length);
 list<int> temp = direction[random];
 direction[random] = direction[i];
 direction[i] = temp;
 }

 //初始化迷宫地图
 for (int i = 0; i < rowsum; i++) {
 list<int> mazemaplist = new list();
 list<bool> visitedlist = new list();
 list<bool> pathlist = new list();

 for (int j = 0; j < columnsum; j++) {
 //行和列都为基数则设置为路，否则设置为墙
 if (i % 2 == 1 && j % 2 == 1) {
 mazemaplist.add(1); //设置为路
 } else {
 mazemaplist.add(0); //设置为墙
 }
 visitedlist.add(false);
 pathlist.add(false);
 }
 mazemap.add(mazemaplist);
 visited.add(visitedlist);
 path.add(pathlist);
 }
 //初始化迷宫起点与终点位置
 mazemap[_startx][_starty] = 1;
 mazemap[_endx][_endy] = 1;
 }

 //返回迷宫行数
 int getrowsum() {
 return _rowsum;
 }

 //返回迷宫列数
 int getcolumnsum() {
 return _columnsum;
 }

 //返回迷宫入口x坐标
 int getstartx() {
 return _startx;
 }

 //返回迷宫入口y坐标
 int getstarty() {
 return _starty;
 }

 //返回迷宫出口x坐标
 int getendx() {
 return _endx;
 }

 //返回迷宫出口y坐标
 int getendy() {
 return _endy;
 }

 //判断[i][j]是否在迷宫地图内
 bool isinarea(int i, int j) {
 return i >= 0 && i < _rowsum && j >= 0 && j < _columnsum;
 }
}

position.dart //位置类（实体类）
注：x对应二维数组中的行下标，y对应二维数组中的列下标(往后也是)

class position extends linkedlistentry<position>{
 int _x, _y; //x对应二维数组中的行下标，y对应二维数组中的列下标
 position _preposition; //存储上一个位置
 
 position(int x, int y, { position preposition = null } ) {
 this._x = x;
 this._y = y;
 this._preposition = preposition;
 }

 //返回x坐标（）
 int getx() {
 return _x;
 }

 //返回y坐标（）
 int gety() {
 return _y;
 }

 //返回上一个位置
 position getpreposition() {
 return _preposition;
 }
}

random_queue.dart //随机队列
入队：头部或尾部（各50%的概率）
出队：头部或尾部（各50%的概率）
底层数据结构：linkedlist

class randomqueue {
 linkedlist<position> _queue;

 randomqueue(){
 _queue = new linkedlist();
 }

 //往随机队列里添加一个元素
 void addrandom(position position) {
 if (random().nextint(100) < 50) {
 //从头部添加
 _queue.addfirst(position);
 }
 //从尾部添加 
 else {
 _queue.add(position);
 }
 }
 
 //返回随机队列中的一个元素
 position removerandom() {
 if (_queue.length == 0) {
 throw "数组元素为空";
 }
 if (random().nextint(100) < 50) {
 //从头部移除
 position position = _queue.first;
 _queue.remove(position);
 return position;
 } else {
 //从尾部移除
 position position = _queue.last;
 _queue.remove(position);
 return position;
 }
 }

 //返回随机队列元素数量
 int getsize() {
 return _queue.length;
 }

 //判断随机队列是否为空
 bool isempty() {
 return _queue.length == 0;
 }
}

main.dart //迷宫游戏视图层和控制层

1. app全局设置

void main() => runapp(myapp());

class myapp extends statelesswidget {
 @override
 widget build(buildcontext context) {
 if (platform.isandroid) {
 // 以下两行 设置android状态栏为透明的沉浸。写在组件渲染之后，是为了在渲染后进行set赋值，覆盖状态栏，写在渲染之前materialapp组件会覆盖掉这个值。
 systemuioverlaystyle systemuioverlaystyle = systemuioverlaystyle(statusbarcolor: colors.transparent);
 systemchrome.setsystemuioverlaystyle(systemuioverlaystyle);
 }
 return materialapp(
 title: '方块迷宫', //应用名
 theme: themedata(
 primaryswatch: colors.blue, //主题色
 ),
 debugshowcheckedmodebanner: false, //不显示debug标志
 home: myhomepage(), //主页面
 );
 }
}

2.界面初始化

 class myhomepage extends statefulwidget {
 myhomepage({key key}) : super(key: key);

 @override
 _myhomepagestate createstate() => _myhomepagestate();
}

class _myhomepagestate extends state<myhomepage> {
 int gamewidth, gameheight; //游戏地图宽度和高度
 double itemwidth, itemheight; //每个小方块的宽度和高度
 int level = 1;  //当前关卡数（共10关）
 int rowsum = 15; //游戏地图行数
 int columnsum = 15; //游戏地图列数
 int surplustime; //游戏剩余时间
 bool istip = false; //是否使用提示功能
 timer timer;  //计时器
 mazegamemodel _model; //迷宫游戏数据层

 //初始化状态
 @override
 void initstate() {
 super.initstate();
 _model = new mazegamemodel(rowsum, columnsum);

 //新建一个事件循环队列，确保不堵塞主线程
 new future(() {
 //生成一个迷宫
 _dogenerator(_model.getstartx(), _model.getstarty() + 1);
 });

 //设置倒计时
 _setsurplustime(level);
 }

3.界面整体结构

 @override
 widget build(buildcontext context) {
 //获取手机屏幕宽度，并让屏幕高度等于屏幕宽度（确保形成正方形迷宫区域）
 //结果向下取整，避免出现实际地图宽度大于手机屏幕宽度的情况
 gameheight = gamewidth = mediaquery.of(context).size.width.floor();
 //每一个小方块的宽度和长度（屏幕宽度/列数）
 itemheight = itemwidth = (gamewidth / columnsum);
 return scaffold(
 appbar: preferredsize(
 //设置标题栏高度
 preferredsize: size.fromheight(40),
 //标题栏区域
 child: _appbarwidget()),
 body: listview(
 children: <widget>[
 //游戏地图区域
 _gamemapwidget(),
 //游戏提示与操作栏区域
 _gametipwidget(),
 //游戏方向控制区域
 _gamecontrolwidget(),
 ],
 ),
 );
 }

4.游戏地图区域

注：由于游戏提示与操作栏区域、游戏方向键控制区域不是本文章要讲的重点，故不详细介绍，有兴趣的朋友可以到完整项目源码地址中查看。

 //游戏地图区域
 widget _gamemapwidget(){
 return container(
 width: gameheight.todouble(),
 height: gameheight.todouble(),
 color: colors.white,
 child: center(
 //可堆叠布局（配合positioned绝对布局使用）
 child: stack(
 //按行遍历
 children: list.generate(_model.mazemap.length, (i) {
 return stack(
 //按列遍历
  children: list.generate(_model.mazemap[i].length, (j) {
  //绝对布局
  return positioned(
  //每个方块的位置
  left: j * itemwidth.todouble(),
  top: i * itemheight.todouble(),
  //每个方块的大小和颜色
  child: container(
  width: itemwidth.todouble(),
  height: itemheight.todouble(),
  //位于顶层的颜色应放在前面进行判断，避免被其他颜色覆盖
  //墙->蓝灰色
  //路->白色
  //玩家角色->蓝色
  //迷宫终点-> 深橘色
  //迷宫正确路径->橙色
  color: _model.mazemap[i][j] == 0
  ? colors.bluegrey
  : (_model.playerx == i && _model.playery == j)
  ? colors.blue
  : (_model.getendx() == i && _model.getendy() == j)
  ? colors.deeporange
  : _model.path[i][j] ? colors.orange : colors.white));
  }));
 }),
 ),
 ));
 }

5.生成迷宫

//开始生成迷宫地图
 void _dogenerator(int x, int y) {
 randomqueue queue = new randomqueue();
 //设置起点
 position start = new position(x, y);
 //入队
 queue.addrandom(start);
 _model.visited[start.getx()][start.gety()] = true;
 while (queue.getsize() != 0) {
 //出队
 position curposition = queue.removerandom();
 //对上、下、左、右四个方向进行遍历，并获得一个新位置
 for (int i = 0; i < 4; i++) {
 int newx = curposition.getx() + _model.direction[i][0] * 2;
 int newy = curposition.gety() + _model.direction[i][1] * 2;
 //如果新位置在地图范围内且该位置没有被访问过
 if (_model.isinarea(newx, newy) && !_model.visited[newx][newy]) {
 //入队
 queue.addrandom(new position(newx, newy, preposition: curposition));
 //设置该位置为已访问
 _model.visited[newx][newy] = true;
 //设置该位置为路
 _setmodelwithroad(curposition.getx() + _model.direction[i][0], curposition.gety() + _model.direction[i][1]);
 }
 }
 }
 }

6.自动解迷宫（提示功能）

//自动解迷宫（提示功能）
 //从起点位置开始（使用递归的方式）求解迷宫，如果求解成功则返回true,否则返回false
 bool _dosolver(int x, int y) {
 if (!_model.isinarea(x, y)) {
 throw "坐标越界";
 }
 //设置已访问
 _model.visited[x][y] = true;
 //设置该位置为正确路径
 _setmodelwithpath(x, y, true);

 //如果该位置为终点位置，则返回true
 if (x == _model.getendx() && y == _model.getendy()) {
 return true;
 }
 //对四个方向进行遍历，并获得一个新位置
 for (int i = 0; i < 4; i++) {
 int newx = x + _model.direction[i][0];
 int newy = y + _model.direction[i][1];
 //如果该位置在地图范围内，且该位置为路，且该位置没有被访问过，则继续从该点开始递归求解
 if (_model.isinarea(newx, newy) &&
 _model.mazemap[newx][newy] == mazegamemodel.map_road &&
 !_model.visited[newx][newy]) {
 if (_dosolver(newx, newy)) {
 return true;
 }
 }
 }
 
 //如果该位置不是正确的路径，则将该位置设置为非正确路径所途径的位置
 _setmodelwithpath(x, y, false);
 return false;
 }

7.控制玩家角色移动

移动到新位置

//控制玩家角色移动
 void _doplayermove(string direction) {
 switch (direction) {
 case "上":
 //如果待移动的目标位置在迷宫地图内，且该位置是路，则进行移动
 if (_model.isinarea(_model.playerx - 1, _model.playery) && _model.mazemap[_model.playerx - 1][_model.playery] == 1) {
 setstate(() {
 _model.playerx--;
 });
 }
 break;
//省略其他三个方向的代码

玩家到达终点位置

//如果玩家角色到达终点位置
if (_model.playerx == _model.getendx() && _model.playery == _model.getendy()) {
 istip = false; //刷新可提示次数
 timer.cancel(); //取消倒计时
 //如果当前关是第10关
 if (level == 10) {
 showdialog(
 barrierdismissible: false,
 context: context,
 builder: (buildcontext context) {
 return alertdialog(
 content: text("骚年,你已成功挑战10关，我看你骨骼惊奇，适合玩迷宫（狗头"),
 actions: <widget>[
  new flatbutton(
  child: new text('继续挑战第10关(新地图)', style: textstyle(fontsize: 16)),
  onpressed: () {
  setstate(() {
  _model.playerx = _model.getstartx();
  _model.playery = _model.getstarty();
  });
  //重新初始化数据
  _model = new mazegamemodel(rowsum, columnsum);
  //生成迷宫和设置倒计时
  _dogenerator(_model.getstartx(), _model.getstarty() + 1);
  _setsurplustime(level);
  navigator.of(context).pop();
  },
  )
 ],
 );
 });
 }
 //如果当前关不是第10关
 else {
 showdialog(
 barrierdismissible: false,
 context: context,
 builder: (buildcontext context) {
 return alertdialog(
 content: text("恭喜闯关成功"),
 actions: <widget>[
  new flatbutton(
  child: new text('挑战下一关', style: textstyle(fontsize: 16)),
  onpressed: () {
  setstate(() {
  //关卡数+1，玩家角色回到起点
  level++;
  _model.playerx = _model.getstartx();
  _model.playery = _model.getstarty();
  });
  //重新初始化数据
  _model = new mazegamemodel(rowsum = rowsum + 4, columnsum = columnsum + 4);
  //生成迷宫和设置倒计时
  _dogenerator(_model.getstartx(), _model.getstarty() + 1);
  _setsurplustime(level);
  navigator.of(context).pop();
  },
  )
 ],
 );
 });
 }
 }

注：其他与控制逻辑相关的方法不在此文中详细介绍，有兴趣的朋友可以到完整项目源码地址中浏览。

总结

到此这篇关于flutter随机迷宫生成和解迷宫小游戏功能的源码的文章就介绍到这了,更多相关flutter迷宫小游戏内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！