2020-12-14

最新推荐文章于 2024-10-10 08:21:07 发布
最新推荐文章于 2024-10-10 08:21:07 发布
阅读量134 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53089619/article/details/111150072
版权 
                 基于 A*搜索算法迷宫游戏开发

1、项目概述
（1）项目目标和主要内容
<1>迷宫游戏是非常经典的游戏，在该题中要求随机生成一个迷宫，并求解迷宫；
<2>要求查找并理解迷宫生成的算法，并尝试用两种不同的算法来生成随机的迷宫。
<3>要求游戏支持玩家走迷宫，和系统走迷宫路径两种模式。玩家走迷宫，通过键盘 方向键控制，并在行走路径上留下痕迹；系统走迷宫路径要求基于 A算法实现，输出走迷宫的最优路径并显示。设计交互友好的游戏图形界面。
（2）项目的主要功能
<1>迷宫游戏可以锻炼我们对数据结构中图的更好的理解
<2>迷宫游戏可以通过键盘控制方向，输出走的方向。
2、编写程序的语言为Java。
3、A算法的原理
A* （A-Star)算法是bai一种静态路网du中求解最短路最有zhi效的直接dao搜索方法。注意是最有效的直接搜索算法。之后涌shu现了很多预处理算法（ALT，CH，HL等等），在线查询效率是A*算法的数千甚至上万倍。
公式表示为： f(n)=g(n)+h(n),其中 f(n) 是从初始点经由节点n到目标点的估价函数，g(n) 是在状态空间中从初始节点到n节点的实际代价，
h(n) 是从n到目标节点最佳路径的估计代价。保证找到最短路径（最优解的）条件，关键在于估价函数f(n)的选取：估价值h(n)<= n到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范围大，效率低。但能得到最优解。并且如果h(n)=d(n)，即距离估计h(n)等于最短距离，那么搜索将严格沿着最短路径进行， 此时的搜索效率是最高的。如果 估价值>实际值,搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。
4、对于项目的想法
2.1项目总体框架
包括系统框架图或层次逻辑图，设计思想等。系统详细设计
【1】 模块划分图及描述
在这里插入图片描述

【2】 存储结构、内存分配
在这里插入图片描述

【3】 程序流程图及描述
在这里插入图片描述
2.2关键算法分析
算法 1：函数名GameClient
【1】 算法功能
图形界面的实现和优先级的判断
【2】 算法基本思想
继承父类JFrame，构造图形界面。
【3】 算法空间、时间复杂度分析
<1>算法空间复杂度分析：递归算法来说，一般都比较简短，算法本身所占用的存储空间较少，但运行时需要一个附加堆栈，从而占用较多的临时工作单元；若写成非递归算法，一般可能比较长，算法本身占用的存储空间较多，但运行时将可能需要较少的存储单元。
<2>算法时间复杂度分析：当追求一个较好的时间复杂度时，可能会使空间复杂度的性能变差，即可能导致占用较多的存储空间；反之，当追求一个较好的空间复杂度时，可能会使时间复杂度的性能变差，即可能导致占用较长的运行时间。另外，算法的所有性能之间都存在着或多或少的相互影响。因此，当设计一个算法(特别是大型算法)时，要综合考虑算法的各项性能，算法的使用频率，算法处理的数据量的大小，算法描述语言的特性，算法运行的机器系统环境等各方面因素，才能够设计出比较好的算法。算法的时间复杂度和空间复杂度合称为算法的复杂度。
【4】 代码逻辑（可用伪代码描述）
public class GameClient extends JFrame{

public GameClient(){
this.getContentPane().add(new GamePanel(20, 40));
pack();
setTitle(“pic0”);
setVisible(true);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); }

public static void main(String[] args) {
new GameClient();
}

}

算法 2：函数名 GamePanel
【1】 算法功能
实现对JFrame方法的布置，键盘控制走的方向
【2】 算法基本思想
图，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。
【3】 算法空间、时间复杂度分析
<1>算法空间复杂度分析：递归算法来说，一般都比较简短，算法本身所占用的存储空间较少，但运行时需要一个附加堆栈，从而占用较多的临时工作单元；若写成非递归算法，一般可能比较长，算法本身占用的存储空间较多，但运行时将可能需要较少的存储单元。
<2>算法时间复杂度分析：当追求一个较好的时间复杂度时，可能会使空间复杂度的性能变差，即可能导致占用较多的存储空间；反之，当追求一个较好的空间复杂度时，可能会使时间复杂度的性能变差，即可能导致占用较长的运行时间。另外，算法的所有性能之间都存在着或多或少的相互影响。因此，当设计一个算法(特别是大型算法)时，要综合考虑算法的各项性能，算法的使用频率，算法处理的数据量的大小，算法描述语言的特性，算法运行的机器系统环境等各方面因素，才能够设计出比较好的算法。算法的时间复杂度和空间复杂度合称为算法的复杂度。
【4】 代码逻辑（可用伪代码描述）
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

