SoloCodigo

Hola, soy nuevo y me gustaría saber si aquí podríais ayudarme.

En caso afirmativo os dejo aquí el código actual de mi programa y os digo principalmente que es lo que he detectado que no funciona.

Objetivos del programa:

El programa pide unos datos al inicio y los devuelve al final del juego y eso lo hace correctamente.

El juego tiene 8 piezas diferentes (una de ellas declarada con un tipo diferente por simplificación y evasión de problemas posteriores) todas ellas con forma y color diferente.

El juego coloca una pieza en el tablero siempre que no quedan piezas en el tablero o la anterior no se puede mover.

La coloca en la parte más alta en una posición horizontal al azar.

las pizas bajan automáticamente y mientras bajan utilizando las flechas horizontales es posible moverlas a los lados. Además con la flecha hacia arriba o la barra espaciadora puede rotar un cuarto de vuelta hacia la drecha.

las piezas pueden rotar o desplazarse lateralmene sólo una vez por cada posición que baja y puede hacer primero una cosa o la otra, pero siempre bajar es lo último que hace.

Sólo se moverá o rotará si después de ello no sobresaldrá de los límites del tablero ni se superpondrá a ninguna otra pieza ya existente.

Después de cada pieza que se queda quieta el programa comprueba si hay filas llenas y de ser así las elimina y todas los trozos de pieza que quedan porencima bajan todo lo que pueden.

Cuando una pieza nueva se coloca y queda superpuesta a otra se termina la partida.

Cuando se aprieta la tecla Esc también se termina la partida

Si la partida termina se pregunta si se desea volver a jugar, pero a partir de aquí todo va bien.

Problemas:

Que yo haya detectado de momento falla en la rotación de las piezas:

Donde no las rota sino que las deja igual i mientras bajan pueden ocurrir cosas extrañas como detenerse a medio camino, o comerse bloques que ya estaban puestos.

Después cuando una pieza nueva del mismo tipo que la que se intentó rotar entra en el tablero entra rotada y lo mismo ocurre con las sigueintes.

También tiene otro problema a la hora de eliminar filas llenas pero creo que ese no es tan difícil de descubrir y reparar, supongo que es un error de acceso a memoria.

y ahora dejo el código:

Tetris.c:

/********************************************************************************************************************************/
/*                                 Tetris   2.0                                                                         */
/********************************************************************************************************************************/

/********************************************************************************************************************************/
//         Capçalera del programa i tipus de dades
/********************************************************************************************************************************/

#include   "Rutines_v1.h"
#include   <conio.h>
#include   <stdlib.h>

#define   colors   8
#define   KEY_SPC   32

typedef   struct
{
   int   fila;
   int   columna;
   int   color;
} Tquadret;

typedef   struct   Tjugador
{
   char   nom[10];
   int      data1;
   int      data2;
   int      data3;
   int      punts;
   struct   Tjugador   *seguent;
} jugador;

typedef struct   Trosset
{
   int      pos[NCol];
   int      fila;
   int      permis;
   struct   Trosset   *seguent;
} TTros;

/********************************************************************************************************************************/
//         Funcions i procediments per esborrar peces i files plenes del taulell de joc
/********************************************************************************************************************************/

void   EsborraPeca(Tquadret peca[3][3][colors+1], Tquadret quadret, int c, int taulell[NFil][NCol])   /*Procediment que esborra una peça del taulell*/
{
   int   i, j;

   if   (c==1)
      taulell[quadret.fila][quadret.columna]=0;
   else
      for(i=0; i<3; i++)
         for(j=0; j<3; j++)
            if   (peca[j][c].color!=0)
               taulell[peca[j][c].fila][peca[j][c].columna]=0;
}

int   EsborraLinia(int taulell[NFil][NCol], int f[NFil])   /*Funció que esborra totes les files plenes del taulell, fa baixar les altres el màxim possible i retorna el nombre de files esborrades*/
{
   int   i, j, k, s=0;

   for   (i=0; i<NFil; i++)
      if   (f[NFil-1-i]!=0)
      {
         s++;

         for   (j=0; j<NCol; j++)
            taulell[NFil-1-i][j]=0;
      }

   for   (i=0; i<NFil; i++)
      if   ((f[NFil-1-i]!=0)&&(NFil-2-i!=0))
         for   (j=0; j<NFil-2-i; j++)
            for   (k=0; k<NCol; k++)
            {
               taulell[NFil-1-i][k]=taulell[NFil-2-i][k];
               taulell[NFil-2-i][k]=0;
            }
   return   s;
}

