Java-俄罗斯方块最新完善版

于 2018-12-25 19:14:21 发布
阅读量1.2w 收藏 7
点赞数
文章标签： Java小案例
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42721694/article/details/85252756
版权

趋于完善版

步骤1：

package game;

import java.awt.image.BufferedImage;

public class Cell {
	private int row;
	private int col;
	private BufferedImage image;
	public Cell(){}
	public Cell(int row, int col ,BufferedImage image) {
		super();
		this.row = row;
		this.col = col;
		this.image = image;
	}
	public int getRow() {
		return row;
	}
	public void setRow(int row) {
		this.row = row;
	}
	public int getCol() {
		return col;
	}
	public void setCol(int col) {
		this.col = col;
	}
	public void left(){
		col--;
	}
	public void down(){
		row++;
	}
	public void right(){
		col++;
	}
	@Override
	public String toString() {
		return "Cell [row=" + row + ", col=" + col + "]";
	}
	public BufferedImage getImage() {
		return image;
	}
	public void setImage(BufferedImage image) {
		this.image = image;
	}
}

步骤2：

package game;

public class Tetromino {
	Cell[] cells = new Cell[4];
	/**向左移动*/
	public void moveLeft(){
		for(int i=0;i<cells.length;i++){
			cells[i].left();
		}
	}
	/**向下移动*/
	public void moveDown(){
		for(int i=0;i<cells.length;i++){
			cells[i].down();
		}
	}
	/**向右移动*/
	public void moveRight(){
		for(int i=0;i<cells.length;i++){
			cells[i].right();
		}
	}
	/**添加一个方法,随机产生一种子类对象*/
	public static Tetromino randomOne(){
		Tetromino one = null;
		int num = (int)(Math.random()*7);
		switch(num){
		case 0:one = new T();break;
		case 1:one = new I();break;
		case 2:one = new O();break;
		case 3:one = new S();break;
		case 4:one = new Z();break;
		case 5:one = new J();break;
		default:one = new L();
		}
		return one;
	}
	/**使用内部类定义7个子类型*/
	static class T extends Tetromino{
		public T(){
			cells[0] = new Cell(0,4,TestTetromino.T);
			cells[1] = new Cell(0,3,TestTetromino.T);
			cells[2] = new Cell(0,5,TestTetromino.T);
			cells[3] = new Cell(1,4,TestTetromino.T);
		}
	}
	static class I extends Tetromino{
		public I(){
			cells[0] = new Cell(0,4,TestTetromino.I);
			cells[1] = new Cell(0,3,TestTetromino.I);
			cells[2] = new Cell(0,5,TestTetromino.I);
			cells[3] = new Cell(0,6,TestTetromino.I);
		}
	}
	static class O extends Tetromino{
		public O(){
			cells[0] = new Cell(0,4,TestTetromino.O);
			cells[1] = new Cell(0,3,TestTetromino.O);
			cells[2] = new Cell(1,3,TestTetromino.O);
			cells[3] = new Cell(1,4,TestTetromino.O);
		}
	}
	static class S extends Tetromino{
		public S(){
			cells[0] = new Cell(0,4,TestTetromino.S);
			cells[1] = new Cell(0,5,TestTetromino.S);
			cells[2] = new Cell(1,3,TestTetromino.S);
			cells[3] = new Cell(1,4,TestTetromino.S);
		}
	}
	static class Z extends Tetromino{
		public Z(){
			cells[0] = new Cell(0,4,TestTetromino.Z);
			cells[1] = new Cell(0,3,TestTetromino.Z);
			cells[2] = new Cell(1,4,TestTetromino.Z);
			cells[3] = new Cell(1,5,TestTetromino.Z);
		}
	}
	static class J extends Tetromino{
		public J(){
			cells[0] = new Cell(0,4,TestTetromino.J);
			cells[1] = new Cell(0,3,TestTetromino.J);
			cells[2] = new Cell(0,5,TestTetromino.J);
			cells[3] = new Cell(1,5,TestTetromino.J);
		}
	}
	static class L extends Tetromino{
		public L(){
			cells[0] = new Cell(0,4,TestTetromino.L);
			cells[1] = new Cell(0,3,TestTetromino.L);
			cells[2] = new Cell(0,5,TestTetromino.L);
			cells[3] = new Cell(1,3,TestTetromino.L);
		}
	}
	/**
	 * 变形:旋转
	 */
	public void rotate() {
		int num = cells[1].getRow();
		cells[1].setRow(cells[0].getRow()+cells[1].getCol()-cells[0].getCol());
		cells[1].setCol(cells[0].getCol()+cells[0].getRow()-num);
		num = cells[2].getRow();
		cells[2].setRow(cells[0].getRow()+cells[2].getCol()-cells[0].getCol());
		cells[2].setCol(cells[0].getCol()+cells[0].getRow()-num);
		num = cells[3].getRow();
		cells[3].setRow(cells[0].getRow()+cells[3].getCol()-cells[0].getCol());
		cells[3].setCol(cells[0].getCol()+cells[0].getRow()-num);
	}
	/**
	 * 碰撞
	 * @param cell 已堆积的方块
	 * @return true / false
	 */
	public boolean hit(Cell cell) {
		for(int i=0;i<cells.length;i++){
			if((cells[i].getCol()==cell.getCol()&&
					cells[i].getRow()==cell.getRow()-1)){
				return true;
			}
		}
		return false;
	}
	/**
	 * 底边的碰撞
	 * @param cell 
	 * @return
	 */
	public boolean hitBound() {
		for(int i=0;i<cells.length;i++){
			if(cells[i].getRow()>=19){
				return true;
			}
		}
		return false;
	}
	public boolean hitLeft(Cell[] cs) {
		for(int i=0;i<cs.length;i++){
			for(int j=0;j<cells.length;j++){
				if(cells[j].getRow()==cs[i].getRow()&&
						cells[j].getCol()==cs[i].getCol()+1){
					return true;
				}
			}
		}
		return false;
	}
	public boolean hitRight(Cell[] cs) {
		for(int i=0;i<cs.length;i++){
			for(int j=0;j<cells.length;j++){
				if(cells[j].getRow()==cs[i].getRow()&&
						cells[j].getCol()==cs[i].getCol()-1){
					return true;
				}
			}
		}
		return false;
	}
}