import javax.swing.*;

public class GamePanel extends JPanel implements KeyListener{

int[][] map;
MapUtil mapUtil;
int row,col;
int leftX,leftY;
int manX,manY;
int direction;
int manIndex;
Image[] pics;

public static final int BLANK=-1,MAN=0,WALL=1,EXIT=2,UP=1,DOWN=2,LEFT=3,RIGHT=4;

public GamePanel(int row,int col){
this.row = row;
this.col = col;
leftX = 0;
leftY = 0;
manX = 1;
manY = 1;
pics = new Image[20];
mapUtil = new MapUtil(row, col);
map = mapUtil.getMap();
map[manX][manY] = MAN;
manIndex = 0;
direction = DOWN;
getPics();
setPreferredSize(new Dimension((col*2+1)20,(row2+1)*20));
addKeyListener(this);
setFocusable(true);
}

private void getPics() {
for(int i=0;i<20;i++){
pics[i] = Toolkit.getDefaultToolkit().getImage(“D:/Game/MazeGameEasy/pic”+i+".png");
}
}

public void paint(Graphics g){

  g.clearRect(0, 0, getWidth(), getHeight());
  for(int i=0;i<2*row+1;i++){
     for(int j=0;j<2*col+1;j++){
        if(map[i][j]==WALL){
           g.drawImage(pics[0],leftX+20*j, leftY+20*i, 20, 20, this);
        }else if(map[i][j]==MAN){
           
           switch(direction){
           case UP:
              g.drawImage(pics[1],leftX+20*j, leftY+20*i, 20, 20,this);
              g.drawImage(pics[3+manIndex], leftX+20*j, leftY+20*i, 20, 20, this);
              break;
           case DOWN:
              g.drawImage(pics[1],leftX+20*j, leftY+20*i, 20, 20,this);
              g.drawImage(pics[7+manIndex], leftX+20*j, leftY+20*i, 20, 20, this);
              break;
           case LEFT:
              g.drawImage(pics[1],leftX+20*j, leftY+20*i, 20, 20,this);
              g.drawImage(pics[11+manIndex], leftX+20*j, leftY+20*i, 20, 20, this);
              break;
           case RIGHT:
              g.drawImage(pics[1],leftX+20*j, leftY+20*i, 20, 20,this);
              g.drawImage(pics[15+manIndex], leftX+20*j, leftY+20*i, 20, 20, this);
              break;
           }
           
        }else if(map[i][j]==BLANK){
           g.drawImage(pics[1],leftX+20*j, leftY+20*i, 20, 20,this);
        }else{
           g.drawImage(pics[2],leftX+20*j, leftY+20*i, 20, 20,this);
        }
     }
  }

}

@Override
public void keyPressed(KeyEvent e) {
switch(e.getKeyCode()){
case KeyEvent.VK_UP:
if(map[manX-1][manY]!=WALL){
if(map[manX-1][manY]==EXIT){
JOptionPane.showMessageDialog(this, “pic0”);
return ;
}

        if(direction==UP){
           manIndex=manIndex+1==4?0:++manIndex;
        }else{
           manIndex=0;
           direction=UP;
        }           
  
        map[manX][manY] = BLANK;
        manX -= 1;
        map[manX][manY] = MAN;
     }
     ;break;
  case KeyEvent.VK_DOWN:
     if(map[manX+1][manY]!=WALL){
        if(map[manX+1][manY]==EXIT){
           JOptionPane.showMessageDialog(this, "pic0");
           return ;
        }     
        
        if(direction==DOWN){
           manIndex=manIndex+1==4?0:++manIndex;
        }else{
           manIndex=0;
           direction=DOWN;
        }
        
        map[manX][manY] = BLANK;
        manX += 1;
        map[manX][manY] = MAN; 
     }
     ;break;
  case KeyEvent.VK_LEFT:
     if(map[manX][manY-1]!=WALL){
        if(map[manX][manY-1]==EXIT){
           JOptionPane.showMessageDialog(this, "pic0");
           return ;
        }     
        
        if(direction==LEFT){
           manIndex=manIndex+1==4?0:++manIndex;
        }else{
           manIndex=0;
           direction=LEFT;
        }
        map[manX][manY] = BLANK;
        manY -= 1;
        map[manX][manY] = MAN; 
     }
     ;break;
  case KeyEvent.VK_RIGHT:
     if(map[manX][manY+1]!=WALL){
        if(map[manX][manY+1]==EXIT){
           JOptionPane.showMessageDialog(this, "pic0");
           return ;
        }     
        if(direction==RIGHT){
           manIndex=manIndex+1==4?0:++manIndex;
        }else{
           manIndex=0;
           direction=RIGHT;
        }
        map[manX][manY] = BLANK;
        manY += 1;
        map[manX][manY] = MAN; 
     }
     ;break;
  }
  repaint();

}

@Override
public void keyReleased(KeyEvent e) {

}

@Override
public void keyTyped(KeyEvent e) {

}

}

