Java实现经典游戏2048的示例代码

目录
  • 前言
  • 主要设计
  • 功能截图
  • 代码实现
    • 界面布局类
    • 业务逻辑类
  • 总结

前言

2014年Gabriele Cirulli利用周末的时间写2048这个游戏的程序,仅仅只是好玩而已。他想用一种不同的视觉展现效果和更快速的动画来创造属于自己的游戏版本。

游戏是用java语言实现,采用了swing技术进行了界面化处理,设计思路用了面向对象思想。

主要需求

每次控制所有方块向同一个方向运动,两个相同数字的方块撞在一起之后合并成为他们的和,每次操作之后会在空白的方格处随机生成一个2或者4,最终得到一个“2048”的方块就算胜利了。如果16个格子全部填满并且相邻的格子都不相同也就是无法移动的话,那么游戏就会结束。

主要设计

1、游戏面板生成显示

2、方块设计

3、键盘监听,方向键控制数字移动

4、数字移动逻辑算法处理

5、数字累加到2048,游戏胜利

功能截图

游戏开始

移动效果

代码实现

界面布局类

public class Game2048View implements ActionListener{
	Block[] blocks;		//方块
	JPanel myJPanel;	//主面板
	JPanel jp1,jp2;		//子面板
//	int moveFlag;				// 用于累计移动的次数
	boolean numFlag;		// 用于判断是否还能加入新的数字
	JLabel scroeValue;		//显示分数

	public Game2048View(JFrame myJFrame){
		blocks=new Block[16];
//		moveFlag=0;
		numFlag=true;
		this.myJPanel=(JPanel)myJFrame.getContentPane();///获取内容面板
		setJp1();
		myJPanel.add(jp1,BorderLayout.NORTH);
		setJp2();
		myJPanel.add(jp2, BorderLayout.CENTER);
		myJFrame.addKeyListener(new Game2048Logic(this,myJFrame,blocks,numFlag,scroeValue));
	}

	public void addc(JPanel jp1,Component component, GridBagConstraints gbc,int gridwidth,int gridheight, int weightx,int weighty,int gridx,int gridy) {
		//此方法用来添加控件到容器中
		gbc.gridwidth=gridwidth;		//该方法是设置组件水平所占用的格子数,如果为0,就说明该组件是该行的最后一个
		gbc.gridheight=gridheight;		//该方法是设置组件垂直所占用的格子数
		gbc.weightx=weightx;				//该方法设置组件水平的拉伸幅度,如果为0就说明不拉伸,不为0就随着窗口增大进行拉伸,0到1之间
		gbc.weighty=weighty;				//该方法设置组件垂直的拉伸幅度,如果为0就说明不拉伸,不为0就随着窗口增大进行拉伸,0到1之间
		gbc.gridx=gridx;
		gbc.gridy=gridy;
		gbc.fill=GridBagConstraints.BOTH;
		jp1.add(component,gbc);
	}

	public void setJp1() {
		GridBagLayout gbLayout=new GridBagLayout();
		jp1=new JPanel(gbLayout);

		JPanel Jtitle=new JPanel();
		JLabel title=new JLabel("2048");
		title.setFont(new Font("font", Font.PLAIN, 45));//类型、风格、大小
		title.setHorizontalAlignment(JLabel.LEFT);//jLabel的文本左右对齐属性设置方法,对齐方式
		Jtitle.add(title);
		jp1.add(Jtitle);

		JPanel Jscroe=new JPanel(new GridLayout(2, 1));//new GridLayout(2, 1)为网格布局样式。其中的参数“2”“1”分别为网格的“行数”和“列数”。
		JLabel scroe=new JLabel("Scroe");
		scroe.setFont(new Font("font", Font.PLAIN, 16));
		scroe.setHorizontalAlignment(JLabel.CENTER);
		scroeValue=new JLabel("0");
		scroeValue.setFont(new Font("font", Font.PLAIN, 16));
		scroeValue.setHorizontalAlignment(JLabel.CENTER);
		Jscroe.add(scroe);
		Jscroe.add(scroeValue);
		jp1.add(Jscroe);

		JPanel Jnoite=new JPanel();
		JLabel noite=new JLabel("方向键移动数字累加至2048");
		noite.setFont(new Font("font", Font.PLAIN, 14));
		noite.setHorizontalAlignment(JLabel.LEFT);
		Jnoite.add(noite);
		jp1.add(Jnoite);

		JPanel JnewGame=new JPanel();
		JButton newGame=new JButton("New Game");
		newGame.setHorizontalAlignment(JButton.CENTER);
		newGame.addActionListener(this);
		JnewGame.add(newGame);
		jp1.add(JnewGame);

		GridBagConstraints gbc=new GridBagConstraints();
		addc(jp1, Jtitle, gbc, 3, 2, 60, 60, 0, 0);
		addc(jp1, Jscroe, gbc, 0, 2, 40, 60, 3, 0);
		addc(jp1, Jnoite, gbc, 3, 1, 60, 40, 0, 2);
		addc(jp1, JnewGame, gbc, 0, 1, 40, 40, 3, 2);
	}

