Codigo Memoria Poo

/**
* Contiene las clases que definen la lógica del juego Tetris

**/
package tetris;
// ********************************************* Tablero
package tetris;
import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.GridLayout;
import javax.swing.BorderFactory;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
/**
* Crea el tablero de juego con las dimensiones (número de casillas de alto y de ancho,
* y tamaño del lado de las casillas) pasadas como parámetros.
* Es un contenedor al que agregamos las casillas (JLabel)
* El objeto instanciado a partir de esta clase
* proporciona los métodos necesarios para chequear el estado de las casillas y
* modificarlo, cambiando su color de fondo, simulando el movimiento de las piezas.
* Así mismo, se encarga de comprobar si se ha llenado alguna fila, de limpiar las filas
* llenas y bajar las casillas ocupadas por encima de ésta. Las piezas regirán su comportamiento
* preguntando a los métodos de la clase Tablero el estado de las casillas a ocupar en sus movimientos.
*
* @author David Codon Aguera - NIF 28889531J
*/
@SuppressWarnings("serial")
public class Tablero extends JFrame {
private JPanel panel;

private JLabel[][] casilla;
private int filas, columnas;
/**
* Constructor de la clase
*
* @param filas Número de filas del tablero
* @param columnas Número de columnas del tablero
* @param size Tamaño de las casillas
*/
public Tablero(int filas, int columnas, int size){
/*Establecemos el layout del JFrame como GridLayout(1,1), para que las casillas sean todas iguales
* y ocupe todo el espacio. El tamaño lo dará la suma de los tamaños de las casillas
*/
this.setLayout(new GridLayout(1,1));
this.filas = filas;
this.columnas = columnas;
Container contenedor = getContentPane();
casilla = new JLabel[filas][columnas];

panel = new JPanel(new GridLayout(filas, columnas));
for(int x = 0; x < filas; x++){
for(int y = 0; y < columnas; y++){
casilla[x][y] = new JLabel("");
casilla[x][y].setBorder(BorderFactory.createLineBorder(Color.black));
casilla[x][y].setOpaque(true);
casilla[x][y].setPreferredSize(new Dimension(size, size));
casilla[x][y].setBackground(Color.white);
panel.add(casilla[x][y]);
}
}
contenedor.add(panel);
this.pack();
this.setVisible(true);
}
/**
* Devuelve la casilla correspondiente a unas coordenadas en el tablero
* @return la casilla[x][y]
*/
public JLabel getCasilla(int x, int y) {
return casilla[x][y];
}
/**
* Establece el color de fondo para la casilla que pasamos como parámetro
* @param casilla la casilla (JLabel) al que vamos a cambiar el color de fondo
* @param c color de fondo
*/
public void setBackGroundColor(JLabel casilla, Color c){
casilla.setBackground(c);
}
/**
* Devuelve el color de fondo de una casilla
* @param casilla La casilla cuyo color queremos saber
* @return El color de fondo de la casilla
*/
public Color getBackGroundColor(JLabel casilla){
return casilla.getBackground();
}
/**
* Recorre el tablero mientras haya alguna fila completa
*/
public void limpiarTablero(){
/* Recorremos el tablero buscando filas completas */
boolean masFilas = false;
do {
masFilas = recorrerFila();
} while (masFilas);
}
/**
* Testea el tablero, buscando filas completas (color de fondo distinto a blanco)
* Si la fila está completa, borra la fila y baja el resto
* @see Método bajarFichas
* @return true si ALGUNA fila está completa
*/
private boolean recorrerFila() {
for(int x = filas-1; x > 1; x--){ //En las dos primeras filas no pueden completarse líneas
/* Si la fila está completa, la limpiamos */
if(filaCompleta(x)) {
bajarFichas(x);
return true;
}
}
return false;
}
/**
* Comprueba si una fila está completa
* @param fila Fila a comprobar
* @return true si la fila está completa
*/
private boolean filaCompleta(int fila) {
if(getBackGroundColor(getCasilla(fila, y)) == Color.white){
//completa = false;
return false;
}
}
return true;
}
/**
* Baja las piezas desde una fila dada, hacia arriba, una posición
* @param fila Fila a comprobar
*/
private void bajarFichas(int fila){
for (int x=fila;x>2;x--){
setBackGroundColor(getCasilla(x, y), (getBackGroundColor(getCasilla(x-1, y))));
}
}
}
/**
* Muestra el mensaje "FIN DEL JUEGO"
*/
public void finDeJuego(){
casilla[10][4].setText("F");
casilla[10][5].setText("I");
casilla[10][6].setText("N");
casilla[11][4].setText("D");
casilla[11][5].setText("E");
casilla[11][6].setText("L");
casilla[12][3].setText("J");
casilla[12][4].setText("U");
casilla[12][5].setText("E");
casilla[12][6].setText("G");
casilla[12][7].setText("O");
}
}
// ************************************** Tetris
package tetris;
import java.awt.KeyEventPostProcessor;
import java.awt.KeyboardFocusManager;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.util.Random;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.Timer;
import piezas.Barra;
import piezas.Cuadrado;
import piezas.Ese;
import piezas.Pieza;
import piezas.Siete;
import piezas.Zeta;
import piezas.Te;
import piezas.Efe;
/**
* Juego del Tetris
* @author David Codón Agüera - NIF 28889531J
*/
/**
* En esta clase se estipulan los parámetros generales del juego:
* dimensiones del tablero, intervalo de caída de las piezas y tamaño de las casillas.
* Se inicializan el tablero y las piezas, y se sincroniza el comportamiento de éstas
* con la intervención del usuario, mediante pulsaciones de las teclas de cursor.
* Las piezas se generan de forma aleatoria.
*/
public class Tetris {
final static int FILAS = 25;
final static int COLUMNAS = 12;
final static int TAMANO = 25;
private static final Random rand = new Random();
private static Pieza ficha;
private static Tablero tablero;
private static Timer timer;
private static int periodo = 1000;
private static long inicioContador = System.currentTimeMillis();
private static int rotaciones = 0;
/**
* @param args
*/
@SuppressWarnings("serial")
public static void main(String[] args) {
/**
* Dimensiones del tablero: largo, ancho y tamaño de la casilla
*/
tablero = new Tablero(FILAS, COLUMNAS, TAMANO); // Tablero de juego
ficha = nuevaFicha(tablero);
/* Controlador de eventos de teclado */

KeyboardFocusManager kb = KeyboardFocusManager.getCurrentKeyboardFocusManager();
kb.addKeyEventPostProcessor(new KeyEventPostProcessor(){
@Override
public boolean postProcessKeyEvent(KeyEvent e) {
if (e.getID() == KeyEvent.KEY_PRESSED) {
switch (e.getKeyCode()) {
case KeyEvent.VK_UP:
if((rotaciones<4) || (System.currentTimeMillis() -
inicioContador)>1000){
rotarFicha();
}
break;
case KeyEvent.VK_LEFT:
moverFichaIzquierda();
break;
case KeyEvent.VK_RIGHT:
moverFichaDerecha();
break;
case KeyEvent.VK_DOWN:
break;
}
}
return false;
}
});
/* Temporizador */
Action repintar = new AbstractAction(){
@Override
public void actionPerformed(ActionEvent arg0) {
if(!caerFicha()){
tablero.finDeJuego();
timer.stop();
}
};
};
timer = new Timer(periodo,repintar);
timer.start();
}
/**
* Llama al ḿetodo moverDerecha de la clase Pieza
* {@link piezas.pieza#moverDerecha}
*/
private static void moverFichaDerecha() {
try {
ficha.moverDerecha(tablero);
} catch (NullPointerException e) {
System.out.println("error derecha");
}
}
/**
* Llama al ḿetodo moverIzquierda de la clase Pieza
* {@link piezas.pieza#moverIzquierda}
**/
private static void moverFichaIzquierda() {
//try {
ficha.moverIzquierda(tablero);
//} catch (NullPointerException e) {
//System.out.println("error izquierda");
//}
}
/**
* Llama al ḿetodo rotarFicha de la clase Pieza
* {@link piezas.pieza#rotarFicha}
* Incrementa el valor del contador, para controlar
* un máximo de 4 giros por segundo
**/
private static void rotarFicha() {
try {
if(ficha.rotar(tablero)){
rotaciones++;
}
}
catch (NullPointerException e) {
System.out.println("error rotar");
}
}
/**
* Comprueba si una ficha del juego puede caer (las casillas de debajo están libres),
* llamando al método caer de la clase Ficha,
* y si no pueden salir fichas nuevas, llamand al método finDelJuego de la clase Ficha.
* Si no puede caer la ficha, pero no ha terminado el juego, limpia el tablero, saca ficha nueva
*
* @return true si la ficha puede caer; false si no puede caer o ha terminado el juego
*
*/
private static boolean caerFicha(){
boolean retorno = true;
try{
if(!ficha.isFinDelJuego()) {
if(!ficha.caer(tablero)){
tablero.limpiarTablero();
ficha = nuevaFicha(tablero);
}
inicioContador = System.currentTimeMillis();
rotaciones = 0;
retorno = true;
}else {
retorno = false;
}
} catch (NullPointerException e) {
System.out.println("Null en caerFicha");
retorno = false;
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("fuera de array en caerFicha");
retorno = false;
}
return retorno;
}
/**
* Instancia un objeto del tipo Pieza que será la ficha del juego a tratar
* Se inicializa, aleatoriamente, con una de las distintas piezas
* @param tablero El tablero de juego
* @return la ficha
*/
private static Pieza nuevaFicha(Tablero tablero) {
try{
int tipoFicha = rand.nextInt(7);
Pieza ficha;
switch(tipoFicha){
case 0:
ficha = new Cuadrado(tablero,FILAS, COLUMNAS);
return ficha;
case 1:
return ficha;
case 2:
return ficha;
case 3:
return ficha;
case 4:
ficha = new Siete(tablero,FILAS, COLUMNAS);
return ficha;
case 5:
ficha = new Te(tablero,FILAS, COLUMNAS);
return ficha;
case 6:
ficha = new Zeta(tablero,FILAS, COLUMNAS);
return ficha;
}
} catch (NullPointerException e){
System.out.println("Fin del Juego");
timer.stop();
}
return null;
}
}
// ******************************************** Barra
package piezas;
//import javax.swing.JLabel;
import tetris.Tablero;
/**
* pieza Barra
* @author David codon Aguera - 28889531J
*/
public class Barra extends Pieza {
public Barra(Tablero tablero, int filas, int columnas) {

super(tablero, filas, columnas);
colorFicha = Color.cyan;
inicializar(tablero);
}
/**
* {@inheritDoc}
*/
public boolean inicializar(Tablero tablero){
origenX = 1;
origenY = 4;
estado = 1;
finDelJuego = false;
if (estanLibresNuevas(tablero)) {
asignaPosicion(tablero, colorFicha);
} else { //Si no puede crearse una nueva
pieza, fin del juego
finDelJuego = true;
}
return false;
}
/**
* {@inheritDoc}
*/
@Override
public boolean caer(Tablero tablero) {
int oldOrigenX = origenX;
boolean retorno = false;
if (estanLibres(tablero, "abajo")) {
/* Borramos la ficha actual */
asignaPosicion(tablero, Color.white);
/* Pintamos la ficha nueva */
origenX = oldOrigenX + 1;
retorno = true;
}
return retorno;
}
/**
* {@inheritDoc}
*/
private void asignaPosicion(Tablero tablero,Color c) {
switch(estado){
case 1:
for (int y = 0; y < 4; y++) {
tablero.setBackGroundColor(tablero.getCasilla(origenX, origenY+y), c);
}
break;
case 2:
for (int x = 0; x < 4; x++) {
tablero.setBackGroundColor(tablero.getCasilla(origenX+x, origenY+1), c);
}
break;
}
}
/**
* {@inheritDoc}
*/
@Override
public boolean moverDerecha(Tablero tablero) {
if (estanLibres(tablero, "derecha")) {
/* Borramos posición actual */
/* Asignamos nueva posición */
origenY = origenY + 1;
asignaPosicion(tablero,colorFicha);
return true;
}
return false;
}
/**
* {@inheritDoc}
*/
@Override
public boolean moverIzquierda(Tablero tablero) {
if (estanLibres(tablero, "izquierda")) {
origenY = origenY - 1;
retorno = true;
}
return retorno;
}
/**
* {@inheritDoc}
*/
@Override
public boolean rotar(Tablero tablero) {
if ( (origenX > 2)) { //Antes de la fila 3, no puede girar (no cabe)
switch (estado) {
case 1: //Horizontal
/* Comprobamos si están libres las casillas */
if(!(
estaLibre(tablero,origenX+1,origenY+1)
&& estaLibre(tablero,origenX+2,origenY+1)
)){
return false;
}
reescribirFicha(tablero);
break;
case 2: //Vertical
if(!(
estaLibre(tablero,origenX,origenY)
&& estaLibre(tablero,origenX,origenY+2)
)){
return false;
}
break;
}
return true;
}
return false;
}
/**
* {@inheritDoc}
*/
private boolean estanLibresNuevas(Tablero tablero) {
boolean libre = true;
for (int y = origenY; y < origenY + 4; y++) {
if((tablero.getBackGroundColor(tablero.getCasilla(origenX, y)) != Color.white)){
libre = false;
}
}
return libre;
}
/**
* {@inheritDoc}
*/
private boolean estanLibres(Tablero tablero, String sentido) {
switch (estado) {
if (sentido.equals("abajo")) { //Comprueba las casillas de abajo
for(int y = 0; y < 4; y++) {
if (!estaLibre(tablero, origenX+1, origenY+y)){
libre = false;
}
}
} else if (sentido.equals("derecha")) { //Comprueba las casillas de la derecha
libre = estaLibre(tablero,origenX, origenY + 4);
} else { //Comprueba las casillas de la
izquierda
libre = estaLibre(tablero,origenX,origenY-1);
}
break;
case 2: //Vertical
libre = estaLibre(tablero, origenX+4, origenY+1);
for (int x = 0; x < 4; x++) {
if(!estaLibre(tablero, origenX+x, origenY+2)){
libre = false;
}
}
} else { //Comprueba
las casillas de la izquierda
for (int x = 0; x < 4; x++) {
if(!estaLibre(tablero, origenX+x, origenY)){
libre = false;
}
}
}
break;
default:
break;
}
return libre;
}
/**
* {@inheritDoc}
*/
@Override
public boolean isFinDelJuego() {
return finDelJuego;
}
/**
* {@inheritDoc}
*/
private void reescribirFicha(Tablero tablero){
/* Asignamos nueva posición*/
if(estado == 1){
estado = 2;
} else {
estado = 1;
}
}
}
// ********************************************** Cuadrado
package piezas;
/**
* pieza 'Cuadrado'
*/
public class Cuadrado extends Pieza{
public Cuadrado(Tablero tablero, int filas, int columnas) {
colorFicha = Color.yellow;
}
/**
* {@inheritDoc}
*/
origenX = 1;
origenY = 5;
finDelJuego = true;
}
return false;
}
/**
* {@inheritDoc}
*/
@Override
retorno = true;
}
return retorno;
}
/**
* {@inheritDoc}
*/
for (int x = 0; x < 2; x++){
for (int y = 0; y < 2; y++) {
tablero.setBackGroundColor(tablero.getCasilla(origenX+x, origenY+y), c);
}
}
}
/**
* {@inheritDoc}
*/
@Override
return true;
}
return false;
}
/**
* {@inheritDoc}
*/
@Override
retorno = true;
}
return retorno;
}
/**
* {@inheritDoc}
*/
for(int x = 0; x < origenX+2;x++){
if((tablero.getBackGroundColor(tablero.getCasilla(x, y)) != Color.white)){
libre = false;
}
}
}
return libre;
}
/**
* {@inheritDoc}
*/
if (!estaLibre(tablero, origenX+2, y)){
libre = false;
}
}
if (!(
estaLibre(tablero, origenX, origenY+2)
&& estaLibre(tablero, origenX+1, origenY+2)
)){
libre = false;
}
} else { //Comprueba las casillas de la izquierda
if (!(
estaLibre(tablero, origenX, origenY-1)
&& estaLibre(tablero, origenX+1, origenY-1)
)){
libre = false;
}
}
return libre;
}
/**
* {@inheritDoc}
*/
@Override
return finDelJuego;
}
}
// **************************************** Efe
package piezas;
/**
* pieza 'Efe'
*/
public class Efe extends Pieza{
public Efe(Tablero tablero, int filas, int columnas) {

colorFicha = Color.black;
}
/**
* {@inheritDoc}
*/
origenX = 1;
origenY = 4;
estado = 1;
finDelJuego = true;
}
return false;
}
/**
* {@inheritDoc}
*/
@Override
retorno = true;
}
return retorno;
}
/**
* {@inheritDoc}
*/
switch(estado){
case 1:
tablero.setBackGroundColor(tablero.getCasilla(origenX, origenY), c);
tablero.setBackGroundColor(tablero.getCasilla(origenX+1, origenY), c);
tablero.setBackGroundColor(tablero.getCasilla(origenX+1, origenY+1), c);
break;
case 2:
tablero.setBackGroundColor(tablero.getCasilla(origenX, origenY+1), c);
break;
case 3:
break;
case 4:
break;
}
}
/**
* {@inheritDoc}
*/
@Override
return true;
}
return false;
}
/**
* {@inheritDoc}
*/
@Override
retorno = true;
}
return retorno;
}
/**
* {@inheritDoc}
*/
@Override
if ((origenX > 2)) { //Antes de la fila 3, no puede girar (no cabe)
switch (estado) {
if(!(
&& estaLibre(tablero, origenX+2,origenY)
)){
return false;
}
break;
case 2: //Vertical
if(!(
&& estaLibre(tablero, origenX+1,origenY+2)
)){
return false;
}
break;
case 3:
if(!(
estaLibre(tablero, origenX+1, origenY+1)
&& estaLibre(tablero, origenX+2, origenY)
)){
return false;
}
break;
case 4:
if(!(
estaLibre(tablero, origenX, origenY)
)){
return false;
}
break;
}
return true;
}
return false;
}
/**
* {@inheritDoc}
*/
if(estado==4){
estado = 1;
} else {
estado++;
}
}
/**
* {@inheritDoc}
*/
if(!(
tablero.getBackGroundColor(tablero.getCasilla(origenX, origenY)) == Color.white
&& tablero.getBackGroundColor(tablero.getCasilla(origenX+1, origenY)) ==
Color.white
&& tablero.getBackGroundColor(tablero.getCasilla(origenX+1, origenY+1)) ==
Color.white
&& tablero.getBackGroundColor(tablero.getCasilla(origenX+1, origenY+2)) ==
Color.white
)){
libre = false;
}
return libre;
}
/**
* {@inheritDoc}
*/
switch (estado) {
case 1: //Rabo largo
izquierda
/* Comprobar casillas de abajo */
if (sentido.equals("abajo")) { //Comprueba las casillas de la derecha
//Comprobar sólo 3 casillas
if(!(
estaLibre(tablero,origenX+2,origenY)
))
{
libre = false;
}
//comprobar dos casillas
if(!(
estaLibre(tablero,origenX,origenY+1)
)) {
libre = false;
}
izquierda
if(!(
estaLibre(tablero,origenX,origenY-1)
&& estaLibre(tablero,origenX+1,origenY-1)
)) {
libre = false;
}
}
break;
arriba
if(!(
)) {
libre = false;
}
if(!(
)) {
libre = false;
}
if(!(estaLibre(tablero,origenX,origenY-1)
)) {
libre = false;
}
}
break;
derecha
if(!(
)) {
libre = false;
}
if(!(
)) {
libre = false;
}
if(!(
)) {
libre = false;
}
}
break;
abajo
if(!(
)) {
libre = false;
}
if(!(
)) {
libre = false;
}
if(!(
&& estaLibre(tablero,origenX+1,origenY)
)) {
libre = false;
}
}
break;
default:
break;
}
return libre;
}
/**
* {@inheritDoc}
*/
@Override
return finDelJuego;
}
}
// ************************************************ Ese
package piezas;
/**
* pieza 'Ese'
*/
public class Ese extends Pieza{
public Ese(Tablero tablero, int filas, int columnas) {

colorFicha = Color.green;
}
origenX = 1;
origenY = 4;
estado = 1;
finDelJuego = true;
}
return false;
}
/**
* {@inheritDoc}
*/
@Override
retorno = true;
}
return retorno;
}
/**
* {@inheritDoc}
*/
switch(estado){
case 1:
break;
case 2:
break;
}
}
/**
* {@inheritDoc}
*/
@Override
return true;
}
return false;
}
/**
* {@inheritDoc}
*/
@Override
retorno = true;
}
return retorno;
}
/**
* {@inheritDoc}
*/
@Override
if ( (origenX > 2)) { //Antes de la fila 3, no puede girar (no cabe)
switch (estado) {
if (!(
)) {
return false;
}
break;
case 2: //Vertical
if(!(
&& estaLibre(tablero, origenX, origenY+2)
)){
return false;
}
break;
}
return true;
}
return false;
}
/**
* {@inheritDoc}
*/
if(
tablero.getBackGroundColor(tablero.getCasilla(origenX, origenY+1)) !=
Color.white
&& tablero.getBackGroundColor(tablero.getCasilla(origenX, origenY+2)) !=
Color.white
&& tablero.getBackGroundColor(tablero.getCasilla(origenX+1, origenY)) !=
Color.white
&& tablero.getBackGroundColor(tablero.getCasilla(origenX+1, origenY+1)) !=
Color.white
){
libre = false;
}
return libre;
}
/**
* {@inheritDoc}
*/
switch (estado) {
if(!(
))
{
libre = false;
}
if(!(
)) {
libre = false;
}
}else { //Comprueba las casillas de la
izquierda
if(!(
)) {
libre = false;
}
}
break;
case 2: //Vertical
if (sentido.equals("abajo")) { //Comprueba las casillas de abajo-2
casillas
if(!(
)) {
libre = false;
}
} else if (sentido.equals("derecha")) { //Comprueba las casillas de la derecha-3 casillas
if(!( estaLibre(tablero,origenX,origenY+1)
)) {
libre = false;
}
las casillas de la izquierda-3 casillas
if(!(estaLibre(tablero,origenX,origenY-1)
)) {
libre = false;
}
}
break;
default:
break;
}
return libre;
}
/**
* {@inheritDoc}
*/
@Override
return finDelJuego;
}
/**
* {@inheritDoc}
*/
if(estado == 1){
estado = 2;
} else {
estado = 1;
}
}
}
/**
* Contiene las clases que definen las piezas del juego del tetris
**/
package piezas;
// **************************************** Pieza
package piezas;
import javax.swing.JLabel;
import javax.swing.Timer;
/**
* Abstración de una ficha del juego.
* Implementa completamente sólo los métodos que son comunes a todas las piezas.
* El resto de los métodos devuelven true o no están implementados,
* porque deberán ser implementados en las distintas piezas que la heredan
* @author David Codoń Agüera - NIF 28889531J
*
*/
public class Pieza {
protected JLabel[][] posicion;
protected int origenX, origenY;
protected int estado;
protected int filas, columnas;
protected Color colorFicha;
protected boolean finDelJuego;
protected Timer timer;
public Pieza(Tablero tablero, int filas, int columnas){

this.filas = filas;
this.columnas = columnas;
}
/**
* Inicializa el tablero, estableciendo el origen de filas y columnas,
* el estado inicial y comprueba si pueden generarse nuevas piezas.
* Si no se pueden, establece finDelJuego a true.
* @param tablero
* @return true si puede caer Y baja. False si no puede bajar
*/
protected boolean inicializar(Tablero tablero){
return true;
}
/**
* Mueve la ficha una fila hacia abajo
* @param tablero
* @return true si se ha podido mover
*/
public boolean caer(Tablero tablero){
return true;
}
/**
* Mueve la ficha una posición a la izquierda
* Comprueba que las casllas a ocupar están libres, y
* que no se salen del tablero
* return true si se ha podido mover
*/
public boolean moverIzquierda(Tablero tablero){
return true;
}
/**
* Mueve la ficha una posición a la derecha
* Comprueba que las casllas a ocupar están libres, y
* que no se salen del tablero
*/
public boolean moverDerecha(Tablero tablero){
return true;
}
/**
* Gira la ficha hacia el siguiente estado, en sentido horario
* Comprueba que las casillas a asignar están libres
*/
public boolean rotar(Tablero tablero){
return true;
}
/**
* Dibuja la ficha en el lugar que le corresponda
* con el color asignado al tipo de pieza
* @param c Color de la ficha
*/
@SuppressWarnings("unused")
private void asignaPosicion(Tablero tablero, Color c){}
/**
* Comprueba si las casillas que corresponden a la ficha están ocupadas en el tablero
* @return true si las casillas no están ocupadas
*/
private boolean estanLibresNuevas(Tablero tablero){
return true;
}
/**
* Comprueba si las posiciones indicadas por (x,y) están libres en el tablero
* @param tablero El tablero d ejuego
* @param sentido Hacia donde tiene que ver si las casillas están libres
* @return true si están libres
*/
private boolean estanLibres(Tablero tablero, String sentido){
return true;
}
/**
* Comprueba si las casillas de unas coordenadas dadas pertenecen al tablero
* y si están ocupadas
*
* @param tablero El tabero de juego
* @param x fila
* @param y columna
* @return true si las casillas no están ocupadas
*/
protected boolean estaLibre(Tablero tablero, int x, int y){
if((x>=0 && x<filas) && (y>=0 && y<columnas)) {
if (tablero.getBackGroundColor(tablero.getCasilla(x, y)) != Color.white) {
return false;
}
return true;
} else {
return false;
}
}
/**
* Devuelve true si el juego ha terminado
* @return true si fin de juego
*/
public boolean isFinDelJuego(){
return true;
}
/**
* Borra la posición actual y pinta la ficha en la posición nueva
*/
private void reescribirFicha(Tablero tablero){ }
}
// ************************************************* Siete
package piezas;
/**
* pieza Siete
*/
public class Siete extends Pieza{
public Siete(Tablero tablero, int filas, int columnas) {

colorFicha = Color.orange;
}
/**
* {@inheritDoc}
*/

origenX = 1;
origenY = 4;
estado = 1;
finDelJuego = true;
}
return false;
}
/**
* {@inheritDoc}
*/
@Override
retorno = true;
}
return retorno;
}
/**
* {@inheritDoc}
*/
switch(estado){
case 1:
break;
case 2:
break;
case 3:
break;
case 4:
break;
}
}
/**
* {@inheritDoc}
*/
@Override
return true;
}
return false;
}
/**
* {@inheritDoc}
*/
@Override
retorno = true;
}
return retorno;
}
/**
* {@inheritDoc}
*/
@Override
switch (estado) {
if(!(
)){
return false;
}
break;
case 2: //Vertical
if(!(
estaLibre(tablero, origenX,origenY+1)
&& estaLibre(tablero, origenX,origenY+2)
)){
return false;
}
break;
case 3:
if(!(
estaLibre(tablero, origenX+1,origenY+1)
)){
return false;
}
break;
case 4:
if(!(
)){
return false;
}
break;
}
return true;
}
return false;
}
/**
* {@inheritDoc}
*/
if(estado==4){
estado = 1;
} else {
estado++;
}
}
/**
* {@inheritDoc}
*/
for(int x=origenX; x<origenX+3; x++){
if((tablero.getBackGroundColor(tablero.getCasilla(x, origenY+1)) != Color.white)){
libre = false;
}
if(x==origenX && (tablero.getBackGroundColor(tablero.getCasilla(x, origenY)) !=
Color.white)){
libre = false;
}
}
return libre;
}
/**
* {@inheritDoc}
*/
switch (estado) {
izquierda
if (sentido.equals("abajo")) { //Comprueba las casillas de la derecha
if(!(
))
{
libre = false;
}
if(!(
)) {
libre = false;
}
izquierda
if(!(
)) {
libre = false;
}
}
break;
arriba
if(!(
)) {
libre = false;
}
if(!(
)) {
libre = false;
}
if(!(
)) {
libre = false;
}
}
break;
derecha
if(!(
)) {
libre = false;
}
if(!(
)) {
libre = false;
}
if(!(
)) {
libre = false;
}
}
break;
abajo
if(!(
)) {
libre = false;
}
if(!(
)) {
libre = false;
}
if(!(
)) {
libre = false;
}
}
break;
default:
break;
}
return libre;
}
/**
* {@inheritDoc}
*/
@Override
return finDelJuego;
}
}
// *********************************************** Cuadrado
package piezas;
/**
* pieza Cuadrado
*/public class Te extends Pieza{
public Te(Tablero tablero, int filas, int columnas) {

colorFicha = Color.magenta;
}
origenX = 1;
origenY = 4;
estado = 1;
finDelJuego = true;
}
return false;
}
/**
* {@inheritDoc}
*/
@Override
retorno = true;
}
return retorno;
}
/**
* {@inheritDoc}
*/
switch(estado){
case 1:
for(int y=origenY; y<origenY+3; y++){
tablero.setBackGroundColor(tablero.getCasilla(origenX+1,y), c);
}
break;
case 2:
tablero.setBackGroundColor(tablero.getCasilla(x,origenY), c);
}
break;
case 3:
tablero.setBackGroundColor(tablero.getCasilla(origenX,y), c);
}
break;
case 4:
tablero.setBackGroundColor(tablero.getCasilla(x, origenY+1), c);
}
break;
}
}
/**
* {@inheritDoc}
*/
@Override
return true;
}
return false;
}
/**
* {@inheritDoc}
*/
@Override
retorno = true;
}
return retorno;
}
/**
* {@inheritDoc}
*/
@Override
switch (estado) {
case 1: //Piquito arriba
if(!(
)){
return false;
}
break;
case 2: //Piquito derecha
if(!(
&& estaLibre(tablero, origenX,origenY+2)
)){
return false;
}
break;
case 3: //Piquito abajo
if(!(
estaLibre(tablero, origenX+1, origenY)
)){
return false;
}
break;
case 4: //Piquito izquierda
if(!(
estaLibre(tablero, origenX+1, origenY+2)
)){
return false;
}
break;
}
return true;
}
return false;
}
/**
* {@inheritDoc}
*/
if(estado==4){
estado = 1;
} else {
estado++;
}
}
/**
* {@inheritDoc}
*/
if((tablero.getBackGroundColor(tablero.getCasilla(origenX+1, y)) != Color.white)){
libre = false;
}
if((tablero.getBackGroundColor(tablero.getCasilla(origenX+1, origenY+1)) != Color.white))
{
libre = false;
}
}
return libre;
}
/**
* {@inheritDoc}
*/
switch (estado) {
if (sentido.equals("abajo")) {
if(!(estaLibre(tablero,origenX+2,origenY)
))
{
libre = false;
}
if(!(
)) {
libre = false;
}
izquierda
if(!(
)) {
libre = false;
}
}
break;
case 2: //Vertical
casillas
if(!(
)) {
libre = false;
}
if(!(
)) {
libre = false;
}
if(!(
)) {
libre = false;
}
}
break;
case 3:
casillas
if(!(
)) {
libre = false;
}
if(!(
)) {
libre = false;
}
if(!(
)) {
libre = false;
}
}
break;
case 4:
casillas
if(!(
)) {
libre = false;
}
if(!(
)) {
libre = false;
}
if(!(
)) {
libre = false;
}
}
break;
default:
break;
}
return libre;
}
/**
* {@inheritDoc}
*/
@Override
return finDelJuego;
}
}
// **************************************** Zeta
package piezas;
/**
* pieza 'zeta'
*
*/
public class Zeta extends Pieza{
public Zeta(Tablero tablero, int filas, int columnas) {

colorFicha = Color.red;
}
/**
* {@inheritDoc}
*/
origenX = 1;
origenY = 4;
estado = 1;
finDelJuego = true;
}
return false;
}
/**
* {@inheritDoc}
*/
@Override
retorno = true;
}
return retorno;
}
/**
* {@inheritDoc}
*/
switch(estado){
case 1:
break;
case 2:
break;
}
}
/**
* {@inheritDoc}
*/
@Override
if (estanLibres(tablero,"derecha")){
retorno = true;
}
return retorno;
}
/**
* {@inheritDoc}
*/
@Override
if (estanLibres(tablero,"izquierda")){
retorno = true;
}
return retorno;
}
/**
* {@inheritDoc}
*/
@Override
if ( (origenX > 2)) { //Antes de la fila 3, no puede girar (no
cabe)
switch (estado) {
/* Comprobamos si están libres las casillas
* Comprobar dos casillas*/
for(int x=1; x<3; x++){
if (!estaLibre(tablero,origenX+x,origenY)) {
return false;
}
}
break;
case 2: //Vertical
if (!estaLibre(tablero, origenX+1, origenY+2)) {
return false;
}
break;
}
return true;
}
return false;
}
/**
* {@inheritDoc}
*/
if(
tablero.getBackGroundColor(tablero.getCasilla(origenX, origenY)) !=
Color.white
&& tablero.getBackGroundColor(tablero.getCasilla(origenX,
origenY+1)) != Color.white
&& tablero.getBackGroundColor(tablero.getCasilla(origenX+1,
&& tablero.getBackGroundColor(tablero.getCasilla(origenX+1,
){
libre = false;
}
return libre;
}
/**
* {@inheritDoc}
*/
switch (estado) {
case 1:
//Horizontal
if (sentido.equals("abajo")) {
if(!(
))
{
libre = false;
}
} else if (sentido.equals("derecha")) { //Comprueba las casillas de la derecha y
límite y
if(!(
)) {
libre = false;
}
} else { //Comprueba las
casillas de la izquierda
if(!(
)) {
libre = false;
}
}
break;
case 2:
//Vertical
if (sentido.equals("abajo")) { //Comprueba las casillas de
abajo-2 casillas
if(!(
estaLibre(tablero,origenX+3,origenY) &&
)) {
libre = false;
}
} else if (sentido.equals("derecha")) { //Comprueba las casillas de la derecha-3
casillas
if(!(
)) {
libre = false;
}
} else {
//Comprueba las casillas de la izquierda-3 casillas
if(!(
estaLibre(tablero,origenX,origenY) &&
estaLibre(tablero,origenX+1,origenY-1)
)) {
libre = false;
}
}
break;
default:
break;
}
return libre;
}
/**
* {@inheritDoc}
*/
@Override
return finDelJuego;
}
/**
* {@inheritDoc}
*/
if(estado == 1){
estado = 2;
} else {
estado = 1;
}
}
}

Codigo Memoria Poo

Cargado por

Copyright:

Formatos disponibles

Codigo Memoria Poo

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Codigo Memoria Poo

Cargado por

Copyright:

Formatos disponibles

/**

* Contiene las clases que definen la lógica del juego Tetris

private JPanel panel;

casilla = new JLabel[filas][columnas];

/* Controlador de eventos de teclado */

public Barra(Tablero tablero, int filas, int columnas) {

public Efe(Tablero tablero, int filas, int columnas) {

public Ese(Tablero tablero, int filas, int columnas) {

public Pieza(Tablero tablero, int filas, int columnas){

public Siete(Tablero tablero, int filas, int columnas) {

public boolean inicializar(Tablero tablero){

public Te(Tablero tablero, int filas, int columnas) {

public Zeta(Tablero tablero, int filas, int columnas) {

También podría gustarte