100 puntos por mil líneas de código fuente del programa en lenguaje C
Tetris tiene tu nombre:
#include lt;stdio.hgt
#include lt;dos.hgt; incluir lt;conio.hgt;
#include lt;graphics.hgt;
#include lt;stdlib.hgt;
#include lt ;tiempo. hgt;
#include lt;math.hgt;
#ifdef __cplusplus
#define __CPPARGS ...
#else
#define __CPPARGS
#endif
#define MINBOXSIZE 23 /* Tamaño mínimo de bloque*/
#define BGCOLOR 7 /* Fondo colorear*/
#define GX 200
#define GY 10
#define SJNUM 1000 /* Siempre que el jugador alcance mil puntos Nivel más uno*/
/* Código clave*/
#define VK_LEFT 0x4b00
#define VK_RIGHT 0x4d00
#define VK_DOWN 0x5000
#define VK_UP 0x4800
#define VK_HOME 0x4700
#define VK_END 0x4f00
#define VK_SPACE 0x3920
#define VK_ESC 0x011b
#define VK_ENTER 0x1c0d
/* Definir la dirección del Tetris (lo defino como 4 tipos)*/
# define F_DONG 0
#define F_NAN 1
#define F_XI 2
#define F_BEI 3
#define NEXTCOL 20 /* Requerido La coordenada vertical del siguiente bloque a dibujar*/
#define NEXTROW 12 /* La coordenada horizontal del siguiente bloque a dibujar*/
#define MAXROW 14 /* Tamaño de la pantalla del juego*/
#define MAXCOL 20
#define SCCOL -16 /*Posición relativa en la pantalla del juego monitor grande*/
#define SCROW -16
int gril[22][16]; /* Coordenadas de la pantalla del juego*/
int col=1, row=7 /* Coordenadas horizontales y verticales del bloque actual*/
int boxfx=0, boxgs=0; /* La forma y dirección del bloque actual*/
int nextboxfx=0, nextboxgs=0, maxcol=22; dirección de un bloque*/
int minboxcolor=6, nextminboxcolor=6
int num=0 /*Puntos de juego*/
int dj=0, gamedj[10]={18, 16, 14, 12, 10, 8, 6, 4, 2, 1} /* Nivel de juego*/
/* A continuación utilizo una matriz 3D para registrar la forma inicial y la dirección del cuadro*/
int boxstr[7][4][16]={{
{1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0},
{0,1,0,0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
{1, 1, 0, 0, 0, 1, 1, 0, 0 ,0,0,0,0,0,0,0},
{0,1,0,0,1,1,0,0,1,0,0,0,0, 0, 0, 0}},
{
{0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0}, p>
{0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{1 , 0 , 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0}},
{
{1 , 1 ,0,0,0,1,0,0,0,1,0,0,0,0,0,0},
{1,1,1,0,1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{1, 0, 0, 0, 1, 0, 0, 0, 1, 1 , 0 ,0,0,0,0,0},
{0,0,1,0,1,1,1,0,0,0,0,0,0,0, 0, 0}},
{
{1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
{1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0,1,0,0,0,1,0,0,1,1,0,0,0,0,0,0},
{1,1,1 ,0 ,0,0,1,0,0,0,0,0,0,0,0,0,0}},
{
{0,1,0 ,0 ,0,1,0,0,0,1,0,0,0,1,0,0},
{0,0,0,0,1,1,1, 1, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0 , 0 ,1,0,0},
{0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0} },
{
{1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0.0, 0, 0, 0},
{1,1,0,0,1,1,0,0,0,0,0,0.0,0,0,0},
{1,1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0.0, 0, 0, 0},
{1, 1, 0, 0, 1, 1, 0, 0 , 0 ,0,0,0.0,0,0,0}},
{
{0,0,0,0,1,1,1,0,0 ,1 ,0,0,0,0,0,0},
{1,0,0,0,1,1,0,0,1,0,0,0,0, 0, 0, 0},
{0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0.0, 0, 0, 0},
{0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0}}
}
/* Obtener aleatoriamente el bloque actual y el siguiente bloque
La forma y dirección del cuadro*/
void boxrad()
{
minboxcolor=nextminboxcolor
boxgs=nextboxgs;
p>
boxfx=nextboxfx;
srand(tiempo(0));
nextminboxcolor=rand()14 1;
if(nextminboxcolor= =1||nextminboxcolor==7||nextminboxcolor==8)
nextminboxcolor=14
nextboxfx=F_DONG
nextboxgs=rand()7;
}
/*Inicializar maqueta de gráficos*/
void init(int gdrive, int gmode) {
int errorcode;
initgraph(amp; gdrive, amp; gmode, "..\\bgi"); p>
código de error =graphresult();
if(código de error!=grOk){
printf("error de: s", grapherrormsg(código de error)
salir (1);
}
}
void f24(int x, int y)
{
static int bandera=0;
int i, j, m, k
int n
int a[2; ][66]={ {0x00, 0x00, 0x00, 0x00, 0x30, 0x00,
0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30,
0x00 , 0x00, 0x30, 0xF0 , 0x04, 0x30, 0x78, 0x0C,
0x30, 0x18, 0x0C, 0x31, 0x00, 0x0C, 0x31, 0x80,
0x0C, 0x33, 0x80 , 0x0C, 0x13, 0x00 , 0x08, 0x07,
0x00, 0x00, 0x06, 0x00, 0x00, 0x0C, 0x00, 0x00,
0x18, 0x00, 0x00, 0x38, 0x00 , 0x00, 0x60, 0x00 ,
0x01, 0xC0, 0x00, 0x03, 0x80, 0x00, 0x0E, 0x00,
0x00, 0x38, 0x00, 0x00},
{0x01, 0x80, 0x00, 0x03, 0x80, 0x00,
0x07, 0x06, 0x00, 0x2E, 0x1F, 0x00, 0x38, 0x76,
0x00, 0x33, 0x66, 0x1E, 0x13, 0x7F, 0xFE, 0x13,
0x76, 0xC6, 0x13, 0x64, 0xC6, 0x13, 0x7C, 0x86,
0x17, 0x60, 0xBC, 0x3F, 0x6C, 0x9C, 0x33, 0x6E,
0x8C, 0x32, 0x7E, 0x
80, 0x06, 0xF0, 0x80, 0x06,
0x60, 0x80, 0x0C, 0x00, 0x80, 0x0C, 0x00, 0x80,
0x18, 0x00, 0x80, 0x10, 0x00, 0x80, 0x00, 0x00,
0x80, 0x00, 0x00, 0x80} };
bandera=(bandera)2;
for(i=0; ilt; 66; i =3)
para(k=i;klt;i 3;k)
para(j=0;jlt;8;j)
{
n=pow(2,7-j);
m=a[bandera][k]/n;
a [bandera][k]=a[bandera][k]n;
if(mamp;amp;(j (k-i)*8)!=24amp;amp;(j (k-i)*8 )!=23amp;amp;(j (k-i)*8)!=0)
putpixel(x j (k-i)*8, y i/3, 1);
}
}
/* Borrar pantalla en modo gráfico*/
void cls()
{
setfillstyle(SOLID_FILL, 0);
setcolor(0);
bar(0, 0, 640, 480); p>/*Borrado de pantalla avanzado en modo gráficos*/
void clscr(int a, int b, int c, int d, int color){
setfillstyle (SOLID_FILL, color
setcolor(color);
bar(a, b, c, d
}
/*Dibujo); del cuadrado más pequeño*/
void minbox(int asc, int bsc, int color, int bdcolor){
int a=0, b=0
p>
a=SCCOL asc;
b=SCROW bsc;
clscr(a 1, b 1, a-1 MINBOXSIZE, b-1 MINBOXSIZE , color);
if(color!=BGCOLOR){
f24(a, b 1
setcolor(bdcolor
);línea (a 1, b 1, a-1 MINBOXSIZE, b 1
línea(a 1, b 1, a 1, b-1 MINBOXSIZE
line(a 1, b-1 MINBOXSIZE, a-1 MINBOXSIZE, b-1 MINBOXSIZE);
}
}
/*Texto que aparece en el juego*/
void txt(int a, int b, char *txt, fuente int, color int){
establecer color
(color);
settextstyle(0, 0, fuente);
outtextxy(a, b, txt); >/*dibujo de Windows*/
void win(int a, int b, int c, int d, int bgcolor, int bordercolor){
clscr(a, b, c , d, bgcolor);
setcolor(bordercolor);
línea(a, b, c, b
línea(a, b, a); , d);
línea(a, d, c, d);
línea(c, b, c, d
}
p>
/* Dibujo del bloque actual*/
void funbox(int a, int b, int color, int bdcolor){
int i, j
p>
int boxz[4][4]
for(i=0;ilt;16;i)
boxz[i/4][i4]= boxstr[boxgs][boxfx][i]
for(i=0;ilt;4;i)
for(j=0;jlt;4;j)
if(boxz[i][j]==1)
minbox((j fila a)*MINBOXSIZE, ( i col b)*MINBOXSIZE, color, bdcolor);
}
/*Dibujo del siguiente bloque*/
void nextfunbox(int a , int b, int color, int bdcolor){
int i, j
int boxz[4][4]; 0;ilt;16;i)
boxz[i/4][i4]=boxstr[nextboxgs][nextboxfx][i];
clscr((a-1) *MINBOXSIZE, (b-1)*MINBOXSIZE, (3 a) *MINBOXSIZE, (4 b) *MINBOXSIZE, 2
for(i=0;ilt;4;i)
for(j=0;jlt;4;j )
if(boxz[i][j]==1)
minbox((j a)*MINBOXSIZE , (i b)*MINBOXSIZE, color, bdcolor);
}
/*Definición de interrupción de tiempo*/
#define TIMER 0x1c
int TimerCounter=0;
interrupción nula ( *oldhandler)(__CPPARGS);
interrupción nula newhandler(__CPPARGS){
TimerCounter; >
oldhandler();
}
void SetTimer(interrupción nula (*IntProc)(__CPPARGS)){
oldhandler=
getvect(TIMER);
disable();
setvect(TIMER, IntProc);
enable(); /p>
/*Debido a las reglas del juego, eliminar una fila con el cuadrado más pequeño*/
void delcol(int a){
int i, j
for(i=a;igt;1;i--)
for(j=1;jlt;15;j){
minbox (j *MINBOXSIZE, i*MINBOXSIZE, BGCOLOR, BGCOLOR)
gril[i][j]=gril[i-1][j]; i] [j]==1)
minbox(j*MINBOXSIZE, i*MINBOXSIZE, minboxcolor, 0
}
}
/*Eliminar todas las líneas con el cuadrado más pequeño*/
void delete(){
int i, j, zero, delgx=0; p>char *nm="00000";
for(i=1;ilt;21;i){
cero=0; j=1;jlt;15;j)
if(gril[i][j]==0)
cero=1
if( cero==0){
delcol(i);
delgx
}
}
num=num delgx*delgx*10;
dj=num/10000;
sprintf(nm, "d", num); , 173, 500, 200, 2);
txt(456, 173, "Puntuación: ", 1, 4);
txt(456, 193, nm, 1, 4);
}
/*La interrupción de tiempo finaliza*/
void KillTimer(){
disable(); p>
disable();
void KillTimer(){
disable();
p>
setvect(TIMER, controlador antiguo) ;
enable();
}
/* Pruebe si el bloque actual puede caer hacia abajo*/
int downok() {
int i, j, k=1, a[4][4]
for(i=0; ilt; 16; i)
>a[i/4][i4]=boxstr[boxgs][boxfx][i];
for(i=0;ilt;4;i )
for( j=0;jlt;4;j)
if(a[i][j] amp; amp; gril[col i 1][fila j] )
k= 0;
return(k);
}
/* Prueba si el bloque actual puede moverse hacia la izquierda* /
int leftok (){
int i, j, k=1, a[4][4]
for(i=0; ilt;16;i)
;a[i/4][i4]=
boxstr[boxgs][boxfx][i];
for(i=0;ilt;4;i)
for(j=0;jlt;4;j)
if(a[i][j] amp; amp; gril[col i][fila j-1])
k=0
return; (k);
}
/* Pruebe si el bloque actual puede moverse hacia la derecha*/
int rightok(){
int i, j, k=1, a[4][4];
for(i=0; ilt; 16; i)
a[i/4 ][ i4]=boxstr[boxgs][boxfx][i];
for(i=0;ilt;4;i)
for(j=0;jlt; 4; j )
if(a[i][j] amp; amp; gril[col i][fila j 1])
k=0;
return(k);
}
/* Pruebe si el bloque actual se puede deformar*/
int upok(){
int i, j, k=1, a[4][4];
for(i=0;ilt;4;i)
for(i =0;ilt ;16;i)
a[i/4][i4]=boxstr[boxgs][boxfx 1][i]
for(i=3 ;igt;= 0; i--)
for(j=3;jgt;=0;j--)
if(a[i][j] amp; amp; gril[ col i][fila j])
k=0
return(k); /*Bloque actual Después de caer, marque las coordenadas de la pantalla */
void setgril(){
int i, j, a[4][4]; p>funbox (0, 0, minboxcolor, 0);
for(i=0;ilt;16;i)
a[i/4][i4]=boxstr [boxgs] [boxfx][i];
for(i=0;ilt;4;i)
for(j=0;jlt;4;j)
if(a[i][j])
gril[col i][fila j]=1
col=1; /p>
}
/*Juego terminado*/
void gameover(){
int i, j
for(j=1;jlt;15;j )
minbox(j*MINBOXSIZE, i*MINBOXSIZE , 2, 0);
txt(56, 206, "Juego terminado", 4, 0);
txt(53, 203, "Juego terminado", 4, 4); );
}
/*Configuración de teclas*/
void call_key(int keyx){
switch(keyx){
caso VK_DOWN: { /
*Tecla de flecha hacia abajo, agrega uno a la abscisa.
*/
if(downok()){
col
funbox(0, 0, minboxcolor, 0);}
else{
funbox(0, 0, minboxcolor, 0);
setgril();
nextfunbox(NEXTCOL, NEXTROW, 4, 4);
boxrad();
nextfunbox(NEXTCOL, NEXTROW, nextminboxcolor, 0);
eliminar()
}
p>
p>
break;
}
case VK_UP: { /*Tecla de dirección hacia arriba, gira la forma de dirección 90 grados*/
if(upok( ))
boxfx;
if(boxfxgt; 3)
boxfx=0
funbox( 0, 0, minboxcolor, 0);
break;
}
case VK_LEFT: { /*Tecla de dirección izquierda, ordenada menos uno*/
if(leftok())
fila--;
funbox(0, 0, minboxcolor, 0); /p>
}
case VK_RIGHT: { /*tecla de dirección derecha, coordenada vertical más uno*/
if(rightok())
fila;
funbox(0, 0, minboxcolor, 0);
break
}
case VK_SPACE: /*Espacio; barra, cae directamente a Finalmente, se establecen los que pueden caer */
while(downok())
col
funbox(0, 0; , minboxcolor, 0);
setgril();
nextfunbox(NEXTCOL, NEXTROW, 4, 4)
boxrad();
nextfunbox(NEXTCOL, NEXTROW, nextminboxcolor, 0);
eliminar();
romper
predeterminado:
{
txt(423, 53, "¡Clave incorrecta!", 1, 4
txt(428, 80, "¡Ingrese cualquier clave AG!", 1, 4);
getch();
clscr(420, 50, 622, 97, 2); /p>
}
/*Inicio de interrupción de tiempo*/
void timezd(void){
int key; >SetTimer(newhandler);
boxrad();
nextfunbox(NEXTCOL, NEXTROW, nextminboxcolor,
for(;;){
si( bioskey(1)){
clave=bios
clave(0);
funbox(0, 0, BGCOLOR, BGCOLOR);
if(clave==VK_ESC)
romper;
call_key(clave);
}
if(TimerCountergt;gamedj[dj]){
TimerCounter=0; >if(downok()){
funbox(0, 0, BGCOLOR, BGCOLOR); 0);
}
else {
if(col==1){
juego();
getch();
romper
}
setgril();
eliminar();
funbox(0, 0, minboxcolor, 0);
col=1; fila=7
funbox(0, 0, BGCOLOR, BGCOLOR); >
nextfunbox(NEXTCOL, NEXTROW, 4, 4);
boxrad();
nextfunbox(NEXTCOL, NEXTROW, nextminboxcolor,
}
}
}
/*Se inicia el programa principal*/
void main( vacío){
int i, j
char *nm="00000";
init(VGA, VGAHI
/*Inicialización de coordenadas de pantalla*/
for(i=0; ilt; =MAXCOL 1; i)
for(j =0;jlt;=MAXROW 1;j)
gril[i][j]=0
for(i=0;ilt;=MAXCOL 1;i) {
gril[i][0]=1
gril[i][15]=1
}
para; (j=1;jlt;=MAXROW;j){
gril[0][j]=1
gril[21][j]=1; >
}
clscr(0, 0, 640, 480, 15
ganar(1, 1, 639, 479, 2, 15); >
win(SCCOL MINBOXSIZE-2, SCROW MINBOXSIZE-2, SCCOL 15*MINBOXSIZE 2, SCROW 21*MINBOXSIZE 2, BGCOLOR,
srand(time(0)); p>
nextboxgs=rand()7;
nextboxfx=rand()4;
sprintf(nm, "d", num);
txt(456, 173, "Puntuación: ", 1, 4
txt(456, 193, nm, 1, 4); 243, "
Cuadro siguiente: ", 1, 4);
timezd();
KillTimer();
closegraph();
}