JavaFx五子棋

效果图：

框架：SpringBoot+JavaFx

GobangFxmlView.java

import de.felixroske.jfxsupport.AbstractFxmlView;
import de.felixroske.jfxsupport.FXMLView;

@FXMLView(value = "/fxml/Gobang.fxml", title = "Gobang", bundle = "i18n.index", encoding = "utf-8")
public class GobangFxmlView extends AbstractFxmlView {
}

Gobang.fxml

<?xml version="1.0" encoding="UTF-8"?>

<?import javafx.geometry.*?>
<?import javafx.scene.control.*?>
<?import javafx.scene.shape.*?>
<?import java.lang.*?>
<?import javafx.scene.layout.*?>
<?import javafx.scene.canvas.Canvas?>

<BorderPane maxHeight="-Infinity" maxWidth="-Infinity"
            minHeight="-Infinity" minWidth="-Infinity"
            prefHeight="800.0" prefWidth="842.0"
            xmlns="http://javafx.com/javafx/8"
            xmlns:fx="http://javafx.com/fxml/1" fx:controller="com.maxinhai.world.controller.GobangController">
   <center>
      <Pane fx:id="pane" prefHeight="800.0" prefWidth="800.0" BorderPane.alignment="CENTER">
         <children>
            <Canvas fx:id="canvas" height="800.0" width="800.0" />
         </children>
      </Pane>
   </center>
   <top>
      <HBox prefHeight="42.0" prefWidth="800.0" BorderPane.alignment="CENTER">
         <children>
            <Button mnemonicParsing="false" text="首页" onAction="#toIndex">
               <HBox.margin>
                  <Insets bottom="5.0" left="5.0" right="5.0" top="5.0" />
               </HBox.margin>
            </Button>
            <Button mnemonicParsing="false" text="开始" onAction="#reset">
               <HBox.margin>
                  <Insets bottom="5.0" left="5.0" right="5.0" top="5.0" />
               </HBox.margin>
            </Button>
            <Button mnemonicParsing="false" text="再来一局" onAction="#reset">
               <HBox.margin>
                  <Insets bottom="5.0" left="5.0" right="5.0" top="5.0" />
               </HBox.margin>
            </Button>
            <Button mnemonicParsing="false" text="保存图片" onAction="#saveImage">
               <HBox.margin>
                  <Insets bottom="5.0" left="5.0" right="5.0" top="5.0" />
               </HBox.margin>
            </Button>
         </children>
      </HBox>
   </top>
</BorderPane>

GobangController.java

import com.maxinhai.world.component.MsgAlert;
import de.felixroske.jfxsupport.FXMLController;
import javafx.embed.swing.SwingFXUtils;
import javafx.event.EventHandler;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.SnapshotParameters;
import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.image.Image;
import javafx.scene.image.WritableImage;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.Pane;
import javafx.scene.paint.Color;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.imageio.ImageIO;
import java.io.File;
import java.io.IOException;
import java.math.BigDecimal;
import java.net.URL;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 五子棋Game控制器
 */
@SuppressWarnings("all")
@FXMLController
public class GobangController extends BaseController implements Initializable {

    private static final Logger logger = LoggerFactory.getLogger(GobangController.class);

    @FXML
    private Pane pane;
    @FXML
    private Canvas canvas;

    private GraphicsContext graphicsContext2D = null;
    private double align = 53.33;
    private String flag = "A";
    private boolean isFinish = false;
    private String result = "";

    private static List<Map<String, Double>> indexList = new ArrayList<>(14*14);
    private static List<Map<String, Double>> useIndexList = new ArrayList<>(10);

    @Override
    public void initialize(URL location, ResourceBundle resources) {
        draw();

        // 点击事件
        canvas.setOnMouseClicked(new EventHandler<MouseEvent>() {
            @Override
            public void handle(MouseEvent event) {

                if(isFinish) {
                    pane.setDisable(true);
                    MsgAlert.alert(result);
                } else {
                    double x = event.getX();
                    double y = event.getY();
                    logger.info("坐标: [{},{}]", x, y);
                    indexList.forEach(index -> {
                        double startX = index.get("startX").doubleValue();
                        double endX = index.get("endX").doubleValue();
                        double startY = index.get("startY").doubleValue();
                        double endY = index.get("endY").doubleValue();
                        // 判断是否在落子范围内
                        if(x > startX && x < endX && y > startY && y < endY) {

                            // 计算胜负
                            computeResult(startX, endX, startY, endY);

                            Map<String, Double> useIndex = new HashMap<>();
                            useIndex.put("startX", startX);
                            useIndex.put("endX", endX);
                            useIndex.put("startY", startY);
                            useIndex.put("endY", endY);
                            // 判断是否落子
                            if(isContains(useIndexList, useIndex)) {
                                logger.info("已落子!");
                            } else {
                                // 黑白子切换
                                if("A".equals(flag)) {
                                    graphicsContext2D.setFill(Color.BLACK);
                                    graphicsContext2D.strokeOval(startX, startY, 40, 40);
                                    graphicsContext2D.fillOval(startX, startY, 40, 40);
                                    useIndex.put("author", 1.0);
                                    flag = "B";
                                } else {
                                    graphicsContext2D.setFill(Color.WHITE);
                                    graphicsContext2D.strokeOval(startX, startY, 40, 40);
                                    graphicsContext2D.fillOval(startX, startY, 40, 40);
                                    useIndex.put("author", 2.0);
                                    flag = "A";
                                }
                                useIndexList.add(useIndex);
                            }

                            // 计算胜负
                            computeResult(startX, endX, startY, endY);

                        } else {
                            //logger.info("不在棋盘范围内!");
                        }

                    });
                }
            }
        });
    }