/********************************************************************************************************************************/
//         Procediments per comprobar la possibilitat de moure una peça o d'esborrar alguna fila
/********************************************************************************************************************************/

int   Permis(Tquadret peca[3][3][colors+1], Tquadret quadret, int c, int x, int y, int h, int taulell[NFil][NCol])   /*Comproba si es possible moure una peça a alguna posició concreta i retorna 0 si no és possible o 1 si ho és*/
{
   int   i, j, k, l, p;

   if   ((((x>NFil-2)||(y<1)||(y>NCol-2))&&(c!=1))||(((x>NFil-1)||(y<0)||(y>NCol-1))&&(c==1)))
      p=0;
   else   
   {
      if   (h==0)
         EsborraPeca(peca, quadret, c, taulell);
      p=1;
      if   (c==1)
      {
         if   (taulell

• [y]!=0)

            p=0;
      }
      else   
      {
         i=0;
         k=x-1;
         do
         {
            j=0;
            l=y-1;
            do
            {
               if   ((peca[j][c].color!=0)&&(taulell[k][l]!=0))
                  p=0;
               j++;
               l++;
            }while   ((j<3)&&(p!=0));
            i++;
            k++;
         }while   ((i<3)&&(p!=0));
      }
   }
   return   p;
}

int   PermisRotar(Tquadret peca[3][3][colors+1], Tquadret quadret, int c, int taulell[NFil][NCol])   /*Funció que comproba si es possible rotar una peça i retorna 0 si no és possible o 1 si ho és*/
{
   int   i, j, p;

   EsborraPeca(peca, quadret, c, taulell);

   i=0;
   do
   {
      j=0;
      do
      {
         if   ((peca[j][c].color!=0)&&(taulell[j][3-i]!=0))
            p=0;
         else   p=1;
         j++;
      }while   ((j<3)&&(p!=0));
      i++;
   }while   ((i<3)&&(p!=0));

   return   p;
}

int   ComprovarLinia(int taulell[NFil][NCol], int f[NFil])   /*Funció que comprova si existeix al menys una fila plena, si existeix retorna 1 i si no retorna 0. També conserva la informació de quines files estan plenes*/
{
   int   i, j, l, r;

   for (i=0; i<NFil; i++)
      f=0;
   r=0;
   i=0;
   do
   {
      j=0;
      do
      {
         if   (taulell[j]!=0)
            l=1;
         else   l=0;
         j++;
      }while   ((j<NCol)&&(l==1));
      if   (l==1)
      {
         f=1;
         r=1;
      }
      i++;
   }while   (i<NFil);

   return   r;
}

/********************************************************************************************************************************/
//         Procediments per moure una peça
/********************************************************************************************************************************/

void   PecaEsquerra(Tquadret peca[3][3][colors+1], Tquadret *quadret, int c)   /*Procediment que mou una peça una posició a esquerra*/
{
   int   i, j;

   if   (c==1)
      quadret->columna=quadret->columna-1;
   else
      for   (i=0; i<3; i++)
         for   (j=0; j<3; j++)
            peca[j][c].columna=peca[j][c].columna-1;
}

void   PecaDreta(Tquadret peca[3][3][colors+1], Tquadret *quadret, int c)   /*Procediment que mou una peça una posició a la dreta*/
{
   int i, j;

   if   (c==1)
      quadret->columna=quadret->columna+1;
   else
      for   (i=0; i<3; i++)
         for   (j=0; j<3; j++)
            peca[j][c].columna=peca[j][c].columna+1;
}

void   PecaAbaix(Tquadret peca[3][3][colors+1], Tquadret *quadret, int c)   /*Procediment que mou una peça una posició abaix*/
{
   int   i, j;

   if   (c==1)
      quadret->fila=quadret->fila+1;
   else
      for   (i=0; i<3; i++)
         for   (j=0; j<3; j++)
            peca[j][c].fila=peca[j][c].fila+1;
}

void   RotaPeca(Tquadret peca[3][3][colors+1], int c)   /*Procediment que rota una peça -90º*/
{
   int i, j;
   Tquadret m[3][3];

   for   (i=0; i<3; i++)
      for   (j=0; j<3; j++)
      {
         m[j].color=peca[j][c].color;
         m[j].columna=peca[j][c].columna;
         m[j].fila=peca[j][c].fila;
      }

   for   (i=0; i<3; i++)
      for   (j=0; j<3; j++)
      {
         peca[j][c].color=m[2-j].color;
         peca[j][c].columna=m[2-j].columna;
         peca[j][c].fila=m[2-j].fila;
      }
}