算法 3：函数名MapUtil
【1】 算法功能
进行测试
【2】 算法基本思想
遍历函数
【3】 算法空间、时间复杂度分析
<1>算法空间复杂度分析：简单
<2>算法时间复杂度分析：算法的所有性能之间都存在着或多或少的相互影响。因此，当设计一个算法(特别是大型算法)时，要综合考虑算法的各项性能，算法的使用频率，算法处理的数据量的大小，算法描述语言的特性，算法运行的机器系统环境等各方面因素，才能够设计出比较好的算法。算法的时间复杂度和空间复杂度合称为算法的复杂度。
【4】 代码逻辑（可用伪代码描述）
public class MapUtil {
Union unionUtil;
ArrayList list;
ArrayList map;
int row;
int col;

public MapUtil(int row,int col){
this.row = row;
this.col = col;
unionUtil = new Union(row*col);
list = new ArrayList();
map = new ArrayList();
init();
}

public void init(){
for(int i=0;i<col-1;i++){
list.add(new Edge(i,i+1,(int) (Math.random()*100000)));
}

  for(int i=0;i<row-1;i++){
     list.add(new Edge(i*col,(i+1)*col,(int) (Math.random()*100000)));
  }
  
  for(int i=1;i<row;i++){
     for(int j=1;j<col;j++){
        list.add(new Edge(i*col+j-1,i*col+j,(int) (Math.random()*100000)));
        list.add(new Edge((i-1)*col+j,i*col+j,(int) (Math.random()*100000)));
     }
  }
  
  Collections.sort(list,new Comparator<Edge>() {
      @Override
        public int compare(Edge o1, Edge o2) {
           if(o1.value<o2.value)
              return -1;
           else
              return 1;
        }
  })；
  
  int count = 0;

  for(Edge edge:list){
     int start = edge.start;
     int end = edge.end;
     if(!unionUtil.isConnected(start, end)){
        unionUtil.union(start, end);
        map.add(edge);
        count++;
        if(count==col*row-1)
           break;
     }
  }

}

public int[][] getMap(){
int[][] array1 = new int[2row+1][2col+1]；
for(int i=1;i<2row+1;i+=2){
for(int j=1;j<2col+1;j+=2){
array1[i][j] = -1;
}
}

  for(int i=1;i<2*row+1;i+=2){
     for(int j=2;j<2*col+1;j+=2){
        array1[i][j] = 1;
     }
  }
  for(int i=0;i<2*row+1;i+=2){
     for(int j=1;j<2*col+1;j++){
        array1[i][j] = 1;
     }
  }
  
  
        for(int i=0;i<2*row+1;i++){
     array1[i][0] = 1;
  }
  }
  for(Edge edge:map){
     int start = edge.start;
     int end = edge.end;
     if(Math.abs(start-end)==1){
        int x = start/col;
        int y = start%col;
        array1[2*x+1][2*y+2] = -1;
     }else{
        int x = start/col;
        int y = start%col;
        array1[2*x+2][2*y+1] = -1;
     }  
  }


  for(int i=0;i<2*row+1;i++){
     for(int j=0;j<2*col+1;j++){
        if(array1[i][j]==-1)
           System.out.print(" ");
        else
           System.out.print("#");
     }
     System.out.println();
  }
  array1[2*row][2*col-1] = 2;
  
