开博第一天，想写点有意义的东西！

<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">随笔</span>

太过愚笨，学了很久java，终于能写点小东西，写出来鼓励一下自己

<俄罗斯方块 java版>

首先需要感谢“马士兵”老师的学习视频，让我学习有了目标，有了体系。

虽然我还学的尚浅，但我还在继续努力。

记录一下的独立的第一个的代码（当然也有借鉴大神的思路）

1、开始准备写“俄罗斯方块”时，按照刚看完马士兵老师j2se的几个项目的惯性思路，new一个窗口出来，窗口里new出来一个Panel和两个Button，遇到第一个问题，这三个玩意不受控制，j2se的知识点忘记了，原来是setLayout(null)没加。

2、接着考虑怎么画出方块，这也是我的最大的误区，我想着就是画出所有的方块，完全没考虑后续的怎么判断，怎么调用，同时遇到第二个问题，Panel上加监听，但是没反应，必须点击到Panel才可以收到监听，也算是纠结了一天，终于在度娘的帮助下找到requestFocus();用于获取焦点。

3、简单一点说，程序进入瓶颈，或者说象是死胡同，因为是全是画出来的，而且所有的绘画线程都在Panel的线程中，因为我在马士兵老师的视频里看到都是这样的，以至于移动和控制都在一个线程里，全TM乱了，导致了停滞了几天，找问题，我知道我的整个框架有问题了，但是我不知道怎么办，我是迷茫的，打游戏的心思也没有了。没人问是我最揪心的。

4、沉寂了几天，差点准备放弃这见鬼的游戏，最后还问了女朋友的意见，到底我有没有必要坚持下去，最后还是打算坚持着在研究研究，度娘是我唯一的帮手，找到大神们的代码和思路，给了我很多启发，也很受打击，因为像我一样以画出方块为思路的很少，都是以数组形式为核心来调用控制，我也终于打算推翻我以前所以写的，重写，我要加粗表达我心中的累，不知道圈内的大神有没有过。

5、再次感谢以下两位博主的文章给了我思路，【“benpaodelvzi”（http://bbs.csdn.net/topics/340119430）】【“姜楠”（http://www.cnblogs.com/ZJUT-jiangnan/archive/2013/02/26/2934244.html）】，他们的思路都很清晰。给了我很多启发。“benpaodelvzi”的文章中墙的加入给我思路解决了出界的问题。促成了<俄罗斯方块>游戏的完成。

6、最后是写完后的一些建议，网上很多人说，java写游戏没什么卵用，但我想说，对于初学者来说，这是写基础，能让你将基础内容融合，虽然很多没有涉及到，但是更多时候是一种实现思想和其中解决问题的过程学习。最后还是要感谢度娘的支持！

【以下贴出部分代码，并不是我小气，因为我还想继续能修改的好些，完成后补充】

// 积木的类
public class Block implements Runnable{
	int x, y;
	int style;
	Box blockBox[][];
	Grid grid;
	Boolean moving = true;
	
	static int[][] shape = {
			{0x4444, 0x0f00, 0x4444, 0x0f00},   //I
			{0x0622, 0x02e0, 0x4460, 0x0740},   //7
			{0x0644, 0x0e20, 0x2260, 0x0470},   //反7
			{0x0c60, 0x2640, 0x0630, 0x0264},   //Z
			{0x06c0, 0x4620, 0x0360, 0x0462},   //S
			{0x0e40, 0x2620, 0x0270, 0x0464},   //T
			{0x0660, 0x0660, 0x0660, 0x0660}    //o
	};
	