/********************************************************************************************************************************/
//         Procediments per trobar segments flotants i reubicar-los
/********************************************************************************************************************************/

void   LocalitzaTrossos(TTros *Tros, int taulell[NFil][NCol])   /*Procediment que fa una llista de tots els segments que potser estan flotant*/
{
   int   i, j;
   TTros   *primer;

   for   (i=0; i<NCol; i++)
      Tros->pos=0;

   for   (i=1; i<NFil; i++)
   {
      for   (j=0; j<NCol; j++)
      {
         if   (taulell[NFil-1-i][j]!=0)
         {
            if   (Tros==NULL)
            {
               Tros=(TTros*)malloc(sizeof(TTros));
               primer=Tros;
            }
            else
            {
               Tros->seguent=(TTros*)malloc(sizeof(TTros));
               Tros=Tros->seguent;
            }
            Tros->seguent=NULL;
            Tros->fila=NFil-1-i;
         }
         do
         {
            Tros->pos[j]=taulell[NFil-1-i][j];

            if   (j<NCol-1)
               j++;
         }while   ((taulell[NFil-1-i][j]!=0)&&(j!=NCol-1));
      }
   }
   Tros=primer;
}

void   BaixaTrossos(TTros *Tros, int taulell[NFil][NCol])   /*Procediment que baixa tots els segments flotants el màxim possible*/
{
   int   i, z;
   TTros   *primer;

   primer=Tros;

   do
   {
      z=0;

      do
      {
         Tros->permis=1;

         for   (i=0; i<NCol; i++)
            if   ((taulell[Tros->fila+1]!=0)&&(Tros->pos!=0))
               Tros->permis=0;

         if   (Tros->permis!=0)
            for   (i=0; i<NCol; i++)
               if   (Tros->pos!=0)
               {
                  taulell[Tros->fila]=0;
                  taulell[Tros->fila+1]=Tros->pos;
                  z=1;
               }

         Tros=Tros->seguent;
         free(primer);
         primer=Tros;

      }while   (Tros!=NULL);
   }while   (z!=0);
}


/********************************************************************************************************************************/
//         Altres procediments
/********************************************************************************************************************************/

void   PintaPeca(Tquadret peca[3][3][colors+1], Tquadret quadret, int c, int taulell[NFil][NCol])   /*Procediment que pinta una peça al taulell*/
{
   int i, j;

   if   (c==1)
      taulell[quadret.fila][quadret.columna]=1;
   else
      for   (i=0; i<3; i++)
         for   (j=0; j<3; j++)
            if   (peca[j][c].color!=0)
               taulell[peca[j][c].fila][peca[j][c].columna]=peca[j][c].color;
}

void   ColocaPeca(Tquadret peca[3][3][colors+1], Tquadret *quadret, int k, int c)   /*Procediment que dona a la peça les coordenades d'on cau*/
{
   int i, j;

   if   (c==1)
   {
      quadret->fila=0;
      quadret->columna=k;
   }
   else
      for   (i=0; i<3; i++)
         for   (j=0; j<3; j++)
         {
            peca[j][c].fila=i;
            peca[j][c].columna=j+k-1;
         }
}

void   InicialitzaPeces(Tquadret peca[3][3][colors+1], Tquadret *quadret)   /*Procediment que dona forma i color a cada peça*/
{
   int i, j, c;

   for   (c=2; c<colors+1; c++)
      for   (i=0; i<3; i++)
         for   (j=0; j<3; j++)
            peca[j][c].color=c;

   quadret->color=1;

   for   (i=0; i<2; i++)
      for   (j=1; j<3; j++)
         peca[j][3].color=0;

   for   (i=0; i<2; i++)
      for   (j=0; j<3; j=j+2)
         peca[j][4].color=0;

   for   (i=0; i<2; i++)
      peca[2][5].color=0;

   for   (i=1; i<3; i++)
      peca[0][6].color=0;

   peca[2][0][7].color=0;
   peca[0][2][7].color=0;
   peca[1][2][7].color=0;

   peca[0][0][8].color=0;
   peca[1][0][8].color=0;
   peca[2][2][8].color=0;
}