  return array1;

}

public void print(){
int index = 0;
for(Edge edge:map){
if(index%10==0)
System.out.println();
System.out.print("("+edge.start+","+edge.end+","+edge.value+")");
index ++;
}
}

}

3、程序运行结果分析
开始界面：

结束界面：
4、总结
1、项目的难点和关键点
在这个项目中，难点在于代码的编写，在编写代码过程中最难的还是优先级的完成，图论算法中由任意一点出发遍历整个连通图的其他所有顶点的遍历算法即可找到一条从迷宫入口到迷宫出口的路径。
2、项目的评价
图论算法中由任意一点出发遍历整个连通图的其他所有顶点的遍历算法即可找到一条从迷宫入口到迷宫出口的路径。
3、心得体会
在这次的简易计算机的实现过程中，使我对Java有了更深的理解。
5、实验代码
package maze;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class MapUtil {
Union unionUtil;
ArrayList list;
ArrayList map;
int row;
int col;

public MapUtil(int row,int col){
this.row = row;
this.col = col;
unionUtil = new Union(row*col);
list = new ArrayList();
map = new ArrayList();
init();
}

public void init(){
for(int i=0;i<col-1;i++){
list.add(new Edge(i,i+1,(int) (Math.random()*100000)));
}

  for(int i=0;i<row-1;i++){
     list.add(new Edge(i*col,(i+1)*col,(int) (Math.random()*100000)));
  }
  
  for(int i=1;i<row;i++){
     for(int j=1;j<col;j++){
        list.add(new Edge(i*col+j-1,i*col+j,(int) (Math.random()*100000)));
        list.add(new Edge((i-1)*col+j,i*col+j,(int) (Math.random()*100000)));
     }
  }
  
  Collections.sort(list,new Comparator<Edge>() {
      @Override
        public int compare(Edge o1, Edge o2) {
           if(o1.value<o2.value)
              return -1;
           else
              return 1;
        }
  });
  
  int count = 0;

  for(Edge edge:list){
     int start = edge.start;
     int end = edge.end;
     if(!unionUtil.isConnected(start, end)){
        unionUtil.union(start, end);
        map.add(edge);
        count++;
        if(count==col*row-1)
           break;
     }
  }

}

public int[][] getMap(){
int[][] array1 = new int[2row+1][2col+1];

  for(int i=1;i<2*row+1;i+=2){
     for(int j=1;j<2*col+1;j+=2){
        array1[i][j] = -1;
     }
  }
  
  
  for(int i=1;i<2*row+1;i+=2){
     for(int j=2;j<2*col+1;j+=2){
        array1[i][j] = 1;
     }
  }
  

  for(int i=0;i<2*row+1;i+=2){
     for(int j=1;j<2*col+1;j++){
        array1[i][j] = 1;
     }
  }
  

  for(int i=0;i<2*row+1;i++){
     array1[i][0] = 1;
  }
  
  
  for(Edge edge:map){
     int start = edge.start;
     int end = edge.end;
     if(Math.abs(start-end)==1){
        int x = start/col;
        int y = start%col;
        array1[2*x+1][2*y+2] = -1;
     }else{
        int x = start/col;
        int y = start%col;
        array1[2*x+2][2*y+1] = -1;
     }  
  }


  for(int i=0;i<2*row+1;i++){
     for(int j=0;j<2*col+1;j++){
        if(array1[i][j]==-1)
           System.out.print(" ");
        else
           System.out.print("#");
     }
     System.out.println();
  }
  array1[2*row][2*col-1] = 2;
  
  return array1;

}

public void print(){
int index = 0;
for(Edge edge:map){
if(index%10==0)
System.out.println();
System.out.print("("+edge.start+","+edge.end+","+edge.value+")");
index ++;
}
}

}

import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

import javax.swing.*;

