1163 lines
36 KiB
C++
1163 lines
36 KiB
C++
/********
|
||
Bases simples para recrear el juego TETRIS en modo texto y monoProceso
|
||
********/
|
||
|
||
#include <conio.h>
|
||
#include <stdlib.h>
|
||
#include <dos.h>
|
||
#include <time.h>
|
||
|
||
// Ya que el lenguaje carece de BOOLEANOS definimos unas macros
|
||
#define bool int
|
||
#define true 1
|
||
#define false 0
|
||
|
||
// N£mero de piezas con las que jugamos
|
||
#define NUMERO_DE_PIEZAS 7
|
||
#define ANCHO_TABLERO 15
|
||
#define ALTO_TABLERO 23
|
||
|
||
typedef enum tipoPieza { PIEZA_CUADRADA=1, PIEZA_LINEA, PIEZA_Rizq, PIEZA_Rder, PIEZA_Lder, PIEZA_Lizq,PIEZA_T };
|
||
|
||
|
||
// Definimos que es para nosotros una pieza
|
||
typedef struct {
|
||
tipoPieza tipo; // Tipo de pieza que estamos definiendo
|
||
int rotacion, proxRot; // Estado ¢ rotaci¢n actual de la pieza
|
||
int posX, posY, proxX; // Coordenadas de la pieza
|
||
} pieza;
|
||
|
||
// Definimos una partida
|
||
typedef struct {
|
||
// Necesitamos un tablero para jugar
|
||
char tablero[ALTO_TABLERO][ANCHO_TABLERO];
|
||
|
||
pieza piezaActual; // e informaci¢n de la pieza en juego
|
||
|
||
int lineas; // Estad¡sticas del n£mero de lineas conseguidas
|
||
int piezas; // Estad¡sticas del n£mero de piezas jugadas
|
||
int puntuacion; // Puntuaci¢n actual para esta partida
|
||
} partida;
|
||
|
||
pieza obtenerPieza(void);
|
||
void AnimaticaTimeSlice(void);
|
||
void dibujaPieza( pieza P, int color );
|
||
pieza obtenerPieza(void);
|
||
void procesaTecla( bool *salir, bool *pausa, bool *tocaMover );
|
||
void dibujaPieza( pieza P, int color );
|
||
void dibujaPiezaSOLIDA( pieza P, int color );
|
||
void dibujaPiezaHUECA( pieza P, int color );
|
||
int anchoPieza( pieza P );
|
||
int altoPieza( pieza P );
|
||
void muestraTablero(void);
|
||
bool piezaColisiona( char tablero[ALTO_TABLERO][ANCHO_TABLERO], pieza P );
|
||
bool actualizaFicha(bool bajarFicha);
|
||
int colorPieza(pieza P);
|
||
void procesaColision();
|
||
void fijaPieza();
|
||
/*******************************************************************/
|
||
|
||
partida partidaActual;
|
||
bool pSolida=true;
|
||
|
||
void eliminaLineaTablero( int Y )
|
||
{
|
||
int i,j;
|
||
for (i=0;i<ANCHO_TABLERO;i++)
|
||
for (j=Y;j>0;j--)
|
||
partidaActual.tablero[j][i] = partidaActual.tablero[j-1][i];
|
||
|
||
for (i=0;i<ANCHO_TABLERO;i++)
|
||
partidaActual.tablero[0][i] = 0;
|
||
};
|
||
|
||
void RedibujaTablero(void)
|
||
{
|
||
for (int i=0; i<ANCHO_TABLERO; i++)
|
||
for (int j=0; j<ALTO_TABLERO; j++)
|
||
{
|
||
gotoxy(i*2+2,j+1); textcolor( partidaActual.tablero[j][i] );
|
||
cprintf("ÛÛ");
|
||
}
|
||
};
|
||
|
||
void inicializaJuego(void)
|
||
{
|
||
randomize(); // Inicializamos el generador de numeros
|
||
|
||
partidaActual.lineas = 0; // Inicializamos las estadisticas
|
||
partidaActual.piezas = 0;
|
||
partidaActual.puntuacion = 0;
|
||
|
||
for(int i=0;i<ANCHO_TABLERO;i++) // Vaciamos el tablero
|
||
for(int j=0;j<ALTO_TABLERO;j++)
|
||
partidaActual.tablero[j][i] = 0;
|
||
|
||
partidaActual.piezaActual = obtenerPieza();
|
||
}
|
||
|
||
// Genera de forma aleatoria una pieza y un estado (rotacion)
|
||
pieza obtenerPieza(void)
|
||
{
|
||
pieza p;
|
||
|
||
p.tipo = random(NUMERO_DE_PIEZAS)+1;
|
||
p.rotacion = random(4);
|
||
p.proxRot = p.rotacion;
|
||
|
||
p.posX = 3;
|
||
p.proxX = 3;
|
||
p.posY = 0;//altoPieza(p)-1;
|
||
return p;
|
||
}
|
||
|
||
// Procesamos las posible teclas
|
||
void procesaTecla( bool *salir, bool *pausa, bool *tocaMover )
|
||
{
|
||
switch( getch() )
|
||
{
|
||
case 'B':
|
||
case 'b':
|
||
pSolida = true;
|
||
break;
|
||
case 'h':
|
||
case 'H':
|
||
pSolida = false;
|
||
break;
|
||
case 't':
|
||
partidaActual.piezaActual.tipo = (partidaActual.piezaActual.tipo+1)%7;
|
||
break;
|
||
case 's':
|
||
case 'S':
|
||
*salir = true;
|
||
break;
|
||
case 'p':
|
||
case 'P':
|
||
*pausa = (*pausa==false) ? true : false;
|
||
break;
|
||
case 'N':
|
||
case 'n':
|
||
muestraTablero();
|
||
inicializaJuego();
|
||
break;
|
||
// Teclas especiales
|
||
case 0:
|
||
switch( getch() )
|
||
{
|
||
// Flecha izquierda
|
||
case 75:
|
||
// Solo si no estamos en el borde del tablero
|
||
if ( partidaActual.piezaActual.posX > 0 )
|
||
partidaActual.piezaActual.proxX = partidaActual.piezaActual.posX-1;
|
||
break;
|
||
// Flecha derecha
|
||
case 77:
|
||
if ((partidaActual.piezaActual.posX+anchoPieza(partidaActual.piezaActual)) < ANCHO_TABLERO)
|
||
partidaActual.piezaActual.proxX = partidaActual.piezaActual.posX+1;
|
||
break;
|
||
// Flecha arriba
|
||
case 72:
|
||
partidaActual.piezaActual.proxRot = (partidaActual.piezaActual.rotacion+1)%4;
|
||
break;
|
||
// Flecha Abajo
|
||
case 80:
|
||
*tocaMover = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Nuestras posibles piezas
|
||
void dibujaPieza( pieza P, int color )
|
||
{
|
||
if ( pSolida ) dibujaPiezaSOLIDA(P,color);
|
||
else dibujaPiezaHUECA(P,color);
|
||
}
|
||
|
||
void dibujaPiezaSOLIDA( pieza P, int color )
|
||
{
|
||
int X, Y;
|
||
X = P.posX*2+2; // Coordenas iniciales para dibujar
|
||
Y = P.posY+1; // mas una correcci¢n visual (hay que encajar
|
||
// el tablero en la pantalla)
|
||
|
||
textcolor(color); // Establecemos el color de la pieza
|
||
|
||
switch( P.tipo )
|
||
{
|
||
/*******************
|
||
ROTACION 0 ROTACION 1 ROTACION 2 ROTACION 3
|
||
*********************/
|
||
|
||
// ÛÛÛÛ ÛÛÛÛ ÛÛÛÛ ÛÛÛÛ
|
||
// ÛÛÛÛ ÛÛÛÛ ÛÛÛÛ ÛÛÛÛ
|
||
case PIEZA_CUADRADA:
|
||
switch( P.rotacion )
|
||
{
|
||
case 0:
|
||
gotoxy(X,Y); cprintf("ÛÛÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛÛÛ");
|
||
break;
|
||
case 1:
|
||
gotoxy(X,Y); cprintf("ÛÛÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛÛÛ");
|
||
break;
|
||
case 2:
|
||
gotoxy(X,Y); cprintf("ÛÛÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛÛÛ");
|
||
break;
|
||
case 3:
|
||
gotoxy(X,Y); cprintf("ÛÛÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛÛÛ");
|
||
break;
|
||
}
|
||
break;
|
||
// ÛÛ
|
||
// ÛÛ ÛÛÛÛÛÛ ÛÛÛÛÛÛ ÛÛÛÛÛÛ
|
||
// ÛÛ
|
||
case PIEZA_LINEA:
|
||
switch( P.rotacion )
|
||
{
|
||
case 0:
|
||
gotoxy(X,Y); cprintf("ÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛ");
|
||
gotoxy(X,Y+2); cprintf("ÛÛ");
|
||
break;
|
||
case 1:
|
||
gotoxy(X,Y); cprintf("ÛÛÛÛÛÛ");
|
||
break;
|
||
case 2:
|
||
gotoxy(X,Y); cprintf("ÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛ");
|
||
gotoxy(X,Y+2); cprintf("ÛÛ");
|
||
break;
|
||
case 3:
|
||
gotoxy(X,Y); cprintf("ÛÛÛÛÛÛ");
|
||
break;
|
||
}
|
||
break;
|
||
// ÛÛ ÛÛ
|
||
// ÛÛÛÛ ÛÛÛÛ ÛÛÛÛ ÛÛÛÛ
|
||
// ÛÛÛÛ ÛÛ ÛÛÛÛ ÛÛ
|
||
case PIEZA_Rizq:
|
||
switch( P.rotacion )
|
||
{
|
||
case 0:
|
||
gotoxy(X,Y); cprintf("ÛÛÛÛ");
|
||
gotoxy(X+2,Y+1); cprintf("ÛÛÛÛ");
|
||
break;
|
||
case 1:
|
||
gotoxy(X+2,Y); cprintf("ÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛÛÛ");
|
||
gotoxy(X,Y+2); cprintf("ÛÛ");
|
||
break;
|
||
case 2:
|
||
gotoxy(X,Y); cprintf("ÛÛÛÛ");
|
||
gotoxy(X+2,Y+1); cprintf("ÛÛÛÛ");
|
||
break;
|
||
case 3:
|
||
gotoxy(X+2,Y); cprintf("ÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛÛÛ");
|
||
gotoxy(X,Y+2); cprintf("ÛÛ");
|
||
break;
|
||
}
|
||
break;
|
||
// ÛÛ ÛÛ
|
||
// ÛÛÛÛ ÛÛÛÛ ÛÛÛÛ ÛÛÛÛ
|
||
// ÛÛÛÛ ÛÛ ÛÛÛÛ ÛÛ
|
||
case PIEZA_Rder:
|
||
switch( P.rotacion )
|
||
{
|
||
case 0:
|
||
gotoxy(X+2,Y) ; cprintf("ÛÛÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛÛÛ");
|
||
break;
|
||
case 1:
|
||
gotoxy(X,Y); cprintf("ÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛÛÛ");
|
||
gotoxy(X+2,Y+2); cprintf("ÛÛ");
|
||
break;
|
||
case 2:
|
||
gotoxy(X+2,Y); cprintf("ÛÛÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛÛÛ");
|
||
break;
|
||
case 3:
|
||
gotoxy(X,Y); cprintf("ÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛÛÛ");
|
||
gotoxy(X+2,Y+2); cprintf("ÛÛ");
|
||
break;
|
||
}
|
||
break;
|
||
// ÛÛ ÛÛÛÛ
|
||
// ÛÛ ÛÛÛÛÛÛ ÛÛ ÛÛ
|
||
// ÛÛÛÛ ÛÛ ÛÛ ÛÛÛÛÛÛ
|
||
case PIEZA_Lizq:
|
||
switch( P.rotacion )
|
||
{
|
||
case 0:
|
||
gotoxy(X,Y); cprintf("ÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛ");
|
||
gotoxy(X,Y+2); cprintf("ÛÛÛÛ");
|
||
break;
|
||
case 1:
|
||
gotoxy(X,Y); cprintf("ÛÛÛÛÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛ");
|
||
break;
|
||
case 2:
|
||
gotoxy(X,Y); cprintf("ÛÛÛÛ");
|
||
gotoxy(X+2,Y+1); cprintf("ÛÛ");
|
||
gotoxy(X+2,Y+2); cprintf("ÛÛ");
|
||
break;
|
||
case 3:
|
||
gotoxy(X+4,Y); cprintf("ÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛÛÛÛÛ");
|
||
break;
|
||
}
|
||
break;
|
||
// ÛÛ ÛÛÛÛ
|
||
// ÛÛ ÛÛ ÛÛ ÛÛÛÛÛÛ
|
||
// ÛÛÛÛ ÛÛÛÛÛÛ ÛÛ ÛÛ
|
||
case PIEZA_Lder:
|
||
switch( P.rotacion )
|
||
{
|
||
case 0:
|
||
gotoxy(X+2,Y); cprintf("ÛÛ");
|
||
gotoxy(X+2,Y+1); cprintf("ÛÛ");
|
||
gotoxy(X,Y+2); cprintf("ÛÛÛÛ");
|
||
break;
|
||
case 1:
|
||
gotoxy(X,Y); cprintf("ÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛÛÛÛÛ");
|
||
break;
|
||
case 2:
|
||
gotoxy(X,Y); cprintf("ÛÛÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛ");
|
||
gotoxy(X,Y+2); cprintf("ÛÛ");
|
||
break;
|
||
case 3:
|
||
gotoxy(X,Y); cprintf("ÛÛÛÛÛÛ");
|
||
gotoxy(X+4,Y+1); cprintf("ÛÛ");
|
||
break;
|
||
}
|
||
break;
|
||
// ÛÛ ÛÛ
|
||
// ÛÛ ÛÛÛÛ ÛÛÛÛÛÛ ÛÛÛÛ
|
||
// ÛÛÛÛÛÛ ÛÛ ÛÛ ÛÛ
|
||
case PIEZA_T:
|
||
switch( P.rotacion )
|
||
{
|
||
case 0:
|
||
gotoxy(X+2,Y); cprintf("ÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛÛÛÛÛ");
|
||
break;
|
||
case 1:
|
||
gotoxy(X,Y); cprintf("ÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛÛÛ");
|
||
gotoxy(X,Y+2); cprintf("ÛÛ");
|
||
break;
|
||
case 2:
|
||
gotoxy(X,Y); cprintf("ÛÛÛÛÛÛ");
|
||
gotoxy(X+2,Y+1); cprintf("ÛÛ");
|
||
break;
|
||
case 3:
|
||
gotoxy(X+2,Y); cprintf("ÛÛ");
|
||
gotoxy(X,Y+1); cprintf("ÛÛÛÛ");
|
||
gotoxy(X+2,Y+2); cprintf("ÛÛ");
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
|
||
}
|
||
/* Devuelve la anchura de una pieza segun su tipo y rotacion actual
|
||
*/
|
||
|
||
int anchoPieza( pieza P )
|
||
{
|
||
int anchuraPiezas[8][4]={ {0,0,0,0},{2,2,2,2}, {1,3,1,3}, {3,2,3,2},
|
||
{3,2,3,2}, {2,3,2,3}, {2,3,2,3},
|
||
{3,2,3,2} };
|
||
|
||
return anchuraPiezas[P.tipo][P.rotacion];
|
||
}
|
||
|
||
/* Devuelve la altura de una pieza segun su tipo y rotacion actual
|
||
*/
|
||
int altoPieza( pieza P )
|
||
{
|
||
int alturaPiezas[8][4]={ {0,0,0,0}, {2,2,2,2}, {3,1,3,1}, {2,3,2,3},
|
||
{2,3,2,3}, {3,2,3,2}, {3,2,3,2},
|
||
{2,3,2,3} };
|
||
|
||
return alturaPiezas[P.tipo][P.rotacion];
|
||
}
|
||
|
||
void muestraTablero(void)
|
||
{
|
||
int i;
|
||
|
||
clrscr();
|
||
|
||
/* MARCO DEL TABLERO */
|
||
textcolor( LIGHTGREEN );
|
||
//123456789-123456789-123456789-
|
||
gotoxy(1,1); cprintf( "¿ ÃÄÄÄÄÄ>");
|
||
textcolor( GREEN );
|
||
cprintf(" T E T R I S ");
|
||
textcolor( LIGHTGREEN );
|
||
cprintf("<ÄÄÄ--- - ú");
|
||
for(i=0;i<ALTO_TABLERO; i++)
|
||
{
|
||
gotoxy(1,i+2); cprintf("³ ³");
|
||
}
|
||
gotoxy(1,24); cprintf("ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ");
|
||
|
||
/// Informacion de las teclas
|
||
gotoxy(35,18); textcolor(RED); cprintf("N"); textcolor(BLUE); cprintf("ueva Partida");
|
||
gotoxy(35,19); textcolor(RED); cprintf("P"); textcolor(BLUE); cprintf("ausa");
|
||
|
||
gotoxy(35,23); textcolor(RED); cprintf("B"); textcolor(BLUE); cprintf("loques Solidos");
|
||
gotoxy(35,24); textcolor(RED); cprintf("H"); textcolor(BLUE); cprintf("uecos");
|
||
}
|
||
|
||
|
||
// Punto de entrada a la aplicacion
|
||
void main(void)
|
||
{
|
||
clock_t start;
|
||
bool salir, pausa, colision; // L¢gicos de control
|
||
bool tocaMover = true;
|
||
|
||
inicializaJuego(); // Inicializamos el juego Actual
|
||
muestraTablero(); // Mostramos el Tablero
|
||
|
||
salir = false;
|
||
pausa = false;
|
||
// Entramos en un bucle cuyo £nico fin
|
||
// ser para acabar el programa
|
||
while( !salir )
|
||
{
|
||
/****** BLOQUE DE CONTROL DE COMANDOS
|
||
Se encarga (sin detener la ejecuci¢n del programa de procesar
|
||
las teclas pulsadas por el usuario).
|
||
*******/
|
||
if ( kbhit() ) // Solo si hay alguna tecla en el buffer
|
||
procesaTecla(&salir,&pausa,&tocaMover);// procesamos dicha tecla
|
||
// vaciar buffer
|
||
while( kbhit() ) getch();
|
||
/****** BLOQUE DE RETARDO
|
||
Se encarga de indicar si ha de actualizarse los movimientos de
|
||
las fichas o no (sin detener la ejecuci¢n del programa).
|
||
NOTA: temporalmente se ha colocado un "delay" hasta terminar el
|
||
bloque.
|
||
*******/
|
||
if ( tocaMover == false )
|
||
tocaMover = ( ( clock() - start ) / CLK_TCK > 0.5 ) ? true : false ;
|
||
|
||
/****** BLOQUE DE ACTUALIZACION DE FICHA
|
||
Actualiza la posici¢n actual de la FICHA en el tablero e informa
|
||
de posibles colisiones (choque con otras piezas).
|
||
*******/
|
||
if ( !pausa )
|
||
{
|
||
// Si no estamos en pausa y la pieza ha cambiado
|
||
if ( tocaMover==true || (partidaActual.piezaActual.proxX!=partidaActual.piezaActual.posX || partidaActual.piezaActual.rotacion != partidaActual.piezaActual.proxRot ) )
|
||
colision = actualizaFicha(tocaMover);
|
||
/**** SEGUNDA MITAD DEL CONTROL DE TIEMPO */
|
||
if ( tocaMover == true )
|
||
{
|
||
start = clock();
|
||
tocaMover = false;
|
||
}
|
||
|
||
/****** CONTROL DE COLISIONES
|
||
Fija la ficha en el tablero en caso de colision y procesa
|
||
posibles eliminaciones de linea/piezas.
|
||
*******/
|
||
if ( colision )
|
||
{
|
||
fijaPieza(); // Fijamos la pieza en el tablero
|
||
procesaColision(); // Procesamos la colision
|
||
partidaActual.piezaActual = obtenerPieza();
|
||
colision = false;
|
||
tocaMover = true;
|
||
}
|
||
|
||
// Demostracion de que nada se detiene
|
||
AnimaticaTimeSlice();
|
||
}
|
||
}
|
||
}
|
||
|
||
// Hacemos la ficha permanente en el tablero
|
||
void fijaPieza()
|
||
{
|
||
int X,Y, rotacion; // posicion base
|
||
X = partidaActual.piezaActual.posX;
|
||
Y = partidaActual.piezaActual.posY;
|
||
rotacion = partidaActual.piezaActual.rotacion;
|
||
|
||
switch ( partidaActual.piezaActual.tipo )
|
||
{
|
||
case PIEZA_CUADRADA:
|
||
partidaActual.tablero[Y][X] =PIEZA_CUADRADA;
|
||
partidaActual.tablero[Y+1][X] =PIEZA_CUADRADA;
|
||
partidaActual.tablero[Y][X+1] =PIEZA_CUADRADA;
|
||
partidaActual.tablero[Y+1][X+1] =PIEZA_CUADRADA;
|
||
break;
|
||
case PIEZA_LINEA:
|
||
if ( rotacion == 0 || rotacion == 2 )
|
||
{
|
||
partidaActual.tablero[Y][X] =PIEZA_LINEA;
|
||
partidaActual.tablero[Y+1][X]=PIEZA_LINEA;
|
||
partidaActual.tablero[Y+2][X]=PIEZA_LINEA;
|
||
} else {
|
||
partidaActual.tablero[Y][X] =PIEZA_LINEA;
|
||
partidaActual.tablero[Y][X+1]=PIEZA_LINEA;
|
||
partidaActual.tablero[Y][X+2]=PIEZA_LINEA;
|
||
}
|
||
break;
|
||
case PIEZA_Lizq:
|
||
switch( rotacion )
|
||
{
|
||
case 0: // |_
|
||
partidaActual.tablero[Y][X] = PIEZA_Lizq;
|
||
partidaActual.tablero[Y+1][X] = PIEZA_Lizq;
|
||
partidaActual.tablero[Y+2][X] = PIEZA_Lizq;
|
||
partidaActual.tablero[Y+2][X+1] = PIEZA_Lizq;
|
||
break;
|
||
case 1: // |ùùù
|
||
partidaActual.tablero[Y][X] = PIEZA_Lizq;
|
||
partidaActual.tablero[Y+1][X] = PIEZA_Lizq;
|
||
partidaActual.tablero[Y][X+1] = PIEZA_Lizq;
|
||
partidaActual.tablero[Y][X+2] = PIEZA_Lizq;
|
||
break;
|
||
case 2: // ù|
|
||
partidaActual.tablero[Y][X] = PIEZA_Lizq;
|
||
partidaActual.tablero[Y][X+1] = PIEZA_Lizq;
|
||
partidaActual.tablero[Y+1][X+1] = PIEZA_Lizq;
|
||
partidaActual.tablero[Y+2][X+1] = PIEZA_Lizq;
|
||
break;
|
||
case 3: // ___|
|
||
partidaActual.tablero[Y][X+2] = PIEZA_Lizq;
|
||
partidaActual.tablero[Y+1][X] = PIEZA_Lizq;
|
||
partidaActual.tablero[Y+1][X+1] = PIEZA_Lizq;
|
||
partidaActual.tablero[Y+1][X+2] = PIEZA_Lizq;
|
||
break;
|
||
}
|
||
break;
|
||
case PIEZA_Lder:
|
||
switch( rotacion )
|
||
{
|
||
case 0: // Ü
|
||
// ÜÛ
|
||
partidaActual.tablero[Y][X+1] = PIEZA_Lder;
|
||
partidaActual.tablero[Y+1][X+1] = PIEZA_Lder;
|
||
partidaActual.tablero[Y+2][X] = PIEZA_Lder;
|
||
partidaActual.tablero[Y+2][X+1] = PIEZA_Lder;
|
||
break;
|
||
case 1: // ÛÜÜÜ
|
||
partidaActual.tablero[Y][X] = PIEZA_Lder;
|
||
partidaActual.tablero[Y+1][X] = PIEZA_Lder;
|
||
partidaActual.tablero[Y+1][X+1] = PIEZA_Lder;
|
||
partidaActual.tablero[Y+1][X+2] = PIEZA_Lder;
|
||
break;
|
||
case 2: // Ûß
|
||
// Û
|
||
partidaActual.tablero[Y][X] = PIEZA_Lder;
|
||
partidaActual.tablero[Y][X+1] = PIEZA_Lder;
|
||
partidaActual.tablero[Y+1][X] = PIEZA_Lder;
|
||
partidaActual.tablero[Y+2][X] = PIEZA_Lder;
|
||
break;
|
||
case 3: // ßßßÛ
|
||
partidaActual.tablero[Y][X] = PIEZA_Lder;
|
||
partidaActual.tablero[Y][X+1] = PIEZA_Lder;
|
||
partidaActual.tablero[Y][X+2] = PIEZA_Lder;
|
||
partidaActual.tablero[Y+1][X+2] = PIEZA_Lder;
|
||
break;
|
||
}
|
||
break;
|
||
case PIEZA_Rizq:
|
||
switch( rotacion )
|
||
{
|
||
case 0: // ßÛÜ
|
||
case 2:
|
||
partidaActual.tablero[Y][X] = PIEZA_Rizq;
|
||
partidaActual.tablero[Y][X+1] = PIEZA_Rizq;
|
||
partidaActual.tablero[Y+1][X+1] = PIEZA_Rizq;
|
||
partidaActual.tablero[Y+1][X+2] = PIEZA_Rizq;
|
||
break;
|
||
case 1: // ÜÛ
|
||
case 3: // ß
|
||
partidaActual.tablero[Y][X+1] = PIEZA_Rizq;
|
||
partidaActual.tablero[Y+1][X+1] = PIEZA_Rizq;
|
||
partidaActual.tablero[Y+1][X] = PIEZA_Rizq;
|
||
partidaActual.tablero[Y+2][X] = PIEZA_Rizq;
|
||
break;
|
||
}
|
||
break;
|
||
case PIEZA_Rder:
|
||
switch( rotacion )
|
||
{
|
||
case 0: // ÜÛß
|
||
case 2:
|
||
partidaActual.tablero[Y][X+1] = PIEZA_Rder;
|
||
partidaActual.tablero[Y][X+2] = PIEZA_Rder;
|
||
partidaActual.tablero[Y+1][X] = PIEZA_Rder;
|
||
partidaActual.tablero[Y+1][X+1] = PIEZA_Rder;
|
||
break;
|
||
case 1: // ÛÜ
|
||
case 3: // ß
|
||
partidaActual.tablero[Y][X] = PIEZA_Rder;
|
||
partidaActual.tablero[Y+1][X] = PIEZA_Rder;
|
||
partidaActual.tablero[Y+1][X+1] = PIEZA_Rder;
|
||
partidaActual.tablero[Y+2][X+1] = PIEZA_Rder;
|
||
break;
|
||
}
|
||
break;
|
||
case PIEZA_T:
|
||
switch( rotacion )
|
||
{
|
||
case 0: // ÜÛÜ
|
||
partidaActual.tablero[Y][X+1] = PIEZA_T;
|
||
partidaActual.tablero[Y+1][X] = PIEZA_T;
|
||
partidaActual.tablero[Y+1][X+1] = PIEZA_T;
|
||
partidaActual.tablero[Y+1][X+2] = PIEZA_T;
|
||
break;
|
||
|
||
case 1: // ÛÜ
|
||
// ß
|
||
partidaActual.tablero[Y][X] = PIEZA_T;
|
||
partidaActual.tablero[Y+1][X] = PIEZA_T;
|
||
partidaActual.tablero[Y+1][X+1] = PIEZA_T;
|
||
partidaActual.tablero[Y+2][X] = PIEZA_T;
|
||
break;
|
||
case 2: //ÜÜÜ
|
||
// ß
|
||
partidaActual.tablero[Y][X] = PIEZA_T;
|
||
partidaActual.tablero[Y][X+1] = PIEZA_T;
|
||
partidaActual.tablero[Y][X+2] = PIEZA_T;
|
||
partidaActual.tablero[Y+1][X+1] = PIEZA_T;
|
||
break;
|
||
case 3: // ÜÛ
|
||
// ß
|
||
partidaActual.tablero[Y][X+1] = PIEZA_T;
|
||
partidaActual.tablero[Y+1][X] = PIEZA_T;
|
||
partidaActual.tablero[Y+1][X+1] = PIEZA_T;
|
||
partidaActual.tablero[Y+2][X+1] = PIEZA_T;
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
void procesaColision()
|
||
{
|
||
int X,Y,A, i,j;
|
||
bool noHayLINEA[3]={true,true,true}; // 3 es el alto MAXIMO de una PIEZA
|
||
|
||
// Miramos la pieza actual y vemos si consiguio una linea...
|
||
A = altoPieza( partidaActual.piezaActual );
|
||
X = partidaActual.piezaActual.posX;
|
||
Y = partidaActual.piezaActual.posY;
|
||
|
||
// Vemos si DE LAS POSIBLES LINEAS (alto de la ficha) DONDE ENCAJO
|
||
// alguna ha podido hacer linea.
|
||
for( i=0; i<A && i<3; i++ )
|
||
{
|
||
noHayLINEA[i] = false; // Inicialmente HAY linea
|
||
// En el momento que exista un HUECO en la HORIZONTAL, la cagaste
|
||
for ( j=0; j<ANCHO_TABLERO && noHayLINEA[i]==false; j++ )
|
||
noHayLINEA[i] = (partidaActual.tablero[Y+i][j] == 0) ? true : false;
|
||
}
|
||
|
||
// Ademas hace rato que me canse de "describir" y "comentar" el programa
|
||
if ( noHayLINEA[0]==false || noHayLINEA[1]==false || noHayLINEA[2]==false )
|
||
{
|
||
// Actualizamos el tablero
|
||
if ( noHayLINEA[0]==false )
|
||
eliminaLineaTablero( Y );
|
||
if ( noHayLINEA[1]==false )
|
||
eliminaLineaTablero( Y+1 );
|
||
if ( noHayLINEA[2]==false )
|
||
eliminaLineaTablero( Y+2 );
|
||
|
||
// ESTO DETENDRA LA EJECUCION DEL PROGRAMA
|
||
// PERO WUUUEEENO, ESTO SOLO ES UN EJEMPLO QUE MAS QUEREIS
|
||
for(i=0;i<10;i++)
|
||
if ( noHayLINEA[j]==false )
|
||
{
|
||
for( j=0;j<A;j++) {
|
||
gotoxy( 2,Y+1+j ); textcolor(GREEN); cprintf("±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±");
|
||
}
|
||
delay(50);
|
||
for( j=0;j<A;j++) {
|
||
gotoxy( 2,Y+1+j ); textcolor(LIGHTGREEN); cprintf("²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²");
|
||
}
|
||
delay(100);
|
||
for( j=0;j<A;j++) {
|
||
gotoxy( 2,Y+1+j ); textcolor(WHITE); cprintf("ÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ");
|
||
}
|
||
delay(50);
|
||
}
|
||
|
||
RedibujaTablero();
|
||
}
|
||
}
|
||
|
||
/*
|
||
La colision de una pieza en el tablero, depende del tipo, rotacion
|
||
y posiciones dentro de este.
|
||
*/
|
||
bool piezaColisiona( char tablero[ALTO_TABLERO][ANCHO_TABLERO], pieza P )
|
||
{
|
||
bool colision;
|
||
colision = false;
|
||
|
||
/*
|
||
// Solo si no estamos en el borde del tablero
|
||
colision = ( P.posX < 0 );
|
||
*/
|
||
/*
|
||
// COLISION por la derecha FRUTO DE UNA ROTACION
|
||
colision = ( ((P.posX+anchoPieza(P)) > ANCHO_TABLERO) );
|
||
*/
|
||
// Comprobamos una posible colision con la base del tablero
|
||
if ( colision == false )
|
||
colision = ((P.posY+altoPieza(P)) > ALTO_TABLERO );
|
||
|
||
// Comprobamos colisiones DENTRO DEL TABLERO
|
||
/***********/
|
||
if ( colision == false && P.tipo==PIEZA_CUADRADA)
|
||
colision = tablero[P.posY+1][P.posX]!=0 || tablero[P.posY+1][P.posX+1]!=0 ||
|
||
tablero[P.posY][P.posX]!=0 || tablero[P.posY][P.posX+1]!=0;
|
||
|
||
if ( colision == false && P.tipo==PIEZA_LINEA )
|
||
{
|
||
if ( P.rotacion == 0 || P.rotacion == 2 )
|
||
colision = tablero[P.posY+0][P.posX]!=0 ||
|
||
tablero[P.posY+1][P.posX]!=0 ||
|
||
tablero[P.posY+2][P.posX]!=0
|
||
;
|
||
else
|
||
colision = (tablero[P.posY][P.posX]!=0 ||
|
||
tablero[P.posY][P.posX+1]!=0 ||
|
||
tablero[P.posY][P.posX+2]!=0 );
|
||
}
|
||
|
||
if ( colision == false && P.tipo==PIEZA_Lizq )
|
||
{
|
||
switch( P.rotacion )
|
||
{
|
||
case 0: // |_
|
||
colision = tablero[P.posY+2][P.posX] != 0 ||
|
||
tablero[P.posY+2][P.posX+1] != 0 ||
|
||
tablero[P.posY+0][P.posX]!=0 ||
|
||
tablero[P.posY+1][P.posX]!=0;
|
||
break;
|
||
case 1: // |ùùù
|
||
colision = tablero[P.posY+1][P.posX] != 0 ||
|
||
tablero[P.posY][P.posX+1] != 0 ||
|
||
tablero[P.posY][P.posX+2] != 0 ||
|
||
tablero[P.posY][P.posX]!=0;
|
||
break;
|
||
case 2: // ù|
|
||
colision = tablero[P.posY][P.posX] != 0 ||
|
||
tablero[P.posY+2][P.posX+1] != 0||
|
||
tablero[P.posY+0][P.posX+1]!=0 ||
|
||
tablero[P.posY+1][P.posX+1]!=0;
|
||
break;
|
||
case 3: // |___
|
||
colision = tablero[P.posY+1][P.posX] != 0 ||
|
||
tablero[P.posY+1][P.posX+1] != 0 ||
|
||
tablero[P.posY+1][P.posX+2] != 0 ||
|
||
tablero[P.posY][P.posX]!=0;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if ( colision == false && P.tipo==PIEZA_Lder )
|
||
{
|
||
switch( P.rotacion )
|
||
{
|
||
case 0: // Ü
|
||
// ÜÛ
|
||
colision = tablero[P.posY+2][P.posX] != 0 ||
|
||
tablero[P.posY+2][P.posX+1] != 0 ||
|
||
tablero[P.posY+0][P.posX+1]!=0 ||
|
||
tablero[P.posY+1][P.posX+1]!=0;
|
||
break;
|
||
case 1: // ÛÜÜÜ
|
||
colision = tablero[P.posY+1][P.posX] != 0 ||
|
||
tablero[P.posY+1][P.posX+1] != 0 ||
|
||
tablero[P.posY+1][P.posX+2] != 0 ||
|
||
tablero[P.posY][P.posX]!=0;
|
||
break;
|
||
case 2: // Ûß
|
||
// Û
|
||
colision = tablero[P.posY][P.posX+1] != 0 ||
|
||
tablero[P.posY+2][P.posX] != 0 ||
|
||
tablero[P.posY][P.posX]!=0 ||
|
||
tablero[P.posY+1][P.posX]!=0;
|
||
break;
|
||
case 3: // ßßßÛ
|
||
colision = tablero[P.posY][P.posX] != 0 ||
|
||
tablero[P.posY][P.posX+1] != 0 ||
|
||
tablero[P.posY+1][P.posX+2] != 0 ||
|
||
tablero[P.posY][P.posX+2]!=0;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if ( colision == false && P.tipo==PIEZA_Rizq )
|
||
{
|
||
switch( P.rotacion )
|
||
{
|
||
case 0: // ßÛÜ
|
||
case 2:
|
||
colision = tablero[P.posY][P.posX] != 0 ||
|
||
tablero[P.posY+1][P.posX+1] != 0 ||
|
||
tablero[P.posY+1][P.posX+2] != 0 ||
|
||
tablero[P.posY][P.posX+1]!=0;
|
||
break;
|
||
case 1: // ÜÛ
|
||
case 3: // ß
|
||
colision = tablero[P.posY+2][P.posX] != 0 ||
|
||
tablero[P.posY+1][P.posX+1] != 0 ||
|
||
tablero[P.posY+1][P.posX]!=0 ||
|
||
tablero[P.posY+1][P.posX+1]!=0;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if ( colision == false && P.tipo==PIEZA_Rder )
|
||
{
|
||
switch( P.rotacion )
|
||
{
|
||
case 0: // ÜÛß
|
||
case 2:
|
||
colision = tablero[P.posY+1][P.posX] != 0 ||
|
||
tablero[P.posY+1][P.posX+1] != 0 ||
|
||
tablero[P.posY][P.posX+2] != 0 ||
|
||
tablero[P.posY+0][P.posX+1]!=0;
|
||
break;
|
||
case 1: // ÛÜ
|
||
case 3: // ß
|
||
colision = tablero[P.posY+1][P.posX] != 0 ||
|
||
tablero[P.posY+2][P.posX+1] != 0 ||
|
||
tablero[P.posY+1][P.posX]!=0 ||
|
||
tablero[P.posY+1][P.posX+1]!=0;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if ( colision == false && P.tipo==PIEZA_T )
|
||
{
|
||
switch( P.rotacion )
|
||
{
|
||
case 0: // ÜÛÜ
|
||
colision = tablero[P.posY+1][P.posX] != 0 ||
|
||
tablero[P.posY+1][P.posX+1] != 0 ||
|
||
tablero[P.posY+1][P.posX+2] != 0 ||
|
||
tablero[P.posY+0][P.posX+1]!=0;
|
||
break;
|
||
|
||
case 1: // ÛÜ
|
||
// ß
|
||
colision = tablero[P.posY+2][P.posX] != 0 ||
|
||
tablero[P.posY+1][P.posX+1] != 0 ||
|
||
tablero[P.posY+0][P.posX]!=0 ||
|
||
tablero[P.posY+1][P.posX]!=0;
|
||
break;
|
||
case 2: //ÜÜÜ
|
||
// ß
|
||
colision = tablero[P.posY][P.posX] != 0 ||
|
||
tablero[P.posY+1][P.posX+1] != 0 ||
|
||
tablero[P.posY][P.posX+2] != 0 ||
|
||
tablero[P.posY][P.posX+1]!=0;
|
||
break;
|
||
case 3: // ÜÛ
|
||
// ß
|
||
colision = tablero[P.posY+1][P.posX] != 0 ||
|
||
tablero[P.posY+2][P.posX+1] != 0 ||
|
||
tablero[P.posY][P.posX+1]!=0 ||
|
||
tablero[P.posY+1][P.posX+1]!=0;
|
||
break;
|
||
}
|
||
}
|
||
|
||
/************/
|
||
|
||
|
||
|
||
|
||
return colision;
|
||
}
|
||
|
||
/**********
|
||
Este proceso se encarga de actualizar la pieza en la pantalla, e informar
|
||
en caso de colision con otra pieza del tablero.
|
||
***********/
|
||
bool actualizaFicha(bool bajarFicha)
|
||
{
|
||
bool colision;
|
||
int alturaPieza, rot, x;
|
||
pieza nuevaPosicionPieza;
|
||
|
||
// Primero borramos la pieza anterior sobre el tablero
|
||
// (esto se hace dibujandola del color de fondo).
|
||
dibujaPieza( partidaActual.piezaActual, 0 );
|
||
|
||
// Esta sera la nueva posicion de la pieza (en caso de no colision)
|
||
nuevaPosicionPieza = partidaActual.piezaActual;
|
||
// COLISION por la derecha FRUTO DE UNA ROTACION
|
||
rot = nuevaPosicionPieza.rotacion;
|
||
nuevaPosicionPieza.rotacion = nuevaPosicionPieza.proxRot;
|
||
colision = ( ((nuevaPosicionPieza.posX+anchoPieza(nuevaPosicionPieza)) > ANCHO_TABLERO) );
|
||
if ( colision == true )
|
||
{
|
||
nuevaPosicionPieza.proxRot = rot;
|
||
nuevaPosicionPieza.rotacion = rot;
|
||
}
|
||
|
||
if ( bajarFicha == true )
|
||
nuevaPosicionPieza.posY++;
|
||
|
||
// Parece que intenta mover la pieza HORIZONTALMENTE
|
||
if ( nuevaPosicionPieza.posX != nuevaPosicionPieza.proxX )
|
||
{
|
||
x = nuevaPosicionPieza.posX;
|
||
nuevaPosicionPieza.posX = nuevaPosicionPieza.proxX;
|
||
// Si el desplazamiento horizontal hace colisionar la pieza, se aborta este
|
||
if ( piezaColisiona( partidaActual.tablero, nuevaPosicionPieza) )
|
||
nuevaPosicionPieza.posX = x;
|
||
}
|
||
|
||
// Miramos si podemos bajar la pieza un punto hacia abajo.
|
||
colision = piezaColisiona( partidaActual.tablero, nuevaPosicionPieza );
|
||
|
||
// Si no hay colisi¢n, entonces actualizamos la posicion de la pieza
|
||
if ( colision==false )
|
||
partidaActual.piezaActual = nuevaPosicionPieza;
|
||
|
||
// Finalmente dibujamos la pieza
|
||
dibujaPieza( partidaActual.piezaActual, colorPieza(partidaActual.piezaActual) );
|
||
|
||
return colision;
|
||
}
|
||
|
||
// Elegimos un color para cada tipo de pieza
|
||
int colorPieza(pieza P)
|
||
{
|
||
return P.tipo+1;
|
||
}
|
||
|
||
// Esta funcion dibuja una figura al azar en el rectangulo definido
|
||
void AnimaticaTimeSlice(void)
|
||
{
|
||
static bool reiniciarTIMER = false;
|
||
static clock_t s;
|
||
static pieza p = obtenerPieza();
|
||
|
||
if ( reiniciarTIMER == true )
|
||
{
|
||
reiniciarTIMER = false;
|
||
s=clock();
|
||
}
|
||
|
||
if ( (clock()-s)/CLK_TCK > 0.1 )
|
||
{
|
||
dibujaPieza( p, 0 );
|
||
p = obtenerPieza();
|
||
p.posX = 16 + random(12);
|
||
p.posY = 2 + random(5);
|
||
dibujaPieza( p, random(15) );
|
||
reiniciarTIMER = true;
|
||
}
|
||
|
||
/* REPRESENTO EL ESTADO ACTUAL DEL TABLERO
|
||
/// HAY QUE SABER QUE HAY PARA VER SI TODO VA BIEN ////
|
||
123456789012345
|
||
60
|
||
Üß Û
|
||
*/
|
||
for (int i=0;i<ANCHO_TABLERO;i++)
|
||
for (int j=0; j<ALTO_TABLERO;j++)
|
||
{ gotoxy( 60+i,2+j);
|
||
textcolor(partidaActual.tablero[j][i]);
|
||
cprintf("þ",partidaActual.tablero[j][i]);
|
||
}
|
||
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////////////
|
||
//////// ESTO SON SOLO CHORRADITAS DECORATIVAS PARA PERDER EL TIEMPO ////
|
||
/////////////////////////////////////////////////////////////////////////
|
||
void dibujaPiezaHUECA( pieza P, int color )
|
||
{
|
||
int X, Y;
|
||
X = P.posX*2+2; // Coordenas iniciales para dibujar
|
||
Y = P.posY+1; // mas una correcci¢n visual (hay que encajar
|
||
// el tablero en la pantalla)
|
||
|
||
textcolor(color); // Establecemos el color de la pieza
|
||
|
||
switch( P.tipo )
|
||
{
|
||
/*******************
|
||
ROTACION 0 ROTACION 1 ROTACION 2 ROTACION 3
|
||
*********************/
|
||
|
||
// ÛÛÛÛ ÛÛÛÛ ÛÛÛÛ ÛÛÛÛ
|
||
// ÛÛÛÛ ÛÛÛÛ ÛÛÛÛ ÛÛÛÛ
|
||
case PIEZA_CUADRADA:
|
||
switch( P.rotacion )
|
||
{
|
||
case 0:
|
||
case 1:
|
||
case 2:
|
||
case 3:
|
||
gotoxy(X,Y); cprintf("ÚÄÄ¿");
|
||
gotoxy(X,Y+1); cprintf("ÀÄÄÙ");
|
||
break;
|
||
}
|
||
break;
|
||
// ÛÛ
|
||
// ÛÛ ÛÛÛÛÛÛ ÛÛÛÛÛÛ ÛÛÛÛÛÛ
|
||
// ÛÛ
|
||
case PIEZA_LINEA:
|
||
switch( P.rotacion )
|
||
{
|
||
case 0:
|
||
case 2:
|
||
gotoxy(X,Y); cprintf("Ú¿");
|
||
gotoxy(X,Y+1); cprintf("³³");
|
||
gotoxy(X,Y+2); cprintf("ÀÙ");
|
||
break;
|
||
case 1:
|
||
case 3:
|
||
gotoxy(X,Y); cprintf("ÍÍÍÍÍÍ");
|
||
break;
|
||
}
|
||
break;
|
||
// ÛÛ ÛÛ
|
||
// ÛÛÛÛ ÛÛÛÛ ÛÛÛÛ ÛÛÛÛ
|
||
// ÛÛÛÛ ÛÛ ÛÛÛÛ ÛÛ
|
||
case PIEZA_Rizq:
|
||
switch( P.rotacion )
|
||
{
|
||
case 0:
|
||
case 2:
|
||
gotoxy(X,Y); cprintf("ÍÍ¿¿");
|
||
gotoxy(X+2,Y+1); cprintf("ÀÀÍÍ");
|
||
break;
|
||
case 1:
|
||
case 3:
|
||
gotoxy(X+2,Y); cprintf("Ú¿");
|
||
gotoxy(X,Y+1); cprintf("ÚÍÍÙ");
|
||
gotoxy(X,Y+2); cprintf("ÀÙ");
|
||
break;
|
||
}
|
||
break;
|
||
// ÛÛ ÛÛ
|
||
// ÛÛÛÛ ÛÛÛÛ ÛÛÛÛ ÛÛÛÛ
|
||
// ÛÛÛÛ ÛÛ ÛÛÛÛ ÛÛ
|
||
case PIEZA_Rder:
|
||
switch( P.rotacion )
|
||
{
|
||
case 0:
|
||
case 2:
|
||
gotoxy(X+2,Y) ; cprintf("ÚÚÍÍ");
|
||
gotoxy(X,Y+1); cprintf("ÍÍÙÙ");
|
||
break;
|
||
case 1:
|
||
case 3:
|
||
gotoxy(X,Y); cprintf("Ú¿");
|
||
gotoxy(X,Y+1); cprintf("ÀÍÍ¿");
|
||
gotoxy(X+2,Y+2); cprintf("ÀÙ");
|
||
break;
|
||
}
|
||
break;
|
||
// ÛÛ ÛÛÛÛ
|
||
// ÛÛ ÛÛÛÛÛÛ ÛÛ ÛÛ
|
||
// ÛÛÛÛ ÛÛ ÛÛ ÛÛÛÛÛÛ
|
||
case PIEZA_Lizq:
|
||
switch( P.rotacion )
|
||
{
|
||
case 0:
|
||
gotoxy(X,Y); cprintf("Ú¿");
|
||
gotoxy(X,Y+1); cprintf("³³");
|
||
gotoxy(X,Y+2); cprintf("ÀÄÍÙ");
|
||
break;
|
||
case 1:
|
||
gotoxy(X,Y); cprintf("ÚÍÍÍÍÍ");
|
||
gotoxy(X,Y+1); cprintf("ÀÙ");
|
||
break;
|
||
case 2:
|
||
gotoxy(X,Y); cprintf("ÚÍÍ¿");
|
||
gotoxy(X+2,Y+1); cprintf("³³");
|
||
gotoxy(X+2,Y+2); cprintf("ÀÙ");
|
||
break;
|
||
case 3:
|
||
gotoxy(X+4,Y); cprintf("Ú¿");
|
||
gotoxy(X,Y+1); cprintf("ÍÍÍÍÍÙ");
|
||
break;
|
||
}
|
||
break;
|
||
// ÛÛ ÛÛÛÛ
|
||
// ÛÛ ÛÛ ÛÛ ÛÛÛÛÛÛ
|
||
// ÛÛÛÛ ÛÛÛÛÛÛ ÛÛ ÛÛ
|
||
case PIEZA_Lder:
|
||
switch( P.rotacion )
|
||
{
|
||
case 0:
|
||
gotoxy(X+2,Y); cprintf("Ú¿");
|
||
gotoxy(X+2,Y+1); cprintf("³³");
|
||
gotoxy(X,Y+2); cprintf("ÀÍÍÙ");
|
||
break;
|
||
case 1:
|
||
gotoxy(X,Y); cprintf("Ú¿");
|
||
gotoxy(X,Y+1); cprintf("ÀÍÍÍÍÍ");
|
||
break;
|
||
case 2:
|
||
gotoxy(X,Y); cprintf("ÚÍÍÍ");
|
||
gotoxy(X,Y+1); cprintf("³³");
|
||
gotoxy(X,Y+2); cprintf("ÀÙ");
|
||
break;
|
||
case 3:
|
||
gotoxy(X,Y); cprintf("ÍÍÍÍÍ¿");
|
||
gotoxy(X+4,Y+1); cprintf("ÀÙ");
|
||
break;
|
||
}
|
||
break;
|
||
// ÛÛ ÛÛ
|
||
// ÛÛ ÛÛÛÛ ÛÛÛÛÛÛ ÛÛÛÛ
|
||
// ÛÛÛÛÛÛ ÛÛ ÛÛ ÛÛ
|
||
case PIEZA_T:
|
||
switch( P.rotacion )
|
||
{
|
||
case 0:
|
||
gotoxy(X+2,Y); cprintf("É»");
|
||
gotoxy(X,Y+1); cprintf("ÍÍÊÊÍÍ");
|
||
break;
|
||
case 1:
|
||
gotoxy(X,Y); cprintf("Ú¿");
|
||
gotoxy(X,Y+1); cprintf("³ÌÍÍ");
|
||
gotoxy(X,Y+2); cprintf("ÀÙ");
|
||
break;
|
||
case 2:
|
||
gotoxy(X,Y); cprintf("ÍÍËËÍÍ");
|
||
gotoxy(X+2,Y+1); cprintf("ȼ");
|
||
break;
|
||
case 3:
|
||
gotoxy(X+2,Y); cprintf("Ú¿");
|
||
gotoxy(X,Y+1); cprintf("Í͹³");
|
||
gotoxy(X+2,Y+2); cprintf("ÀÙ");
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
|
||
}
|