详细解读java的连连看游戏的源代码--【课程设计】_连连看代码java

本系列校训

互相伤害互相卷，玩命学习要你管，天生我才必有用，我命由我不由天！

毕设的技术铺垫

环境及工具：

本系列环境

项目说明

这个游戏工作量比较小，也比较粗糙。但是算法就相当的烧脑，当做学习还是相当的不错的。当毕业设计就有点拿不出手了。不过，真的能想明白算法的，毕业找工作也不是难事
界面：

总体设计

代码部分

文件编码问题。如果出现乱码，请自行根据下图设置项目编码。

项目文件目录如下：

关键核心代码：
应用软件的核心代码是指这个程序最关键部分的代码。例如WinRAR，它的核心代码就是压缩算法部分，而诸如用户界面、操作系统移植等部分就无足轻重了。
商城类的核心代码是指业务层的代码,比如你商城的核心代码就是:商品、购物车、创建订单、支付这些代码就是核心代码。

作为程序员，我们经常需要看懂别人的代码。特别是在开源社区中，我们需要理解许多优秀的开源项目的代码。而在Gitee这样的代码托管平台上，我们如何快速有效地看懂别人的代码呢？本文将为大家介绍一些方法。

1.阅读README和项目介绍

在Gitee上，许多开源项目都会有自己的README文件或项目介绍。这些文件一般会介绍项目的背景、功能、使用方法等内容，可以帮助我们快速了解这个开源项目的基本情况。如果我们能够从这些文件中找到与自己相关的内容，就可以快速入手这个开源项目的代码。

2.了解项目结构和代码组织

在阅读代码之前，我们需要先了解这个开源项目的代码结构和代码组织方式。通常，开源项目会将不同的功能模块封装到不同的代码文件中，并按照一定的目录结构组织起来。如果我们能够了解这个开源项目的代码组织方式，就能更加快速地找到所需的代码。

3.利用IDE和工具

IDE和一些代码阅读工具可以帮助我们更快速、更高效地阅读代码。例如，Java开发者可以使用Eclipse或IntelliJ IDEA这样的IDE，可以快速打开代码文件、查看类、方法和变量等信息。另外，一些代码阅读工具，如Source Insight、CodeCompare等，可以帮助我们更方便地查看代码的结构和关系，以及快速跳转到相关代码。

4.关注代码注释和文档

良好的代码注释和文档可以帮助我们更快速地理解代码。因此，在阅读别人的代码时，我们可以将注意力放在代码注释和文档上。有些开源项目会提供详细的文档，有些则注重代码注释。如果我们能够针对代码注释和文档有一个系统的阅读和理解，就能更快速地掌握别人的代码。

5.跑通测试和运行项目

如果我们想更深入地了解别人的代码，可以试着跑通相关的测试，或者直接运行这个开源项目。通过跑测试和运行项目，我们可以更加直观地了解代码的实现细节和具体的业务逻辑。

总结：

以上就是在Gitee上快速理解他人代码的一些方法，希望对大家有所帮助。当然，阅读代码是一件需要耐心和细心的事情，需要我们多花一点时间和心思。只有沉下心来，慢慢阅读每一行代码，才能真正理解它们的含义和作用。

主界面

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.*;

//单JFrame实现连连看V2.0版
//具有统计消去方块的个数功能，
//2012-7-07 18:12

public class LLKFrame3 extends JFrame {

	// 显示已消去方块数量,由于其他类访问所以定义为static
	static JTextField textarea1 = new JTextField(10);
	JPanel panel1 = new JPanel();
	LLKPanel centerPanel;