public class GamePanel extends JPanel implements KeyListener{

int[][] map;
MapUtil mapUtil;
int row,col;
int leftX,leftY;
int manX,manY;
int direction;
int manIndex;
Image[] pics;

public static final int BLANK=-1,MAN=0,WALL=1,EXIT=2,UP=1,DOWN=2,LEFT=3,RIGHT=4;

public GamePanel(int row,int col){
this.row = row;
this.col = col;
leftX = 0;
leftY = 0;
manX = 1;
manY = 1;
pics = new Image[20];
mapUtil = new MapUtil(row, col);
map = mapUtil.getMap();
map[manX][manY] = MAN;
manIndex = 0;
direction = DOWN;
getPics();
setPreferredSize(new Dimension((col*2+1)20,(row2+1)*20));
addKeyListener(this);
setFocusable(true);
}

private void getPics() {
for(int i=0;i<20;i++){
pics[i] = Toolkit.getDefaultToolkit().getImage(“D:/Game/MazeGameEasy/pic”+i+".png");
}
}

public void paint(Graphics g){

  g.clearRect(0, 0, getWidth(), getHeight());
  for(int i=0;i<2*row+1;i++){
     for(int j=0;j<2*col+1;j++){
        if(map[i][j]==WALL){
           g.drawImage(pics[0],leftX+20*j, leftY+20*i, 20, 20, this);
        }else if(map[i][j]==MAN){
           
           switch(direction){
           case UP:
              g.drawImage(pics[1],leftX+20*j, leftY+20*i, 20, 20,this);
              g.drawImage(pics[3+manIndex], leftX+20*j, leftY+20*i, 20, 20, this);
              break;
           case DOWN:
              g.drawImage(pics[1],leftX+20*j, leftY+20*i, 20, 20,this);
              g.drawImage(pics[7+manIndex], leftX+20*j, leftY+20*i, 20, 20, this);
              break;
           case LEFT:
              g.drawImage(pics[1],leftX+20*j, leftY+20*i, 20, 20,this);
              g.drawImage(pics[11+manIndex], leftX+20*j, leftY+20*i, 20, 20, this);
              break;
           case RIGHT:
              g.drawImage(pics[1],leftX+20*j, leftY+20*i, 20, 20,this);
              g.drawImage(pics[15+manIndex], leftX+20*j, leftY+20*i, 20, 20, this);
              break;
           }
           
        }else if(map[i][j]==BLANK){
           g.drawImage(pics[1],leftX+20*j, leftY+20*i, 20, 20,this);
        }else{
           g.drawImage(pics[2],leftX+20*j, leftY+20*i, 20, 20,this);
        }
     }
  }

}

@Override
public void keyPressed(KeyEvent e) {
switch(e.getKeyCode()){
case KeyEvent.VK_UP:
if(map[manX-1][manY]!=WALL){
if(map[manX-1][manY]==EXIT){
JOptionPane.showMessageDialog(this, “pic0”);
return ;
}

        if(direction==UP){
           manIndex=manIndex+1==4?0:++manIndex;
        }else{
           manIndex=0;
           direction=UP;
        }           
  
        map[manX][manY] = BLANK;
        manX -= 1;
        map[manX][manY] = MAN;
     }
     ;break;
  case KeyEvent.VK_DOWN:
     if(map[manX+1][manY]!=WALL){
        if(map[manX+1][manY]==EXIT){
           JOptionPane.showMessageDialog(this, "pic0");
           return ;
        }     
        
        if(direction==DOWN){
           manIndex=manIndex+1==4?0:++manIndex;
        }else{
           manIndex=0;
           direction=DOWN;
        }
        
        map[manX][manY] = BLANK;
        manX += 1;
        map[manX][manY] = MAN; 
     }
     ;break;
  case KeyEvent.VK_LEFT:
     if(map[manX][manY-1]!=WALL){
        if(map[manX][manY-1]==EXIT){
           JOptionPane.showMessageDialog(this, "pic0");
           return ;
        }     
        
        if(direction==LEFT){
           manIndex=manIndex+1==4?0:++manIndex;
        }else{
           manIndex=0;
           direction=LEFT;
        }
        map[manX][manY] = BLANK;
        manY -= 1;
        map[manX][manY] = MAN; 
     }
     ;break;
  case KeyEvent.VK_RIGHT:
     if(map[manX][manY+1]!=WALL){
        if(map[manX][manY+1]==EXIT){
           JOptionPane.showMessageDialog(this, "pic0");
           return ;
        }     
        if(direction==RIGHT){
           manIndex=manIndex+1==4?0:++manIndex;
        }else{
           manIndex=0;
           direction=RIGHT;
        }
        map[manX][manY] = BLANK;
        manY += 1;
        map[manX][manY] = MAN; 
     }
     ;break;
  }
  repaint();

}

@Override
public void keyReleased(KeyEvent e) {

}

@Override
public void keyTyped(KeyEvent e) {

}

}
public class Union {

int count;
int[] parent;
int[] rank;
public Union(int count){
this.count = count;
parent = new int[count];
rank = new int[count];
for(int i=0;i<count;i++){
parent[i] = i;
rank[i] = 1;
}
}

public int find(int p){
while(parent[p]!=p){
p = parent[p];
parent[p] = parent[parent[p]];
}
return parent[p];
}

public boolean isConnected(int p,int q){
return find§==find(q);
}

public void union(int p,int q){
int pRoot = find§;
int qRoot = find(q);
if(pRoot == qRoot){
return ;
}
if(rank[pRoot]<rank[qRoot]){
parent[pRoot] = qRoot;
}else if(rank[pRoot]>rank[qRoot]){
parent[qRoot] = pRoot;
}else{
parent[pRoot] = qRoot;
rank[qRoot]++;
}
}

}