	public void setJp2() {
		addBlock();
		initBlock();
		initBlock();
	}

	/**
	 * 添加方块
	 */
	public void addBlock(){
		jp2=new JPanel();
		/*
		 * setLayout是对当前组件设置为流式布局.组件在窗体中从左到右依次排列 如果排到行的末尾 换行排列
		 * GridLayout(int rows, int cols, int hgap, int vgap)
			创建具有指定行数和列数的网格布局。
			rows - 该 rows 具有表示任意行数的值
			cols - 该 cols 具有表示任意列数的值
			hgap - 水平间距
			vgap - 垂直间距
		 */
		jp2.setLayout(new GridLayout(4, 4, 5, 5));
		for (int i = 0; i < blocks.length; i++) {
			blocks[i]=new Block();
			blocks[i].setHorizontalAlignment(JLabel.CENTER);// 不透明的标签
			blocks[i].setOpaque(true);// 设置控件不透明
			jp2.add(blocks[i]);
		}
	}

	/**
	 * 初始化方块
	 */
	public void initBlock(){
		while (numFlag) {
			int index=(int) (Math.random()*16);
			if (blocks[index].getText().trim().equals("")) {
				blocks[index].setValue("2");
				break;
			} else {
				continue;
			}
		}
	}

	/**
	 * 获得第一个子面板的高度
	 */
	public int getMyJPanelHeidth() {
		return jp1.getSize().height;
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO 自动生成的方法存根
		newGame();
	}

	/**
	 * 重新开始游戏
	 */
	public void newGame() {
		for (int i = 0; i < blocks.length; i++) {
			blocks[i].setValue("");
		}
		numFlag=true;
		scroeValue.setText("0");
		initBlock();
		initBlock();
	}
}

业务逻辑类

public class Game2048Logic implements KeyListener{
	Block[] blocks;
	boolean numFlag;		// 用于判断是否还能加入新的数字
	JLabel scroeValue;		//显示分数
	int blocksarr[]=new int[4];		//保存一行/列方块中的数值
	JFrame myJFrame;
	int scroe=0;
	Game2048View game2048View;

	//初始化键盘事件
	public Game2048Logic(Game2048View game2048View, JFrame myJFrame, Block[] blocks,boolean numFlag,JLabel scroeValue) {
		// TODO 自动生成的构造函数存根
		this.blocks=blocks;
		this.numFlag=numFlag;
		this.scroeValue=scroeValue;
		this.myJFrame=myJFrame;
		this.game2048View=game2048View;
	}

	//初始化按钮事件
	public Game2048Logic() {
		// TODO 自动生成的构造函数存根
	}

	public boolean getnumFlag() {
		return numFlag;
	}