	public LLKFrame3() {
		JLabel label1 = new JLabel("已消去方块数量:");

		JButton exitButton, newlyButton;
		newlyButton = new JButton("重来一局");
		exitButton = new JButton("退出");
		this.setLayout(new BorderLayout());
		panel1.setLayout(new FlowLayout());
		panel1.add(label1);
		panel1.add(textarea1);

		panel1.add(newlyButton);
		panel1.add(exitButton);
		textarea1.setEditable(false);
		textarea1.setText(Integer.toString(0));// 显示已消去方块数量
		Container contentPane = getContentPane();
		contentPane.add(panel1, BorderLayout.NORTH);
		centerPanel = new LLKPanel();
		contentPane.add(centerPanel, BorderLayout.CENTER);
		this.setBounds(280, 100, 640, 660); // 500 450
		this.setVisible(true);
		this.setFocusable(true);
		// 鼠标事件监听
		exitButton.addMouseListener(new MouseAdapter() {// 退出
					@Override
					public void mouseClicked(MouseEvent e) {
						System.exit(0);
					}
				});
		// 鼠标事件监听
		newlyButton.addMouseListener(new MouseAdapter() {// 重来一局
					@Override
					public void mouseClicked(MouseEvent e) {
						textarea1.setText(Integer.toString(0));// 显示已消去方块数量
						centerPanel.StartNewGame();
						centerPanel.Init_Graphic();
					}
				});
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		LLKFrame3 llk = new LLKFrame3();
	}
}




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

解析主程序。
主流程。
exitButton = new JButton(“退出”);

// 鼠标事件监听
		exitButton.addMouseListener(new MouseAdapter() {// 退出
					@Override
					public void mouseClicked(MouseEvent e) {
						System.exit(0);
					}
				});
1
2
3
4
5
6
7

newlyButton = new JButton(“重来一局”);

// 鼠标事件监听
		newlyButton.addMouseListener(new MouseAdapter() {// 重来一局
					@Override
					public void mouseClicked(MouseEvent e) {
						textarea1.setText(Integer.toString(0));// 显示已消去方块数量
						centerPanel.StartNewGame();
						centerPanel.Init_Graphic();
					}
				});
1
2
3
4
5
6
7
8
9

另一个主类 ， 用于画与计算。

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Point;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.util.ArrayList;
import java.util.Random;

import javax.imageio.ImageIO;
import javax.swing.*;

public class LLKPanel extends JPanel implements MouseListener{
	/**
	 * 
	 */
    private int W = 50;                  //动物方块图案的宽度
    private int GameSize=10;             //布局大小即行列数
    private boolean Select_first = false;   //是否已经选中第一块
    private int x1, y1;                  //被选中第一块的地图坐标
    private int x2, y2;                  //被选中第二块的地图坐标
    private Point z1=new Point(0,0);
    private Point z2=new Point(0,0);    //折点棋盘坐标
    private int m_nCol = 10;
    private int m_nRow = 10;
    private int[] m_map = new int[10*10];
    private int BLANK_STATE = -1;
    public enum  LinkType {LineType,OneCornerType,TwoCornerType};
    LinkType LType;                       //连通方式

