【java】单机版五子棋

最新推荐文章于 2021-04-11 21:00:28 发布
最新推荐文章于 2021-04-11 21:00:28 发布
阅读量718 收藏 12
点赞数 4
分类专栏： java 文章标签： 五子棋
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fragile_spume/article/details/73385622
版权 
import java.awt.Container;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Vector;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

//单机版五子棋主框架类
public class MyChess extends JFrame implements ActionListener{

    private ChessBoard CB = null;
    JPanel jp1 = null;
    JMenuBar jmb1 = null;
    JButton jb1 = null;
    JButton jb2 = null;
    JButton jb3 = null;
    JButton jb4 = null;
    JMenu jm1 = null;
    public MyChess(){               
        CB = new ChessBoard();
        Container contentPane=getContentPane();  
        contentPane.add(CB);  
        CB.setOpaque(true);  //设置控件不透明
        jm1 = new JMenu();
        jmb1 = new JMenuBar();
        Font font=new Font("方正舒体",Font.BOLD,22);//设置按钮所需字体
        //定义三个按钮
        jb1 = new JButton("开始");
        jb1.setFont(font);
        jb2 = new JButton("退出");
        jb2.setFont(font);
        jb3 = new JButton("悔棋");
        jb3.setFont(font);
        jb4 = new JButton("关于");
        jb4.setFont(font);
        jp1 = new JPanel();
        this.setTitle("单机版五子棋");//设置标题
        this.setSize(660, 730);//设置窗体大小
        this.setLocationRelativeTo(null);//使窗体显示在屏幕的正中间     
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setJMenuBar(jmb1);
        jmb1.add(jb1);
        jmb1.add(jb2);
        jmb1.add(jb3);
        jmb1.add(jb4);
        //注册监听
        jb1.addActionListener(this);
        jb1.setActionCommand("开始");
        jb2.addActionListener(this);
        jb2.setActionCommand("退出");
        jb3.addActionListener(this);
        jb3.setActionCommand("悔棋");
        jb4.addActionListener(this);
        jb4.setActionCommand("关于");
    }

        public void actionPerformed(ActionEvent e) {
            if (e.getActionCommand().equals("开始")){
                CB.startGame();
            }else if(e.getActionCommand().equals("退出")){
                if(JOptionPane.showConfirmDialog(null, "确定退出吗？") == JOptionPane.YES_OPTION){
                    System.exit(0);
                }       
            }else if(e.getActionCommand().equals("悔棋")){
                CB.goback();
            }else if(e.getActionCommand().equals("关于")){
                JOptionPane.showMessageDialog(null, "这是一个用java编写的小游戏\n作者：筱筱\n日期：20170617\n请尊重版权，谢谢！");
            }
        }
    public static void main(String[] args){
        MyChess mychess = new MyChess();//创建主框架
        mychess.setVisible(true);//显示主框架
    }
}
package Mychess02;

import java.awt.Color;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.RenderingHints;
import java.awt.Toolkit;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.geom.Ellipse2D;
import java.util.HashSet;
import java.util.Vector;

import javax.swing.JOptionPane;
import javax.swing.JPanel;

import com.sun.prism.j2d.paint.RadialGradientPaint;

import fiveChess01.Point;

//单机版五子棋棋盘类
public class ChessBoard extends JPanel implements MouseListener{
    private int margin  = 20;//页边距
    private int space  = 30;//网格间距
    private int row = 20;//行数
    private int column = 20;//列数
    ChessPiece[] chessList = new ChessPiece[(row+1)*(column+1)];//初始每个数组元素为null
    boolean isBlack = true;//默认开始是黑棋先
    boolean isgameover = false;//游戏是否结束
    int chessCount;//当前棋盘棋子的个数
    int xIndex,yIndex;//当前刚下棋子的索引
    Vector v_info = null;//所有每步走棋的信息
    private Color colortemp;

