package russia.game.square;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.Serializable;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Random;
import javax.swing.*;
/**
* 游戏界面类 思路 当方块落到底部时用二维数组储存
*
* @author lyj
*
*/
public class RussiaGame extends JPanel implements Serializable, KeyListener {
/**
*
*/
private static final long serialVersionUID = 1L;
/**
* 数组的行数和列数 初始话界面的大小为 22行 12列
*/
private static final int ROW_SIZE = 22, COLUMN_SIZE = 12;
/**
* 界面宽度
*/
private static final int WIDTH_SIZE = 344;
/**
* 界面高度
*/
private static final int HEIGHT_SIZE = 375;
/**
* 储存格子的数组
*/
private static int[][] shapeMap = new int[ROW_SIZE][COLUMN_SIZE];
int[][] random;// 用来装载随机形状的二维数组
/**
* 用来记载移动的坐标
*/
private int move_x = 5, move_y = -2;
/**
* 方块大小
*/
private static final int SQUARE_SIZE = 20;
/**
* 方块矩阵的大小
*/
private static final int MATRIX_SIZE = 5;
/**
* 分数
*/
private int scores = 0;
/**
* 判断游戏是否结束的标志
*/
private boolean canPlay = true;
/**
* 休眠时间
*/
private int SLEEP_TIME = 500;
/**
* 暂停游戏
*/
private boolean SLEEPGAME = true;
/**
* ENTER 建的值用来标记暂停事件
*/
static final int VK_ENTER = 10;
/**
* 下一个方块
*
*/
static int[][] next;
/**
* 用来装载当期方块和下一个方块
*/
private LinkedList<int[][]> shapeList = new LinkedList<int[][]>();
private Map<Points, Color> colorMap=new HashMap<Points, Color>();
/**
* 当前方块的颜色
*/
private Color randomColor=null;
/**
* 下个方块的颜色
*/
private Color nextColor=null;
private LinkedList<Color> colors=new LinkedList<Color>();
public RussiaGame() {
randomShape();
randomColor();
colorMap=FileHelpers.readColor();
scores=FileHelpers.getScores();
randomColorList();
initShape();
javax.swing.Timer time = new Timer(SLEEP_TIME, new GameLitsner());
time.start();
setBackground(Color.DARK_GRAY);
setSize(new Dimension(WIDTH_SIZE, HEIGHT_SIZE));
}
private void initShape() {
shapeMap = FileHelpers.read(ROW_SIZE, COLUMN_SIZE);
}
/**
* 判断是否能旋转 如果下一个图形所在的坐标没有越界和没有
*
* @return true转换 false 不转换
*/
private boolean canTurnChange(int[][] newRandom) {
boolean canTurn = true;
if (move_y >=0){
for (int i = MATRIX_SIZE - 1; i >= 0; i--) {
for (int j = 0; j < MATRIX_SIZE; j++) {
if (newRandom[i][j] == 1) {
if (shapeMap[move_y + i][move_x + j] == 1
|| shapeMap[move_y + i][move_x + j] == 2) {
canTurn = false;
break;
}
}
}
}
}
return canTurn;
}
/**
* 消行
*
* @return
*/
private int[][] delteLine() {
int count = 0;
for (int i = ROW_SIZE - 2; i >= 1; i--) {
if (canDelete(shapeMap[i])) {
scores += 10;
for (int j = 1; j <= 10; j++) {
shapeMap[i][j] = 0;
count++;
}
}
if(count>=1){
for (int j = 1; j <= 10; j++) {
Points down=new Points(i,j);
Points up =new Points(i-1,j);
Color cor=colorMap.get(up);
if(cor!=null){
colorMap.remove(down);
colorMap.put(down,cor);
colorMap.remove(up);
}
}
}
if (count >= 1) {
int[] temp = shapeMap[i];
shapeMap[i] = shapeMap[i - 1];
shapeMap[i - 1] = temp;
}
}
return shapeMap;
}
protected boolean canDelete(int[] line) {
for (int i = 1, size = 10; i <= size; i++) {
if (line[i] == 0) {
return false;
}
}
return true;
}
/**
* 重新开始游戏
*/
private void restart() {
for (int i = 0; i <= 20; i++) {
for (int j = 1; j <= 10; j++) {
shapeMap[i][j] = 0;
}
}
canPlay = true;
}
/**
* 判断游戏是否结束
*
* @return
*/
private boolean gameOver() {
int[] top = shapeMap[0];// 获得顶部
for (int i = 1; i < COLUMN_SIZE - 1; i++) {
if (top[i] == 1) {
return true;
}
}
return false;
}
/**
* 盘能是否能下落
*
* @return
*/
private boolean canDown() {
boolean canDown = true;
int x = move_x == -1 ? move_x + 2 : move_x + 1;
int len = shapeLength();
if (move_y >= 0 && move_x < 12)
for (int i = MATRIX_SIZE - 1; i >= 0; i--) {
for (int j = 0; j < MATRIX_SIZE; j++) {
if (random[i][j] == 1&&move_y+i+1<=21) {
if (shapeMap[move_y + i + 1][move_x + j] == 1) {
canDown = false;
break;
}
}
}
}
if (move_y >= 0 && x < 12 && shapeMap[move_y + len][x] == 2) {
canDown = false;
}
return canDown;
}
/**
* 判断是否能左移
*
* @return
*/
private boolean canLeft() {
boolean canLeft = true;
if(move_y>=0)
for (int i = MATRIX_SIZE - 1; i >= 0; i--) {
for (int j = 0; j < MATRIX_SIZE; j++) {
if (random[i][j] == 1) {
if (shapeMap[move_y + i][move_x + j - 1] == 1
|| shapeMap[move_y + i][move_x + j - 1] == 2) {
canLeft = false;
break;
}
}
}
}
return canLeft;
}
/**
* 获得方块的长度
*/
private int shapeLength() {
for (int leng = 5; leng >= 1; leng--) {
int[] number = random[leng - 1];
for (int index = 0; index < 5; index++) {
if (number[index] == 1) {
return leng;
}
}
}
return -1;
}
/**
* 画当前方块
*
* @param gs
*/
private void paintCurr(java.awt.Graphics gs, int[][] randoms) {
gs.setColor(randomColor);
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (randoms[i][j] == 1) {
gs.fill3DRect(j * SQUARE_SIZE + move_x * SQUARE_SIZE, i
* SQUARE_SIZE + move_y * SQUARE_SIZE, SQUARE_SIZE,
SQUARE_SIZE, true);
}
}
}
}
private void paintNext(java.awt.Graphics gs) {
gs.setColor(nextColor);
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (next[i][j] == 1) {
gs.fill3DRect(j * SQUARE_SIZE + 250, i * SQUARE_SIZE,
SQUARE_SIZE, SQUARE_SIZE,true);
}
}
}
}
/**
* 画走马灯
* @param gs
*/
private void paintTwinkLight(java.awt.Graphics gs){
int index=0;
gs.setColor(Color.BLACK);
for (int i = 1; i <= 22; i++) {
gs.setColor(colorList.get(index));
gs.fillOval(3, (i-1)* SQUARE_SIZE+2, 15, 15);
index++;
}
for (int j = 1; j <=10; j++) {
gs.setColor(colorList.get(index));
gs.fillOval( j*SQUARE_SIZE+3, 21* SQUARE_SIZE+2, 15, 15);
index++;
}
for (int i = 22; i >=1; i--) {
gs.setColor(colorList.get(index));
gs.fillOval( 11*SQUARE_SIZE+3, (i-1)*SQUARE_SIZE+2, 15, 15);
index++;
}
}
private static LinkedList<Color> colorList=new LinkedList<Color>();
private static void randomColorList(){
int index=0;
for(int i=1;i<=54;i++){
colorList.add(Shapes.shapeColors[index]);
if(index==7){
index=0;
}
index++;
}
}
@Override
// 画组建的方法
protected void paintComponent(java.awt.Graphics g) {
super.paintComponent(g);
Image bc = new ImageIcon("save/333.jpg").getImage();
g.drawImage(bc, 0, 0, getWidth(), getHeight(), this);
g.setColor(Color.red);
g.drawString("分数" + scores, 250, 150);
g.drawString("F5 清屏重新开始 ", 250, 190);
g.drawString("ENTER 暂停\\开始游戏", 250, 230);
g.drawString("ESC 退出并保存", 250, 270);
paintNext(g);
paintTwinkLight(g);
// 绘制当前方块
paintCurr(g, random);
// 画已经落下的方块
for (int j = 0; j < ROW_SIZE; j++) {
for (int i = 0; i < COLUMN_SIZE; i++) {
if (shapeMap[j][i] == 1) {
Points p=new Points(j,i);
if(colorMap.get(p)!=null){
g.setColor(colorMap.get(p));
}
g.fill3DRect(i * SQUARE_SIZE, j * SQUARE_SIZE, SQUARE_SIZE,
SQUARE_SIZE, true);
}
if (shapeMap[j][i] == 2) {
g.setColor(Color.black);
g.drawRect(i * SQUARE_SIZE, j * SQUARE_SIZE, SQUARE_SIZE,
SQUARE_SIZE);
}
}
}
};
/**
* 生成随机形状
*
* @return
*/
private void randomShape() {
Random ran = new Random();
int len=Shapes.shapeAry.length;
if (shapeList.size() == 2) {
shapeList.removeFirst();
shapeList.addLast(Shapes.shapeAry[ran.nextInt(len)]);
} else {
shapeList.addFirst(Shapes.shapeAry[ran.nextInt(len)]);
shapeList.addLast(Shapes.shapeAry[ran.nextInt(len)]);
}
random = shapeList.getFirst();
next = shapeList.getLast();
}
private void randomColor(){
Random ran = new Random();
if(colors.size()==2){
colors.removeFirst();
colors.addLast(Shapes.shapeColors[ran.nextInt(Shapes.shapeColors.length)]);
}
else{
colors.addFirst(Shapes.shapeColors[ran.nextInt(Shapes.shapeColors.length)]);
colors.addLast(Shapes.shapeColors[ran.nextInt(Shapes.shapeColors.length)]);
}
randomColor=colors.getFirst();
nextColor=colors.getLast();
}
/**
* 画墙壁的方法
*/
private void clearMap() {
shapeMap = new int[ROW_SIZE][COLUMN_SIZE];
for (int i = 0; i < ROW_SIZE; i++) {
shapeMap[i][0] = 2;
shapeMap[i][COLUMN_SIZE - 1] = 2;
}
// 画底部的格子
for (int j = 0; j < COLUMN_SIZE; j++) {
shapeMap[ROW_SIZE - 1][j] = 2;
}
}
private void turnLef() {
if (move_y>=0&&canLeft()) {
move_x--;
shapeMap = delteLine();
repaint();
}
}
/**
* 判断是否能右移
*
* @return
*/
private boolean canRight() {
boolean canRight = true;
if(move_y>=0)
for (int i = MATRIX_SIZE - 1; i >= 0; i--) {
for (int j = 0; j < MATRIX_SIZE; j++) {
if (random[i][j] == 1) {
if (shapeMap[move_y + i][move_x + j + 1] == 1
|| shapeMap[move_y + i][move_x + j + 1] == 2) {
canRight = false;
break;
}
}
}
}
return canRight;
}
private void turnRight() {
if (move_y>=0&&canRight()) {
move_x++;
shapeMap = delteLine();
repaint();
}
}
private void turnUp() {
int[][] newRandom = rounding();
if (canTurnChange(newRandom)) {
random = newRandom;
}
shapeMap = delteLine();
repaint();
}
private void turnDown() {
if (canDown())
move_y++;
shapeMap = delteLine();
repaint();
}
/**
* 旋转矩阵
*
* @return
*/
public int[][] rounding() {
int[][] newRandom = new int[random.length][random[0].length];
if (random == Shapes.shapeAry[2] ) {
return random;
}
else if(random == Shapes.shapeAry[5]){
return Shapes.shapeAry[6];
}
else if(random == Shapes.shapeAry[6]){
return Shapes.shapeAry[5];
}
for (int i = 0; i < random.length; i++) {
for (int j = 0; j < random[0].length; j++) {
newRandom[j][random[0].length - i - 1] = random[i][j];
}
}
return newRandom;
}
class GameLitsner implements ActionListener {
public void actionPerformed(ActionEvent e) {
if (SLEEPGAME)
if (gameOver() == false) {
if (canDown()) {
move_y++;
shapeMap = delteLine();
Color first=colorList.getFirst();
colorList.removeFirst();
colorList.addLast(first);
repaint();
} else {
shapeMap = delteLine();
addShapeAndColor();
Color first=colorList.getFirst();;
colorList.removeFirst();
colorList.addLast(first);
move_x = 5;
move_y = -5;
randomShape();
randomColor();
repaint();
}
}
else
canPlay = false;
}
}
/**
* 添加下落好的方块和颜色
*/
private void addShapeAndColor() {
int len = shapeLength();
int index = len == 3 ? 3 : 4;
for (int i = 0; i < 5; i++, index--) {
for (int j = 0; j < 5; j++) {
if (random[i][j] == 1 && move_y + len - index >= 0) {
shapeMap[move_y + len - index][move_x + j] = 1;
Points ps=new Points(move_y + len - index,move_x + j);
colorMap.put(ps, randomColor);
}
}
}
}
public void keyPressed(KeyEvent key) {
if (canPlay && SLEEPGAME)
switch (key.getKeyCode()) {
// 改变形状
case KeyEvent.VK_UP:
case KeyEvent.VK_W:
turnUp();
break;
// 下落
case KeyEvent.VK_DOWN:
case KeyEvent.VK_S:
turnDown();
break;
// 左移
case KeyEvent.VK_LEFT:
case KeyEvent.VK_A:
turnLef();
break;
// 右移
case KeyEvent.VK_RIGHT:
case KeyEvent.VK_D:
turnRight();
break;
case KeyEvent.VK_ESCAPE:
int isSave=JOptionPane.showConfirmDialog(null, "是否保存游戏", null, JOptionPane.YES_NO_OPTION);
if (isSave == 0) {
FileHelpers.wirte(shapeMap, ROW_SIZE, COLUMN_SIZE);
FileHelpers.write(colorMap,scores);
} else {
clearMap();
FileHelpers.wirte(shapeMap, ROW_SIZE, COLUMN_SIZE);
FileHelpers.write(null,0);
}
System.exit(1000);
break;
}
if (key.getKeyCode() == KeyEvent.VK_F5) {
restart();
}
if (key.getKeyCode() == VK_ENTER) {
SLEEPGAME = SLEEPGAME == true ? false : true;
} else if (canPlay == false) {
JOptionPane.showMessageDialog(null, "Game Over!");
scores = 0;
}
}
public void keyReleased(KeyEvent e) {
// TODO Auto-generated method stub
}
public void keyTyped(KeyEvent e) {
// TODO Auto-generated method stub
}
}
最近下载更多
最近浏览更多