	@Override
	public void keyPressed(KeyEvent e) {
		// TODO 自动生成的方法存根
		int[] blocksarr=getBlock();
		switch (e.getKeyCode()) {
		case KeyEvent.VK_UP:
			colBlock("up");
			hasEmptyBlock();
			if (Arrays.equals(blocksarr, getBlock())) {
			} else {
				refershBlock();
			}
			isGameFail("up");
			break;
		case KeyEvent.VK_DOWN:
			colBlock("down");
			hasEmptyBlock();
			if (Arrays.equals(blocksarr, getBlock())) {
			} else {
				refershBlock();
			}
			isGameFail("down");
			break;
		case KeyEvent.VK_LEFT:
			rowBlock("left");
			hasEmptyBlock();
			if (Arrays.equals(blocksarr, getBlock())) {
			} else {
				refershBlock();
			}
			isGameFail("left");
			break;
		case KeyEvent.VK_RIGHT:
			rowBlock("right");
			hasEmptyBlock();
			if (Arrays.equals(blocksarr, getBlock())) {
			} else {
				refershBlock();
			}
			isGameFail("right");
			break;
		default:
			break;
		}
		scroeValue.setText(""+scroe);
		win();
	}

	/**
	 * 垂直方向方块移动处理函数
	 */
	public void colBlock(String direction){
		int tmp1=0;
		int tmp2=0;
		int index=0;
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				if (blocks[tmp1].getText().trim().equals("")) {
					tmp1+=4;
					if (tmp1>=16) {
						break;
					} else {
						continue;
					}
				} else {
					blocksarr[index]=Integer.parseInt(blocks[tmp1].getText().trim());
					index+=1;
					tmp1+=4;
					if (tmp1>=16 || index>=4) {
						break;
					} else {
						continue;
					}
				}
			}
			switch (direction) {
			case "up":
				blocksarr=handleBlocksarr(blocksarr);
				break;
			case "down":
				blocksarr=reverseArr(handleBlocksarr(reverseArr(blocksarr)));
				break;
			default:
				break;
			}