public class Edge{

int start;
int end;
int value;

public Edge(){

}

public Edge(int start,int end,int value){
this.start = start;
this.end = end;
this.value = value;
}

}

import java.awt.event.WindowEvent;

import javax.swing.JFrame;
import javax.swing.JLabel;

public class GameClient extends JFrame{

public GameClient(){
this.getContentPane().add(new GamePanel(20, 40));
pack();
setTitle(“pic0”);
setVisible(true);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}

public static void main(String[] args) {
new GameClient();
}

}

qq_53089619
关注
GamePanel类
小通的博客
05-17 1818
package com.bigdata.tankbattle; import javax.swing.*; import java.awt.*; import java.util.ArrayList; import java.util.Iterator; import java.util.List; // game panel : 游戏面板 public class GamePanel extends JPanel { // 控制游戏是否结束 private static bo..
推荐一款开源游戏面板 - GamePanelX V3
gitblog_00029的博客
03-18 578
推荐一款开源游戏面板 - GamePanelX V3 GamePanelX-V3 The Original Free and Open Source Game Control Panel 项目地址: https://gitcode.com/gh_mirrors/g...
Java小游戏学习--狂神版贪吃蛇
qq_53207385的博客
09-23 454
​​​​​​ 目录 前言 一、GamePanel类的创建 二、数据导入和启动类 1.启动类StartGames 2.资源导入Data 总结 前言 文章主要从三个类的创建和作用角度来总结这次Java小游戏的学习经验。 一、GamePanel类的创建 GamePanel类主要负责游戏的背景画布的创建和核心逻辑的处理 GamePane继承了JPanel类并且实现了接口KeyListener,ActionListe..
Java swing 单机版五子棋
ZHANGLIZENG的博客
03-17 3112
一.此五子棋是基于java的swing开发，是单机版，源码见git：https://github.com/zhangliqingyun/FiveChess.git，先看效果图 二.功能介绍 1.首先建立程序启动类 public class MyFiveChess { public static void main(String[] args) { GamePane...
Java五子棋（人机版），昨天买的棋子今天就用不上了
javadada1197的博客
07-22 1772
效果图 由于篇长的原因有需要LeetCode刷题笔记+视频中源码资料+Java全栈开发学习路线图私信回复“java笔记” 实现思路 1.创建运行窗口并添加背景色。 2.绘制棋盘。 3.用二维数组来控制起码落子位置、绘制指示器。 4.鼠标在落子位置处点击可落子。 5.落子后检查是否获得胜利。 6.机器判断下一步，并落子。 7.机器判断是否获得胜利。 代码实现 创建窗口 首先创建一个...
gmall2020-mock-log-2020-04-01.jar
12-30
用户行为日志生成脚本
温控器W1308说明2020-12-14 11.33.pdf
12-25
W1308温控器的使用说明，纸质文档怕找不到了，上传一份备查。需要的自行下载吧。
SDR-Radio V3.0.26, 64-bit, 2020-12-14_1012.exe
02-02
功能最强大的软件无线电接收软件SDR-Radio V3.0.26, 64-bit, 2020-12-14_1012
SDR-Radio V3.0.26, 32-bit, 2020-12-14_1019.exe
02-02
功能最强大的软件无线电接收软件SDR-Radio V3.0.26, 32-bit, 2020-12-14_1019
Toy_project_naver_webtoon:BITCAMP 2020-12-14〜2021-05-28最终团队项目
04-29
■玩具项目：Naver Webtoon页面（ ）； 20201/03/05〜2021/03/28完成 授予页面 索引页->崔京植 蒙页->车允珠 星期二页面->金允oo 星期三->张水妍 星期四->李刚三 星期五-> Seoyoon Kim ...现在可以通过使用基本标签...
GamePanelX:免费/开源网页游戏面板。 轻松控制游戏服务器。-开源
05-08
原始的免费开源游戏控制面板
GamePanelX-V3：原始的免费和开源游戏控制面板
02-02
============= GamePanelX-V3 由Ryan Gehrig创建 GamePanelX是一个免费的开源游戏控制面板。 它是始于2007年的第一个功能齐全且实用的游戏控制面板。 网站： ： 说明文件： : 论坛： ： 最新下载： :
2020-12-11
qq_53089619的博客
12-11 134
计算机计算器的设计与实现 1、项目概述 （1）项目目标和主要内容 <1>能通过设计的按钮控件输入并实现简单算术运算，要求表达式在编辑框中显示，能将运算结果，输出在编辑框内显示； <2>能够实现混合运算的求解，算术表达式中包括加、减、乘、除、括号等运算符；并且能够识别括号，优先级正确。 <3>并保存历史的表达式运算记录。 （2）项目的主要功能 计算器的设计与实现，设计一个简单的计算器，能够实现加、加、减、乘、除、括号等运算符；并且能够识别括号，优先级正确，可以保存历史表达式
俄罗斯方块游戏开发 ——图形化编程java swing 项目
weixin_53070478的博客
04-13 2541
通过java swing技术开发的俄罗斯方块游戏，实现了基础的游戏绘制、移动逻辑、消除逻辑、得分统计、死亡判定、预测方块等功能。 成果展示截图： 游戏介绍： 俄罗斯方块的规则为：玩家不断操作下落的不同板块，直达底部，并刷新新的板块。在操作时通过调整位置和旋转方向，使得落下的方块可以填满一整层，每当一层填满，则该层会消失，上方所积累的方块会落下，同时积累分数，当累积到上方空间不足以刷新新的方块，且整个空间无法消除时，则游戏结束 游戏场地：10×20的平面网格地图。每个单位为相同...
Java游戏开发 —— 象棋
小木鱼的博客
01-05 1万+
一个AI极其弱智的象棋游戏，有事AI那块暂时未做完！
GamePanelX-V3：开源游戏控制面板的先锋
gitblog_01028的博客
10-10 902
GamePanelX-V3：开源游戏控制面板的先锋 GamePanelX-V3 The Original Free and Open Source Game Control Panel 项目地址: https://gitcode....
Java实现坦克大战（源码全）
O_C_E_A_N_的博客
04-05 1万+
开头 参考自尚学堂，后文代码CV并添加图片资源即可运行 对代码有一定的重构，功能的添加(按‘G’开挂) 评论区留联系方式（微信除外），看到后会发送图片资源。 项目结构 GamePanel KeyMonitor (内部类) keyPressed(KeyEvent): void keyReleased(KeyEvent): void launch(): void paint(Graphics): void main(String[]): void package com.company.tank; im
Gamepanel
qq_45736058的博客
03-22 1272
package 巴什博奕; import javax.swing.*; import javax.swing.Timer; import java.awt.; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.KeyEvent; import java.awt...
老Java程序员花两天做了个消消乐（天天爱消除）
热门推荐
编程界明世隐的博客
06-22 5万+
引言： 一直就想做一个消消乐，这次正好找到了素材，就自己琢磨写了一个，我觉得这个游戏难点就在消除后的下落。 效果图 实现思路 1.绘制窗口、按钮、边框等 2.实现Card类，用来代表每一个小图形。 3.创建二维数组9行8列 最后 加入积分、游戏结束、重新开始、音效等等就完成了 看到这里的大佬，动动发财的小手 点赞 + 回复 + 收藏，能【 关注 】一波就更好了。 想要代码的 加微信 或 私聊 我！ 为了帮助更多小白从零进阶 Java 工程师，从CSDN官方那边搞来了一套 《Java 工程师学习成长知识图谱
account date 10033.253012 2020-09-14 07:18:00 10128.197543 2020-09-14 08:27:00 10117.731249 2020-09-14 12:39:00这种python画图
最新发布
10-19
'date': ['2020-09-14 07:18:00', '2020-09-14 08:27:00', '2020-09-14 12:39:00']} df = pd.DataFrame(data) # 将日期字符串转换为datetime格式 df['date'] = pd.to_datetime(df['date']) # 创建时间序列图 plt....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值