SoloCodigo
Programación General => C/C++ => Visual C++ => Mensaje iniciado por: Cloud_Skywalker en Lunes 17 de Diciembre de 2007, 14:31
-
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
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.