Código fuente de TV Box 4.5
renderizado vacío (void) /*Función de dibujo única*/
/*Tenga en cuenta que esta función Vuelve a dibujar todo el mapa, de acuerdo con las coordenadas medias de la cuadrícula y el cuadro pequeño en el mapa, dibuja el cuadro pequeño en la posición apropiada*/
/*Por supuesto/*Los gráficos de DOS son muy bajos, pero aquí está el dibujo en pantalla completa. Todavía está bien. Utilizo un buffer doble para intercambiar los dibujos, me hace sentir mejor*/
void init map(void /*Inicializar el mapa (cuadro grande)*/
/ * Como se mencionó anteriormente, hay un círculo de 1 en esta matriz bidimensional para evitar que el cuadro pequeño se salga de los límites, y esta es la función que genera el círculo*/
void new game( ); /*Crear un nuevo juego*/
/*Esta función inicializa uno o más relojes y construye el primer cuadro desplegable. Por supuesto, una vez completada la construcción, vista previa*/
void rotateBox(int box 1[5][5], int box 2[5][5]);
/* Miembros de la función principal, gire el cuadro1 90 grados en el sentido contrario a las agujas del reloj y guárdelo en el cuadro2 */
void rebidnext();
/*Miembros de la función principal, genere el siguiente cuadro */
int drop();
/*Miembro de la función principal, mueve el cuadro desplegable hacia abajo (en realidad aumenta el valor Y del cuadro desplegable). Por supuesto, es necesario determinar si se superpone con la cuadrícula del mapa y el mapa. La operación de colocación no se puede completar y devuelve 0*/
void putBox();
/. *Además de esto, suelte el cuadro y el mapa son dos dimensiones independientes. */*Cuando la caída falla, la pequeña caja volverá a la cima y caerá nuevamente. Cuando esto suceda, el contenido original de la caja se convertirá, por supuesto, en el contenido del mapa. putBox es escribir el contenido del cuadro que cae en el mapa según XY */
void clear();
/*Esta función se ejecuta después de que falla la caída y putBox, y escanea todo el mapa *//*Y elimina toda la fila de la matriz de puntos. Los detalles específicos se describen en la función */
int move(int dir);
/*Mover el cuadro desplegable hacia la izquierda o hacia la derecha, dir significa izquierda o derecha, el igual que drop*/
int test(int mx, int my, int box[5][5]);
/*Esto es para determinar si el cuadro es consistente con el mapa en MX y mis coordenadas Puntos clave donde se superponen cuadrículas no vacías. Esta es una función muy común */
int rotate();
/* Gira el cuadro desplegable. Por supuesto, si la rotación entra en conflicto con el mapa, la rotación se cancelará y se devolverá 0, pero el valor de retorno parece inútil ~ */
int new fall();
/*Crea un elemento que cae, copia el contenido de la vista previa "siguiente" en el cuadro desplegable */* y mueve el cuadro desplegable a la parte superior del mapa.
Por supuesto, durante este proceso, si hay un conflicto en la parte superior, devolverá 0, lo que significa que está lleno... gameOver*/
int main();
/* Finalmente llega a la función principal, donde puedes ver toda la estructura del estante del juego*/
/*, incluido el bucle principal del juego, el procesamiento del teclado, etc...*/
/*** ********************************************** ******* *\
*Área variable*
\************************ ******** *******************************/
/*En el explicación anterior, es posible que algunas se ignoren porque es posible que no conozca las variables reales utilizadas*/
int map[MAX_Y+4][MAX_X+4];/*Map\big box...MAX_X, Y es el área visible*/
/*Dije que necesitamos colocar dos "guardias" afuera*/
int curbox[5][5] /*El que falta actualmente. box*/
int curx, cury/*Guardar la posición del cuadro activo actual en el mapa*/
int next box[5][5] /*El cuadro que contiene la siguiente forma*/
/*Estos son solo algunos cuadros y coordenadas*/
/*Hay siete cuadrículas gráficas estándar de Tetris, que se copiarán en la correspondiente boxes*/*...: ) */
Int box[MAX_C][5][5] = {/*MAX_C(7) box predefinido*/
{
{ 0,0,0,0,0},
{0,0,0,0,0},
{1,1,1 ,1,0},
{0,0,0,0,0},
{0,0,0,0,0}
},
{
{0,0,0,0,0},
{0,0,1,0,0},
{0 ,1,1,1,0},
{0,0,0,0,0},
{0,0,0, 0,0}
},
{
{0,0,0,0,0},
{0, 1,1,0,0 },
{0,0,1,1,0},
{0,0,0,0,0},
{0, 0,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,0, 0,0},
{0,1,1,0,0},
{0,0,1,0,0},
{0,0,1,0,0},
{0,0,0,0,0}
},
{
{0,0,0,0,0},
{0,0,1,1,0},
{ 0,0,1,0 ,0},
{0,0,1,0,0},
{0,0,0,0,0}
},
{
{0,0,0,0,0},
{0,0,1,1, 0},
{0,0,1,1,0},
{0,0,0,0,0},
{0 ,0,0,0, 0}
}
};
/****************** ************** *******************************\
*Reloj*
\ ***********
**************************************/
/* La parte del reloj también es fácil de entender, una se usa para configurar el reloj y la otra se usa para probar el estado de activación del reloj*/
Temporizador tDown/*El intervalo normal del reloj de inactividad será mayor */
Temporizador tFast/*Usar descenso rápido cuando se presiona KEY_DOWN*/
int speed = 13 /*Controlar el intervalo de tiempo de descenso*/
#Definir fast_ INTV 1 /*Intervalo de reloj rápido*/
Int GetTickCount() {/*Leer reloj del BIOS*/
int ret
ret = peek ( 0x0, 0x46e);/*Realmente lee el contenido de la memoria en 0:046e*/
ret & lt& lt= 8;/*Este lugar es $ % # $ $ % & ^*/< / p>
ret += peek(0x0, 0x 46c); /*Hay tantas cosas nuevas, busca algunos libros para leer*/
Return (ret);
}
int setTimer(Timer *t, unsigned int intv, BOOL en) {
t->; habilitado = en/*Establecer reloj*/
t->; intervel = intv
t->; última vez = GetTickCount(); /*lasttime registra el último */
/* Qué /*tickcount devuelve */
/*Entonces, cuando el tiempo se prueba nuevamente, se genera un nuevo recuento de ticks.
Restar el último tickcount da un intervalo de tiempo que se puede comparar con el intervalo para determinar si está activado*/
Devuelve 0;
}
Boolstesttimer (temporizador * t) {/*Explicación de las seis líneas anteriores:)*/
Unsigned int tmp, dt;
Si (! (t->; habilitado)) devuelve FALSO
tmp = GetTickCount();
dt = tmp-(t-& gt; última vez
if(dt & gt; = t- >); intervalo) {
t->lasttime = tmp
Devolver VERDADERO
}
Devolver FALSO
}
representación vacía (void) {
int x, y;
static int c page = 0 /*Página actual, use */
#define STARTX 50 /*Define varias constantes*/
#Define STARTY 0
#Define lente 18
setactivepage( cPage=(cPage == 0? 1:0));/*Seleccionar página*/
borrar dispositivo();/*Borrar pantalla*/
establecer color(15);
Rectángulo (STARTX + LEN * 2 - 2,
STARTY + LEN * 3 - 2
STARTX + LEN * (MAX_X - 2) + 2 ,
STARTY+LEN *(MAX _ Y-2)+2);
/*Dibuja el contorno en blanco*/
setfillstyle(SOLID_FILL, 5);
for(y = 3; y & ltMAX _ Y-2; Y++) {/*Dibujar un mapa*/
for(x = 2; x & ltMAX _ X-2 ; + INICIO,
x * LEN + STARTX + LEN,
y * LEN+INICIO+LEN);
bar( x * LEN + INICIOX + 1 ,
y * LEN + INICIO + 1,
x * LARGO + INICIOX + LEN - 2,
y * LARGO+INICIO+LEN-2 ) ;
}
}
}
/*No compliques demasiado la operación de dibujo, solo para escribir*/
/*En el párrafo anterior, el mapa se refleja en la pantalla de acuerdo con el entramado del mapa local*/
for(y = 0; y & lt5;Y++) {/* Dibujar objetos que caen*/
for(x = 0; x & lt5;x++) {
if(curbox[y][x]) {
if (y+cury>2) {
Rectángulo ((x + curx) * LEN + STARTX,
(y + cury) * LEN + STARTY,
(x + curx) * LEN + STARTX + LEN,
(y+cury)* LEN+STARTY+LEN);
bar((x+curx) )* LEN+INICIOX+1，
(y + c
ury) * LEN + STARTY + 1,
(x + curx) * LEN + STARTX + LEN - 2,
(y+cury)* LEN+STARTY+LEN-2 );
}
}
}
}
/*Según el cuadro desplegable en el map Coordenadas, dibuja el cuadro desplegable en el área correspondiente*/
for(y = 0; y & lt5;Y++) {/*Dibuja el siguiente*/
for( x = 0; x <5; * LARGO + 10,
x * LARGO + 338,
y * LARGO + 28; LARGO + 321,
y * LARGO + 11,
x * LARGO + 336,
y * LARGO + 26
}
}
/*Esto generará una vista previa del siguiente cuadro*/
setvisual page(c página );/*Asegúrate de estar en la página Sorteo*/
/*Muéstralo*/
}
/******* *********** **********************************\
*Parte de inicialización*
\************************************ ************ **********/
/*Proporciona newGame() para inicializar un nuevo juego*/
Void initMap(void) {/*Inicializar mapeo*/
int x, y /*Necesitamos un círculo de guardias...*/
for(y = 0 ; y & ltMAX _ Y; y++) {
for(x = 0; x & ltMAX _ X; x++) {
if(x & lt; 2 | |
mapa[y][x]= 1;
si no mapa[y][x]=
}
}/ *Esta forma se inicializa aquí*/
}/*Por supuesto que no hay cobertura...*/
Void newGame() {/*Crea un nuevo juego*/< / p>
int x, y;
init map(); /*Inicializar mapa*/
srand(GetTickCount()); /*Inicializar generador aleatorio*/
rebidnext(); /*Crear siguiente*/
setTimer(& tDown, speed, 1 /*Iniciar reloj (rápido y lento)*/
<); p>setTimer(& tFast, FAST_INTV, 1);new fall(); /*Operar el cuadro de caída*/
/*Entonces el primero Los bloques que caen están listos en la parte superior del mapa*/
}
/************************ *** ******************************\
*Funciones principales*
\ ********************************************** ** ****/
cuadro de rotación nulo(int box 1[5][5], int box2[5][5]
]) {
/*Rotar cuadro1 y salida a cuadro2*/
int x, y;
for(x = 0; x & lt5;X++ ) /*Esta función puede requerir real*/
for(y = 4;y & gt= 0;Y-)/*Escríbalo para impresionar*/
cuadro 2 [ y][x]= box 1[x][4-y];
}
Void rebuidNext() {/* *Crea la siguiente forma y colócala en el siguiente cuadro */
int i, x, y;
I = random(MAX_C);/*Elige uno de varios cuadrados*/
for(y = 0; y & lt5;Y++) /*y cópialo*/
for(x = 0;x & lt5;x++)
siguiente cuadro[y] [x]= box[I][y][x];/*Copiar*/
}
Int drop() {/*Seguimiento, devolución exitosa o fallida*/
int newy/*La nueva posición donde se colocará el cuadro*/
newy = cury+1 /*es la posición Y actual+1*/
if (test(curx, newy, curbox)) {
cury = newy/*El cuadro de prueba está en esta posición*/
Retorno 1 /*¿Hay algún conflicto? Si no, */
}/*Establecer cury directamente */*/
Devuelve 0;
}
Void putBox( ) {/*Rellena el cuadro delimitador en el mapa*/
int x, y;
for(y = 0; y & lt5;Y++) /*Esto también es simple , principalmente es para root */
for(x = 0; x & lt5;X++) /*según curx, cury representa la posición*/
if(curbox[ y][x] )
map[y+cury][x+curx]= curbox[y][x];
}
Vacío claro () {/* Borrar toda la línea*/
/*Esta función es realmente muy ineficiente, para decirlo simplemente.
Probado de principio a fin*/
/*El algoritmo específico es: desde la fila 0 hasta la última fila, pruebe si la cuadrícula del mapa está llena. comience desde la fila actual. El mapa de arriba elimina una línea */
int x, y
int dx, dy
int complete flag; /p>
for (y = 0; y & ltMAX _ Y-2; Y++) {/*Las dos últimas filas están reservadas*/
Indicador completo = 1 /*Se supone completo*; /
for(x = 2; x & ltMAX _ X-2; p>Bandera completa = 0;
Pausa;
}
}
If(fullflag) {/*Bajar una línea* /
for(dy = y; dy & gt0;dy -)
for(dx = 2; dx & ltMAX _ X-2; dx++)
mapa[dy][dx]= mapa[dy-1][dx];
para (dx = 2; dx & ltMAX _ X-2; dx++)
map [0][dx]= 0;
/*Y borra la primera línea*/
}
}
}
Int move(int dir) {/*Devolución exitosa o fallida*/
int newx
if(dir)newx = curx+1;
/*Como soltar, preparar coordenadas en movimiento*/
si no newx = curx-1 ;
If(test(newx, cury, curbox)) { /*Prueba si hay un conflicto*/
curx = newx/*Cambiar curx*/
Devuelve 1;
}
Devuelve 0;
}
int prueba(int mx, int my, int box [5][5]) {
/*Probar si la caja puede aterrizar En mx, mi posición en el mapa*/*Esta es la función más crítica para determinar si hay un conflicto no nulo */*Pero el algoritmo sigue siendo muy simple*/
int x, y;
p>for(y = 0; y & lt5;y++)
for(x = 0; x & lt5;x++)
if(mapa[y+my ][x+MX]&& box[y][x])
Devuelve 0;
Devuelve 1;
}
int rotar() {
int x, y
<; p>int newbox[5][5]; /*Debemos rotar el cuadro actual al nuevo cuadro* //*Probar el conflicto de este nuevo cuadro nuevamente*/
rotateBox(curbox, new box); /*Ir a nuevo cuadro*/
if (test(curx, cury, newbox)) {
/*Y el nuevo cuadro puede ser colocado en el mapa sin conflicto*/
for(y = 0; y & lt5;y++ )
for(x = 0; x & lt5;x++)
curbox[y][x]= new box[y][x]; /*Copiar a*/
Devolver 1
}
De lo contrario, devuelve 0;
}
Int newfall() {/ *No se pueden crear elementos descendentes.
Return 0*/
int x, y;
curx = MAX _ X/2-2 /*Reasignar la posición del cuadro pequeño*/
for(y = 0;y & lt5;y++)
for(x = 0;x & lt5;x++)
curbox[y][x]= siguiente cuadro[y][x];/*Copiar el siguiente cuadro*/
rebidnext();/*Reconstruir nextBox*/
Regresar Prueba (curx, cury, curbox);
}
/*************************** *** *************************************\
*Principal funciones: toda la estructura del juego *
\************************************ *********** *******************/
int main() {
char key; /*Registrar la clave actual*/
int I;
int gd = VGA, gm = VGAMED/*Inicializar modo de gráficos*/
Temporizador * ptDown/*Reloj abajo (rápido o lento) */
Timer trender /*Para evitar que el renderizado suponga demasiada carga para el programa*/
/*Utilice el reloj para controlar la velocidad de renderizado*/*Establezca el intervalo = 1,* /*Entonces es 18 FPS, por supuesto no hasta los 60 FPS estándar... Después de todo, es DOS...*/
setTimer(& trender, 1, 1);
init graph(&gd,&gm,"";/*Inicializar gráfico*/
nuevo juego();/ *Nuevo juego...*/
While(1) {/*Bucle principal del juego*/
If(kbhit()) {/*Si se presiona el teclado*/
key = getch(); /* Leer el valor de la clave en key*/
}
else key = 0;
Cambiar (tecla){/*Juzga la tecla de lectura*/
Caso index_UP:
rotate() /*, gira el cuadro desplegable*/
Pausa;
Puntos clave del caso_ Abajo:
ptDown = &tFast/*use tFast clock*/
Pausa;
Caso palabra clave_izquierda:
Mover(0);/*Mover a la izquierda*/
Romper;
Caso keyword_right:
Mover(1) ;/*A la derecha Mover*/
Romper;
Case key_ESC:
closegraph() /*Finalizar juego*/
Salir( 0);
Valor predeterminado:
ptDown = & amptDown/*Usar velocidad original*/
}
If(testTimer( ptDown)) {/*El paradero se ha establecido arriba.
El reloj utilizado está en ptDown */
if (!Drop()) {/* falls, 0*/
putBox() /*; Escribe en el mapa */
clear(); /*Borrar toda la línea*/
if (!Newfall()) {/*Crea una nueva caída si falla, Se acabó el juego*/
closegraph();
Salir(0);
}
}
}
if(testTimer(&Trender)) /*Finalmente...proporcionar;dar...*/
render();
}
}.
/*Fin de este programa*/
Lo ejecuto con Turbo C porque siempre dice que tengo un error de sintaxis. Pero simplemente no sé qué pasa. Por favor ayúdenme a ejecutarlo y ayúdenme a descubrir qué está mal. ¡Estoy muy agradecida! ! ! ! Gracias