Foro de fuente Tc
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á en pantalla completa. Aún puedes hacer dibujos. 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\large box...MAX_X, Y es el área visible*/
/*Dije que necesitamos colocar dos "guardias" afuera*/
int curbox[5][5] /*El cuadro que falta actualmente*; /
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 los cuadros correspondientes* /*...:) * /
Int box[MAX_C][5][5] = {/*MAX_C(7) cuadro 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}
},
p>
{
{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*/
Timer tDown/*The el intervalo de tiempo de descenso normal será mayor*/
Temporizador tFast/*Usar descenso rápido cuando se presiona KEY_DOWN*/
int speed = 13 /*Controlar el intervalo de tiempo de descenso*; /
#Define fast_INTV 1 /*Intervalo de reloj rápido*/
Int GetTickCount() {/*Leer reloj BIOS*/
int ret
ret = peek(0x0, 0x46e); /*El contenido de la memoria en realidad se lee en 0:046e*/
ret lt lt= 8 /*Este lugar es $ # $ $; ; ^*/
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->;
t->; intervel = intv
t->; última vez = GetTickCount() /*lasttime registra la última vez*/
/* Qué /*tickcount devuelve*/
/*Entonces, cuando se vuelve a probar el tiempo, se genera un nuevo tickcount.
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->; intervel); ) {
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; x ) {
if(map[y][x]) {
rectangle(x * LEN STARTX,
y * LEN STARTY,
x * LEN STARTX LEN,
y * LEN STARTY LEN);
bar( x * LEN STARTX 1,
y * LEN STARTY 1,
x * LEN STARTX LEN - 2,
y * LEN STARTY LEN-2);
}
}
}
/*No introduzcas la operación de dibujo demasiado complicada, solo para escribir*/
/*En el párrafo anterior, el mapa se refleja en la matriz de puntos según el local. mapa en la pantalla*/
for(y = 0; y lt5; Y ) {/*Dibuja un cuerpo que cae*/
for(x = 0; x lt5; x) {
if(curbox[y][x]) {
if(y cury gt; 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 STARTX 1,
(y cury) * LEN STARTY 1,
(x curx) * LEN STARTX LEN - 2,
(y cury)* LEN STARTY LEN-2);
}
}
}
}
/*Dibuje el cuadro desplegable en el área correspondiente de acuerdo con las coordenadas del cuadro desplegable en el mapa* /
for(y = 0; y lt5; Y ) {/*Dibujar a continuación*/
for(x = 0; x lt5; x) {
if(nextbox[y][x]) {
rectangle(x * LEN 320,
y * LEN 10,
x * LEN 338,
y * LEN 28);
barra( x * LEN 321,
y * LEN 11,
x * LEN 336,
y * LEN 26);
}
}
}
/* Esto Se dibujará una vista previa del siguiente cuadro*/
setvisual page(c página) /*Asegúrese de que esté dibujado en la página*/
/*Mostrarlo* /
}
/********************************* ******* ****************\
*Parte de inicialización*
\******** ******** ****************************************/
/*Se proporcionó newGame() para inicializar el nuevo juego*/
Void initMap(void) {/*Inicializar el mapa*/
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 | | x gtMAX _ X-3 | | y gt; MAX_Y - 3)
mapa[y][x]= 1;
else map [y][x]= 0;
}
}/*Esta forma se inicializa aquí*/
}/*Sin portada, por supuesto.. .*/
Void newGame() {/*Crear un nuevo juego*/
int x, y;
init map();/*Inicializar mapeo */
srand(GetTickCount()); /*Inicializar el generador aleatorio*/
rebidnext(); el siguiente*/
setTimer (&tDown, speed, 1 /*Iniciar reloj (rápido y lento)*/
setTimer(amp;tFast, FAST_INTV, 1);
new fall( ); /* Operar el cuadro desplegable*/
/*Para que el primer bloque que cae esté listo en la parte superior del mapa*/
}
/************************************************ * ****\
*Funciones principales*
\*************************** **** *******************************/
anular cuadro de rotación(int box 1[5][5] , int box2[5][5]) {
/*Rotar box1 y enviar a box2*/
int x, y;
for(x = 0; x lt5;
caja 2[y][x]= caja 1[x][4-y];
}
Void rebuidNext() {/* *Crea la siguiente forma y colócala en el cuadro siguiente */
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]= cuadro[I][y][x];/*Copiar*/
}
Int drop () {/*Seguimiento, retorno exitoso o fallido */
int newy/*la nueva posición donde se colocará la caja*/
newy = cury 1; la posición Y actual 1*/
if(test(curx, newy, curbox)) {
cury = newy/*El cuadro de prueba está en esta posición*/
Return 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 para raíz */
for(x = 0; x lt5; /p>
map[y cury][x curx]= curbox[y][x];
}
Void clear() {/*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 /*Asumir completo*/
for(x = 2; x ltMAX _ X-2; 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];
for(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;
/* Al igual que soltar, prepara las coordenadas movidas*/
else newx = curx-1;
If(test(newx, cury, curbox)) {/*Prueba si hay un conflicto */
curx = newx/*switch curx*/
Return 1;
}
Devuelve 0;
}
int test(int mx, int my, int box[5][5]) {
/*Prueba si la caja puede aterrizar en mx, estoy en el mapa La posición en */*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;
for (y = 0;y lt5;y)
for(x = 0 ;x lt5;x)
if(mapa[y my][x MX] amp; amp cuadro cuadrado[y][x])
devuelve 0;
devuelve 1;
}
int rotar() {
p>
int x,y;
int newbox[5][5]; /*Tenemos que rotar el cuadro actual al nuevo cuadro*/
/*Prueba nuevamente Conflictos con este nuevo cuadro*/
rotateBox (curbox, new box); /*Ir a nuevo cuadro*/
if(test(curx, cury, newbox)) {
/*Y se puede colocar el nuevo marco. 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, devolver 0;
}
Int nueva caída()
{/*No se puede crear un elemento descendente. 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*/
Volver a la prueba ( curx, cury, curbox);
}
/*************************** ** *********************************\
*Funciones principales: todo el juego estructura*
\****************************************** ****** *******************/
int main() {
char key /*Registrar el clave actual*/
int I;
int gd = VGA, gm = VGAMED/*Inicializar modo de gráficos*/
Temporizador *ptDown/*Reloj abajo (rápido o lento)*/
Temporizador de tendencia /*Para evitar que el renderizado suponga demasiada carga para el programa*/
/*Utilice el reloj para controlar la velocidad de renderizado* /*Establecer en intervalo = 1,*/* Entonces es 18 FPS, por supuesto no hasta los 60 FPS estándar... Después de todo, es DOS...*/
setTimer(amp; trender, 1, 1);
init graph(amp; gd, ampgm, ""; /*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 (clave){ /*Juzga la clave de lectura*/
Caso index_UP:
rotate();/*, rotar cuadro desplegable*/
Romper;
Caso clave point_down:
p>ptDown = amptFast/*use tFast clock*/
break;
case keyword_left:
move(0);/ *Mover a la izquierda*/
Romper;
Case keyword_right:
Mover(1);/*Mover a la derecha */
Pausa;
Case key_ESC:
closegraph(); /*Fin del juego*/
Salir(0);
Valor predeterminado:
ptDown = amptDown/*Usar velocidad original*/
}
If(testTimer(ptDown)) { /*Ya se ha establecido su paradero.
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(amp;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