/********************************************************************************************************************************/
//         Programa principal
/********************************************************************************************************************************/

void   main()
   {

//-----Declaració de les variables------------------------------------------------------------------------------------------------

   int   x, y, i, j, k, m, n, p, c, s, f[NFil], taulell[NFil][NCol];

   char   despl, resposta;

   int   buit, quieta, p_mov, p_rot;   /*Lògics*/

   jugador   *partida, *primer;

   Tquadret   peca[3][3][colors+1], quadret, *q;

   TTros   *Tros;

//--------------------------------------------------------------------------------------------------------------------------------
//-----Joc------------------------------------------------------------------------------------------------------------------------

   partida=(jugador*)malloc(sizeof(jugador));
   primer=partida;

   p=1;
   q=&quadret;

   InicialitzaPeces(peca, q);
   
   srand( (unsigned)time( NULL ) );

//-----Partida--------------------------------------------------------------------------------------------------------------------

   do
   {
      system("cls");
      printf("Introdueix el teu nom i la data d'avui (dia, mes i any)");

      fflush(stdin);
      gets(partida->nom);
      scanf("%d", &partida->data1);
      scanf("%d", &partida->data2);
      scanf("%d", &partida->data3);

      partida->punts=0;

      for   (i=0; i<NFil; i++)   //   Inicialització del taulell
         for   (j=0; j<NCol; j++)
            taulell[j]=0;

      system("cls");
      MostraTaulell();

      buit=1;

//-----Introducció de noves peces-------------------------------------------------------------------------------------------------

      do
      {
         if   (buit!=0)   //   Es col·loca una nova peça al taulell
         {
            c=NumAleatori(7)+1;
            k=NumAleatori(NCol-3)+1;

            ColocaPeca(peca, q, k, c);
            buit=0;
         }

         PintaPeca(peca, quadret, c, taulell);
         quieta=0;

//-----Caiguda d'una peça---------------------------------------------------------------------------------------------------------

         do
         {
            MostraPeces(taulell, c, partida->nom, partida->punts, 0);

            despl=0;   //   Determinació de si s'ha apretat alguna tecla
            Sleep(100);

            if   (_kbhit())
               while   (_kbhit())
                  despl=getch();

            switch   (despl)      //   Moviment de la peça segons la tecla apretada
            {
               case   KEY_SPC:
               case   KEY_UP:      if   (c!=1)
                              {
                                 p_rot=PermisRotar(peca, quadret, c, taulell);

                                 if   (p_rot!=0)
                                    RotaPeca(peca, c);

                                 PintaPeca(peca, quadret, c, taulell);
                                 MostraPeces(taulell, c, partida->nom, partida->punts, 0);
                              }
                              m=1;
                              break;

               case   KEY_LEFT:   if   (c==1)
                              {
                                 x=quadret.fila;
                                 y=quadret.columna-1;
                              }
                              else
                              {
                                 x=peca[1][0][c].fila;
                                 y=peca[1][0][c].columna;
                              }
                              
                              p_mov=Permis(peca, quadret, c, x, y, 0, taulell);
                                 
                              if   (p_mov!=0)
                                 PecaEsquerra(peca, q, c);

                              PintaPeca(peca, quadret, c, taulell);
                              MostraPeces(taulell, c, partida->nom, partida->punts, 0);
                              n=1;
                              break;

               case   KEY_RIGHT:   if   (c==1)
                              {
                                 x=quadret.fila;
                                 y=quadret.columna+1;
                              }
                              else
                              {
                                 x=peca[1][2][c].fila;
                                 y=peca[1][2][c].columna;
                              }
                           
                              p_mov=Permis(peca, quadret, c, x, y, 0, taulell);

                              if   (p_mov!=0)
                                 PecaDreta(peca, q, c);

                              PintaPeca(peca, quadret, c, taulell);
                              MostraPeces(taulell, c, partida->nom, partida->punts, 0);
                              n=1;
                              break;
            }

            MostraPeces(taulell, c, partida->nom, partida->punts, 0);

            despl=0;   //   Determinació de si s'ha apretat alguna tecla
            Sleep(100);

            if   (_kbhit())
               while   (_kbhit())
                  despl=getch();

            switch   (despl)      //   Moviment de la peça segons la tecla apretada
            {
               case   KEY_SPC:
               case   KEY_UP:      if   (m!=1)
                              {
                                 if   (c!=1)
                                 {
                                    p_rot=PermisRotar(peca, quadret, c, taulell);
   
                                    if   (p_rot!=0)
                                       RotaPeca(peca, c);

                                    PintaPeca(peca, quadret, c, taulell);
                                    MostraPeces(taulell, c, partida->nom, partida->punts, 0);
                                 }
                              }
                              break;

               case   KEY_LEFT:   if   (n!=1)
                              {
                                 if   (c==1)
                                 {
                                    x=quadret.fila;
                                    y=quadret.columna-1;
                                 }
                                 else
                                 {
                                    x=peca[1][0][c].fila;
                                    y=peca[1][0][c].columna;
                                 }
                              
                                 p_mov=Permis(peca, quadret, c, x, y, 0, taulell);
                                    
                                 if   (p_mov!=0)
                                    PecaEsquerra(peca, q, c);
   
                                 PintaPeca(peca, quadret, c, taulell);
                                 MostraPeces(taulell, c, partida->nom, partida->punts, 0);
                              }
                              break;

               case   KEY_RIGHT:   if   (n!=1)
                              {
                                 if   (c==1)
                                 {
                                    x=quadret.fila;
                                    y=quadret.columna+1;
                                 }
                                 else
                                 {
                                    x=peca[1][2][c].fila;
                                    y=peca[1][2][c].columna;
                                 }
                           
                                 p_mov=Permis(peca, quadret, c, x, y, 0, taulell);

                                 if   (p_mov!=0)
                                    PecaDreta(peca, q, c);

                                 PintaPeca(peca, quadret, c, taulell);
                                 MostraPeces(taulell, c, partida->nom, partida->punts, 0);
                              }
                              break;
            }
            m=0;
            n=0;

            if   (c==1)
            {
               x=quadret.fila+1;
               y=quadret.columna;
            }
            else
            {
               x=peca[2][1][c].fila;
               y=peca[2][1][c].columna;
            }
            p_mov=Permis(peca, quadret, c, x, y, 0, taulell);   //   Moviment cap abaix de la peça

            if   ((p_mov!=0)&&(despl!=KEY_ESC))
               PecaAbaix(peca, q, c);
            else   if   (despl!=KEY_ESC)
               quieta=1;

            PintaPeca(peca, quadret, c, taulell);

         }while   ((despl!=KEY_ESC)&&(quieta==0));

//--------------------------------------------------------------------------------------------------------------------------------

         partida->punts=partida->punts+PuntsPerPeca;

//-----Esborrat de files plenes---------------------------------------------------------------------------------------------------

         while   (ComprovarLinia(taulell, f))
         {
            s=EsborraLinia(taulell, f);
            partida->punts=partida->punts+PuntsPerFila*s;

            LocalitzaTrossos(Tros, taulell);
            BaixaTrossos(Tros, taulell);
         }

//--------------------------------------------------------------------------------------------------------------------------------

         if   (despl!=KEY_ESC)
         {
            c=NumAleatori(7)+1;
            k=NumAleatori(NCol-3)+1;

            ColocaPeca(peca, q, k, c);
            p_mov=Permis(peca, quadret, c, 1, k, 1, taulell);
         }
      }while   ((despl!=KEY_ESC)&&(p_mov!=0));

      PintaPeca(peca, quadret, c, taulell);
      MostraPeces(taulell, c, partida->nom, partida->punts, 0);
      Sleep(1500);
      system("cls");

      printf("\nJa has perdut\n");
      Sleep(1000);
      system("cls");
      printf("\nVols tornar a jugar? Escriu s/S ó n/N\n");

      do
      {
         resposta=getch();

         if   ((resposta=='s')||(resposta=='S'))
         {
            p++;
            partida->seguent=(jugador*)malloc(sizeof(jugador));
            partida=partida->seguent;
         }
      }while   ((resposta!='s')&&(resposta!='S')&&(resposta!='n')&&(resposta!='N'));

//--------------------------------------------------------------------------------------------------------------------------------

   }while   ((resposta!='n')&&(resposta!='N'));

//--------------------------------------------------------------------------------------------------------------------------------

//-----Retorn de les dades de les partides----------------------------------------------------------------------------------------

   partida=primer;
   system("cls");

   for   (i=1; i<p; i++)
   {
      printf("\n%s, %d/%d/%d\n", partida->nom, partida->data1, partida->data2, partida->data3);

      partida=partida->seguent;
      free(primer);
      primer=partida;
   }
   printf("\n%s, %d/%d/%d\n", partida->nom, partida->data1, partida->data2, partida->data3);
   free(partida);
}