步骤3：

package game;

import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.util.Arrays;
import java.util.Timer;
import java.util.TimerTask;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
/**TestTetromino 是一个画板*/
public class TestTetromino extends JPanel{
	//常量 矩形的宽度,方格的宽度
	public static final int CELL_SIZE = 26;
	
	//成员变量
	Tetromino currentOne = Tetromino.randomOne();
	Tetromino currentNext = Tetromino.randomOne();
	private Cell[] cs = {};
	private boolean[][] b = new boolean[20][10];
	private int state;
	public static final int RUNNING = 0;
	public static final int GAMEOVER = 1;
	
	
	private int score=0;
	
	public static BufferedImage I;
	public static BufferedImage T;
	public static BufferedImage O;
	public static BufferedImage S;
	public static BufferedImage Z;
	public static BufferedImage J;
	public static BufferedImage L;
	public static BufferedImage tetris;
	public static BufferedImage gameover;
	static{
		try {
			//read读取硬盘上的图片
			//getResource(String path):path是图片的相对当前包的位置
			I = ImageIO.read(TestTetromino.class.getResource("I.png"));
			T = ImageIO.read(TestTetromino.class.getResource("T.png"));
			O = ImageIO.read(TestTetromino.class.getResource("O.png"));
			S = ImageIO.read(TestTetromino.class.getResource("S.png"));
			Z = ImageIO.read(TestTetromino.class.getResource("Z.png"));
			J = ImageIO.read(TestTetromino.class.getResource("J.png"));
			L = ImageIO.read(TestTetromino.class.getResource("L.png"));
			tetris = ImageIO.read(TestTetromino.class.getResource("tetris.png"));
			gameover = ImageIO.read(TestTetromino.class.getResource("gameover.png"));
		} catch (Exception e) {
			//打印栈中的信息
			e.printStackTrace();
		}
		
	}
	/**重写绘制功能,此功能画板默认调用*/
	public void paint(Graphics g){
		g.drawImage(tetris,0, 0, null);
		//平移坐标轴
		g.translate(15, 15);
		paintScore(g);
		panelWall(g);
		paintCurrentOne(g);
		paintCurrentNext(g);
		paintCs(g);
		paintState(g);
	}
	private void paintState(Graphics g) {
		if(state==GAMEOVER){
			g.drawImage(gameover, 0, 0, null);
		}
	}
	private void paintCurrentNext(Graphics g) {
		Cell[] cells = currentNext.cells;
		for(int i=0;i<cells.length;i++){
			Cell cell = cells[i];
			int col = cell.getCol();
			int row = cell.getRow();
			g.drawImage(cell.getImage(), col*CELL_SIZE+270, row*CELL_SIZE+25, null);
		}
	}
	private void paintScore(Graphics g) {
		Font font = new Font(Font.SANS_SERIF,Font.BOLD,20);
		g.setFont(font);
		g.drawString("SCORE:"+score, 340, 270);
	}
	private void paintCs(Graphics g) {
		Cell[] cells = cs;
		for(int i=0;i<cells.length;i++){
			Cell cell = cells[i];
			int col = cell.getCol();
			int row = cell.getRow();
			g.drawImage(cell.getImage(), col*CELL_SIZE, row*CELL_SIZE, null);
		}
	}
	/**绘制当前下落的四方块*/
	private void paintCurrentOne(Graphics g) {
		//获取正在下落的方块组合内的数组对象
		Cell[] cells = currentOne.cells;
		for(int i=0;i<cells.length;i++){
			Cell cell = cells[i];
			int col = cell.getCol();
			int row = cell.getRow();
			g.drawImage(cell.getImage(), col*CELL_SIZE, row*CELL_SIZE, null);
		}
	}
	/**绘制一个墙,20行,10列的表格*/
	public void panelWall(Graphics g){
		for(int i=0;i<20;i++){
			for(int j=0;j<10;j++){
				//横坐标j,纵坐标i
				g.drawRect(j*CELL_SIZE, i*CELL_SIZE, CELL_SIZE, CELL_SIZE);
			}
		}
	}
	private Timer timer;
	public void action(){
		/*
		 * 定义监听器对象,用于监听键盘事件
		 * */
		KeyListener l = new KeyAdapter(){
			public void keyPressed(KeyEvent e){
				int code = e.getKeyCode();
				System.out.println("code:"+code);
				if(state==RUNNING){
					switch(code){
					case 37:
						if(!currentOne.hitLeft(cs)){
							currentOne.moveLeft();
						}
						break;
					case 39:
						if(!currentOne.hitRight(cs)){
							currentOne.moveRight();
						}
						break;
					case 40:currentOne.moveDown();break;
					case 38:currentOne.rotate();
					}
					outOfBoundAction();//越界
				}
				if(code==83){
					cs = new Cell[]{};
					b = new boolean[20][10];
					score = 0;
					currentOne = Tetromino.randomOne();
					currentNext = Tetromino.randomOne();
					state=RUNNING;
				}
				//重新绘制
				repaint();
			}
		};
		//面板添加键盘监听事件
		this.addKeyListener(l);
		//面板设置成屏幕焦点
		this.requestFocus();
		timer = new Timer();
		timer.schedule(new TimerTask(){
			public void run(){
				if(state==RUNNING){
					hitAction();//碰撞
					
					hitBoundAction();//碰撞底边
					deleteAction();//消除
					gameoverAction();//检查游戏是否结束
				}
				repaint();
				
			}
		},0,1);
		
		while(true){
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			if(state==RUNNING){
				currentOne.moveDown();
			}
			//重写绘制整个画板上的内容
			repaint();
		}
	}
	protected void gameoverAction() {
		if(isGameOver()){
			state = GAMEOVER;
		}
	}
	private boolean isGameOver() {
		for(int i=0;i<cs.length;i++){
			if(cs[i].getRow()==0){
				return true;
			}
		}
		return false;
	}
	protected void deleteAction() {
		for(int i=0;i<b.length;i++){
			boolean bool = false;
			for(int j=0;j<b[0].length;j++){
				if(!b[i][j]){
					bool = true;
					break;
				}
			}
			if(!bool){
				score+=15;
				for(int k=0;k<cs.length;k++){
					if(cs[k].getRow()==i){
						cs[k] = cs[cs.length-1];
						cs = Arrays.copyOf(cs, cs.length-1);
						k--;
					}
				}
				for(int k=0;k<cs.length;k++){
					if(cs[k].getRow()<i){
						cs[k].setRow(cs[k].getRow()+1);
					}
				}
			}		
		}
		b = new boolean[20][10];
		for(int i=0;i<cs.length;i++){
			b[cs[i].getRow()][cs[i].getCol()] = true;
		}
	}
	/**
	 * 到底边
	 */
	private void hitBoundAction() {
		Cell[] cells = currentOne.cells; 
		for(int i=0;i<cells.length;i++){
			if(currentOne.hitBound()){
				for(int j=0;j<cells.length;j++){
					cs = Arrays.copyOf(cs, cs.length+1);
					cs[cs.length-1] = cells[j];
					b[cs[cs.length-1].getRow()][cs[cs.length-1].getCol()] = true;
				}
				currentOne = currentNext;
				currentNext = Tetromino.randomOne();
				break;
			}
		}
	}
	/**
	 * 方块间的碰撞
	 */
	protected void hitAction() {
		for(int i=0;i<cs.length;i++){
			if(currentOne.hit(cs[i])){
				Cell[] cells = currentOne.cells;
				for(int j=0;j<cells.length;j++){
					cs = Arrays.copyOf(cs, cs.length+1);
					cs[cs.length-1] = cells[j];
					b[cs[cs.length-1].getRow()][cs[cs.length-1].getCol()] = true;
				}
				currentOne = currentNext;
				currentNext = Tetromino.randomOne();
				break;
			}
		}
	}
	/**
	 * 左右边界
	 */
	protected void outOfBoundAction() {
		Cell[] cells = currentOne.cells;
		for(int i=0;i<cells.length;i++){
			if(cells[i].getCol()<0){
				for(int j=0;j<cells.length;j++){
					cells[j].setCol(cells[j].getCol()+1);
				}
				break;
			}else if(cells[i].getCol()>9){
				for(int j=0;j<cells.length;j++){
					cells[j].setCol(cells[j].getCol()-1);
				}
				break;
			}
		}
	}
	public static void main(String[] args) {
		//创建一个游戏窗口
		JFrame frame = new JFrame("俄罗斯方块");
		//设计窗口的大小
		frame.setSize(540, 588);
		//创建一个画板对象
		TestTetromino panel = new TestTetromino();
		//画板嵌入窗口
		frame.add(panel);
		
		//设置窗口居中
		frame.setLocationRelativeTo(null);
		//设置窗口关闭
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		//设置可见性
		frame.setVisible(true);
		panel.action();
	}
}

