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

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

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;
 }
}

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;
 }
}

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;
 }
}

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(), //主页面
 );
 }
}

 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);
 }

 @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(),
 ],
 ),
 );
 }

 //游戏地图区域
 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));
  }));
 }),
 ),
 ));
 }

//开始生成迷宫地图
 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]);
 }
 }
 }
 }

//自动解迷宫（提示功能）
 //从起点位置开始（使用递归的方式）求解迷宫，如果求解成功则返回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;
 }

//控制玩家角色移动
 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();
  },
  )
 ],
 );
 });
 }
 }