//--------------------------------------------------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------------------------------------------------

Rutines_v1.c:

#include "Rutines_v1.h"


//===================================================================================
// NOM: NumAleatori
//===================================================================================
// DESCRIPCIÓ:  Funció per generar un número aleatori entre 0 i max
//===================================================================================
int NumAleatori(int max)
{
   int num;

   num=((int)ceil(((double)rand()/RAND_MAX)*(max+1)))%(max+1);

   return num;
}


//===================================================================================
// NOM: Gotoxy
//===================================================================================
// DESCRIPCIÓ: Permet posar el cursor en una posicio donada
//===================================================================================
void gotoxy(int c,int f,HANDLE screen)
{
 COORD position = { c, f };
 SetConsoleCursorPosition(screen,position);
}


//===================================================================================
// NOM: TextColor
//===================================================================================
// DESCRIPCIÓ: Funcio per canviar els colors de texte i fons de la consola DOS
//===================================================================================
void TextColor(int fontcolor,int backgroundcolor,HANDLE screen)
{
   unsigned short color_attribute;
   color_attribute = backgroundcolor;
   color_attribute = _rotl(color_attribute,4) | fontcolor;
   SetConsoleTextAttribute(screen,color_attribute);
}


//===================================================================================
// NOM: MostraTaulell
//===================================================================================
// DATA: 08 / 10 / 2007
//===================================================================================
// DESCRIPCIÓ: Funcio que permet mostrar el tauler de joc.
//===================================================================================
void MostraTaulell(void)
{

   // ------------------------------------------------------------------------------
   // FORMAT TAULELL:
   //
   // El vector FT (Format Taulell) conté a cada posició el codi d'un determinat
   // caràcter ASCII. Si modifiquem els valors  d'aquest vector, l'aparença del
   // taulell, també variarà.
   //   
   // index 0 -> Contorn lateral.
   // index 1 -> Cantonada inferior esquerre.
   // index 2 -> Cantonada inferior dreta.
   // index 3 -> Contorn inferior.
   int FT[4]={186,200,205,188};   
   
   // ------------------------------------------------------------------------------
   // Altres variables:
   int f,c;
   HANDLE  screen= GetStdHandle(STD_OUTPUT_HANDLE);

   // ------------------------------------------------------------------------------   
   for(f=0;f<NFil;f++)
   {
      TextColor(LIGHTGREY,BLACK,screen);

      gotoxy(DespC,DespF+f,screen);
      printf("%c",FT[0]);

      gotoxy(DespC+NCol+1,DespF+f,screen);      
      printf("%c",FT[0]);
   }

   gotoxy(DespC,DespF+f,screen);
   printf("%c",FT[1]);

   for(c=0;c<NCol;c++)
      printf("%c",FT[2]);
   
   printf("%c",FT[3]);

   // ------------------------------------------------------------------------------   
   gotoxy(DespC,DespF+NFil+2,screen);
   for(c=0;c<NCol+2;c++)
      printf("%c",FT[2]);

   gotoxy(DespC,DespF+NFil+4,screen);
   for(c=0;c<NCol+2;c++)
      printf("%c",FT[2]);

}