	public LLKPanel() {		
		setPreferredSize(new Dimension(500, 450));
		this.addMouseListener(this);//否则鼠标单击无反应
		StartNewGame();		
	}
	public void StartNewGame()
    {
        //初始化地图,将地图中所有方块区域位置置为空方块状态
        for(int iNum=0;iNum<(m_nCol*m_nRow);iNum++)
        {
            m_map[iNum] = BLANK_STATE;
        }
        Random r = new Random();
        //生成随机地图
        //将所有匹配成对的动物物种放进一个临时的地图中
        ArrayList  tmpMap=new ArrayList ();	
        for(int i=0;i<(m_nCol*m_nRow)/4;i++)
            for(int j=0;j<4;j++)
                tmpMap.add(i);

        //每次从上面的临时地图中取走(获取后并在临时地图删除)
        //一个动物放到地图的空方块上
        for (int i = 0; i < m_nRow * m_nCol; i++)
        {	
            //随机挑选一个位置
            int nIndex = r.nextInt(tmpMap.size())  ;
            //获取该选定物件放到地图的空方块
            m_map[i]=(Integer)tmpMap.get(nIndex);
            //在临时地图除去该动物
            tmpMap.remove(nIndex);		
        }
    }
    public void Init_Graphic()
    {
        Graphics g = this.getGraphics();           //生成Graphics对象
        for (int i = 0; i< 10 * 10; i++)
        {                
            g.drawImage(create_image(m_map[i]), W * (i % GameSize)+W, 
             W * (i / GameSize)+W, W, W,this);
        }
    }  
    //create_image（）方法实现按标号n从所有动物图案的图片中截图。
    private Image create_image(int n)  //按标号n截图 
    {
    	int x=0;
    	int y=n*39 ;
    	int w=39;
    	int h=39;
    	BufferedImage src=null;
    	BufferedImage newpic=null;
    	try{
    		 src = ImageIO.read(new File("pic\\animal2.bmp"));
    	}
    	catch(Exception e)
    	{
    		System.out.println(e);
    	}
    	newpic=src.getSubimage(x, y, w, h);//截取原图中矩形区域的图形
    	return newpic;
    }
    ///
    ///   检测是否已经赢得了游戏
    ///
    boolean IsWin()
    {
        //检测所有是否尚有非未被消除的方块
        // (非BLANK_STATE状态)
        for(int i=0;i<m_nRow*m_nCol;i++)
        {
            if(m_map[i] != BLANK_STATE)
            {
                return false;
            }
        }
        return true;
    }
    private boolean IsSame(int x1, int y1,int x2, int y2)
    {
        if (m_map[y1 * m_nCol + x1] == m_map[y2 * m_nCol + x2])
            return true;
        else
            return false; 
    }
    //
    //X直接连通即垂直方向连通
    //
    boolean X_Link(int x, int y1,int y2)
    {
        //保证y1的值小于y2
        if(y1>y2)
        {
	        //数据交换
	        int n=y1;
	        y1=y2;
	        y2=n;
        }

        //直通 	
        for(int i=y1+1;i<=y2;i++)
        {
	        if(i==y2)
		        return true;
	        if(m_map[i*m_nCol+x]!=BLANK_STATE)
		        break;
        }
        return false;
    }

    //
    //Y直接连通即水平方向连通
    //
    boolean Y_Link(int x1,int x2,int y)
    {
        if(x1>x2)
        {
	        int x=x1;
	        x1=x2;
	        x2=x;
        }
        //直通
        for(int i=x1+1;i<=x2;i++)
        {
	        if(i==x2)
		        return true;
	        if(m_map[y*m_nCol+i]!=BLANK_STATE)
		        break;
        }
        return false;
    }