    public ChessBoard(){
        v_info = new Vector();
        addMouseListener(this);
        addMouseMotionListener(new MouseMotionListener(){
            public void mouseDragged(MouseEvent arg0) {
            }
            public void mouseMoved(MouseEvent e) {
                //将鼠标点击的坐标位置转换成网格索引
                int x1 = (e.getX()-margin+space/2)/space;
                int y1 = (e.getY()-margin+space/2)/space;
                if(x1<0||x1>row||y1<0||y1>column||isgameover||findChess(x1,y1)){
                    setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
                }else {
                    setCursor(new Cursor(Cursor.HAND_CURSOR));//鼠标改成手的形状
                }

            }

        });
    }
    public void paint(Graphics g){
        super.paint(g);//画棋盘
        g.setColor(Color.black);
        //画横线
        for(int i=0; i<row+1; i++){
            g.drawLine(margin, margin+i*space, margin+space*column, margin+i*space);    
        }
        //画竖线
        for(int i=0; i<column+1; i++){
            g.drawLine(margin+i*space, margin, margin+i*space, margin+space*row);   
        }
        //画棋子
        for(int i=0;i<chessCount;i++){
            //网格交叉点x、y坐标
            int cross_X = chessList[i].getX()*space+margin;
            int cross_Y = chessList[i].getY()*space+margin;
            g.setColor(chessList[i].getColor());
            colortemp = chessList[i].getColor();
            if(colortemp==Color.BLACK){
                RadialGradientPaint paint = new RadialGradientPaint(cross_X-ChessPiece.diameter/2+25, cross_Y-ChessPiece.diameter/2+10, 20, new float[]{0f,1f}, new Color[]{Color.WHITE, Color.BLACK});
                ((Graphics2D)g).setPaint(paint);
                //消除线段的锯齿状边缘
                ((Graphics2D)g).setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT); 
            }else if(colortemp==Color.WHITE){
                RadialGradientPaint paint = new RadialGradientPaint(cross_X-ChessPiece.diameter/2+25, cross_Y-ChessPiece.diameter/2+10, 70, new float[]{0f, 1f}  
                   , new Color[]{Color.WHITE, Color.BLACK});  
                ((Graphics2D) g).setPaint(paint);  
                ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);  
                ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT);
            }
            //Ellipse2D 类描述窗体矩形定义的椭圆。 此类是所有存储 2D 椭圆的对象的惟一抽象超类。坐标的实际存储表示形式由子类决定。
            Ellipse2D e = new Ellipse2D.Float(cross_X-ChessPiece.diameter/2, cross_Y-ChessPiece.diameter/2, 29, 30);  
            ((Graphics2D) g).fill(e);  
            //标记最后一个棋子的红矩形框                  
            if(i==chessCount-1){//如果是最后一个棋子  
                g.setColor(Color.red);  
                g.drawRect(cross_X-ChessPiece.diameter/2, cross_Y-ChessPiece.diameter/2, 29, 30);  
             }  
        }
    }
    public void mousePressed(MouseEvent e) {
        //游戏结束时，不再能下  
        if(isgameover) return; 
        String colorName=isBlack?"黑棋":"白棋";
        //将鼠标点击的坐标位置转换成网格索引  
        xIndex=(e.getX()-margin+space/2)/space;  
        yIndex=(e.getY()-margin+space/2)/space; 
        //落在棋盘外不能下  
        if(xIndex<0||xIndex>row||yIndex<0||yIndex>column)  return;
        //如果x，y位置已经有棋子存在，不能下  
        if(findChess(xIndex,yIndex))return;
        //可以进行时的处理
        ChessPiece ch=new ChessPiece(xIndex,yIndex,isBlack?Color.black:Color.white);  
        chessList[chessCount++]=ch;  
        if(chessCount%2==0){
            v_info.add(xIndex+"-"+yIndex+Color.white);
        }else{
            v_info.add(xIndex+"-"+yIndex+Color.black);
        }               
        repaint();//通知系统重新绘制

           //如果胜出则给出提示信息，不能继续下棋              
        if(isWin()){  
            String msg=String.format("恭喜，%s赢了！", colorName);  
            JOptionPane.showMessageDialog(this, msg);  
            isgameover=true;  
           }  
           isBlack=!isBlack;  

    }
    private boolean isWin() {
        int continueCount = 0;
        //判断横向的棋子数量
        for(int i=0;i<5;i++){
            if(v_info.contains((xIndex+i)+"-"+yIndex+Color.white)){
                continueCount++;
            }else{
                break;
            }
        }
        if(continueCount>=5){
            return true;
        }else{
            continueCount = 0;
        }
        for(int i=0;i<5;i++){
            if(v_info.contains((xIndex-i)+"-"+yIndex+Color.white)){
                continueCount++;
            }else{
                break;
            }
        }
        if(continueCount>=5){
            return true;
        }else{
            continueCount = 0;
        }
        for(int i=0;i<5;i++){
            if(v_info.contains((xIndex+i)+"-"+yIndex+Color.black)){
                continueCount++;
            }else{
                break;
            }
        }
        if(continueCount>=5){
            return true;
        }else{
            continueCount = 0;
        }
        for(int i=0;i<5;i++){
            if(v_info.contains((xIndex-i)+"-"+yIndex+Color.BLACK)){
                continueCount++;
            }else{
                break;
            }
        }
        if(continueCount>=5){
            return true;
        }else{
            continueCount = 0;
        }
        //判断纵向棋子数量
        for(int i=0;i<5;i++){
            if(v_info.contains(xIndex+"-"+(yIndex+i)+Color.WHITE)){
                continueCount++;
            }else{
                break;
            }
        }
        if(continueCount>=5){
            return true;
        }else{
            continueCount = 0;
        }
        for(int i=0;i<5;i++){
            if(v_info.contains(xIndex+"-"+(yIndex-i)+Color.WHITE)){
                continueCount++;
            }else{
                break;
            }
        }
        if(continueCount>=5){
            return true;
        }else{
            continueCount = 0;
        }
        for(int i=0;i<5;i++){
            if(v_info.contains(xIndex+"-"+(yIndex+i)+Color.BLACK)){
                continueCount++;
            }else{
                break;
            }
        }
        if(continueCount>=5){
            return true;
        }else{
            continueCount = 0;
        }
        for(int i=0;i<5;i++){
            if(v_info.contains(xIndex+"-"+(yIndex-i)+Color.black)){
                continueCount++;
            }else{
                break;
            }
        }
        if(continueCount>=5){
            return true;
        }else{
            continueCount = 0;
        }
        //判断135度倾斜方向
        for(int i=0;i<5;i++){
            if(v_info.contains((xIndex+i)+"-"+(yIndex+i)+Color.WHITE)){
                continueCount++;
            }else{
                break;
            }
        }
        if(continueCount>=5){
            return true;
        }else{
            continueCount = 0;
        }
        for(int i=0;i<5;i++){
            if(v_info.contains((xIndex-i)+"-"+(yIndex-i)+Color.WHITE)){
                continueCount++;
            }else{
                break;
            }
        }
        if(continueCount>=5){
            return true;
        }else{
            continueCount = 0;
        }
        for(int i=0;i<5;i++){
            if(v_info.contains((xIndex+i)+"-"+(yIndex+i)+Color.black)){
                continueCount++;
            }else{
                break;
            }
        }
        if(continueCount>=5){
            return true;
        }else{
            continueCount = 0;
        }
        for(int i=0;i<5;i++){
            if(v_info.contains((xIndex-i)+"-"+(yIndex-i)+Color.BLACK)){
                continueCount++;
            }else{
                break;
            }
        }
        if(continueCount>=5){
            return true;
        }else{
            continueCount = 0;
        }
        //倾斜45度角判断
        for(int i=0;i<5;i++){
            if(v_info.contains((xIndex+i)+"-"+(yIndex-i)+Color.WHITE)){
                continueCount++;
            }else{
                break;
            }
        }
        if(continueCount>=5){
            return true;
        }else{
            continueCount = 0;
        }
        for(int i=0;i<5;i++){
            if(v_info.contains((xIndex-i)+"-"+(yIndex+i)+Color.WHITE)){
                continueCount++;
            }else{
                break;
            }
        }
        if(continueCount>=5){
            return true;
        }else{
            continueCount = 0;
        }
        for(int i=0;i<5;i++){
            if(v_info.contains((xIndex+i)+"-"+(yIndex-i)+Color.BLACK)){
                continueCount++;
            }else{
                break;
            }
        }
        if(continueCount>=5){
            return true;
        }else{
            continueCount = 0;
        }
        for(int i=0;i<5;i++){
            if(v_info.contains((xIndex-i)+"-"+(yIndex+i)+Color.BLACK)){
                continueCount++;
            }else{
                break;
            }
        }
        if(continueCount>=5){
            return true;
        }else{
            continueCount = 0;
        }
        return false;
    }
    private boolean findChess(int x,int y){  
        for(ChessPiece c:chessList){  
            if(c!=null&&c.getX()==x&&c.getY()==y)  
                return true;  
        }  
        return false;  
    }
    //开始游戏
    public void startGame(){
        //清除棋子  
           for(int i=0;i<chessList.length;i++){  
               chessList[i]=null;  
               v_info.removeAll(v_info);
           }  
           //恢复游戏相关的变量值  
           isBlack=true;  
           isgameover=false; //游戏是否结束  
           chessCount =0; //当前棋盘棋子个数  
           repaint();  

    }
    //悔棋
    public void goback(){
        if(chessCount==0)  
               return ;  
           chessList[chessCount-1]=null;  
           chessCount--;  
           v_info.remove(v_info.size()-1);
           if(chessCount>0){  
               xIndex=chessList[chessCount-1].getX();  
               yIndex=chessList[chessCount-1].getY();  
           }  
           isBlack=!isBlack;  
           repaint();  
    }
    public void mouseClicked(MouseEvent arg0) {
        // TODO Auto-generated method stub

    }

    @Override
    public void mouseEntered(MouseEvent arg0) {
        // TODO Auto-generated method stub

    }

    @Override
    public void mouseExited(MouseEvent arg0) {
        // TODO Auto-generated method stub

    }

    @Override
    public void mouseReleased(MouseEvent arg0) {
        // TODO Auto-generated method stub

    }

}