	Block (int x, int y, int style, Grid grid) {
		this.x = x;
		this.y = y;
		this.style = style; 
		this.grid = grid;
		blockBox = new Box[4][4];
		
		int key = 0x8000;
		for(int i=0; i<blockBox.length; i++) {
			for(int j=0; j<blockBox[i].length; j++) {
				if((key & style) != 0) {
					blockBox[i][j] = new Box(1);
				}else {
					blockBox[i][j] = new Box(0);
				} 
				key >>= 1;
			}
		}
		display();
	}
	//显示
	public void display () {
		for(int i=0; i<blockBox.length; i++) {
			for(int j=0; j<blockBox[i].length; j++) {
				if(blockBox[i][j].isColor == 1) {
					if(y+i >= 0){
						grid.getBox(y+i, x+j).setColor(1);
					}
				}
			}
		}
	}
<span style="white-space:pre">	</span>//擦除
	public void erase () {
		for(int i=0; i<blockBox.length; i++) {
			for(int j=0; j<blockBox[i].length; j++) {
				if(blockBox[i][j].isColor == 1) {
					if(y+i >= 0){
						grid.getBox(y+i, x+j).setColor(0);
					}
				}
			}
		}
	}
	//下落线程
	@Override
	public void run() {
		while(moving) {
			//moveTo(x, y+1);
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			if(true) {
				Boolean b = moveTo(x, y+1);
				moving = (b && moving);
			}
		}
		
	}
<span style="white-space:pre">	</span>//旋转到下一个
	private void turnNext() {
		//erase();
		for(int i=0; i<7; i++) {
			for(int j=0; j<4; j++) {
				if(shape[i][j] == this.style) {
					int newStyle = shape[i][(j+1) % 4];
					turnTo(newStyle);
					return;
				}
			}
		}
	}
	//旋转成
	private void turnTo(int newStyle) {
		if(!this.isTurn(newStyle)) {
			return;
		}
		erase();
		int key = 0x8000; 
		for(int i=0; i<blockBox.length; i++) {
			for(int j=0; j<blockBox[i].length; j++) {
				blockBox[i][j].setColor(0);
				if((key & newStyle) != 0) {
					blockBox[i][j].setColor(1);
				}
				key >>= 1;
			}
		}
		this.style = newStyle;
		display();
		grid.repaint();
	}
<span style="white-space:pre">	</span>//移动到
	private synchronized boolean moveTo(int newX, int newY) {
		if(!this.isMove(newX, newY) || !moving){
			return false;
		}
		erase();
		x = newX;
		y = newY;
		display();
		grid.repaint();
		return true;
	}
	//判断移动
	private boolean isMove (int newX, int newY) {
		erase();
		for(int i=0; i<blockBox.length; i++) {
			for(int j=0; j<blockBox[i].length; j++) {
				if(blockBox[i][j].isColor == 1) {
					if(newY+i >= 0) {
						if(grid.getBox(newY+i, newX+j).isColor == 2 || grid.getBox(newY+i, newX+j).isColor == 1) {
							display();
							return false;
						}
					}
				}
			}
		}
		display();
		return true;
	}
<span style="white-space:pre">	</span>//判断旋转
	private boolean isTurn(int newStyle) {
		erase();
		int key = 0x8000; 
		for(int i=0; i<blockBox.length; i++) {
			for(int j=0; j<blockBox[i].length; j++) {
				if((key & newStyle) != 0) {
					if(grid.gridBox[i+y][j+x].isColor == 2 || grid.gridBox[i][j].isColor == 1) {
						display();
						return false;
					}
				}else if (y<0) {
					return false;
				}
				key >>= 1;
			}
		}
		display();
		return true;
	}
	//判断积木的状态
	public boolean isAlive() {
			return moving;
	}
	
	public void keyPressed(KeyEvent e) {
		int keyCode = e.getKeyCode();
		switch(keyCode) {
		case KeyEvent.VK_UP :
			turnNext();
			break;
		case KeyEvent.VK_RIGHT :
			moveTo(x+1, y);
			break;
		case KeyEvent.VK_DOWN :
			moveTo(x, y+1);
			break;
		case KeyEvent.VK_LEFT :
			moveTo(x-1, y);
			break;
		}
	}

}
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Panel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.Random;
//Panel的类，就是网格类，就是二维数组，也可以类似于几百个LED灯
public class Grid extends Panel{
	
	int row, col;
	Box[][] gridBox;
	Image bufferImage = null;
	Block block;
	Boolean playing;
	PlayThread pt = new PlayThread();
	