//===================================================================================
// NOM: MostraMSG
//===================================================================================
// DATA: 09 / 10 / 2007
//===================================================================================
// DESCRIPCIÓ: Funcio que permet mostrar un dels missatges predefinits sobre el
// tauler de joc.
//===================================================================================
void MostraMSG(char *msg,HANDLE screen)
{
   int i,L,C,CC,CF;

   L=strlen(msg); // Longitud de la cadena.
   C=ceil(L/2);  // Punt mig de la cadena.

   CF=floor(NFil/2);
   CC=floor(NCol/2);

   TextColor(RED,BLACK,screen);
   gotoxy(DespC+CC-C,DespF+CF-1,screen);
   for(i=0;i<L+2;i++)
      printf(" ");
   gotoxy(DespC+CC-C,DespF+CF,screen);
   printf(" %s ",msg);
   gotoxy(DespC+CC-C,DespF+CF+1,screen);
   for(i=0;i<L+2;i++)
      printf(" ");   
}


//===================================================================================
// NOM: MostraPeces
//===================================================================================
// DATA: 08 / 10 / 2007
//===================================================================================
// DESCRIPCIÓ: Funcio que permet mostrar les peces que hi hagi en un moment
// determinat. Permet amés anar mostrant la puntuació i el nom del jugador.
//===================================================================================
void MostraPeces(int Tauler[NFil][NCol], int TipusPeces, char *Jugador, int Puntuacio, int Missatge)
{

   // ------------------------------------------------------------------------------
   // Les peces estan representades dins la matriu peces, i cadascuna esta codificada
   // amb un valor entre 0 i 7, que coincideix amb l'index del següent vector que
   // n'especifica el color.
   //
   // index 0 -> No hi ha peça.
   // index 1 -> Color de fons de la peça P.
   // index 2 -> Color de fons de la peça S.
   // index 3 -> Color de fons de la peça L.
   // index 4 -> Color de fons de la peça T.
   // index 5 -> Color de fons de la peça LL.
   // index 6 -> Color de fons de la peça RL.
   // index 7 -> Color de fons de la peça LZ.
   // index 8 -> Color de fons de la peça RZ.
   int CL[9]={BLACK,LIGHTMAGENTA,GREEN,BLUE,CYAN,YELLOW,BROWN,MAGENTA,RED};

   // ------------------------------------------------------------------------------
   // Altres variables:
   int f,c;
   char msg[25];
   HANDLE  screen= GetStdHandle(STD_OUTPUT_HANDLE);   


   // ------------------------------------------------------------------------------
   // Dibuixem les peces:
   for(f=0;f<NFil;f++)
      for(c=0;c<NCol;c++)
      {      
         gotoxy(DespC+c+1,DespF+f,screen);         
         TextColor(CL[Tauler[f][c]],BLACK,screen);

         // Peces Discretes:
         if(TipusPeces==0)
            printf("%c",254);
         // Peces continues:
         else
            printf("%c",177);
      }

   // ------------------------------------------------------------------------------
   // Mostrem el nom del jugador i la puntuació:
   gotoxy(DespC+1,DespF+NFil+1,screen);
   TextColor(LIGHTGREY,BLACK,screen);
   printf("PLAYER: ");
   TextColor(RED,BLACK,screen);
   printf("%s\n",Jugador);


   gotoxy(DespC+1,DespF+NFil+3,screen);
   TextColor(LIGHTGREY,BLACK,screen);
   printf("SCORE: ");
   TextColor(RED,BLACK,screen);
   printf(" %d\n",Puntuacio);

   // ------------------------------------------------------------------------------
   // Missatges predefinits. Cadascun té un codi:
   switch(Missatge)
   {
      case 1:
         strcpy(msg,"PAUSE");         
         MostraMSG(msg,screen);
         break;
      case 2:
         strcpy(msg,"GAME OVER");
         MostraMSG(msg,screen);
         break;      

   }

}