			for (int n = 0; n < blocksarr.length; n++) {
				if (blocksarr[n]==0) {
					blocks[tmp2].setText("");
					blocks[tmp2].setBackground(Color.gray);
				} else {
					blocks[tmp2].setValue(blocksarr[n]+"");
				}
				tmp2+=4;
			}
			index=0;
			tmp1=i+1;
			tmp2=i+1;
			//清空数组blockarr
			for (int n = 0; n < blocksarr.length; n++) {
				blocksarr[n]=0;
			}
		}
	}

	/**
	 * 水平方向方块移动处理函数
	 */
	public void rowBlock(String direction) {
		int tmp1=0;
		int tmp2=0;
		int index=0;
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				if (blocks[tmp1].getText().trim().equals("")) {
					tmp1+=1;
					if (tmp1>=16) {
						break;
					} else {
						continue;
					}
				} else {
					blocksarr[index]=Integer.parseInt(blocks[tmp1].getText().trim());
					index+=1;
					tmp1+=1;
					if (tmp1>=16 || index>=4) {
						break;
					} else {
						continue;
					}
				}
			}

			switch (direction) {
			case "left":
				blocksarr=handleBlocksarr(blocksarr);
				break;
			case "right":
				blocksarr=reverseArr(handleBlocksarr(reverseArr(blocksarr)));
				break;
			default:
				break;
			}

			for (int n = 0; n < blocksarr.length; n++) {
				if (blocksarr[n]==0) {
					blocks[tmp2].setText("");
					blocks[tmp2].setBackground(Color.gray);
				} else {
					blocks[tmp2].setValue(blocksarr[n]+"");
				}
				tmp2+=1;
			}
			index=0;
			//清空数组blockarr
			for (int n = 0; n < blocksarr.length; n++) {
				blocksarr[n]=0;
			}
		}
	}

	/**
	 * 处理并返回一个数组
	 */
	public int[] handleBlocksarr(int[] blocksarr) {
		int index=0;
		int[] result=new int[4];
		for (int i = 0; i < blocksarr.length; i++) {
			//排序
			if (blocksarr[i]!=0) {
				result[index]=blocksarr[i];
				index++;
			}
		}
		if (index==0 || index==1) {
			for (int i = index; i < result.length; i++) {
				result[i]=0;
			}
		} else {
			for (int i = 0; i < blocksarr.length; i++) {
				blocksarr[i]=0;
			}
			switch (index) {
			case 2:
				if (result[0]==result[1]) {
					blocksarr[0]=result[0]+result[1];
					scroe+=result[0]*2;
				} else {
					blocksarr=result;
				}
				break;
			case 3:
				if (result[0]==result[1]) {
					blocksarr[0]=result[0]+result[1];
					scroe+=result[0]*2;
					blocksarr[1]=result[2];
				} else {
					if (result[1]==result[2]) {
						blocksarr[0]=result[0];
						blocksarr[1]=result[1]+result[2];
						scroe+=result[1]*2;
					} else {
						blocksarr=result;
					}
				}
				break;
			case 4:
				if (result[0]==result[1]) {
					blocksarr[0]=result[0]+result[1];
					scroe+=result[0]*2;
					if (result[2]==result[3]) {
						blocksarr[1]=result[2]+result[3];
						scroe+=result[2]*2;
					} else {
						blocksarr[1]=result[2];
						blocksarr[2]=result[3];
					}
				} else {
					if (result[1]==result[2]) {
						blocksarr[0]=result[0];
						blocksarr[1]=result[1]+result[2];
						scroe+=result[1]*2;
						blocksarr[2]=result[3];
					} else {
						blocksarr[0]=result[0];
						blocksarr[1]=result[1];
						if (result[2]==result[3]) {
							blocksarr[2]=result[2]+result[3];
							scroe+=result[2]*2;
						} else {
							blocksarr=result;
						}
					}
				}
				break;
			default:
				break;
			}
			result=blocksarr;
		}
		return result;
	}

	/**
	 * 反转数组eg:45000 --> 00054
	 */
	public int[] reverseArr(int[] arr) {
		int[] tmp=new int[arr.length];
		int index=arr.length-1;
		for (int i = 0; i < arr.length; i++) {
			tmp[index]=arr[i];
			index--;
		}
		return tmp;
	}

	/**
	 * 刷新方块,添加新出现的2或4
	 */
	public void refershBlock(){
		if (numFlag==false) {
		}
		while (numFlag) {
			int index=(int) (Math.random()*16);
			if (blocks[index].getText().trim().equals("")) {
				if (Math.random()<0.8) {
					blocks[index].setValue("2");
				} else {
					blocks[index].setValue("4");
				}
				break;
			} else {
				continue;
			}
		}
	}

	/**
	 * 判断是否有空的方块
	 */
	public void hasEmptyBlock() {
		for (int i = 0; i < blocks.length; i++) {
			if (blocks[i].getText().trim().equals("")) {
				this.numFlag=true;
				break;
			} else {
				this.numFlag=false;
			}
		}
	}

	/**
	 * 判断游戏是否失败
	 */
	public void isGameFail(String direction) {
		boolean result=true;	//true代表失败 false代表没有失败
		int tmp=0;
		if (numFlag == false) { // 表示没有空的方块
			switch (direction) {
			case "up":
			case "down":
				for (int i = 0; i < 4; i++) {
					tmp=i*4;
					for (int j = 0; j < 3; j++) {
						if (blocks[tmp].getText().trim().equals(blocks[tmp+1].getText().trim())) {
							result = false;	//游戏未失败
							break;
						} else {
							tmp++;
						}
					}
					if (result==false) {
						break;
					}
				}
				break;
			case "left":
			case "right":
				for (int i = 0; i < 4; i++) {
					for (int j = 0; j < 3; j++) {
						if (blocks[tmp].getText().trim().equals(blocks[tmp+4].getText().trim())) {
							result = false;	//游戏未失败
							break;
						} else {
							tmp+=4;
							if (tmp>=16) {
								break;
							} else {
								continue;
							}
						}
					}
					tmp=i+1;
					if (result==false) {
						break;
					}
				}
				break;
			default:
				break;
			}
		} else {
			result=false;
		}
		if (result==true) {
			JOptionPane.showMessageDialog( null , "Game Over",null , JOptionPane.ERROR_MESSAGE) ;
			game2048View.newGame();
		} else {
		}
	}

	/**
	 * 判断游戏是否成功,即成功累加至2048
	 */
	public void win() {
		for (int i = 0; i < blocks.length; i++) {
			if (blocks[i].getText().trim().equals("2048")) {
				JOptionPane.showMessageDialog( null , "YOU ARE WIN",null , JOptionPane.ERROR_MESSAGE) ;
				game2048View.newGame();
				break;
			}
		}
	}

	/**
	 * 获得全部方块内容,用于对比
	 */
	public int[] getBlock() {
		int[] blocksarr=new int[16];
		for (int i = 0; i < blocks.length; i++) {
			if (blocks[i].getText().trim().equals("")) {
				blocksarr[i]=0;
			} else {
				blocksarr[i]=Integer.parseInt(blocks[i].getText().trim());
			}
		}
		return blocksarr;
	}

	@Override
	public void keyReleased(KeyEvent e) {
		// TODO 自动生成的方法存根
	}

	@Override
	public void keyTyped(KeyEvent e) {
		// TODO 自动生成的方法存根
	}

}

