javascript俄罗斯方块代码 俄罗斯方块源代码java

【实例简介】

java基础编写的俄罗斯方块

【实例截图】

【核心代码】

package com.akxy.yp.tetris;
//Frame 框, 相框 JFrame窗口框
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
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;
/**
* 俄罗斯方块
* 俄罗斯方块 扩展了 空白面板, 添加了属性: 墙, 正在下落
* 的方块和下一个方块.
*/
public class Tetris extends JPanel {
private int score;//累计分数
private int lines;//销毁的行数
private Cell[][] wall;//(墙 20行X10列)
private Tetromino tetromino;//正在下落的(4格方块，有7种形态)
privateTetromino nextOne;//下一个准备下落的方块
/** 背景图片 */
private static BufferedImage background;
private static BufferedImage overImage;
public static BufferedImage T;
public static BufferedImage S;
public static BufferedImage I;
public static BufferedImage L;
public static BufferedImage J;
public static BufferedImage O;
public static BufferedImage Z;
public static final int ROWS = 20;//行
public static final int COLS = 10;//列
//将图片素材, 复制到包中.
/** 使用静态代码块加载静态的图片 */
static{
try{
//Tetris.class的同一个包中找 "tetris.png"
background=ImageIO.read(
Tetris.class.getResource("tetris.png"));
overImage=ImageIO.read(
Tetris.class.getResource("game-over.png"));
T=ImageIO.read(
Tetris.class.getResource("T.png"));
I=ImageIO.read(
Tetris.class.getResource("I.png"));
S=ImageIO.read(
Tetris.class.getResource("S.png"));
Z=ImageIO.read(
Tetris.class.getResource("Z.png"));
J=ImageIO.read(
Tetris.class.getResource("J.png"));
L=ImageIO.read(
Tetris.class.getResource("L.png"));
O=ImageIO.read(
Tetris.class.getResource("O.png"));
}catch(Exception e){
e.printStackTrace();
}
}
/** JPanel paint() paint画
* 重写 paint() 修改原有的绘制方法
**/
@Override
public void paint(Graphics g) {
//画背景, 画墙, 画正在下落的方块 画下一个方块...
g.drawImage(background, 0, 0, null);
g.translate(15, 15);//坐标系平移
paintWall(g);//画墙
paintTetromino(g);//画正在下落的方块
paintNextOne(g);
paintScore(g);
g.translate(-15, -15);
if(gameOver){
g.drawImage(overImage, 0, 0, null);
}
//g.setColor(new Color(0x0000ff));
//g.drawRect(10, 10, 50, 80);
}
public static final int FONT_COLOR=0x667799;
public static final int FONT_SIZE=30;
private void paintScore(Graphics g) {
int x = 290;
int y = 160;
g.setColor(new Color(FONT_COLOR));
Font font = g.getFont();//取得g当前字体
font = new Font(font.getName(),
font.getStyle(), FONT_SIZE);
g.setFont(font);//更改了g的字体
String str = "SCORE:" score;
g.drawString(str, x, y);
y =56;
str = "LINES:" lines;
g.drawString(str, x, y);
y =56;
str = "[P]Pause";
if(pause){
str = "[C]Continue";
}
if(gameOver){
str = "[S]Start!";
}
g.drawString(str, x, y);
}
private void paintNextOne(Graphics g) {
if(nextOne==null){
return;
}
//将每个格子的row,col 换算为x,y 然后贴图
Cell[] cells = nextOne.cells;
for(int i=0; i
//i = 0 1 2 3
Cell cell = cells[i];
//cell 每个格子
int x = (cell.getCol() 10)*CELL_SIZE;
int y = (cell.getRow() 1)*CELL_SIZE;
g.drawImage(cell.getImage(),
x-1, y-1, null);
}
}
public void paintTetromino(Graphics g){
//System.out.println("paint:" tetromino);
if(tetromino==null){
return;
}
//将每个格子的row,col 换算为x,y 然后贴图
Cell[] cells = tetromino.cells;
for(int i=0; i
//i = 0 1 2 3
Cell cell = cells[i];
//cell 每个格子
int x = cell.getCol() * CELL_SIZE;
int y = cell.getRow() * CELL_SIZE;
g.drawImage(cell.getImage(),
x-1, y-1, null);
}
}
public static final int CELL_SIZE = 26;
/** 画墙 */
private void paintWall(Graphics g){
for(int row=0; row
Cell[] line = wall[row];
//line 代表墙上的每一行
for(int col=0; col
Cell cell = line[col];
//cell 代表墙上的每个格子
int x=col*CELL_SIZE;
int y=row*CELL_SIZE;
if(cell==null){
//g.drawRect(x,y,CELL_SIZE,CELL_SIZE);
}else{
g.drawImage(cell.getImage(),
x-1, y-1, null);
}
}
}
}
/** 在Tetris 添加启动方法 action() */
public void action(){
wall = new Cell[ROWS][COLS];
startAction();
//wall[2][2] = new Cell(2,2, T);
//tetromino = Tetromino.randomOne();
//System.out.println(
//"After rendomOne:" tetromino);
//nextOne = Tetromino.randomOne();
//处理键盘按下事件, 在按下按键时候执行下落方法
KeyAdapter l = new KeyAdapter(){
@Override //key 按键 Pressed按下了
public void keyPressed(KeyEvent e) {
int key = e.getKeyCode();//[c]
if(key==KeyEvent.VK_Q){
System.exit(0);//结束Java进程
}
if(gameOver){
if(key==KeyEvent.VK_S){
startAction();
repaint();
}
return;
}
if(pause){//pause = true
if(key==KeyEvent.VK_C){
continueAction();
repaint();
}
return;
}
switch (key) {
case KeyEvent.VK_DOWN:softDropAction();break;
case KeyEvent.VK_RIGHT:moveRightAction();break;
case KeyEvent.VK_LEFT:moveLeftAction();break;
case KeyEvent.VK_SPACE:hardDropAction();break;
case KeyEvent.VK_UP:rotateRightAction();break;
case KeyEvent.VK_P:pauseAction();break;
}
repaint();//再画一次!
}
};
//下落流程: 监听键盘事件->如果下箭头按下->
//执行下落算法tetromino.softDrop()->
// 修改每个格子对象的数据->调用repaint()->
// 尽快调用paint()->paint方法会根据当前的数据
// 重新绘制界面 -> 看到移动以后的方块了
//绑定事件到当前面板
this.requestFocus();
this.addKeyListener(l);
}
/** 在Tetris 类上添加方法, 向右移动的流程控制 */
public void moveRightAction(){
//尝试先向右移动, 如果发现超出了边界, 就
//向左移动, 修正回来.
tetromino.moveRight();//coincide重叠
if(outOfBounds() || coincide()){
tetromino.moveLeft();
}
}
/** 检查正在下落的方块是否与墙上的砖块重叠 */
private boolean coincide() {
Cell[] cells = tetromino.cells;
for(int i=0; i
Cell cell = cells[i];
int row = cell.getRow();
int col = cell.getCol();
//如果墙的row,col位置上有格子,就重叠了!
if(row>=0 && row
col>=0 && col<=COLS &&
wall[row][col]!=null){
return true;//重叠
}
}
return false;
}
/** 检查当前正在下落的方块是否出界了 */
private boolean outOfBounds(){
Cell[] cells = tetromino.cells;
for(int i=0; i
Cell cell = cells[i];
int col = cell.getCol();
if(col<0 || col>=COLS){
return true;
}
}
return false;
}
public void moveLeftAction(){
tetromino.moveLeft();
if(outOfBounds() || coincide()){
tetromino.moveRight();
}
}
/** 下落流程控制 */
public void softDropAction(){
if(canDrop()){
tetromino.softDrop();
}else{
landIntoWall();
destoryLines();
checkGameOverAction();
tetromino = nextOne;
nextOne = Tetromino.randomOne();
}
}
private static int[] scoreTable ={0,1,10,50,100};
// 0 1 2 3 4
private void destoryLines() {
int lines = 0;
for(int row=0; row
if(fullCells(row)){
deleteRow(row);
lines ;
}
}
this.score = scoreTable[lines];
this.lines =lines;
}
private void deleteRow(int row) {
for(int i=row; i>=1; i--){
System.arraycopy(
wall[i-1], 0, wall[i], 0, COLS);
}
Arrays.fill(wall[0], null);
}
/** 检查当前行的每个格子, 如果有null返回false
* 否则返回 true */
private boolean fullCells(int row) {
Cell[] line = wall[row];
for(Cell cell: line){
if(cell==null){return false; }
}
return true;
}
private void landIntoWall() {
Cell[] cells = tetromino.cells;
for(int i=0; i
Cell cell = cells[i];
int row = cell.getRow();
int col = cell.getCol();
wall[row][col]=cell;
}
}
/** 检查当前的方块是否能够下落, 返回true能够下落 */
private boolean canDrop() {
Cell[] cells = tetromino.cells;
for(int i=0; i
Cell cell = cells[i];
int row = cell.getRow();
if(row == ROWS-1){
return false;
}
}
for(Cell cell: cells){//Java 5 以后可以使用
int row = cell.getRow() 1;
int col = cell.getCol();
if(row>=0 && row
col>=0 && col<=COLS &&
wall[row][col]!=null){
return false;
}
}
return true;
}
/** 硬下落流程, 下落到不能下落为止
* 绑定到 空格(VK_SPACE)事件上
* */
public void hardDropAction(){
while(canDrop()){
tetromino.softDrop();
}
landIntoWall();
destoryLines();
checkGameOverAction();
tetromino = nextOne;
nextOne = Tetromino.randomOne();
}
/** 在Tetris类中添加 旋转流程控制方法 */
public void rotateRightAction(){
tetromino.rotateRight();
if(outOfBounds() || coincide()){
tetromino.rotateLeft();
}
}
private Timer timer;
private boolean pause;
private boolean gameOver;
private long interval = 600;//间隔时间
/** 在Tetris类中添加 开始流程控制 */
public void startAction(){
pause = false; gameOver = false;
score = 0; lines=0;
clearWall();
tetromino = Tetromino.randomOne();
nextOne = Tetromino.randomOne();
timer = new Timer();
timer.schedule(new TimerTask(){
public void run(){
softDropAction();
repaint();
}
}, interval, interval);
}
private void clearWall() {
//Arrays.fill(wall, null);
for(Cell[] line: wall){
Arrays.fill(line, null);
}
//for(int i=0; i
//Arrays.fill(wall[i], null);
//}
}
/** 在Tetris类中添加暂停方法 */
public void pauseAction(){
timer.cancel();
pause = true;
}
public void continueAction(){
timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
softDropAction();
repaint();
}
}, interval, interval);
pause = false;
}
public void checkGameOverAction(){
if(wall[0][4]!=null){
gameOver = true;
timer.cancel();
}
}
public static void main(String[] args) {
JFrame frame = new JFrame();
//在加载Tetris类的时候, 会执行静态代码块
//静态代码块,装载了图片素材, 为图片对象
Tetris tetris = new Tetris();
//tetris.setBackground(new Color(0x0000ff));
frame.add(tetris);
frame.setSize(530, 580);
frame.setLocationRelativeTo(null);
frame.setDefaultCloseOperation(
JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);//在显示窗口时候,会"尽快"
tetris.action();
//的调用paint()方法绘制界面
}
}