    //
    //   一个折点连通
    //
    boolean OneCornerLink(int x1, int y1,int x2, int y2)
    {
        if (x1 > x2) //目标点（x1,y1）,（x2,y2）两点交换
        {
            int n=x1;
            x1=x2;
            x2=n;
            n=y1;
            y1=y2;
            y2=n;
        }
        if (y2 < y1)  //（x1,y1）为矩形左下顶点，（x2,y2）点为矩形右上顶点
        {
            //判断矩形右下角折点（x2,y1）是否空
            if (m_map[y1 * m_nCol + x2] == BLANK_STATE)
            {
                if (Y_Link(x1, x2, y1) && X_Link(x2, y1, y2))
                //判断折点（x2,y1）与两个目标点是否直通
                {
                    z1.x= x2; z1.y = y1; //保存折点坐标到z1
                    return true;
                }
            }
            //判断矩形左上角折点（x1,y2）是否空
            if (m_map[y2 * m_nCol + x1] == BLANK_STATE)
            {
                if (Y_Link(x2 , x1, y2) && X_Link(x1, y2, y1))
                    //判断折点 （x1,y2）与两个目标点是否直通
                {
                    z1.x = x1; z1.y = y2; //保存折点坐标到z1
                    return true;
                }
            }
            return false;
        }
        else    //（x1,y1）为矩形左上顶点，（x2,y2）点为矩形右下顶点
        {
            //判断矩形左下角折点（x1,y2）是否空
            if (m_map[y2 * m_nCol + x1] == BLANK_STATE)
            {
                if (Y_Link(x1, x2, y2) && X_Link(x1, y1, y2 ))
                    //判断折点 （x1,y2）与两个目标点是否直通
                {
                    z1.x = x1; z1.y = y2; //保存折点坐标到z1
                    return true;
                }
            }
            //判断矩形右上角折点（x2,y1）是否空
            if (m_map[y1 * m_nCol + x2] == BLANK_STATE)
            {
                if (Y_Link(x1 , x2, y1) && X_Link(x2, y1, y2))
                    //判断折点（x2,y1）与两个目标点是否直通  
                {
                    z1.x = x2; z1.y = y1; //保存折点坐标到z1
                    return true;
                }
            }
            return false;
        }
    }
    ///
    ///  两个折点连通
    ///
    boolean TwoCornerLink(int x1, int y1, int x2, int y2)
    {
        if (x1 > x2)
        {
            int n = x1;
            x1 = x2;
            x2 = n;
            n = y1;
            y1 = y2;
            y2 = n;
        }
        //右
        int x, y;
        for (x = x1 + 1; x <= m_nCol; x++)
        {
            if (x == m_nCol)
                //两个折点在选中方块的右侧，且两个折点在图案区域之外
                if (XThrough(x2 + 1, y2, true))
                    //Y_Link(x2 + 1, m_nCol-1, y2)&&m_map[y1 * (m_nCol-1) + x]== BLANK_STATE
                {
                    z2.x = m_nCol; z2.y = y1;
                    z1.x = m_nCol; z1.y = y2;
                    return true;
                }
                else
                    break ;
            if (m_map[y1 * m_nCol + x] != BLANK_STATE)
                break;
            if (OneCornerLink(x, y1, x2, y2))
            {
                z2.x = x; z2.y = y1;
                return true;
            }
        }
        //左
        for (x = x1 - 1; x >=-1; x--)
        {
            if (x == -1)
                //两个折点在选中方块的左侧，且两个折点在图案区域之外
                if (XThrough(x2 - 1, y2, false))
                {
                    z2.x = -1; z2.y = y1;
                    z1.x = -1; z1.y = y2;
                    return true;
                }
                else
                    break;

            if (m_map[y1 * m_nCol + x] != BLANK_STATE)
                break;
            if (OneCornerLink(x, y1, x2, y2))
            {
                z2.x = x; z2.y = y1;
                return true;
            }
        }
        //上
        for (y = y1 - 1; y >=-1; y--)
        {
            if (y == -1)
                //两个折点在选中方块的上侧，且两个折点在图案区域之外
                if (YThrough(x2, y2 - 1, false))
                {
                    z2.x = x1; z2.y = -1;
                    z1.x = x2; z1.y = -1;
                    return true;
                }
                else
                    break;
            if (m_map[y * m_nCol + x1] != BLANK_STATE)
                break;
            if (OneCornerLink(x1, y, x2, y2))
            {
                z2.x = x1; z2.y = y;
                return true;
            }
        }
        //下
        for (y = y1 + 1; y <=m_nRow; y++)
        {
            if (y == m_nRow)
                //两个折点在选中方块的下侧，且两个折点在图案区域之外
                if (YThrough(x2, y2 + 1, true))
                {
                    z2.x = x1; z2.y = m_nRow;
                    z1.x = x2; z1.y = m_nRow;
                    return true;
                }
                else
                    break;
            if (m_map[y * m_nCol + x1] != BLANK_STATE)
                break;
            if (OneCornerLink(x1, y, x2, y2))
            {
                z2.x = x1; z2.y = y;
                return true;
            }
        }
        return false;
    }
    boolean XThrough(int x, int y, boolean bAdd)//水平方向判断到边界的连通性  
    {
        if (bAdd)   //True,水平向右判断是否连通（是否为空）
        {
            for (int i = x; i < m_nCol; i++)
                if (m_map[y * m_nCol + i] != BLANK_STATE)
                    return false;
        }
        else      //false, 水平向左判断是否连通（是否为空）
        {
            for (int i = 0; i <= x; i++)
                if (m_map[y * m_nCol + i] != BLANK_STATE)
                    return false;
        }
        return true;
    }

    boolean YThrough(int x, int y, boolean bAdd)  //垂直方向判断到边界的连通性）
    {
        if(bAdd)   //True, 垂直方向向下判断是否连通（是否为空）
        {
            for(int i=y;i<m_nRow;i++)
                if(m_map[i*m_nCol+x]!=BLANK_STATE)
                    return false;
        }
        else      //false, 垂直方向向上判断是否连通（是否为空）
        {
            for(int i=0;i<=y;i++)
                if(m_map[i*m_nCol+x]!=BLANK_STATE)
                    return false;
        }
        return true;
    }