总结

通过此次的《2048游戏》游戏实现,让我对swing的相关知识有了进一步的了解,对java这门语言也有了比以前更深刻的认识。

java的一些基本语法,比如数据类型、运算符、程序流程控制和数组等,理解更加透彻。java最核心的核心就是面向对象思想,对于这一个概念,终于悟到了一些。

以上就是Java实现经典游戏2048的示例代码的详细内容,更多关于Java 2048游戏的资料请关注我们其它相关文章!

(0)

相关推荐

  • java使用OGEngine开发2048

    最近有一款2048的游戏非常火,本文将来介绍一下使用OGEngine游戏引擎开发游戏2048. OGEngine引擎是开源的,我们很容易找到,搭建起来也很方便,我们只需在Android工程下添加OGEngine的jar包或者直接引用源码就可以了. 源码下载:http://www.ogengine.com/download/resources.jsp private void initView() { // 游戏背景 AnimatedSprite game_bg = new AnimatedSpr

  • java实现的2048游戏完整实例

    本文实例讲述了java实现的2048游戏.分享给大家供大家参考,具体如下: 先来看看运行效果: 具体代码如下: package awtDemo; import javax.swing.*; import java.awt.*; import java.awt.event.*; import java.io.*; import java.util.*; @SuppressWarnings("serial") public class Game2048 extends JApplet{ @

  • Java完美实现2048小游戏

    完美地模仿了2048游戏,是根据网友的一个2048改的. Block.java import javax.swing.*; import java.awt.*; public class Block extends JLabel { private int value; public Block() { value = 0;//初始化值为0 setFont(new Font("font", Font.PLAIN, 40));//设定字体 setBackground(Color.gray

  • java版实现2048游戏功能

    本文实例为大家分享了java实现2048游戏功能的具体代码,供大家参考,具体内容如下 功能要求:2048的基本界面,能够实现2048的游戏功能. 总思路:两个类:Game和GameListener. Game负责界面的实现和paint方法的重写 GameListener负责实现键盘和鼠标事件的处理.移动方法,相加方法,输赢判断和随机数的出现都要在键盘监听的方法中实现. 实现分析:要实现2048游戏,首先需要考虑2048都有些什么? 界面实现: 2048的游戏界面很简单,就是一些方格和数字.要实现

  • Java实现2048小游戏(可直接运行)

    运行效果: 1.项目结构 2.代码 BaseData接口 package com.hsy.game; import java.awt.*; public interface BaseData { Font topicFont = new Font("微软雅黑", Font.BOLD, 50); Font scoreFont = new Font("微软雅黑", Font.BOLD, 28); Font normalFont = new Font("宋体&q

  • 200行java代码实现2048小游戏

    本文实例为大家分享了java实现2048小游戏的具体代码,供大家参考,具体内容如下 效果图: 游戏介绍: 1.2048是一款益智类小游戏,刚开始随机出现两个数字,可以上下左右控制数字的移动. 2.当选择一个方向移动后,所有数字都会沿该方向移动到表格尽头,并且空余表格会随机出现2或4,当碰到相同的两个数字时,该两个数字会合并相加成一个数字,直到最大的数字变成2048游戏成功 3.否则当数字填满表格且不能再移动时游戏失败. 游戏代码: import java.awt.*; import java.a

  • java实现2048小游戏(含注释)

    本文实例为大家分享了java实现2048小游戏的具体代码,供大家参考,具体内容如下 实现文件 APP.java import javax.swing.*; public class APP { public static void main(String[] args) { new MyFrame(); } } 类文件 import javax.swing.*; import java.awt.event.ActionEvent; import java.awt.event.ActionList

  • java实现2048游戏源代码

    本文实例为大家分享了java实现2048游戏源代码,供大家参考,具体内容如下 一.主要功能: 1.游戏初始化:新建游戏4×4的16宫格画布,随机格子上生成2或者4两个数字 2.格子的移动:先判断能否移动,移动后判断能否合并,合并后改变格子颜色和数字 3.新格子的生成:移动一次,就在剩余的空格子中随机生成一个2或者4 4.判赢:16宫格中合并出了"2048"则为游戏胜利 5.判输:16宫格中没有剩余空格子且不能再向任何方向移动则为游戏失败 二.项目的主要结构: 在项目2018游戏中,有4

  • java实现2048小游戏

    本文实例为大家分享了java实现2048小游戏的具体代码,供大家参考,具体内容如下 一.实现效果 二.实现代码 Check表示格子,GameView实现游戏视图界面及功能,是核心. Check.java import java.awt.Color; import java.awt.Font; // 方格类 public class Check { public int value; Font font1 = new Font("宋体", Font.BOLD, 46); Font fon

  • Java实现经典游戏2048的示例代码

    目录 前言 主要设计 功能截图 代码实现 界面布局类 业务逻辑类 总结 前言 2014年Gabriele Cirulli利用周末的时间写2048这个游戏的程序,仅仅只是好玩而已.他想用一种不同的视觉展现效果和更快速的动画来创造属于自己的游戏版本. 游戏是用java语言实现,采用了swing技术进行了界面化处理,设计思路用了面向对象思想. 主要需求 每次控制所有方块向同一个方向运动,两个相同数字的方块撞在一起之后合并成为他们的和,每次操作之后会在空白的方格处随机生成一个2或者4,最终得到一个“20

  • Java实现经典游戏打砖块游戏的示例代码

    目录 前言 主要设计 功能截图 代码实现 游戏核心类 小球类 砖块类 总结 前言 <JAVA打砖块>游戏是自制的游戏.玩家操作一根萤幕上水平的“棒子”,让一颗不断弹来弹去的“球”在撞击作为过关目标消去的“砖块”的途中不会落到萤幕底下. 主要设计 设计游戏界面,用swing实现 设计砖块,砖块类, 设计小球,满屏乱跑的小球类,负责打碎砖块 设计棒子,左右移动的木头板类 球碰到砖块.棒子与底下以外的三边会反弹,落到底下会失去一颗球,把砖块全部消去就可以破关. 小球碰到砖块的回调算法设计 小球碰到棒

  • Java实现经典游戏超级玛丽的示例代码

    目录 前言 主要设计 功能截图 代码实现 游戏主界面 马里奥 小怪 总结 前言 在你的童年记忆里,是否有一个蹦跳.顶蘑菇的小人? 如果你回忆起了它,你定然会觉得现在它幼稚.无聊,画面不漂亮,游戏不精彩……但请你记住:这才是真正的游戏,它给了你无限的欢乐! 马里奥是靠吃蘑菇成长,闻名世界的超级巨星.特征是大鼻子.头戴帽子.身穿背带工作服.还留着胡子. 如此经典的游戏,你怎么能错过,快来玩玩吧. <超级玛丽>游戏是用java语言实现,采用了swing技术进行了界面化处理,设计思路用了面向对象思想.

  • JAVA实现经典游戏坦克大战的示例代码

    目录 前言 主要设计 功能截图 代码实现 总结 前言 小时候大家都玩过坦克大战吧,熟悉的旋律和丰富的关卡陪伴了我们一整个寒暑假,还记得传说中的经典坦克大战 吗?那些怀旧的记忆,伴随着我们一起走过来的经典坦克大战,刚开始那战战兢兢,屡屡被敌人坦克击毁的情景历历在目.现在好了,再也不用担心敌人坦克了,可 以横冲直撞,横扫敌人坦克了.快哉!!! <坦克大战>游戏以坦克战斗为主题,用java语言实现,采用了swing技术进行了界面化处理,设计思路用了面向对象思想. 主要需求 可以生成不同的地图,消灭地

  • Java实现经典游戏飞机大战-I的示例代码

    目录 前言 主要设计 功能截图 代码实现 启动类 核心类 核心算法 总结 前言 <飞机大战-I>是一款融合了街机.竞技等多种元素的经典射击手游.华丽精致的游戏画面,超炫带感的技能特效,超火爆画面让你肾上腺素爆棚,给你带来全方位震撼感受,体验飞行战斗的无限乐趣. 游戏是用java语言实现,采用了swing技术进行了界面化处理,设计思路用了面向对象思想. 主要需求 玩家控制一台战斗机,以消灭所有的敌机为胜利,有些敌机会掉落装备,不可错过哦 主要设计 1. 用Swing库做可视化界面 2.鼠标控制战

  • Java实现经典游戏推箱子的示例代码

    目录 前言 主要设计 功能截图 代码实现 核心类 声音播放类 总结 前言 <推箱子>推箱子是一个古老的游戏,目的是在训练你的逻辑思考能力.在一个狭小的仓库中,要求把木箱放到指定的位置,稍不小心就会出现箱子无法移动或者通道被堵住的情况,所以需要巧妙的利用有限的空间和通道,合理安排移动的次序和位置,才能顺利的完成任务. 游戏是用java语言实现,采用了swing技术进行了界面化处理,设计思路用了面向对象思想. 主要需求 控制搬运工上下左右移动,来将箱子推到指定地点 主要设计 1.游戏面板生成显示

  • Java实现经典游戏Flappy Bird的示例代码

    目录 前言 主要设计 功能截图 代码实现 游戏启动类 核心类 工具类 总结 前言 <布谷鸟闯关-简单版>是一个基于java的布谷鸟闯关游戏,摁上键控制鸟的位置穿过管道间的缝隙,需要做碰撞检测,监听键盘事件,背景图片的切换,障碍物管道产生时y轴上需要随机位置. 主要设计 设计游戏界面,用swing实现 设计背景 设计移动墙 设计布谷鸟 设计障碍物 设计背景音乐和音效 由几个关键的布尔类型变量start,crash,over是产生键键盘事件时用来控制界面显示的弹框的 操作:空格键开始游戏,ente

  • Java实现经典游戏黄金矿工的示例代码

    目录 前言 主要设计 功能截图 代码实现 游戏核心类 钩子类 总结 前言 <黄金矿工>游戏是一个经典的抓金子小游戏,它可以锻炼人的反应能力..该游戏中,可以通过“挖矿”获得积分,游戏道具:有3瓶药水,在回收绳子抓金子的时候速度稍快点. 主要设计 设计游戏界面,用swing实现 随机创建金块算法 随机创建石块算法 计时系统设计 积分系统设计 设置鼠标事件,鼠标左键出钩子:鼠标右键开始游戏,确认吃药水等功能. 功能截图 游戏开始: 抓金子 代码实现 游戏核心类 public class GameW

  • Java实现经典游戏泡泡堂的示例代码

    目录 前言 主要设计 功能截图 代码实现 游戏启动类 核心监听类 核心线程类 总结 前言 <泡泡堂I>是一个基于java的自制游戏,游戏设计为双人pk积分赛模式,在这个模式里面,玩家只要率先达到一定分数既可以赢得比赛.玩家可以通过炸箱子可以得到少量的分数,也可以通过炸掉对手然后戳破包围对手的水泡得到大量分数.而玩家如果被泡泡爆炸击中,会被泡泡包裹一段时间,在这段时间内不可以移动和放泡泡,需要等时间过去或者被对手戳破水泡才能获得自由.但如果玩家被自己放的泡泡炸中,会扣一定的分数. 主要设计 设计

  • java poi导出图片到excel示例代码

    本文实例为大家分享了java使用poi导出图片到Excel的具体代码,供大家参考,具体内容如下 代码实现 Controller /** * 导出志愿者/人才数据 * @param talent_type * @return */ @RequestMapping("/exportData") public void exportData(Integer talent_type, HttpServletResponse response) { String fileId = UUID.ra

随机推荐