完成所有功能设计

lib/GamePage.dart

@@ -38,83 +38,115 @@ class GamePageState extends State<GamePage> {
     width = MediaQuery.of(context).size.width * 0.8;
     return Scaffold(
       appBar: AppBar(
+        elevation: 0,
         backgroundColor: _themeFactory!.getTheme().getThemeColor(),
         title: Text("南瓜五子棋"),
         actions: [
           IconButton(
               onPressed: () {
-                if(_viewModel.undo()){
+                if (_viewModel.undo()) {
                   _originator.undo();
+                  Ai.getInstance().init();
+                  for (Position po in _originator.state) {
+                    Ai.getInstance().addChessman(po.dx ~/ (width / 15),
+                        po.dy ~/ (width / 15), po.chess is WhiteChess ? 1 : -1);
+                  }
                   setState(() {});
-                }else{
+                } else {
                   TipsDialog.show(context, "提示", "现阶段不能悔棋");
                 }
               },
-              icon: Icon(Icons.undo))
+              icon: Icon(Icons.undo)),
+          IconButton(
+              onPressed: () {
+                TipsDialog.showByChoose(context, "提示", "是否要投降并重新开局？","是","否",(value){
+                  if(value){
+                    setState(() {
+                      ChessPainter._position = null;
+                      _originator.clean();
+                      _viewModel.reset();
+                      Ai.getInstance().init();
+                    });
+                  }
+                  Navigator.pop(context);
+                });
+              },
+              icon: Icon(Icons.sports_handball)),
+          IconButton(
+              onPressed: () {
+                TipsDialog.showByChoose(context, "提示", "是否重新开局？","是","否",(value){
+                  if(value){
+                    setState(() {
+                      ChessPainter._position = null;
+                      _originator.clean();
+                      _viewModel.reset();
+                      Ai.getInstance().init();
+                    });
+                  }
+                  Navigator.pop(context);
+                });
+              },
+              icon: Icon(Icons.restart_alt)),
         ],
       ),
-      body: ListView(
-        children: [
-          Center(
-            child: Column(
-                mainAxisAlignment: MainAxisAlignment.center,
-                crossAxisAlignment: CrossAxisAlignment.center,
-                mainAxisSize: MainAxisSize.max,
-                children: <Widget>[
-                  Padding(
-                    padding: EdgeInsets.only(bottom: 15.0),
-                    child: CupertinoButton.filled(
-                        padding: EdgeInsets.all(0.0),
-                        child: Text("重置棋盘"),
-                        onPressed: () {
+      body: Container(
+        decoration: new BoxDecoration(
+            gradient: new LinearGradient(
+                colors: [
+                  _themeFactory!.getTheme().getThemeColor(),
+                  Colors.white,
+                ],
+                stops: [
+                  0.0,
+                  1
+                ],
+                begin: FractionalOffset.topCenter,
+                end: FractionalOffset.bottomCenter,
+                tileMode: TileMode.repeated)),
+        child: ListView(
+          children: [
+            Center(
+              child: Column(
+                  mainAxisAlignment: MainAxisAlignment.center,
+                  crossAxisAlignment: CrossAxisAlignment.center,
+                  mainAxisSize: MainAxisSize.max,
+                  children: <Widget>[
+                    Padding (
+                      padding: EdgeInsets.only(top:14,bottom: 30),
+                      child: Text(_viewModel.state,style: TextStyle(color: Colors.white),),
+                    ),
+                    GestureDetector(
+                        onTapDown: (topDownDetails) {
+                          var position = topDownDetails.localPosition;
+                          Chess chess = _viewModel.play();
                           setState(() {
-                            ChessPainter._position = null;
-                            _originator.clean();
-                            Ai.getInstance().init();
-                            // blackChess = null;
+                            ChessPainter._position =
+                                Position(position.dx, position.dy, chess);
                           });
-                        }),
-                  ),
-                  Padding(
-                    padding: EdgeInsets.only(bottom: 15.0),
-                    child: CupertinoButton.filled(
-                        padding: EdgeInsets.all(0.0),
-                        child: Text("Ai下棋"),
-                        onPressed: () {
-                          turnAi();
-                          // blackChess = null;
-                        }),
-                  ),
-                  GestureDetector(
-                      onTapDown: (topDownDetails) {
-                        var position = topDownDetails.localPosition;
-                        Chess chess = _viewModel.play();
-                        setState(() {
-                          ChessPainter._position =
-                              Position(position.dx, position.dy, chess);
-                        });
-                      },
-                      child: Stack(
-                        children: [
-                          CustomPaint(
-                            size: Size(width, width),
-                            painter: CheckerBoardPainter(),
-                          ),
-                          CustomPaint(
-                            size: Size(width, width),
-                            painter: ChessPainter(turnAi),
-                          )
-                        ],
-                      ))
-                ]),
-          ),
-        ],
+                        },
+                        child: Stack(
+                          children: [
+                            CustomPaint(
+                              size: Size(width, width),
+                              painter: CheckerBoardPainter(),
+                            ),
+                            CustomPaint(
+                              size: Size(width, width),
+                              painter: ChessPainter(turnAi),
+                            )
+                          ],
+                        ))
+                  ]),
+            ),
+          ],
+        ),
       ),
     );
   }
 
   /// Ai 下棋
   void turnAi() {
+    // print("Ai下棋");
     if (ChessPainter._position!.chess is WhiteChess &&
         Ai.getInstance().isWin(ChessPainter._position!.dx ~/ (width / 15),
             ChessPainter._position!.dy ~/ (width / 15), 1)) {
@@ -227,8 +259,7 @@ class CheckerBoardPainter extends CustomPainter {
     var mPaint = Paint();
 
     _crossOverBeanList.clear();
-    canvas.drawColor(
-        CupertinoColors.systemGrey, BlendMode.colorBurn); //重绘下整个界面的画布北京颜色
+    //重绘下整个界面的画布北京颜色
     //设置画笔，画棋盘背景
     mPaint
       ..isAntiAlias = true //抗锯齿

lib/ai/Ai.dart

@@ -1,4 +1,3 @@
-
 //下棋业务核心类，与界面棋盘对应，业务放在这里，可以和界面代码分离
 import 'dart:core';
 
@@ -8,28 +7,31 @@ import 'package:gobang/bridge/ChessShape.dart';
 import 'package:gobang/flyweight/ChessFlyweightFactory.dart';
 import 'package:gobang/flyweight/Position.dart';
 
-class Ai{
-
+class Ai {
   Ai._();
 
   static Ai? _ai;
 
-  static Ai getInstance(){
-    if(_ai==null){
+  static Ai getInstance() {
+    if (_ai == null) {
       _ai = Ai._();
     }
     return _ai!;
   }
 
   static var CHESSBOARD_SIZE = 15;
-  static var FIRST = 1;//先手，-1表示机器，1表示人类，与Position类中的对应
-  var chessboard = List.generate(CHESSBOARD_SIZE, (i) => List.filled(CHESSBOARD_SIZE, 0, growable: false), growable: false);//与界面棋盘对应，0代表空，-1代表机器，1代表人类
-  var score = List.generate(CHESSBOARD_SIZE, (i) => List.filled(CHESSBOARD_SIZE, 0, growable: false), growable: false);//每个位置得分
-
-  void init(){
-    FIRST = 1;//默认人类先手
-    for(int i = 0; i  < CHESSBOARD_SIZE; i++){
-      for(int j = 0; j < CHESSBOARD_SIZE; j++){
+  static var FIRST = 1; //先手，-1表示机器，1表示人类，与Position类中的对应
+  var chessboard = List.generate(
+      CHESSBOARD_SIZE, (i) => List.filled(CHESSBOARD_SIZE, 0, growable: false),
+      growable: false); //与界面棋盘对应，0代表空，-1代表机器，1代表人类
+  var score = List.generate(
+      CHESSBOARD_SIZE, (i) => List.filled(CHESSBOARD_SIZE, 0, growable: false),
+      growable: false); //每个位置得分
+
+  void init() {
+    FIRST = 1; //默认人类先手
+    for (int i = 0; i < CHESSBOARD_SIZE; i++) {
+      for (int j = 0; j < CHESSBOARD_SIZE; j++) {
         chessboard[i][j] = 0;
         score[i][j] = 0;
       }
@@ -37,332 +39,371 @@ class Ai{
   }
 
   //落子
-  void addChessman(int x, int y, int owner){
+  void addChessman(int x, int y, int owner) {
     chessboard[x][y] = owner;
-    print("$x,$y,$owner");
   }
 
   //判断落子位置是否合法
-  bool isLegal(int x, int y){
-    if(x >=0 && x < CHESSBOARD_SIZE && y >= 0 && y < CHESSBOARD_SIZE && chessboard[x][y] == 0){
+  bool isLegal(int x, int y) {
+    if (x >= 0 &&
+        x < CHESSBOARD_SIZE &&
+        y >= 0 &&
+        y < CHESSBOARD_SIZE &&
+        chessboard[x][y] == 0) {
       return true;
     }
     return false;
   }
 
   //判断哪方赢了（必定有刚落的子引发，因此只需判断刚落子的周围），owner为-1代表机器，owner为1代表人类
-  bool isWin(int x, int y, int owner){
+  bool isWin(int x, int y, int owner) {
     int sum = 0;
     //判断横向左边
-    for(int i = x - 1; i >= 0; i--){
-      if(chessboard[i][y] == owner){sum++;}
-      else{break;}
+    for (int i = x - 1; i >= 0; i--) {
+      if (chessboard[i][y] == owner) {
+        sum++;
+      } else {
+        break;
+      }
     }
     //判断横向右边
-    for(int i = x + 1; i < CHESSBOARD_SIZE; i++){
-      if(chessboard[i][y] == owner){sum++;}
-      else{break;}
+    for (int i = x + 1; i < CHESSBOARD_SIZE; i++) {
+      if (chessboard[i][y] == owner) {
+        sum++;
+      } else {
+        break;
+      }
+    }
+    if (sum >= 4) {
+      return true;
     }
-    if(sum >= 4) {return true;}
 
     sum = 0;
     //判断纵向上边
-    for(int i = y - 1; i >= 0; i--){
-      if(chessboard[x][i] == owner){sum++;}
-      else{break;}
+    for (int i = y - 1; i >= 0; i--) {
+      if (chessboard[x][i] == owner) {
+        sum++;
+      } else {
+        break;
+      }
     }
     //判断纵向下边
-    for(int i = y + 1; i < CHESSBOARD_SIZE; i++){
-      if(chessboard[x][i] == owner){sum++;}
-      else{break;}
+    for (int i = y + 1; i < CHESSBOARD_SIZE; i++) {
+      if (chessboard[x][i] == owner) {
+        sum++;
+      } else {
+        break;
+      }
+    }
+    if (sum >= 4) {
+      return true;
     }
-    if(sum >= 4) {return true;}
 
     sum = 0;
     //判断左上角到右下角方向上侧
-    for(int i = x - 1, j = y - 1; i >= 0 && j >= 0; i--, j-- ){
-      if(chessboard[i][j] == owner){sum++;}
-      else{break;}
+    for (int i = x - 1, j = y - 1; i >= 0 && j >= 0; i--, j--) {
+      if (chessboard[i][j] == owner) {
+        sum++;
+      } else {
+        break;
+      }
     }
     //判断左上角到右下角方向下侧
-    for(int i = x + 1, j = y + 1; i < CHESSBOARD_SIZE && j < CHESSBOARD_SIZE; i++, j++ ){
-      if(chessboard[i][j] == owner){sum++;}
-      else{break;}
+    for (int i = x + 1, j = y + 1;
+        i < CHESSBOARD_SIZE && j < CHESSBOARD_SIZE;
+        i++, j++) {
+      if (chessboard[i][j] == owner) {
+        sum++;
+      } else {
+        break;
+      }
+    }
+    if (sum >= 4) {
+      return true;
     }
-    if(sum >= 4) {return true;}
 
     sum = 0;
     //判断右上角到左下角方向上侧
-    for(int i = x + 1, j = y - 1; i < CHESSBOARD_SIZE && j >= 0; i++, j-- ){
-      if(chessboard[i][j] == owner){sum++;}
-      else{break;}
+    for (int i = x + 1, j = y - 1; i < CHESSBOARD_SIZE && j >= 0; i++, j--) {
+      if (chessboard[i][j] == owner) {
+        sum++;
+      } else {
+        break;
+      }
     }
     //判断右上角到左下角方向下侧
-    for(int i = x - 1, j = y + 1; i >= 0 && j < CHESSBOARD_SIZE; i--, j++ ){
-      if(chessboard[i][j] == owner){sum++;}
-      else{break;}
+    for (int i = x - 1, j = y + 1; i >= 0 && j < CHESSBOARD_SIZE; i--, j++) {
+      if (chessboard[i][j] == owner) {
+        sum++;
+      } else {
+        break;
+      }
+    }
+    if (sum >= 4) {
+      return true;
     }
-    if(sum >= 4) {return true;}
 
     return false;
-
   }
 
-
   //【【【【【*******整个游戏的核心*******】】】】】______确定机器落子位置
   //使用五元组评分算法，该算法参考博客地址：https://blog.csdn.net/u011587401/article/details/50877828
   //算法思路：对15X15的572个五元组分别评分，一个五元组的得分就是该五元组为其中每个位置贡献的分数，
   //	   一个位置的分数就是其所在所有五元组分数之和。所有空位置中分数最高的那个位置就是落子位置。
-  Position searchPosition(){
+  Position searchPosition() {
     //每次都初始化下score评分数组
-    for(int i = 0; i  < CHESSBOARD_SIZE; i++){
-      for(int j = 0; j < CHESSBOARD_SIZE; j++){
+    for (int i = 0; i < CHESSBOARD_SIZE; i++) {
+      for (int j = 0; j < CHESSBOARD_SIZE; j++) {
         score[i][j] = 0;
       }
     }
 
     //每次机器找寻落子位置，评分都重新算一遍（虽然算了很多多余的，因为上次落子时候算的大多都没变）
     //先定义一些变量
-    int humanChessmanNum = 0;//五元组中的黑棋数量
-    int machineChessmanNum = 0;//五元组中的白棋数量
-    int tupleScoreTmp = 0;//五元组得分临时变量
+    int humanChessmanNum = 0; //五元组中的黑棋数量
+    int machineChessmanNum = 0; //五元组中的白棋数量
+    int tupleScoreTmp = 0; //五元组得分临时变量
 
-    int goalX = -1;//目标位置x坐标
-    int goalY = -1;//目标位置y坐标
-    int maxScore = -1;//最大分数
+    int goalX = -1; //目标位置x坐标
+    int goalY = -1; //目标位置y坐标
+    int maxScore = -1; //最大分数
 
     //1.扫描横向的15个行
-    for(int i = 0; i < 15; i++){
-      for(int j = 0; j < 11; j++){
+    for (int i = 0; i < 15; i++) {
+      for (int j = 0; j < 11; j++) {
         int k = j;
-        while(k < j + 5){
-
-          if(chessboard[i][k] == -1) machineChessmanNum++;
-          else if(chessboard[i][k] == 1)humanChessmanNum++;
+        while (k < j + 5) {
+          if (chessboard[i][k] == -1)
+            machineChessmanNum++;
+          else if (chessboard[i][k] == 1) humanChessmanNum++;
 
           k++;
         }
         tupleScoreTmp = tupleScore(humanChessmanNum, machineChessmanNum);
         //为该五元组的每个位置添加分数
-        for(k = j; k < j + 5; k++){
+        for (k = j; k < j + 5; k++) {
           score[i][k] += tupleScoreTmp;
         }
         //置零
-        humanChessmanNum = 0;//五元组中的黑棋数量
-        machineChessmanNum = 0;//五元组中的白棋数量
-        tupleScoreTmp = 0;//五元组得分临时变量
+        humanChessmanNum = 0; //五元组中的黑棋数量
+        machineChessmanNum = 0; //五元组中的白棋数量
+        tupleScoreTmp = 0; //五元组得分临时变量
       }
     }
 
     //2.扫描纵向15行
-    for(int i = 0; i < 15; i++){
-      for(int j = 0; j < 11; j++){
+    for (int i = 0; i < 15; i++) {
+      for (int j = 0; j < 11; j++) {
         int k = j;
-        while(k < j + 5){
-          if(chessboard[k][i] == -1) machineChessmanNum++;
-          else if(chessboard[k][i] == 1)humanChessmanNum++;
+        while (k < j + 5) {
+          if (chessboard[k][i] == -1)
+            machineChessmanNum++;
+          else if (chessboard[k][i] == 1) humanChessmanNum++;
 
           k++;
         }
         tupleScoreTmp = tupleScore(humanChessmanNum, machineChessmanNum);
         //为该五元组的每个位置添加分数
-        for(k = j; k < j + 5; k++){
+        for (k = j; k < j + 5; k++) {
           score[k][i] += tupleScoreTmp;
         }
         //置零
-        humanChessmanNum = 0;//五元组中的黑棋数量
-        machineChessmanNum = 0;//五元组中的白棋数量
-        tupleScoreTmp = 0;//五元组得分临时变量
+        humanChessmanNum = 0; //五元组中的黑棋数量
+        machineChessmanNum = 0; //五元组中的白棋数量
+        tupleScoreTmp = 0; //五元组得分临时变量
       }
     }
 
     //3.扫描右上角到左下角上侧部分
-    for(int i = 14; i >= 4; i--){
-      for(int k = i, j = 0; j < 15 && k >= 0; j++, k--){
+    for (int i = 14; i >= 4; i--) {
+      for (int k = i, j = 0; j < 15 && k >= 0; j++, k--) {
         int m = k;
         int n = j;
-        while(m > k - 5 && k - 5 >= -1){
-          if(chessboard[m][n] == -1) machineChessmanNum++;
-          else if(chessboard[m][n] == 1)humanChessmanNum++;
+        while (m > k - 5 && k - 5 >= -1) {
+          if (chessboard[m][n] == -1)
+            machineChessmanNum++;
+          else if (chessboard[m][n] == 1) humanChessmanNum++;
 
           m--;
           n++;
         }
         //注意斜向判断的时候，可能构不成五元组（靠近四个角落），遇到这种情况要忽略掉
-        if(m == k-5){
+        if (m == k - 5) {
           tupleScoreTmp = tupleScore(humanChessmanNum, machineChessmanNum);
           //为该五元组的每个位置添加分数
           m = k;
           n = j;
-          for(; m > k - 5 ; m--, n++){
+          for (; m > k - 5; m--, n++) {
             score[m][n] += tupleScoreTmp;
           }
         }
 
         //置零
-        humanChessmanNum = 0;//五元组中的黑棋数量
-        machineChessmanNum = 0;//五元组中的白棋数量
-        tupleScoreTmp = 0;//五元组得分临时变量
+        humanChessmanNum = 0; //五元组中的黑棋数量
+        machineChessmanNum = 0; //五元组中的白棋数量
+        tupleScoreTmp = 0; //五元组得分临时变量
 
       }
     }
 
     //4.扫描右上角到左下角下侧部分
-    for(int i = 1; i < 15; i++){
-      for(int k = i, j = 14; j >= 0 && k < 15; j--, k++){
+    for (int i = 1; i < 15; i++) {
+      for (int k = i, j = 14; j >= 0 && k < 15; j--, k++) {
         int m = k;
         int n = j;
-        while(m < k + 5 && k + 5 <= 15){
-          if(chessboard[n][m] == -1) machineChessmanNum++;
-          else if(chessboard[n][m] == 1)humanChessmanNum++;
+        while (m < k + 5 && k + 5 <= 15) {
+          if (chessboard[n][m] == -1)
+            machineChessmanNum++;
+          else if (chessboard[n][m] == 1) humanChessmanNum++;
 
           m++;
           n--;
         }
         //注意斜向判断的时候，可能构不成五元组（靠近四个角落），遇到这种情况要忽略掉
-        if(m == k+5){
+        if (m == k + 5) {
           tupleScoreTmp = tupleScore(humanChessmanNum, machineChessmanNum);
           //为该五元组的每个位置添加分数
           m = k;
           n = j;
-          for(; m < k + 5; m++, n--){
+          for (; m < k + 5; m++, n--) {
             score[n][m] += tupleScoreTmp;
           }
         }
         //置零
-        humanChessmanNum = 0;//五元组中的黑棋数量
-        machineChessmanNum = 0;//五元组中的白棋数量
-        tupleScoreTmp = 0;//五元组得分临时变量
+        humanChessmanNum = 0; //五元组中的黑棋数量
+        machineChessmanNum = 0; //五元组中的白棋数量
+        tupleScoreTmp = 0; //五元组得分临时变量
 
       }
     }
 
     //5.扫描左上角到右下角上侧部分
-    for(int i = 0; i < 11; i++){
-      for(int k = i, j = 0; j < 15 && k < 15; j++, k++){
+    for (int i = 0; i < 11; i++) {
+      for (int k = i, j = 0; j < 15 && k < 15; j++, k++) {
         int m = k;
         int n = j;
-        while(m < k + 5 && k + 5 <= 15){
-          if(chessboard[m][n] == -1) machineChessmanNum++;
-          else if(chessboard[m][n] == 1)humanChessmanNum++;
+        while (m < k + 5 && k + 5 <= 15) {
+          if (chessboard[m][n] == -1)
+            machineChessmanNum++;
+          else if (chessboard[m][n] == 1) humanChessmanNum++;
 
           m++;
           n++;
         }
         //注意斜向判断的时候，可能构不成五元组（靠近四个角落），遇到这种情况要忽略掉
-        if(m == k + 5){
+        if (m == k + 5) {
           tupleScoreTmp = tupleScore(humanChessmanNum, machineChessmanNum);
           //为该五元组的每个位置添加分数
           m = k;
           n = j;
-          for(; m < k + 5; m++, n++){
+          for (; m < k + 5; m++, n++) {
             score[m][n] += tupleScoreTmp;
           }
         }
 
         //置零
-        humanChessmanNum = 0;//五元组中的黑棋数量
-        machineChessmanNum = 0;//五元组中的白棋数量
-        tupleScoreTmp = 0;//五元组得分临时变量
+        humanChessmanNum = 0; //五元组中的黑棋数量
+        machineChessmanNum = 0; //五元组中的白棋数量
+        tupleScoreTmp = 0; //五元组得分临时变量
 
       }
     }
 
     //6.扫描左上角到右下角下侧部分
-    for(int i = 1; i < 11; i++){
-      for(int k = i, j = 0; j < 15 && k < 15; j++, k++){
+    for (int i = 1; i < 11; i++) {
+      for (int k = i, j = 0; j < 15 && k < 15; j++, k++) {
         int m = k;
         int n = j;
-        while(m < k + 5 && k + 5 <= 15){
-          if(chessboard[n][m] == -1) machineChessmanNum++;
-          else if(chessboard[n][m] == 1)humanChessmanNum++;
+        while (m < k + 5 && k + 5 <= 15) {
+          if (chessboard[n][m] == -1)
+            machineChessmanNum++;
+          else if (chessboard[n][m] == 1) humanChessmanNum++;
 
           m++;
           n++;
         }
         //注意斜向判断的时候，可能构不成五元组（靠近四个角落），遇到这种情况要忽略掉
-        if(m == k + 5){
+        if (m == k + 5) {
           tupleScoreTmp = tupleScore(humanChessmanNum, machineChessmanNum);
           //为该五元组的每个位置添加分数
           m = k;
           n = j;
-          for(; m < k + 5; m++, n++){
+          for (; m < k + 5; m++, n++) {
             score[n][m] += tupleScoreTmp;
           }
         }
 
         //置零
-        humanChessmanNum = 0;//五元组中的黑棋数量
-        machineChessmanNum = 0;//五元组中的白棋数量
-        tupleScoreTmp = 0;//五元组得分临时变量
+        humanChessmanNum = 0; //五元组中的黑棋数量
+        machineChessmanNum = 0; //五元组中的白棋数量
+        tupleScoreTmp = 0; //五元组得分临时变量
 
       }
     }
 
     //从空位置中找到得分最大的位置
-    for(int i = 0; i < 15; i++){
-      for(int j = 0; j < 15; j++){
-        if(chessboard[i][j] == 0 && score[i][j] > maxScore){
+    for (int i = 0; i < 15; i++) {
+      for (int j = 0; j < 15; j++) {
+        if (chessboard[i][j] == 0 && score[i][j] > maxScore) {
           goalX = i;
           goalY = j;
           maxScore = score[i][j];
         }
       }
     }
-    print(maxScore);
 
     if (goalX != -1 && goalY != -1) {
-      return new Position(goalX.toDouble(), goalY.toDouble(), ChessFlyweightFactory.getInstance().getChess(""));
+      return new Position(goalX.toDouble(), goalY.toDouble(),
+          ChessFlyweightFactory.getInstance().getChess(""));
     }
 
     //没找到坐标说明平局了，笔者不处理平局
-    print("没有找到");
-    return new Position(-1, -1, ChessFlyweightFactory.getInstance().getChess(""));
+    return new Position(
+        -1, -1, ChessFlyweightFactory.getInstance().getChess(""));
   }
 
   //各种五元组情况评分表
-  int tupleScore(int humanChessmanNum, int machineChessmanNum){
+  int tupleScore(int humanChessmanNum, int machineChessmanNum) {
     //1.既有人类落子，又有机器落子，判分为0
-    if(humanChessmanNum > 0 && machineChessmanNum > 0){
+    if (humanChessmanNum > 0 && machineChessmanNum > 0) {
       return 0;
     }
     //2.全部为空，没有落子，判分为7
-    if(humanChessmanNum == 0 && machineChessmanNum == 0){
+    if (humanChessmanNum == 0 && machineChessmanNum == 0) {
       return 7;
     }
     //3.机器落1子，判分为35
-    if(machineChessmanNum == 1){
+    if (machineChessmanNum == 1) {
       return 35;
     }
     //4.机器落2子，判分为800
-    if(machineChessmanNum == 2){
+    if (machineChessmanNum == 2) {
       return 800;
     }
     //5.机器落3子，判分为15000
-    if(machineChessmanNum == 3){
+    if (machineChessmanNum == 3) {
       return 15000;
     }
     //6.机器落4子，判分为800000
-    if(machineChessmanNum == 4){
+    if (machineChessmanNum == 4) {
       return 800000;
     }
     //7.人类落1子，判分为15
-    if(humanChessmanNum == 1){
+    if (humanChessmanNum == 1) {
       return 15;
     }
     //8.人类落2子，判分为400
-    if(humanChessmanNum == 2){
+    if (humanChessmanNum == 2) {
       return 400;
     }
     //9.人类落3子，判分为1800
-    if(humanChessmanNum == 3){
+    if (humanChessmanNum == 3) {
       return 1800;
     }
     //10.人类落4子，判分为100000
-    if(humanChessmanNum == 4){
+    if (humanChessmanNum == 4) {
       return 100000;
     }
-    return -1;//若是其他结果肯定出错了。这行代码根本不可能执行
+    return -1; //若是其他结果肯定出错了。这行代码根本不可能执行
   }
-
 }

lib/factory/ThemeFactory.dart

@@ -9,13 +9,13 @@ abstract class ThemeFactory{
 class UserThemeFactory extends ThemeFactory{
   @override
   Theme getTheme() {
-    return new UserTheme();
+    return new YellowTheme();
   }
 }
 
 class AiThemeFactory extends ThemeFactory{
   @override
   Theme getTheme() {
-    return new AiTheme();
+    return new BlueTheme();
   }
 }

lib/factory/UserTheme.dart

@@ -4,14 +4,14 @@ import 'package:flutter/material.dart';
 
 import 'Theme.dart' as t;
 
-class UserTheme extends t.Theme{
+class YellowTheme extends t.Theme{
   @override
   Color getThemeColor() {
-    return Colors.yellow;
+    return Colors.amberAccent;
   }
 }
 
-class AiTheme extends t.Theme{
+class BlueTheme extends t.Theme{
   @override
   Color getThemeColor() {
     return Colors.blue;

lib/main.dart

@@ -11,6 +11,7 @@ class MyApp extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
+      debugShowCheckedModeBanner: false,
       title: '南瓜五子棋',
       theme: ThemeData(
         // This is the theme of your application.

lib/memorandum/CareTaker.dart

@@ -5,8 +5,8 @@ class CareTaker{
 
   void add(Memo state){
     mementoList.add(state);
-    if (mementoList.length>3) {
-      mementoList.removeAt(0);
+    if (mementoList.length > 10) {
+      mementoList.removeRange(0, 1);
     }
   }
 
@@ -15,6 +15,9 @@ class CareTaker{
   }
 
   Memo getLast(){
-    return mementoList.last;
+    Memo memo = mementoList[mementoList.length-3];
+    mementoList.removeLast();
+    mementoList.removeLast();
+    return memo;
   }
 }

lib/memorandum/Memo.dart

@@ -1,11 +1,5 @@
 import 'package:gobang/flyweight/Position.dart';
 
 class Memo {
-  List<Position> _state = [];
-
-  List<Position> get state => _state;
-
-  set state(List<Position> value) {
-    _state = value;
-  }
+  List<Position> state = [];
 }

lib/memorandum/Originator.dart

@@ -1,3 +1,4 @@
+import 'package:gobang/flyweight/Chess.dart';
 import 'package:gobang/flyweight/Position.dart';
 import 'package:gobang/memorandum/CareTaker.dart';
 
@@ -16,15 +17,22 @@ class Originator {
     return _originator;
   }
 
+  bool _canAdd = true; //是否需要添加
+
   List<Position> _state = [];
 
-  List<Position> get state => _state;
+  List<Position> get state{
+    return _state;
+  }
 
   CareTaker _careTaker = CareTaker();
 
   add(Position position) {
-    _state.add(position);
-    _careTaker.add(_save());
+    if(_canAdd) { //因为每次渲染完默认会把最后一个下棋的位置添加上，但在悔棋阶段最后一个是不需要，因此需要这个判断。
+      _state.add(position);
+      _careTaker.add(_save());
+    }
+    _canAdd = true;
   }
 
   _from(Memo memo) {
@@ -32,15 +40,18 @@ class Originator {
   }
 
   Memo _save() {
-    return Memo()..state = this._state;
+    return new Memo()..state.addAll(this._state);
   }
 
   clean(){
     _state = [];
   }
 
-  undo(){
+  undo() {
     Memo memo = _careTaker.getLast();
     _from(memo);
+    _canAdd = false;
   }
+
+
 }

lib/state/State.dart

@@ -2,7 +2,11 @@ import 'package:gobang/state/UserContext.dart';
 
 abstract class State {
   int _step = 0;
+
+  int get step => _step;
   int _rect = 0;
+
+  int get rect => _rect;
   UserContext _userContext;
 
   State(UserContext userContext):_userContext = userContext;
@@ -24,8 +28,6 @@ class StartState extends State {
 
   StartState(UserContext userContext) : super(userContext);
 
-
-
   // 悔棋只能悔棋三次
   @override
   bool regretChess(){
@@ -40,7 +42,7 @@ class StartState extends State {
   @override
   play() {
     super.play();
-    if(_step >= 10) {
+    if(_step >= 4) {
       _userContext.setState(MidState(_userContext).._step = _step.._rect = _rect);
     }
   }
@@ -51,12 +53,18 @@ class StartState extends State {
 class MidState extends State {
   MidState(UserContext userContext) : super(userContext);
 
+  @override
+  int get _rect{
+    return super._rect;
+  }
+
   // 悔棋只能悔棋三次
   @override
   bool regretChess(){
-    if(_rect > 3) {
+    _rect++;
+    if(_rect == 3) {
+      print('切换到白热化阶段');
       _userContext.setState(EndState(_userContext).._step = _step.._rect = _rect);
-      return false;
     }
     return true;
   }

lib/state/UserContext.dart

@@ -4,6 +4,8 @@ class UserContext {
 
   late State _state;
 
+  State get state => _state;
+
   UserContext(){
     _state = StartState(this);
   }
@@ -25,4 +27,8 @@ class UserContext {
   setState(State state){
     _state = state;
   }
+
+  void reset() {
+    _state = StartState(this);
+  }
 }

lib/viewModel/GameViewModel.dart

@@ -1,6 +1,7 @@
 import 'package:gobang/bridge/ChessShape.dart';
 import 'package:gobang/flyweight/Chess.dart';
 import 'package:gobang/flyweight/ChessFlyweightFactory.dart';
+import 'package:gobang/state/State.dart';
 import 'package:gobang/state/UserContext.dart';
 
 class GameViewModel {
@@ -31,5 +32,17 @@ class GameViewModel {
     return _userContext.regretChess();
   }
 
+  get state{
+    if(_userContext.state is StartState){
+      return "热身阶段,不能悔棋，不能投降";
+    } else if(_userContext.state is MidState) {
+      return "入神阶段,可以悔棋且剩余${3 - _userContext.state.rect}次，可以投降";
+    } else if(_userContext.state is EndState) {
+      return "白热化阶段,悔棋次数已用完，但可以投降";
+    }
+  }
 
+  void reset() {
+    _userContext.reset();
+  }
 }