     //
    //  判断选中的两个方块是否可以消除
    //
    boolean IsLink(int x1, int y1, int x2, int y2)
    {
        //X直连方式即垂直方向连通
        if(x1==x2)
        {
            if(X_Link(x1,y1,y2))
            { LType=LinkType.LineType ; return true;}
        }
        //Y直连方式即水平方向连通
        else if(y1==y2)
        {
            if(Y_Link(x1,x2,y1))
            { LType = LinkType.LineType; return true; }
        }
        //一个转弯（折点）的联通方式
        if(OneCornerLink(x1,y1,x2,y2))
        {
            LType = LinkType.OneCornerType ; 
            return true; 
        }
        //两个转弯（折点）的联通方式
        else if(TwoCornerLink(x1,y1,x2,y2))
        {
            LType = LinkType.TwoCornerType;
            return true;
        }
        return false;
    }

    private boolean Find2Block()
    {
        boolean bFound = false;
        //第一个方块从地图的0位置开始
        for (int i = 0; i < m_nRow * m_nCol; i++)
        {
            //找到则跳出循环
            if (bFound)
                break;
            //无动物的空格跳过
            if (m_map[i] == BLANK_STATE)
                continue;
            //第二个方块从前一个方块的后面开始
            for (int j = i + 1; j < m_nRow * m_nCol; j++)
            {

                //第二个方块不为空 且与第一个方块的动物相同
                if (m_map[j] != BLANK_STATE && m_map[i] == m_map[j])
                {
                    //算出对应的虚拟行列位置
                    x1 = i % m_nCol;
                    y1 = i / m_nCol;
                    x2 = j % m_nCol;
                    y2 = j / m_nCol;

                    //判断是否可以连通
                    if (IsLink(x1, y1, x2, y2))
                    {
                        bFound = true;
                        break;
                    }
                }
            }
        }
        if (bFound)
        {
            //（x1,y1）与（x2,y2）连通
            Graphics2D g2 =(Graphics2D) this.getGraphics();     //生成Graphics对象 
            g2.setColor(Color.RED);
            BasicStroke s=new BasicStroke(4); //创建宽度是４的画笔
    		g2.setStroke(s);
            g2.drawRect(x1 * W + 1 + W, y1 * W + 1 + W, W - 3, W - 3);
            g2.drawRect(x2 * W + 1 + W, y2 * W + 1 + W, W - 3, W - 3);
        }
        return bFound;
    }

 
    /// <summary>
    /// 画选中方块之间连接线
    /// </summary>
    private void DrawLinkLine(int x1, int y1, int x2, int y2,LinkType LType)
    { 
        Graphics g = this.getGraphics();     //生成Graphics对象
        Point p1 = new Point(x1 * W + W / 2+W, y1 * W + W / 2+W);
        Point p2 = new Point(x2 * W + W / 2+W, y2 * W + W / 2+W);
        if (LType == LinkType.LineType)
            g.drawLine(p1.x,p1.y,p2.x,p2.y);
        if (LType == LinkType.OneCornerType)
        {
            Point pixel_z1 = new Point(z1.x * W + W / 2+W, z1.y * W + W / 2+W);
            g.drawLine(p1.x,p1.y,pixel_z1.x,pixel_z1.y);
            g.drawLine(pixel_z1.x,pixel_z1.y, p2.x,p2.y);
        }
        if (LType == LinkType.TwoCornerType)
        {
            Point pixel_z1 = new Point(z1.x * W + W / 2+W, z1.y * W + W / 2+W);
            Point pixel_z2 = new Point(z2.x * W + W / 2+W, z2.y * W + W / 2+W);
            if (!(p1.x == pixel_z2.x || p1.y == pixel_z2.y))
            {
                //p1与pixel_z2不在一直线上，则pixel_z1，pixel_z2交换
                Point c;
                c = pixel_z1;
                pixel_z1 = pixel_z2;
                pixel_z2 = c;
            }
            g.drawLine( p1.x,p1.y, pixel_z2.x,pixel_z2.y);
            g.drawLine( pixel_z2.x,pixel_z2.y, pixel_z1.x,pixel_z1.y);
            g.drawLine( pixel_z1.x,pixel_z1.y, p2.x,p2.y);
        } 
    }

