commit ebbc0ae26cd1c6efac78bff3b53571a600a34eb9
Author: jdg <jd@infdj.com>
Date:   Sun Sep 12 20:34:18 2021 +0200

    First commit 25/05/2003

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..c2a351f
--- /dev/null
+++ b/README.md
@@ -0,0 +1,9 @@
+#C++ 
+ 
+ 
+*25/05/2003* 
+ 
+ToDo: wwtcf? 
+ 
+ 
+![screenshot](/C++.png "Screenshot") 
diff --git a/TETRIS.CPP b/TETRIS.CPP
new file mode 100644
index 0000000..5b67013
--- /dev/null
+++ b/TETRIS.CPP
@@ -0,0 +1,1162 @@
+/********
+ 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;
+ }
+
+}
diff --git a/TETRIS.EXE b/TETRIS.EXE
new file mode 100644
index 0000000..e209452
Binary files /dev/null and b/TETRIS.EXE differ
diff --git a/TETRIS.PIF b/TETRIS.PIF
new file mode 100644
index 0000000..5f14e17
Binary files /dev/null and b/TETRIS.PIF differ