Rutines_v1.h:

//===================================================================================
#include <math.h>
#include <string.h>
#include <time.h>
#include <windows.h>
#include <stdio.h>

//===================================================================================
// Definicio de colors
#define BLACK 0
#define BLUE 1
#define GREEN 2
#define CYAN 3
#define RED 4
#define MAGENTA 5
#define BROWN 6
#define LIGHTGREY 7
#define DARKGREY 8
#define LIGHTBLUE 9
#define LIGHTGREEN 10
#define LIGHTCYAN 11
#define LIGHTRED 12
#define LIGHTMAGENTA 13
#define YELLOW 14
#define WHITE 15
#define BLINK 128

//===================================================================================
// Definició de tecles
#define KEY_UP 72
#define KEY_DOWN 80
#define KEY_LEFT 75
#define KEY_RIGHT 77
#define KEY_ESC 27

//===================================================================================
// Dimensions del taulell de joc
#define NFil 28
#define NCol 18

//===================================================================================
// Desplaçament del taulell respecte la cantonada superior esquerre
#define DespF 5
#define DespC 27

//===================================================================================
// Definicio de puntuacions
#define PuntsPerPeca 1
#define PuntsPerFila 10

//===================================================================================
// Declaració de funcions
int NumAleatori(int);
void gotoxy(int,int,HANDLE);
void TextColor(int,int,HANDLE);
void MostraTaulell(void);
void MostraMSG(char,HANDLE);
void MostraPeces(int [NFil][NCol],int,char*,int,int);

Muchas gracias por ayudarme.