    private void DrawSelectedBlock(int x, int y, Graphics g)            
    {    	
        //画选中方块的示意边框线
        Graphics2D g2 =(Graphics2D)g;     //生成Graphics对象        
        BasicStroke s=new BasicStroke(4); //创建宽度是4的画笔
		g2.setStroke(s);
        g.drawRect(x * W + 1+W, y * W + 1+W, W - 3, W - 3);
    }     
	// 画游戏界面
	public void paint(Graphics g) {
		//注意此处不能再生成Graphics对象,否则导致错误图像
        //g = this.getGraphics();     
		//注意此处不能清屏,否则出现闪烁问题
        //g.clearRect(0, 0, this.getWidth(), this.getHeight());
        for (int i = 0; i< 10 * 10; i++)
        {
        	if(m_map[i]==BLANK_STATE)//此处不是空百块
        		g.clearRect(W * (i % GameSize)+W, W * (i / GameSize)+W, W, W);
        	else
            g.drawImage(create_image(m_map[i]), W * (i % GameSize)+W, 
             W * (i / GameSize)+W, W, W,this);
        }
        //清除四周连线
        g.clearRect(0, 0, W, 12*W);
        g.clearRect(11*W, 0, W, 12*W);
        g.clearRect(0, 0, 12*W, W);
        g.clearRect(0,11*W , 12*W, W);
	}

	public void mouseClicked(MouseEvent e) {
		// TODO Auto-generated method stub
        Graphics g = this.getGraphics();     //生成Graphics对象
        int x, y;
        if (e.getButton() == MouseEvent.BUTTON1)//左键单击
        {
            //计算点击的方块的位置坐标
            x = (e.getX() - W) / W;
            y = (e.getY() - W) / W;
            System.out.print(x);
            System.out.println(x);
            //如果该区域无方块
            if (m_map[y * m_nCol + x] == BLANK_STATE) return;
            if (Select_first == false)
            {
                x1 = x; y1 = y;
                //画选定（x1,y1)处的框线
                DrawSelectedBlock(x1, y1, g);
                Select_first = true;
            }
            else
            {
                x2 = x; y2 = y;
                //判断第二次点击的方块是否已被第一次点击选取，如果是则返回。
                if ((x1 == x2) && (y1 == y2)) return;
                //画选定（x2,y2)处的框线
                DrawSelectedBlock(x2, y2, g);
                //判断是否连通
                if (IsSame(x1, y1, x2, y2) && IsLink(x1, y1, x2, y2))
                {
                	int grade=Integer.parseInt(LLKFrame3.textarea1.getText())+2;
                	LLKFrame3.textarea1.setText(String.valueOf(grade));
                    DrawLinkLine(x1, y1, x2, y2,LType);   //画选中方块之间连接线
                    System.out.println(x1+"连通"+y1);
                    try 
                    { 
                       Thread.currentThread().sleep(500);//毫秒,延时0.5秒
                    }
                    catch(Exception e1){} 
                    //清空记录方块的值
                    m_map[y1 * m_nCol + x1] = BLANK_STATE;
                    m_map[y2 * m_nCol + x2] = BLANK_STATE;
                    Select_first = false; 
                    repaint();
                }
                else //重新选定第一个方块
                {
                    //重画（x1,y1)处动物图案来达到取消原选定（x1,y1)处的框线
                    int i = y1 * m_nCol + x1;
                    g.drawImage(create_image(m_map[i]), W * (i % GameSize)+W,
                         W * (i / GameSize)+W, W, W,this);
                    //设置重新选定第一个方块的坐标
                    x1 = x; y1 = y;
                    Select_first = true;
                }
            }
        }
        if (e.getButton() == MouseEvent.BUTTON3)//智能查找功能
        {
            if (!Find2Block()) 
            	JOptionPane.showMessageDialog(this, "没有连通的方块了！！");
        }
        //察看是否已经胜利
        if (IsWin())
        {
        	JOptionPane.showMessageDialog(this, "恭喜您胜利闯关,即将开始新局");
            //StartNewGame();
        }		
	}