	Random r = new Random();
	
	Grid (int row, int col) {
		this.row = row;
		this.col = col;
		gridBox = new Box[row][col];
		
		for(int i=0; i<(gridBox.length)-1; i++) {
			for(int j=1; j<(gridBox[i].length)-1; j++) {
				gridBox[i][j] = new Box (0);
			}
		} 
		for(int j=0, i=row-1; j<gridBox[i].length; j++) {
			gridBox[i][j] = new Box(2);
		}
		for(int i=0, j=0, j1=(col-1); i<(gridBox.length-1); i++) {
			gridBox[i][j] = new Box(2);
			gridBox[i][j1] = new Box(2);
		}
		this.addKeyListener(new KeyMonitor());
		//playGame();
	}
	//获取其中一格，每一格的类是Box（未贴出）
	public Box getBox (int row, int col) {
		return gridBox[row][col];
	}
	
	@Override
	public void paint(Graphics g) {
		Color c = g.getColor();
		for(int i=0; i<gridBox.length; i++) {
			for(int j=0; j<gridBox[i].length; j++) {
				if(gridBox[i][j].isColor == 0) {
					g.setColor(Color.LIGHT_GRAY);
					g.fillRect(Box.size*(j-1), Box.size*i, Box.size, Box.size);
					g.setColor(Color.WHITE);
					g.drawRect(Box.size*(j-1), Box.size*i, Box.size, Box.size);
				}else if(gridBox[i][j].isColor == 1){
					g.setColor(Color.ORANGE);
					g.fillRect(Box.size*(j-1), Box.size*i, Box.size, Box.size);
					g.setColor(Color.BLACK);
					g.drawRect(Box.size*(j-1)-1, Box.size*i-1, Box.size, Box.size);
				}
			}
		}
		g.setColor(Color.BLACK);
		g.drawRect(0, 0, Box.size*(col-2), Box.size*(row-1));
		
		g.setColor(c);
	}
<span style="white-space:pre">	</span>//双缓冲
	@Override
	public void update(Graphics g) {
		
		bufferImage = this.createImage(Box.size*col, Box.size*row);
		Graphics bg = bufferImage.getGraphics();
		paint(bg);
		g.drawImage(bufferImage, 0, 0, null);
		
	}
	//new积木和消行的线程
	private class PlayThread implements Runnable {
				
		@Override
		public void run() {
			while(playing) {
				if(block != null) {
					if(block.isAlive()) {
						try {
							Thread.sleep(400);
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						continue;
					}
				}
				isFillLine();
				int x = r.nextInt(4);
				int y = r.nextInt(7);
				block = new Block(col/2-2, -4, Block.shape[y][x], Grid.this);
				new Thread(block).start();
				isGameOver();
			}
		}
	}
	//开始
	public void playGame() {
		playing = true;
		new Thread(pt).start();
	}
	//判断消行
	public void isFillLine () {
		for(int i=0; i<(gridBox.length)-1; i++) {
			int num = 0;
			for(int j=1; j<(gridBox[i].length)-1; j++) {
				if(gridBox[i][j].isColor == 1){
					num ++;
				}
				if(num == (col-2)) {
					eraseLine(i);
				}
			}
		}
	}
	//消行
	private synchronized void eraseLine(int line) {
		if(!block.isAlive()) {
			for(int i=line; i>0; i--) {
				for(int j=1; j<=(gridBox[i].length)-1; j++) {
					gridBox[i][j].isColor = gridBox[i-1][j].isColor;
				}
			}
		}
		repaint();
	}
<span style="white-space:pre">	</span>//判断结束
	public boolean isGameOver () {
		if(block.y < 0) {
			if(!block.isAlive()){
				System.out.println("Game Over");
				return true;
			}
		}
		return false;
	}
	//按键监听
	private class KeyMonitor extends KeyAdapter{

		@Override
		public void keyPressed(KeyEvent e) {
			block.keyPressed(e);
		}
		
	}

}

（关于注释部分，我确实比较懒）

【这是一位小白的代码，请指教】