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

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

本系列校训

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

毕设的技术铺垫

环境及工具:

本系列环境

环境 win7/win11
工具 idea 2018
jdk 1.8
数据库
maven
项目导入方式 打开目录
数据库前端工具

项目说明

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

界面:

总体设计

代码部分

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

项目文件目录如下:

关键核心代码:

应用软件的核心代码是指这个程序最关键部分的代码。例如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();
  }
}

解析主程序。

主流程。

exitButton = new JButton(“退出”);

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

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

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

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

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); //创建宽度是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
  }
}

游戏的过程就是,

不停的黑白,黑白(想像一下围棋)

所以,点第一下的时候,是选中第一方块。

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

一个折点。

这里只要找到这个折点就可以了。

其实,这里要再分是横的折,还是竖的折。

那么最暴力就是横折,把Y从最左,到最右就行了。

(只是一个折的只能是两个点的中间)

-
         |
         |
         -------------
//
    //   一个折点连通
    //
    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;
        }
    }

。。。然后按第一折的点,再思考二个折点的就行了。

其实也没那么复杂。因为只要考虑横着连,还是竖着连的情况就好了

后面的代码用于学习提高好了。

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

界面

论文参考

基于java的坦克大战游戏的设计与实现–毕业论文–【毕业论文】

https://blog.csdn.net/dearmite/article/details/131962993

配套资源

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

相关文章
|
4月前
|
Java 索引
Java实现扑克牌游戏 | 随机发牌 ( 过程拆分详解+完整代码 )
Java实现扑克牌游戏 | 随机发牌 ( 过程拆分详解+完整代码 )
|
1月前
|
开发框架 IDE Java
java制作游戏,如何使用libgdx,入门级别教学
本文是一篇入门级教程,介绍了如何使用libgdx游戏开发框架创建一个简单的游戏项目,包括访问libgdx官网、设置项目、下载项目生成工具,并在IDE中运行生成的项目。
50 1
java制作游戏,如何使用libgdx,入门级别教学
|
3月前
|
人工智能 算法 Java
LeetCode经典算法题:井字游戏+优势洗牌+Dota2参议院java解法
LeetCode经典算法题:井字游戏+优势洗牌+Dota2参议院java解法
50 1
|
4月前
|
Java 编译器 开发者
Java演进问题之Truffle处理不同编程语言的源代码或中间格式如何解决
Java演进问题之Truffle处理不同编程语言的源代码或中间格式如何解决
|
5月前
|
存储 Java C语言
Java面向对象课程设计--类管理系统
Java面向对象课程设计--类管理系统
31 1
|
5月前
|
前端开发 JavaScript Java
计算机Java项目|游戏美术外包管理信息系统
计算机Java项目|游戏美术外包管理信息系统
|
5月前
|
Java 编译器 C语言
JAVA如何编译源代码
JAVA如何编译源代码
31 0
|
5月前
|
Java
使用java编写猜数字游戏
使用java编写猜数字游戏
|
5月前
|
Java API 开发工具
个人微信api接口java调用源代码
个人微信api接口java调用源代码
|
IDE 小程序 前端开发
详细解读java的俄罗斯方块游戏的源代码--【课程设计】
详细解读java的俄罗斯方块游戏的源代码--【课程设计】