    private void computeResult(double startX, double endX, double startY, double endY) {
        List<Map<String, Double>> aIndexList = useIndexList.stream().filter(index -> 1.0 == index.get("author").doubleValue()).collect(Collectors.toList());
        List<Map<String, Double>> bIndexList = useIndexList.stream().filter(index -> 2.0 == index.get("author").doubleValue()).collect(Collectors.toList());
        logger.info("A落子数据:{}", aIndexList);
        logger.info("B落子数据:{}", bIndexList);
        computeResultX(aIndexList, startX, endX, startY, endY);
        computeResultX(bIndexList, startX, endX, startY, endY);
        computeResultY(aIndexList, startX, endX, startY, endY);
        computeResultY(bIndexList, startX, endX, startY, endY);
        computeResultXY(aIndexList, startX, endX, startY, endY);
        computeResultXY(bIndexList, startX, endX, startY, endY);
    }

    /**
     * 计算成功结果(横向计算)
     * @param indexList
     * @param startX
     * @param endX
     * @param startY
     * @param endY
     */
    private void computeResultX(List<Map<String, Double>> indexList, double startX, double endX, double startY, double endY) {
        // 结果1
        List<Map<String, Double>> resultMap1 = new ArrayList<>(5);
        Map<String, Double> result1 = new HashMap<>();
        result1.put("startX", startX);
        result1.put("endX", endX);
        result1.put("startY", startY);
        result1.put("endY", endY);
        resultMap1.add(result1);

        Map<String, Double> result2 = new HashMap<>();
        result2.put("startX", new BigDecimal(startX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2.put("endX", new BigDecimal(endX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2.put("startY", startY);
        result2.put("endY", endY);
        resultMap1.add(result2);

        Map<String, Double> result3 = new HashMap<>();
        result3.put("startX", new BigDecimal(startX+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3.put("endX", new BigDecimal(endX+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3.put("startY", startY);
        result3.put("endY", endY);
        resultMap1.add(result3);

        Map<String, Double> result4 = new HashMap<>();
        result4.put("startX", new BigDecimal(startX+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4.put("endX", new BigDecimal(endX+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4.put("startY", startY);
        result4.put("endY", endY);
        resultMap1.add(result4);

        Map<String, Double> result5 = new HashMap<>();
        result5.put("startX", new BigDecimal(startX+(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5.put("endX", new BigDecimal(endX+(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5.put("startY", startY);
        result5.put("endY", endY);
        resultMap1.add(result5);

        // 结果2
        List<Map<String, Double>> resultMap2 = new ArrayList<>(5);
        Map<String, Double> result2_1 = new HashMap<>();
        result2_1.put("startX", new BigDecimal(startX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_1.put("endX", new BigDecimal(endX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_1.put("startY", startY);
        result2_1.put("endY", endY);
        resultMap2.add(result2_1);

        Map<String, Double> result2_2 = new HashMap<>();
        result2_2.put("startX", startX);
        result2_2.put("endX", endX);
        result2_2.put("startY", startY);
        result2_2.put("endY", endY);
        resultMap2.add(result2_2);

        Map<String, Double> result2_3 = new HashMap<>();
        result2_3.put("startX", new BigDecimal(startX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_3.put("endX", new BigDecimal(endX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_3.put("startY", startY);
        result2_3.put("endY", endY);
        resultMap2.add(result2_3);

        Map<String, Double> result2_4 = new HashMap<>();
        result2_4.put("startX", new BigDecimal(startX+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_4.put("endX", new BigDecimal(endX+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_4.put("startY", startY);
        result2_4.put("endY", endY);
        resultMap2.add(result2_4);

        Map<String, Double> result2_5 = new HashMap<>();
        result2_5.put("startX", new BigDecimal(startX+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_5.put("endX", new BigDecimal(endX+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_5.put("startY", startY);
        result2_5.put("endY", endY);
        resultMap2.add(result2_5);

        // 结果3
        List<Map<String, Double>> resultMap3 = new ArrayList<>(5);
        Map<String, Double> result3_1 = new HashMap<>();
        result3_1.put("startX", new BigDecimal(startX-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_1.put("endX", new BigDecimal(endX-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_1.put("startY", startY);
        result3_1.put("endY", endY);
        resultMap3.add(result3_1);

        Map<String, Double> result3_2 = new HashMap<>();
        result3_2.put("startX", new BigDecimal(startX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_2.put("endX", new BigDecimal(endX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_2.put("startY", startY);
        result3_2.put("endY", endY);
        resultMap3.add(result3_2);

        Map<String, Double> result3_3 = new HashMap<>();
        result3_3.put("startX", startX);
        result3_3.put("endX", endX);
        result3_3.put("startY", startY);
        result3_3.put("endY", endY);
        resultMap3.add(result3_3);

        Map<String, Double> result3_4 = new HashMap<>();
        result3_4.put("startX", new BigDecimal(startX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_4.put("endX", new BigDecimal(endX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_4.put("startY", startY);
        result3_4.put("endY", endY);
        resultMap3.add(result3_4);

        Map<String, Double> result3_5 = new HashMap<>();
        result3_5.put("startX", new BigDecimal(startX+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_5.put("endX", new BigDecimal(endX+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_5.put("startY", startY);
        result3_5.put("endY", endY);
        resultMap3.add(result3_5);


        // 结果4
        List<Map<String, Double>> resultMap4 = new ArrayList<>(5);
        Map<String, Double> result4_1 = new HashMap<>();
        result4_1.put("startX", new BigDecimal(startX-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_1.put("endX", new BigDecimal(endX-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_1.put("startY", startY);
        result4_1.put("endY", endY);
        resultMap4.add(result4_1);

        Map<String, Double> result4_2 = new HashMap<>();
        result4_2.put("startX", new BigDecimal(startX-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_2.put("endX", new BigDecimal(endX-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_2.put("startY", startY);
        result4_2.put("endY", endY);
        resultMap4.add(result4_2);

        Map<String, Double> result4_3 = new HashMap<>();
        result4_3.put("startX", new BigDecimal(startX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_3.put("endX", new BigDecimal(endX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_3.put("startY", startY);
        result4_3.put("endY", endY);
        resultMap4.add(result4_3);

        Map<String, Double> result4_4 = new HashMap<>();
        result4_4.put("startX", startX);
        result4_4.put("endX", endX);
        result4_4.put("startY", startY);
        result4_4.put("endY", endY);
        resultMap4.add(result4_4);

        Map<String, Double> result4_5 = new HashMap<>();
        result4_5.put("startX", new BigDecimal(startX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_5.put("endX", new BigDecimal(endX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_5.put("startY", startY);
        result4_5.put("endY", endY);
        resultMap4.add(result4_5);

        // 结果5
        List<Map<String, Double>> resultMap5 = new ArrayList<>(5);
        Map<String, Double> result5_1 = new HashMap<>();
        result5_1.put("startX", new BigDecimal(startX-(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_1.put("endX", new BigDecimal(endX-(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_1.put("startY", startY);
        result5_1.put("endY", endY);
        resultMap5.add(result5_1);

        Map<String, Double> result5_2 = new HashMap<>();
        result5_2.put("startX", new BigDecimal(startX-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_2.put("endX", new BigDecimal(endX-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_2.put("startY", startY);
        result5_2.put("endY", endY);
        resultMap5.add(result5_2);

        Map<String, Double> result5_3 = new HashMap<>();
        result5_3.put("startX", new BigDecimal(startX-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_3.put("endX", new BigDecimal(endX-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_3.put("startY", startY);
        result5_3.put("endY", endY);
        resultMap5.add(result5_3);

        Map<String, Double> result5_4 = new HashMap<>();
        result5_4.put("startX", new BigDecimal(startX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_4.put("endX", new BigDecimal(endX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_4.put("startY", startY);
        result5_4.put("endY", endY);
        resultMap5.add(result5_4);

        Map<String, Double> result5_5 = new HashMap<>();
        result5_5.put("startX", startX);
        result5_5.put("endX", endX);
        result5_5.put("startY", startY);
        result5_5.put("endY", endY);
        resultMap5.add(result5_5);

        int count = 0;
        for (int index = 0; index < resultMap1.size(); index++) {
            Map<String, Double> result = resultMap1.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count++;
                }
            }
        }
        if(count == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }

        int count_1 = 0;
        for (int index = 0; index < resultMap2.size(); index++) {
            Map<String, Double> result = resultMap2.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count_1++;
                }
            }
        }
        if(count_1 == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }

        int count_2 = 0;
        for (int index = 0; index < resultMap3.size(); index++) {
            Map<String, Double> result = resultMap3.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count_2++;
                }
            }
        }
        if(count_2 == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }

        int count_3 = 0;
        for (int index = 0; index < resultMap4.size(); index++) {
            Map<String, Double> result = resultMap4.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count_3++;
                }
            }
        }
        if(count_3 == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }

        int count_4 = 0;
        for (int index = 0; index < resultMap5.size(); index++) {
            Map<String, Double> result = resultMap5.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count_4++;
                }
            }
        }
        if(count_4 == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }
    }

    /**
     * 计算成功结果(纵向计算)
     * @param indexList
     * @param startX
     * @param endX
     * @param startY
     * @param endY
     */
    private void computeResultY(List<Map<String, Double>> indexList, double startX, double endX, double startY, double endY) {
        // 结果1
        List<Map<String, Double>> resultMap1 = new ArrayList<>(5);
        Map<String, Double> result1 = new HashMap<>();
        result1.put("startX", startX);
        result1.put("endX", endX);
        result1.put("startY", startY);
        result1.put("endY", endY);
        resultMap1.add(result1);

        Map<String, Double> result2 = new HashMap<>();
        result2.put("startX", startX);
        result2.put("endX", startX);
        result2.put("startY", new BigDecimal(startY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2.put("endY", new BigDecimal(endY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap1.add(result2);

        Map<String, Double> result3 = new HashMap<>();
        result3.put("startX", startX);
        result3.put("endX", endX);
        result3.put("startY", new BigDecimal(startY+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3.put("endY", new BigDecimal(endY+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap1.add(result3);

        Map<String, Double> result4 = new HashMap<>();
        result4.put("startX", startX);
        result4.put("endX", endX);
        result4.put("startY", new BigDecimal(startY+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4.put("endY", new BigDecimal(endY+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap1.add(result4);

        Map<String, Double> result5 = new HashMap<>();
        result5.put("startX", startX);
        result5.put("endX", endX);
        result5.put("startY", new BigDecimal(startY+(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5.put("endY", new BigDecimal(endY+(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap1.add(result5);

        // 结果2
        List<Map<String, Double>> resultMap2 = new ArrayList<>(5);
        Map<String, Double> result2_1 = new HashMap<>();
        result2_1.put("startX", startX);
        result2_1.put("endX", endX);
        result2_1.put("startY", new BigDecimal(startY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_1.put("endY", new BigDecimal(endY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap2.add(result2_1);

        Map<String, Double> result2_2 = new HashMap<>();
        result2_2.put("startX", startX);
        result2_2.put("endX", endX);
        result2_2.put("startY", startY);
        result2_2.put("endY", endY);
        resultMap2.add(result2_2);

        Map<String, Double> result2_3 = new HashMap<>();
        result2_3.put("startX", startX);
        result2_3.put("endX", endX);
        result2_3.put("startY", new BigDecimal(startY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_3.put("endY", new BigDecimal(endY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap2.add(result2_3);

        Map<String, Double> result2_4 = new HashMap<>();
        result2_4.put("startX", startX);
        result2_4.put("endX", endX);
        result2_4.put("startY", new BigDecimal(startY+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_4.put("endY", new BigDecimal(endY+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap2.add(result2_4);

        Map<String, Double> result2_5 = new HashMap<>();
        result2_5.put("startX", startX);
        result2_5.put("endX", endX);
        result2_5.put("startY", new BigDecimal(startY+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_5.put("endY", new BigDecimal(endY+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap2.add(result2_5);

        // 结果3
        List<Map<String, Double>> resultMap3 = new ArrayList<>(5);
        Map<String, Double> result3_1 = new HashMap<>();
        result3_1.put("startX", startX);
        result3_1.put("endX", endX);
        result3_1.put("startY", new BigDecimal(startY-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_1.put("endY", new BigDecimal(endY-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap3.add(result3_1);

        Map<String, Double> result3_2 = new HashMap<>();
        result3_2.put("startX", startX);
        result3_2.put("endX", endX);
        result3_2.put("startY", new BigDecimal(startY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_2.put("endY", new BigDecimal(endY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap3.add(result3_2);

        Map<String, Double> result3_3 = new HashMap<>();
        result3_3.put("startX", startX);
        result3_3.put("endX", endX);
        result3_3.put("startY", startY);
        result3_3.put("endY", endY);
        resultMap3.add(result3_3);

        Map<String, Double> result3_4 = new HashMap<>();
        result3_4.put("startX", startX);
        result3_4.put("endX", endX);
        result3_4.put("startY", new BigDecimal(startY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_4.put("endY", new BigDecimal(endY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap3.add(result3_4);

        Map<String, Double> result3_5 = new HashMap<>();
        result3_5.put("startX", startX);
        result3_5.put("endX", endX);
        result3_5.put("startY", new BigDecimal(startY+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_5.put("endY", new BigDecimal(endY+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap3.add(result3_5);


        // 结果4
        List<Map<String, Double>> resultMap4 = new ArrayList<>(5);
        Map<String, Double> result4_1 = new HashMap<>();
        result4_1.put("startX", startX);
        result4_1.put("endX", endX);
        result4_1.put("startY", new BigDecimal(startY-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_1.put("endY", new BigDecimal(endY-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap4.add(result4_1);

        Map<String, Double> result4_2 = new HashMap<>();
        result4_2.put("startX", startX);
        result4_2.put("endX", endX);
        result4_2.put("startY", new BigDecimal(startY-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_2.put("endY", new BigDecimal(endY-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap4.add(result4_2);

        Map<String, Double> result4_3 = new HashMap<>();
        result4_3.put("startX", startX);
        result4_3.put("endX", endX);
        result4_3.put("startY", new BigDecimal(startY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_3.put("endY", new BigDecimal(endY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap4.add(result4_3);

        Map<String, Double> result4_4 = new HashMap<>();
        result4_4.put("startX", startX);
        result4_4.put("endX", endX);
        result4_4.put("startY", startY);
        result4_4.put("endY", endY);
        resultMap4.add(result4_4);

        Map<String, Double> result4_5 = new HashMap<>();
        result4_5.put("startX", startX);
        result4_5.put("endX", endX);
        result4_5.put("startY", new BigDecimal(startY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_5.put("endY", new BigDecimal(endY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap4.add(result4_5);

        // 结果4
        List<Map<String, Double>> resultMap5 = new ArrayList<>(5);
        Map<String, Double> result5_1 = new HashMap<>();
        result5_1.put("startX", startX);
        result5_1.put("endX", endX);
        result5_1.put("startY", new BigDecimal(startY-(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_1.put("endY", new BigDecimal(endY-(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap5.add(result5_1);

        Map<String, Double> result5_2 = new HashMap<>();
        result5_2.put("startX", startX);
        result5_2.put("endX", endX);
        result5_2.put("startY", new BigDecimal(startY-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_2.put("endY", new BigDecimal(endY-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap5.add(result5_2);

        Map<String, Double> result5_3 = new HashMap<>();
        result5_3.put("startX", startX);
        result5_3.put("endX", endX);
        result5_3.put("startY", new BigDecimal(startY-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_3.put("endY", new BigDecimal(endY-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap5.add(result5_3);

        Map<String, Double> result5_4 = new HashMap<>();
        result5_4.put("startX", startX);
        result5_4.put("endX", endX);
        result5_4.put("startY", new BigDecimal(startY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_4.put("endY", new BigDecimal(endY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap5.add(result5_4);

        Map<String, Double> result5_5 = new HashMap<>();
        result5_5.put("startX", startX);
        result5_5.put("endX", endX);
        result5_5.put("startY", startY);
        result5_5.put("endY", endY);
        resultMap5.add(result5_5);

        int count = 0;
        for (int index = 0; index < resultMap1.size(); index++) {
            Map<String, Double> result = resultMap1.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count++;
                }
            }
        }
        if(count == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }

        int count_1 = 0;
        for (int index = 0; index < resultMap2.size(); index++) {
            Map<String, Double> result = resultMap2.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count_1++;
                }
            }
        }
        if(count_1 == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }

        int count_2 = 0;
        for (int index = 0; index < resultMap3.size(); index++) {
            Map<String, Double> result = resultMap3.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count_2++;
                }
            }
        }
        if(count_2 == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }

        int count_3 = 0;
        for (int index = 0; index < resultMap4.size(); index++) {
            Map<String, Double> result = resultMap4.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count_3++;
                }
            }
        }
        if(count_3 == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }

        int count_4 = 0;
        for (int index = 0; index < resultMap5.size(); index++) {
            Map<String, Double> result = resultMap5.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count_4++;
                }
            }
        }
        if(count_4 == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }
    }

    /**
     * 计算成功结果(斜线计算)
     * @param indexList
     * @param startX
     * @param endX
     * @param startY
     * @param endY
     */
    private void computeResultXY(List<Map<String, Double>> indexList, double startX, double endX, double startY, double endY) {
        // 结果1
        List<Map<String, Double>> resultMap1 = new ArrayList<>(5);
        Map<String, Double> result1 = new HashMap<>();
        result1.put("startX", startX);
        result1.put("endX", endX);
        result1.put("startY", startY);
        result1.put("endY", endY);
        resultMap1.add(result1);

        Map<String, Double> result2 = new HashMap<>();
        result2.put("startX", new BigDecimal(startX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2.put("endX", new BigDecimal(endX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2.put("startY", new BigDecimal(startY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2.put("endY", new BigDecimal(endY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap1.add(result2);

        Map<String, Double> result3 = new HashMap<>();
        result3.put("startX", new BigDecimal(startX+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3.put("endX", new BigDecimal(endX+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3.put("startY", new BigDecimal(startY+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3.put("endY", new BigDecimal(endY+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap1.add(result3);

        Map<String, Double> result4 = new HashMap<>();
        result4.put("startX", new BigDecimal(startX+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4.put("endX", new BigDecimal(endX+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4.put("startY", new BigDecimal(startY+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4.put("endY", new BigDecimal(endY+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap1.add(result4);

        Map<String, Double> result5 = new HashMap<>();
        result5.put("startX", new BigDecimal(startX+(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5.put("endX", new BigDecimal(endX+(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5.put("startY", new BigDecimal(startY+(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5.put("endY", new BigDecimal(endY+(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap1.add(result5);

        // 结果2
        List<Map<String, Double>> resultMap2 = new ArrayList<>(5);
        Map<String, Double> result2_1 = new HashMap<>();
        result2_1.put("startX", new BigDecimal(startX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_1.put("endX", new BigDecimal(endX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_1.put("startY", new BigDecimal(startY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_1.put("endY", new BigDecimal(endY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap2.add(result2_1);

        Map<String, Double> result2_2 = new HashMap<>();
        result2_2.put("startX", startX);
        result2_2.put("endX", endX);
        result2_2.put("startY", startY);
        result2_2.put("endY", endY);
        resultMap2.add(result2_2);

        Map<String, Double> result2_3 = new HashMap<>();
        result2_3.put("startX", new BigDecimal(startX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_3.put("endX", new BigDecimal(endX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_3.put("startY", new BigDecimal(startY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_3.put("endY", new BigDecimal(endY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap2.add(result2_3);

        Map<String, Double> result2_4 = new HashMap<>();
        result2_4.put("startX", new BigDecimal(startX+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_4.put("endX", new BigDecimal(endX+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_4.put("startY", new BigDecimal(startY+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_4.put("endY", new BigDecimal(endY+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap2.add(result2_4);

        Map<String, Double> result2_5 = new HashMap<>();
        result2_5.put("startX", new BigDecimal(startX+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_5.put("endX", new BigDecimal(endX+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_5.put("startY", new BigDecimal(startY+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result2_5.put("endY", new BigDecimal(endY+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap2.add(result2_5);

        // 结果3
        List<Map<String, Double>> resultMap3 = new ArrayList<>(5);
        Map<String, Double> result3_1 = new HashMap<>();
        result3_1.put("startX", new BigDecimal(startX-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_1.put("endX", new BigDecimal(endX-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_1.put("startY", new BigDecimal(startY-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_1.put("endY", new BigDecimal(endY-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap3.add(result3_1);

        Map<String, Double> result3_2 = new HashMap<>();
        result3_2.put("startX", new BigDecimal(startX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_2.put("endX", new BigDecimal(endX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_2.put("startY", new BigDecimal(startY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_2.put("endY", new BigDecimal(endY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap3.add(result3_2);

        Map<String, Double> result3_3 = new HashMap<>();
        result3_3.put("startX", startX);
        result3_3.put("endX", endX);
        result3_3.put("startY", startY);
        result3_3.put("endY", endY);
        resultMap3.add(result3_3);

        Map<String, Double> result3_4 = new HashMap<>();
        result3_4.put("startX", new BigDecimal(startX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_4.put("endX", new BigDecimal(endX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_4.put("startY", new BigDecimal(startY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_4.put("endY", new BigDecimal(endY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap3.add(result3_4);

        Map<String, Double> result3_5 = new HashMap<>();
        result3_5.put("startX", new BigDecimal(startX+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_5.put("endX", new BigDecimal(endX+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_5.put("startY", new BigDecimal(startY+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result3_5.put("endY", new BigDecimal(endY+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap3.add(result3_5);


        // 结果4
        List<Map<String, Double>> resultMap4 = new ArrayList<>(5);
        Map<String, Double> result4_1 = new HashMap<>();
        result4_1.put("startX", new BigDecimal(startX-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_1.put("endX", new BigDecimal(endX-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_1.put("startY", new BigDecimal(startY-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_1.put("endY", new BigDecimal(endY-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap4.add(result4_1);

        Map<String, Double> result4_2 = new HashMap<>();
        result4_2.put("startX", new BigDecimal(startX-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_2.put("endX", new BigDecimal(endX-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_2.put("startY", new BigDecimal(startY-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_2.put("endY", new BigDecimal(endY-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap4.add(result4_2);

        Map<String, Double> result4_3 = new HashMap<>();
        result4_3.put("startX", new BigDecimal(startX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_3.put("endX", new BigDecimal(endX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_3.put("startY", new BigDecimal(startY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_3.put("endY", new BigDecimal(endY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap4.add(result4_3);

        Map<String, Double> result4_4 = new HashMap<>();
        result4_4.put("startX", startX);
        result4_4.put("endX", endX);
        result4_4.put("startY", startY);
        result4_4.put("endY", endY);
        resultMap4.add(result4_4);

        Map<String, Double> result4_5 = new HashMap<>();
        result4_5.put("startX", new BigDecimal(startX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_5.put("endX", new BigDecimal(endX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_5.put("startY", new BigDecimal(startY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result4_5.put("endY", new BigDecimal(endY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap4.add(result4_5);

        // 结果4
        List<Map<String, Double>> resultMap5 = new ArrayList<>(5);
        Map<String, Double> result5_1 = new HashMap<>();
        result5_1.put("startX", new BigDecimal(startX-(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_1.put("endX", new BigDecimal(endX-(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_1.put("startY", new BigDecimal(startY-(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_1.put("endY", new BigDecimal(endY-(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap5.add(result5_1);

        Map<String, Double> result5_2 = new HashMap<>();
        result5_2.put("startX", new BigDecimal(startX-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_2.put("endX", new BigDecimal(endX-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_2.put("startY", new BigDecimal(startY-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_2.put("endY", new BigDecimal(endY-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap5.add(result5_2);

        Map<String, Double> result5_3 = new HashMap<>();
        result5_3.put("startX", new BigDecimal(startX-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_3.put("endX", new BigDecimal(endX-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_3.put("startY", new BigDecimal(startY-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_3.put("endY", new BigDecimal(endY-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap5.add(result5_3);

        Map<String, Double> result5_4 = new HashMap<>();
        result5_4.put("startX", new BigDecimal(startX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_4.put("endX", new BigDecimal(endX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_4.put("startY", new BigDecimal(startY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result5_4.put("endY", new BigDecimal(endY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap5.add(result5_4);

        Map<String, Double> result5_5 = new HashMap<>();
        result5_5.put("startX", startX);
        result5_5.put("endX", endX);
        result5_5.put("startY", startY);
        result5_5.put("endY", endY);
        resultMap5.add(result5_5);

        int count = 0;
        for (int index = 0; index < resultMap1.size(); index++) {
            Map<String, Double> result = resultMap1.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count++;
                }
            }
        }
        if(count == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }

        int count_1 = 0;
        for (int index = 0; index < resultMap2.size(); index++) {
            Map<String, Double> result = resultMap2.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count_1++;
                }
            }
        }
        if(count_1 == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }

        int count_2 = 0;
        for (int index = 0; index < resultMap3.size(); index++) {
            Map<String, Double> result = resultMap3.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count_2++;
                }
            }
        }
        if(count_2 == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }

        int count_3 = 0;
        for (int index = 0; index < resultMap4.size(); index++) {
            Map<String, Double> result = resultMap4.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count_3++;
                }
            }
        }
        if(count_3 == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }

        int count_4 = 0;
        for (int index = 0; index < resultMap5.size(); index++) {
            Map<String, Double> result = resultMap5.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count_4++;
                }
            }
        }
        if(count_4 == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }

        // 结果6
        List<Map<String, Double>> resultMap6 = new ArrayList<>(5);
        Map<String, Double> result6_1 = new HashMap<>();
        result6_1.put("startX", startX);
        result6_1.put("endX", endX);
        result6_1.put("startY", startY);
        result6_1.put("endY", endY);
        resultMap6.add(result6_1);

        Map<String, Double> result6_2 = new HashMap<>();
        result6_2.put("startX", new BigDecimal(startX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result6_2.put("endX", new BigDecimal(endX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result6_2.put("startY", new BigDecimal(startY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result6_2.put("endY", new BigDecimal(endY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap6.add(result6_2);

        Map<String, Double> result6_3 = new HashMap<>();
        result6_3.put("startX", new BigDecimal(startX+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result6_3.put("endX", new BigDecimal(endX+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result6_3.put("startY", new BigDecimal(startY-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result6_3.put("endY", new BigDecimal(endY-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap6.add(result6_3);

        Map<String, Double> result6_4 = new HashMap<>();
        result6_4.put("startX", new BigDecimal(startX+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result6_4.put("endX", new BigDecimal(endX+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result6_4.put("startY", new BigDecimal(startY-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result6_4.put("endY", new BigDecimal(endY-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap6.add(result6_4);

        Map<String, Double> result6_5 = new HashMap<>();
        result6_5.put("startX", new BigDecimal(startX+(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result6_5.put("endX", new BigDecimal(endX+(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result6_5.put("startY", new BigDecimal(startY-(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result6_5.put("endY", new BigDecimal(endY-(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap6.add(result6_5);

        // 结果7
        List<Map<String, Double>> resultMap7 = new ArrayList<>(5);
        Map<String, Double> result7_1 = new HashMap<>();
        result7_1.put("startX", new BigDecimal(startX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result7_1.put("endX", new BigDecimal(endX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result7_1.put("startY", new BigDecimal(startY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result7_1.put("endY", new BigDecimal(endY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap7.add(result7_1);

        Map<String, Double> result7_2 = new HashMap<>();
        result7_2.put("startX", startX);
        result7_2.put("endX", endX);
        result7_2.put("startY", startY);
        result7_2.put("endY", endY);
        resultMap7.add(result7_2);

        Map<String, Double> result7_3 = new HashMap<>();
        result7_3.put("startX", new BigDecimal(startX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result7_3.put("endX", new BigDecimal(endX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result7_3.put("startY", new BigDecimal(startY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result7_3.put("endY", new BigDecimal(endY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap7.add(result7_3);

        Map<String, Double> result7_4 = new HashMap<>();
        result7_4.put("startX", new BigDecimal(startX+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result7_4.put("endX", new BigDecimal(endX+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result7_4.put("startY", new BigDecimal(startY-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result7_4.put("endY", new BigDecimal(endY-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap7.add(result7_4);

        Map<String, Double> result7_5 = new HashMap<>();
        result7_5.put("startX", new BigDecimal(startX+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result7_5.put("endX", new BigDecimal(endX+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result7_5.put("startY", new BigDecimal(startY-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result7_5.put("endY", new BigDecimal(endY-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap7.add(result7_5);

        // 结果8
        List<Map<String, Double>> resultMap8 = new ArrayList<>(5);
        Map<String, Double> result8_1 = new HashMap<>();
        result8_1.put("startX", new BigDecimal(startX-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result8_1.put("endX", new BigDecimal(endX-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result8_1.put("startY", new BigDecimal(startY+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result8_1.put("endY", new BigDecimal(endY+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap8.add(result8_1);

        Map<String, Double> result8_2 = new HashMap<>();
        result8_2.put("startX", new BigDecimal(startX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result8_2.put("endX", new BigDecimal(endX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result8_2.put("startY", new BigDecimal(startY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result8_2.put("endY", new BigDecimal(endY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap8.add(result8_2);

        Map<String, Double> result8_3 = new HashMap<>();
        result8_3.put("startX", startX);
        result8_3.put("endX", endX);
        result8_3.put("startY", startY);
        result8_3.put("endY", endY);
        resultMap8.add(result8_3);

        Map<String, Double> result8_4 = new HashMap<>();
        result8_4.put("startX", new BigDecimal(startX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result8_4.put("endX", new BigDecimal(endX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result8_4.put("startY", new BigDecimal(startY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result8_4.put("endY", new BigDecimal(endY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap8.add(result8_4);

        Map<String, Double> result8_5 = new HashMap<>();
        result8_5.put("startX", new BigDecimal(startX+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result8_5.put("endX", new BigDecimal(endX+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result8_5.put("startY", new BigDecimal(startY-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result8_5.put("endY", new BigDecimal(endY-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap8.add(result8_5);


        // 结果9
        List<Map<String, Double>> resultMap9 = new ArrayList<>(5);
        Map<String, Double> result9_1 = new HashMap<>();
        result9_1.put("startX", new BigDecimal(startX-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result9_1.put("endX", new BigDecimal(endX-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result9_1.put("startY", new BigDecimal(startY+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result9_1.put("endY", new BigDecimal(endY+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap9.add(result9_1);

        Map<String, Double> result9_2 = new HashMap<>();
        result9_2.put("startX", new BigDecimal(startX-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result9_2.put("endX", new BigDecimal(endX-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result9_2.put("startY", new BigDecimal(startY+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result9_2.put("endY", new BigDecimal(endY+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap9.add(result9_2);

        Map<String, Double> result9_3 = new HashMap<>();
        result9_3.put("startX", new BigDecimal(startX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result9_3.put("endX", new BigDecimal(endX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result9_3.put("startY", new BigDecimal(startY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result9_3.put("endY", new BigDecimal(endY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap9.add(result9_3);

        Map<String, Double> result9_4 = new HashMap<>();
        result9_4.put("startX", startX);
        result9_4.put("endX", endX);
        result9_4.put("startY", startY);
        result9_4.put("endY", endY);
        resultMap9.add(result9_4);

        Map<String, Double> result9_5 = new HashMap<>();
        result9_5.put("startX", new BigDecimal(startX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result9_5.put("endX", new BigDecimal(endX+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result9_5.put("startY", new BigDecimal(startY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result9_5.put("endY", new BigDecimal(endY-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap9.add(result9_5);

        // 结果4
        List<Map<String, Double>> resultMap10 = new ArrayList<>(5);
        Map<String, Double> result10_1 = new HashMap<>();
        result10_1.put("startX", new BigDecimal(startX-(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result10_1.put("endX", new BigDecimal(endX-(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result10_1.put("startY", new BigDecimal(startY+(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result10_1.put("endY", new BigDecimal(endY+(53.33*4)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap10.add(result10_1);

        Map<String, Double> result10_2 = new HashMap<>();
        result10_2.put("startX", new BigDecimal(startX-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result10_2.put("endX", new BigDecimal(endX-(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result10_2.put("startY", new BigDecimal(startY+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result10_2.put("endY", new BigDecimal(endY+(53.33*3)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap10.add(result10_2);

        Map<String, Double> result10_3 = new HashMap<>();
        result10_3.put("startX", new BigDecimal(startX-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result10_3.put("endX", new BigDecimal(endX-(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result10_3.put("startY", new BigDecimal(startY+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result10_3.put("endY", new BigDecimal(endY+(53.33*2)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap10.add(result10_3);

        Map<String, Double> result10_4 = new HashMap<>();
        result10_4.put("startX", new BigDecimal(startX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result10_4.put("endX", new BigDecimal(endX-(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result10_4.put("startY", new BigDecimal(startY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        result10_4.put("endY", new BigDecimal(endY+(53.33*1)).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
        resultMap10.add(result10_4);

        Map<String, Double> result10_5 = new HashMap<>();
        result10_5.put("startX", startX);
        result10_5.put("endX", endX);
        result10_5.put("startY", startY);
        result10_5.put("endY", endY);
        resultMap10.add(result10_5);

        int count_6 = 0;
        for (int index = 0; index < resultMap6.size(); index++) {
            Map<String, Double> result = resultMap6.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count_6++;
                }
            }
        }
        if(count_6 == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }

        int count_7 = 0;
        for (int index = 0; index < resultMap6.size(); index++) {
            Map<String, Double> result = resultMap6.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count_7++;
                }
            }
        }
        if(count_7 == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }

        int count_8 = 0;
        for (int index = 0; index < resultMap8.size(); index++) {
            Map<String, Double> result = resultMap8.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count_8++;
                }
            }
        }
        if(count_8 == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }

        int count_9 = 0;
        for (int index = 0; index < resultMap9.size(); index++) {
            Map<String, Double> result = resultMap9.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count_9++;
                }
            }
        }
        if(count_9 == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }

        int count_10 = 0;
        for (int index = 0; index < resultMap10.size(); index++) {
            Map<String, Double> result = resultMap10.get(index);
            double startX1 = result.get("startX").doubleValue();
            double endX1 = result.get("endX").doubleValue();
            double startY1 = result.get("startY").doubleValue();
            double endY1 = result.get("endY").doubleValue();
            for (int i = 0; i < indexList.size(); i++) {
                Map<String, Double> map = indexList.get(i);
                double startX2 = map.get("startX").doubleValue();
                double endX2 = map.get("endX").doubleValue();
                double startY2 = map.get("startY").doubleValue();
                double endY2 = map.get("endY").doubleValue();
                if(startX1==startX2 && endX1==endX2 && startY1==startY2 && endY1==endY2) {
                    count_10++;
                }
            }
        }
        if(count_10 == 5) {
            Double author = indexList.get(0).get("author");
            String name = author.doubleValue()==1.0 ? "A方" : "B方";
            MsgAlert.alert("游戏结束," + name + "获胜!");
            result = "游戏结束," + name + "获胜!";
            isFinish = true;
            return;
        }
    }

    /**
     * 重写匹配元素方法
     * @param indexList
     * @param index
     * @return
     */
    private boolean isContains(List<Map<String,Double>> indexList, Map<String, Double> index) {
        double startX1 = index.get("startX").doubleValue();
        double endX1 = index.get("endX").doubleValue();
        double startY1 = index.get("startY").doubleValue();
        double endY1 = index.get("endY").doubleValue();
        for (int i = 0; i < indexList.size(); i++) {
            Map<String, Double> map = indexList.get(i);
            double startX = map.get("startX").doubleValue();
            double endX = map.get("endX").doubleValue();
            double startY = map.get("startY").doubleValue();
            double endY = map.get("endY").doubleValue();
            if(startX1==startX && endX==endX1 && startY1==startY && endY==endY1) {
                return true;
            }
        }
        return false;
    }

    /**
     * 绘制棋盘
     */
    private void draw() {
        if(Objects.isNull(graphicsContext2D)) {
            graphicsContext2D = canvas.getGraphicsContext2D();
        }
        graphicsContext2D.setFill(Color.BURLYWOOD);
        graphicsContext2D.fillRect(0,0,800,800);

        // 绘制纵横线
        //double align = 53.33;
        for(int w=1; w<(800/align); w++) {
            graphicsContext2D.strokeLine(0, align * w, 800, align * w);
        }
        for(int h=1; h<(800/align); h++) {
            graphicsContext2D.strokeLine(align * h, 0, align * h, 800);
        }

        // 绘制棋子
        for(int w1=1; w1<(800/align-1); w1++) {
            for(int h1=1; h1<(800/align-1); h1++) {
                Map<String, Double> index = new HashMap<>();
                index.put("startX", new BigDecimal((align * w1) - 20).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
                index.put("endX", new BigDecimal((align * w1) + 20).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
                index.put("startY", new BigDecimal((align * h1) - 20).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
                index.put("endY", new BigDecimal((align * h1) + 20).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
                indexList.add(index);
            }
        }

        // 绘制四条外边
        graphicsContext2D.setLineWidth(3.0);
        graphicsContext2D.strokeLine(0, 0, 800, 0);
        graphicsContext2D.strokeLine(0, 800, 800, 800);
        graphicsContext2D.strokeLine(0, 0, 0, 800);
        graphicsContext2D.strokeLine(800, 0, 800, 800);
    }

    /**
     * 重置
     */
    @FXML
    private void reset() {
        pane.setDisable(false);
        isFinish = false;
        flag = "A";
        result = "";
        indexList.removeAll(indexList);
        useIndexList.removeAll(useIndexList);
        graphicsContext2D.clearRect(0, 0, 800, 800);
        draw();
    }

    @FXML
    private void saveImage() {
        if(Objects.nonNull(canvas) && Objects.nonNull(graphicsContext2D)) {
            UUID uuid = UUID.randomUUID();
            Image image = new Image("file:C:\Users\Public\world\images\"+uuid+".jpg");
            graphicsContext2D.drawImage(image, 0, 0, 800.00, 800.00);

            File file = new File("C:\Users\Public\world\images\" + uuid + ".jpg");
            WritableImage snapshot = canvas.snapshot(new SnapshotParameters(), null);
            try {
                ImageIO.write(SwingFXUtils.fromFXImage(snapshot, null), "jpg", file);
                MsgAlert.alert("保存图片成功!");
            } catch (IOException e) {
                e.printStackTrace();
                MsgAlert.alert("保存图片失败!"+e.getMessage());
            }
        }
    }

}