package Mychess02;

import java.awt.Color;

public class ChessPiece {
    private int x;//棋盘中x索引
    private int y;//棋盘中y索引
    private Color color;
    public static final int diameter = 30;//直径 
    public ChessPiece(int x, int y, Color color){
        this.x = x;
        this.y = y;
        this.color = color;
    }

    public int getX() {
        return x;
    }
    public int getY() {
        return y;
    }
    public Color getColor(){//获得棋子的颜色  
          return color;  
      }  
}

这里写图片描述
这里写图片描述

Songs_Hu
关注
专栏目录
java五子棋单机版（附带简单的AI实现）
07-21
java写的单机版五子棋AI版，源码在jar文件内～
Java单机版五子棋
Loving you
07-11 1552
一、该游戏需要的实现的： 1、设计主框架，界面。 2、利用ActionListener接口实现按钮事件的监听。 3、重新开始功能的实现。 4、悔棋功能的实现。 5、退出功能的实现。 6、棋盘中棋子点类的定义。 7，利用MouseListener接口实现事件监听，并实现接口里的所有方法。 8，当鼠标移动到棋盘上的交点上，且该点上无棋子时能够变成小手形状。 9，点击棋盘时，利用if语句
Java单机版五子棋源码
09-17
利用Java语言编写各种优秀的实例，例如五子棋游戏，对学习Java语言的新手是个很好的锻炼。
java实现单机版五子棋游戏源码下载
12-10
用java实现的五子棋游戏，是单机版，很简单，可以供参考
JAVA单机版五子棋
11-18
单机版五子棋，利用JAVA的Swing写界面，加入贴图，实现两人黑白棋轮流下子，无禁手，基本实现了所有功能（没有人机功能，需要人机对战的看我另一个版本的五子棋）
java实现单机版五子棋
08-27
本文将详细介绍如何使用Java实现一个简单的单机版五子棋游戏。五子棋是一种双人对弈的策略游戏，目标是在棋盘上形成连续的五个同色棋子，无论是横、竖还是斜线。以下将按照游戏所需的功能进行详细讲解。 一、游戏...
java单机版五子棋
12-02
【Java单机版五子棋】是一款基于Java编程语言开发的桌面游戏，它利用Java的Swing库构建了用户友好的图形用户界面（GUI），使玩家可以在计算机上体验五子棋的乐趣。在这个项目中，我们可以深入探讨Java Swing、事件...
JAVA五子棋单机版
qq_39754389的博客
01-28 452
Java五子棋设计流程： 1.创建窗口和设计一个棋盘界面 2.实现鼠标点击，棋子出现，黑白棋轮流下 3.能够判断输赢 4.添加按钮功能 4 实现结果图： import java.awt.BorderLayout; import java.awt.Color; import java.awt.Cursor; import java.awt
五子棋1.0（Java单机版）
qq_43533435的博客
11-13 668
简介 这个程序实现了单机版五子棋，目前无法联机，只能自己跟自己下。 棋盘是20*20的。 主要功能：下棋、认输、悔棋、重新开始、退出等功能 PS：目前设置只有显示游戏规则。 截图 完整代码 package Gobang; import javax.swing.*; import java.awt.*; import java.awt.event.*; import java.awt.image.*; //import java.applet.*; //import java.net.*; //impo
Java 单机版的五子棋（毕业设计）
05-15
单机版的五子棋 很不错 有简单功能 学习java的可以看看 毕业设计做相关的也可以看看
java 五子棋 源码+算法 .java(经典单机版)
10-11
java 五子棋 算法
五子棋单机版 java实现
12-29
五子棋单机版java实现，窗口大小可变，双人对战， application程序，有比分统计，可暂停游戏，可以悔棋。
单机版五子棋java代码实现。
04-20
这是我暑假时根据书上提供的代码编写的五子棋程序，程序的结构设计很合理，而且有注释，希望大家能从中提取到对自己有用的东西。
五子棋 单机版
05-28
五子棋单机版 内含可执行程序，源码，以及程序开发完整实现文档 此项目由我个人编程实现，您可任意引用，但注意版权归我所有。
单机版五子棋代码
05-22
单机版五子棋代码
java 五子棋_Java GUI 单机版五子棋
weixin_36070282的博客
02-19 165
@SuppressWarnings("ALL")public class MyFrame extendsFrame {private static int y;//鼠标点击的X轴private static int x;//鼠标点击的Y轴private int[][] xY = new int[400][2];//定义二维数组x_y来保存每一个棋子的坐标，用于界面的展示private int a ...
单机java_java实现单机版五子棋小游戏
weixin_42165508的博客
02-12 729
简单的java小游戏–单机版五子棋学了java有一段时间了，今天就来搞一个简单的单机版五子棋游戏。实现功能：那必须能进行基础的输赢判断。还有重新开始的功能，悔棋的功能，先手设置的功能和退出的功能。在右上角能够显示目前轮到哪个棋种下棋。右下角还有一个记录信息框，记录行为，当信息量过多时，可以清除信息内容。成果：初始界面：游戏(获胜)界面：附上代码：Chessframe.javapackage fir...
五子棋(Java版)
落日晨曦
02-22 1271
版本1.0 程序界面: 编译环境： JDK1.6 + Eclipse3.7 下载地址： http://download.csdn.net/detail/yy873259480/5111250
Java实现单机五子棋，含完整代码
m0_52237654的博客
04-11 2337
文章目录五子棋！！实现功能改进方向主体思路遇到的困难完整代码 五子棋！！ 实现功能 基本的棋盘绘制，重绘，输赢判断，悔棋，重新开始 改进方向 添加背景音乐，背景图片美化，用棋子图片代替原棋子（这里只是画不同颜色的圆代表棋子） 主体思路 用一个二维数组代表棋盘状态，数组中不同的值表示空或者红方或者蓝方。鼠标点击时判断点的格子是哪个并修改相应值、画出棋子。 遇到的困难 点击边缘的格子，判断输赢时会超出数组边界，所以要检查一下某一方向是否到达边界 完整代码 package gobang; import java.
Java实现单机版五子棋游戏详细教程
"java实现单机版五子棋" 在Java编程中实现一个单机版的五子棋游戏是一项常见的教学任务，它可以帮助初学者更好地理解面向对象编程、事件监听、图形用户界面（GUI）设计等核心概念。下面将详细解释这个项目的各个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值