Página en revisión
Código en Processing, tomado de: http://www.danepieri.com/tetris_play.html
// Controls:
// Arrow keys for left, right, down, rotate
// Spacebar to drop piece
//import processing.opengl.*;
PFont Hira;
Board myBoard;
Board.BoardBlock[][] myBoardBlock;
fallingPiece myPiece;
int numRows = 15;
int numCol = 10;
int brickSize = 25;
int offset = 20;
int numRowsCleared;
boolean gameIsOver = false;
void setup(){
size(440,415);
stroke(100);
Hira = loadFont("Ziggurat.vlw");
myBoard = new Board();
myBoardBlock = new Board.BoardBlock[10][15];
for (int i=0; i<numCol; i++){
for (int j=0; j<numRows; j++){
myBoardBlock[i][j] = myBoard.new BoardBlock(i,j);
}
}
myPiece = new fallingPiece((int)random(6.99999));
}
void draw(){
background(200);
myBoard.renderBoard();
myBoard.clearFullRows();
myBoard.displayScore();
myBoard.displayGameOver();
myPiece.animate();
}
// ======= Falling Piece Class ===============
// ===========================================
class fallingPiece{
int pieceUsed;
int posCreating;
color pieceCol;
int[][] brickPos = new int[4][2]; // [0]=x [1]=y
// These boolean arrays are used to create the pieces
// however after that a piece is just a set of 4 x and y values
// so really it is four pieces.
boolean[][] I_PIECE = {
{ true, true, true, true }
};
boolean[][] J_PIECE = {
{ true, false, false } ,
{ true, true, true }
};
boolean[][] L_PIECE = {
{ false, false, true },
{ true, true, true }
};
boolean[][] O_PIECE = {
{ true, true },
{ true, true }
};
boolean[][] S_PIECE = {
{ false, true, true },
{ true, true, false }
};
boolean[][] T_PIECE = {
{ false, true, false },
{ true, true, true }
};
boolean[][] Z_PIECE = {
{ true, true, false } ,
{ false, true, true }
};
color[] pieceColors = {
color(0,240,240),color(0,0,240), color(240,160,0),
color(240,240,0), color(0,240,0), color(160,0,240), color(240,0,0) };
boolean[][][] allPieces = {
I_PIECE, J_PIECE, L_PIECE, O_PIECE, S_PIECE, T_PIECE, Z_PIECE
};
// Pieces are rotated according to their relationship to the center brick
int[] centerPiece = {
1, 2, 1, 1, 2, 2, 2 };
// Constructor
fallingPiece(int pieceUsed){
int[][] brickPosTemp = new int[4][2];
this.pieceUsed = pieceUsed;
pieceCol = pieceColors[pieceUsed];
for (int j=0; j<allPieces[pieceUsed][0].length; j++){
for (int i=0; i<allPieces[pieceUsed].length; i++){
if(allPieces[pieceUsed][i][j]){
brickPosTemp[posCreating%4][0] = (numCol/2)-1 + i;
brickPosTemp[posCreating%4][1] = j;
if (myBoardBlock[brickPosTemp[posCreating%4][0]][brickPosTemp[posCreating%4][1]].isTaken() == true){
myBoard.gameOver();
break;
}
posCreating ++;
}
}
if (gameIsOver == true){
break;
}
}
if (gameIsOver == false){
for (int i=0; i<brickPos.length; i++){
brickPos[i][0] = brickPosTemp[i][0];
brickPos[i][1] = brickPosTemp[i][1];
}
}
}
// Functions
void render(){
strokeWeight(1);
for (int i=0; i<brickPos.length; i++){
fill(pieceCol);
rect(
brickPos[i][0]*brickSize+offset,
brickPos[i][1]*brickSize+offset,
brickSize,brickSize);
}
}
void animate(){
if(gameIsOver == false){
if(frameCount%(max(10,(25-numRowsCleared))) == 0 && this.canItMove()){
this.moveY();
}
if(keyPressed){
if (key == CODED){
if(keyCode == RIGHT && this.canItMoveR()){
this.moveRight();
keyPressed = false;
}
else if(keyCode == LEFT && this.canItMoveL()){
this.moveLeft();
keyPressed = false;
}
else if(keyCode == DOWN && this.canItMove()){
this.moveY();
keyPressed = false;
}
else if(keyCode == UP){
this.rotate();
keyPressed = false;
}
}
else if(key == ' '){
while (myPiece.canItMove()){
this.moveY();
}
keyPressed = false;
}
}
this.render();
}
}
void moveY(){
for (int i=0; i<brickPos.length; i++){
brickPos[i][1] ++;
}
}
void moveRight(){
for (int i=0; i<brickPos.length; i++){
brickPos[i][0] ++;
}
}
void moveLeft(){
for (int i=0; i<brickPos.length; i++){
brickPos[i][0] --;
}
}
boolean canItMove(){
for (int i=0; i<brickPos.length; i++){
if(brickPos[i][1] == numRows-1){
this.freezeBlock();
return false;
}
if(myBoardBlock[brickPos[i][0]][brickPos[i][1]+1].isTaken() == true){
this.freezeBlock();
return false;
}
}
return true;
}
boolean canItMoveL(){
for (int i=0; i<brickPos.length; i++){
if(brickPos[i][0] == 0){
return false;
}
if(myBoardBlock[brickPos[i][0]-1][brickPos[i][1]].isTaken() == true){
return false;
}
}
return true;
}
boolean canItMoveR(){
for (int i=0; i<brickPos.length; i++){
if(brickPos[i][0] == numCol-1){
return false;
}
if(myBoardBlock[brickPos[i][0]+1][brickPos[i][1]].isTaken() == true){
return false;
}
}
return true;
}
boolean canItRotate(int x, int y){
if (x > numCol-1
|| x < -1
|| y > numRows-1
|| myBoardBlock[x][y].isTaken() == true
){
return false;
}
return true;
}
void freezeBlock(){
for (int i=0; i<brickPos.length; i++){
myBoardBlock[brickPos[i][0]][brickPos[i][1]].take();
myBoardBlock[brickPos[i][0]][brickPos[i][1]].col = pieceColors[pieceUsed];
}
myPiece = new fallingPiece((int)random(6.9999));
}
void rotate(){
int[][] brickPosTemp = new int[4][2];
boolean isItGoingToRotate = true;
for (int i=0; i<brickPos.length; i++){
if( i != centerPiece[pieceUsed] && pieceUsed != 3){
int xDifference;
int yDifference;
int temp;
xDifference = brickPos[i][0] - brickPos[centerPiece[pieceUsed]][0];
yDifference = brickPos[i][1] - brickPos[centerPiece[pieceUsed]][1];
xDifference *= -1;
// rotate and check if new position is taken
brickPosTemp[i][1] = brickPos[centerPiece[pieceUsed]][1] + xDifference;
brickPosTemp[i][0] = brickPos[centerPiece[pieceUsed]][0] + yDifference;
if(canItRotate(brickPosTemp[i][0], brickPosTemp[i][1]) == false){
isItGoingToRotate = false;
break;
}
}
}
// Actually rotate
if (isItGoingToRotate == true){
for (int i=0; i<brickPos.length; i++){
if( i != centerPiece[pieceUsed] && pieceUsed != 3){
brickPos[i][1] = brickPosTemp[i][1];
brickPos[i][0] = brickPosTemp[i][0];
}
}
}
isItGoingToRotate = true;
}
}
// ============== Board Class ================
// ===========================================
public class Board{
int score = 0;
// constructor
Board(){
}
void clearFullRows(){
int numFullRows = 0;
for (int i=0; i<numRows; i++){
if(myBoardBlock[0][i].isTaken() == true && myBoardBlock[1][i].isTaken() == true && myBoardBlock[2][i].isTaken() == true
&& myBoardBlock[3][i].isTaken() == true && myBoardBlock[4][i].isTaken() == true && myBoardBlock[5][i].isTaken() == true
&& myBoardBlock[6][i].isTaken() == true && myBoardBlock[7][i].isTaken() == true && myBoardBlock[8][i].isTaken() == true
&& myBoardBlock[9][i].isTaken() == true) {
numFullRows ++;
//println("full" + numFullRows);
for (int j=0; j<numCol; j++){
myBoardBlock[j][i].take();
for (int k = i; k>0; k--){
myBoardBlock[j][k].taken = myBoardBlock[j][k-1].taken;
myBoardBlock[j][k].col = myBoardBlock[j][k-1].col;
}
}
}
}
if (numFullRows == 4){
score += 800; // Tetris!!
}
else if(numFullRows > 0){
score = score + (numFullRows * 100);
numRowsCleared += numFullRows;
}
numFullRows = 0;
}
void renderBoard(){
for (int i=0; i<10; i++){
for (int j=0; j<15; j++){
myBoardBlock[i][j].render();
}
}
noFill();
strokeWeight(1);
rect(offset,offset, brickSize*numCol, brickSize*numRows);
}
void gameOver(){
gameIsOver = true;
// println("Game Over");
}
void newGame(){
score = 0;
gameIsOver = false;
for (int i=0; i<numCol; i++){
for (int j=0; j<numRows; j++){
myBoardBlock[i][j].taken = false;
myBoardBlock[i][j].col = color(150,150,230);
}
}
myPiece = new fallingPiece((int)random(6.9999));
//println("New Game");
}
void displayScore(){
textFont(Hira,25);
strokeWeight(1);
fill(255);
text("Score:", width-120,70);
rect(width-130,85, 100,30);
fill(150);
text(score, width-125,110);
}
void displayGameOver(){
if (gameIsOver == true){
int bX = 70;
int bY = 125;
int bWidth = 140;
int bHeight = 32;
fill(220,100);
rect(offset,offset, brickSize*numCol, brickSize*numRows);
textFont(Hira,25);
strokeWeight(1);
fill(255);
text("Game Over!", 70,70);
noStroke();
fill(20,30,200);
rect(bX,bY, bWidth,bHeight);
fill(255,200);
text("New Game", 75,150);
stroke(100);
// Click for new game
if(mouseX > bX && mouseX < bX + bWidth &&
mouseY > bY && mouseX < bY + bHeight){
if(mousePressed){
myBoard.newGame();
}
}
}
}
// ============ Board Block sub class ===============
public class BoardBlock extends Board{
color col;
int x;
int y;
boolean taken;
// Constructor
BoardBlock(int x, int y){
col = color(150,150,230);
this.x = offset+ x*25;
this.y = offset+ y*25;
this.taken = false;
}
// Accessor
boolean isTaken(){
return taken;
}
// Setter
void take(){
this.taken = true;
}
void render(){
fill(col);
if(taken){
strokeWeight(1);
}
else{
strokeWeight(1);
}
rect(x,y, brickSize,brickSize);
}
}
}