用到的图片可以自己在网上寻找*_*

橙以
关注
JAVA版 俄罗斯方块
03-01
可执行JAR包 博文链接：https://xuxiaolei.iteye.com/blog/219770
俄罗斯方块java版
10-10
java版的俄罗斯方块，是基于Jframe的，有界面，当时用来做课程设计的
俄罗斯方块的java实现.zip_俄罗斯方块java通用版
01-06
俄罗斯方块项目，基本功能包括：游戏主界面显示模块、方块及数据显示模块、方块移动控制模块、游戏界面颜色控制模块、游戏进度、等级控制模块等。本项目结构如下： （1）游戏主界面显示模块： 显示游戏和帮助两个菜单； 游戏使用功能键盘，得分 等级； （2）画布、方块显示模块： 可以根据自己的需求来自己动手更改背景图片，在方块下落过程中，根据颜色的变化识别下落的方块。 （3）背景画布模块设计： 游戏用继承自JPanel的GameCanvas类控制背景画布的显示，用rows代表画布的行数，cols代表画布的列数，行数和列数决定着画布拥有方格的数目； （4）方块移动、旋转模块 通过
俄罗斯方块 JAVA版
02-22
一、 课程题目 用JAVA语言编写俄罗斯方块游戏，实现俄罗斯方块游戏的基本功能。课题主要完成目标是利用小应用程序模版及按钮事件、多线程以及相关事件处理完成俄罗斯方块游戏的操作程序。应用到的技术包括类的继承，接口的引用以及各类中重要方法的充分运用paint方法绘制游戏区，移动有效性判断locateFlag()，等），以及多线程的应用实现对方块下落速度的控制（线程的应用（线程的创建、run()方法的使用）），完成后可以巩固JAVA知识，能灵活应用JAVA的相关技术。 二、 题目分析与设计 1、 可行性分析 项目涉及的相关技术在以前都学习过，能够使用小应用程序游戏界面的展示。用Image 对象创建画布，用paint( )方法在画布上绘制棋盘，实现基本界面；利用线程实现方块的不断下落；继承KeyAdapter创建其子类GameKeyLister实现变形；disappear ()实现消行，得分。
JAVA---经典俄罗斯方块游戏完善版
zoe_ranxiaosu的博客
08-08 2309
  进阶版本的欧罗斯经典方块游戏，还没有实现最后满格消格功能，目前 功能：（1）随机方块体下落；（2）控制左右下移动 第一步依然是建立最小的方块类CELL类  package com.hyxy.oop.day08; import java.awt.image.BufferedImage; public class Cell { private int row; private in...
java实现游戏-俄罗斯方块
最新发布
07-30
这是一个使用java实现的简单小游戏，俄罗斯方块（曾经风靡世界近半世纪的经典小游戏）。 ———————————————————————————————————————— 功能尚不完善，但是可以作为基础参考，...
java课程设计报告-俄罗斯方块.doc
10-07
课程设计的目标是利用Java语言开发一个功能完善的俄罗斯方块游戏，包括游戏规则的实现、用户交互界面的设计以及游戏状态的管理。此外，还需要考虑到程序的可读性、可维护性和性能优化。 第二章 设计概要： 2.1 功能...
java俄罗斯方块源码-ersblock:俄罗斯方块游戏--JAVA实现（含双人联机对战）
06-05
java俄罗斯方块源码 注：”双人对战“ 有兴趣的童鞋可以自己完善。:grinning_squinting_face: 作者现在没有时间整合:crying_face: 只需要将exer_in_fight3中的界面整合到ersblocks（单人对战界面）中，用个右下角...
Eluosi.rar_JAVA编写俄罗斯方块_java 俄罗斯方块_游戏
09-14
通过以上知识点的整合与应用，我们可以构建出一个功能完备的JAVA版俄罗斯方块游戏，不仅满足单人游戏的需求，还增加了双人对战和人机对战模式，大大增强了游戏的趣味性和可玩性。在实际开发过程中，开发者还需要不断...
java俄罗斯方块源码-Alibaba-Java-Coding-Guidelines:阿里巴巴-Java-Coding-Guidelines
06-05
java俄罗斯方块源码 前言 ​ 《Java 开发手册》是阿里巴巴集团技术团队的集体智慧结晶和经验总结，经历了多次大规模一线实战的检验及不断完善，公开到业界后，众多社区开发者踊跃参与，共同打磨完善，系统化地整理...
Java开发的游戏 俄罗斯方块 完整源代码
02-25
Java开发的游戏 俄罗斯方块 完整源代码
俄罗斯方块（java版）
12-18
此代码为俄罗斯方块java源代码，是我在学校时做的，有做的不好之处请多多包涵！
java俄罗斯方块（达内版改进）
10-22
这是本人在达内学习时阶段性的一个练习，在老师原版的俄罗斯方块下，又添加了如下功能：1.随着分数增加方块下落速度呈周期性变化。2.添加了速度，转换分数等指标，3.可记录最高分，最高速者的分数。4.添加随机模式，挑战模式：1.高分挑战2.高速挑战. 里头文件包含：1.原达内老师的程序源文件。2.我改进的程序导成的一个jar包，及此程序源码。
俄罗斯方块(java版)
02-02
java做的小游戏,供大家参考
CCF认证 201604 俄罗斯方块
孙振宁
07-11 4101
package csp201604;import java.util.Scanner;/** * 俄罗斯方块 * @author SUN * */ public class Main{public static void main(String[] args) { Main.run();} public static void run(){ Scanner sc =
Java版俄罗斯方块(附源码)
weixin_34013044的博客
08-09 242
最近学习Java SE。一直想找个东西练手。 不过想来想去，还是经典的俄罗斯方块最好了。毕竟这个游戏要考虑的东西还是挺多的，综合性强。用来练练JavaSE还是挺不错的。好了，切入正题。基本说明:开发平台: MyEclipse 7.5测试平台: Windows Server 2008 + Ubuntu Linux 9.04运行界面如下:程序使用方向键控制，向上键控制图形旋转...
俄罗斯方块面向对象版本 (JAVA版本)
03-20
使用面向对象的思想实现了一次俄罗斯方块。有详细注释。大家一起学习一下经典吧。
Java实现俄罗斯方块：代码详解与设计思想
"java代码实现俄罗斯方块" 在Java编程中实现经典的俄罗斯方块游戏涉及到多个核心概念和技术。首先，我们要理解游戏的基本设计思路。俄罗斯方块的规则简单易懂，玩家通过控制各种形状的方块（如I型、T型、L型等）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值