	public void mouseEntered(MouseEvent arg0) {
		// TODO Auto-generated method stub
		
	}
	public void mouseExited(MouseEvent arg0) {
		// TODO Auto-generated method stub
		
	}
	public void mousePressed(MouseEvent arg0) {
		// TODO Auto-generated method stub
		
	}
	public void mouseReleased(MouseEvent arg0) {
		// TODO Auto-generated method stub
		
	}
}




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600

游戏的过程就是，
不停的黑白，黑白（想像一下围棋）
所以，点第一下的时候，是选中第一方块。

技巧，每一个小动物/人物。其实都是一张图片，以不同的Y来显示。

一个折点。
这里只要找到这个折点就可以了。
其实，这里要再分是横的折，还是竖的折。
那么最暴力就是横折，把Y从最左，到最右就行了。
（只是一个折的只能是两个点的中间）

         -
         |
         |
         -------------
1
2
3
4

//
    //   一个折点连通
    //
    boolean OneCornerLink(int x1, int y1,int x2, int y2)
    {
        if (x1 > x2) //目标点（x1,y1）,（x2,y2）两点交换
        {
            int n=x1;
            x1=x2;
            x2=n;
            n=y1;
            y1=y2;
            y2=n;
        }
        if (y2 < y1)  //（x1,y1）为矩形左下顶点，（x2,y2）点为矩形右上顶点
        {
            //判断矩形右下角折点（x2,y1）是否空
            if (m_map[y1 * m_nCol + x2] == BLANK_STATE)
            {
                if (Y_Link(x1, x2, y1) && X_Link(x2, y1, y2))
                //判断折点（x2,y1）与两个目标点是否直通
                {
                    z1.x= x2; z1.y = y1; //保存折点坐标到z1
                    return true;
                }
            }
            //判断矩形左上角折点（x1,y2）是否空
            if (m_map[y2 * m_nCol + x1] == BLANK_STATE)
            {
                if (Y_Link(x2 , x1, y2) && X_Link(x1, y2, y1))
                    //判断折点 （x1,y2）与两个目标点是否直通
                {
                    z1.x = x1; z1.y = y2; //保存折点坐标到z1
                    return true;
                }
            }
            return false;
        }
        else    //（x1,y1）为矩形左上顶点，（x2,y2）点为矩形右下顶点
        {
            //判断矩形左下角折点（x1,y2）是否空
            if (m_map[y2 * m_nCol + x1] == BLANK_STATE)
            {
                if (Y_Link(x1, x2, y2) && X_Link(x1, y1, y2 ))
                    //判断折点 （x1,y2）与两个目标点是否直通
                {
                    z1.x = x1; z1.y = y2; //保存折点坐标到z1
                    return true;
                }
            }
            //判断矩形右上角折点（x2,y1）是否空
            if (m_map[y1 * m_nCol + x2] == BLANK_STATE)
            {
                if (Y_Link(x1 , x2, y1) && X_Link(x2, y1, y2))
                    //判断折点（x2,y1）与两个目标点是否直通  
                {
                    z1.x = x2; z1.y = y1; //保存折点坐标到z1
                    return true;
                }
            }
            return false;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

。。。然后按第一折的点，再思考二个折点的就行了。
其实也没那么复杂。因为只要考虑横着连，还是竖着连的情况就好了
后面的代码用于学习提高好了。

第三个类，是把所有的代码写一起的效果较差。

界面

论文参考
《基于java的坦克大战游戏的设计与实现–毕业论文–【毕业论文】》
https://blog.csdn.net/dearmite/article/details/131962993

配套资源

详细解读java的连连看游戏的源代码–【课程设计】
https://download.csdn.net/download/dearmite/88145623
非VIP
https://download.csdn.net/download/dearmite/88216886