Lenguaje de programación principal ruso
/*
El primer principio de escritura:
Este código de Tetris es muy simple, 40 veces mejor que el que yo escribió el año pasado K es mucho más pequeño.
De hecho, el código central es de solo 3-4K, simple y fácil de entender, y adecuado para aquellos con una pequeña base en el lenguaje C.
Cualquier persona interesada.
Esta es sólo una explicación aproximada del algoritmo central:
Aquí, el diseño clave del juego se coloca en tres cuadros y una coordenada:
El caja grande: una matriz bidimensional que registra la apertura y el cierre de una cuadrícula cuadrada (imagine la etapa del juego)
en una matriz de puntos), también llamado mapa a continuación.
Dos cajas de 5*5: matrices bidimensionales, una que contiene el cuadrado que cae y la otra que contiene el cuadrado que cae.
El siguiente bloque que cae (es decir, el siguiente), por supuesto, estos dos también deben imaginarse como cuadrículas: como tiras largas.
La cuadrícula es:
00000
00100
00100
00100
00100
Ahora todo lo que tienes que hacer es tener este concepto: una caja pequeña que sigue cayéndose de la parte superior de la caja grande.
Los hombres descienden hasta el fondo y colocan la siguiente caja en la caja descendente antes de pasar a la siguiente ronda de descenso. ...
No te preocupes demasiado por los controles del medio.
Ahora nos enfrentamos a un problema:
¿Cómo conectar el cuadro desplegable y el mapa?
Una buena forma es definir otra coordenada: x, y, manteniendo la esquina superior izquierda del pequeño cuadro correspondiente en el mapa.
El subíndice (posición), es decir, cuando x = 0, y = 0, el cuadro pequeño está en la esquina superior izquierda del mapa. Entonces, cuando
Cuando es necesario mover el cuadro pequeño, solo es necesario cambiar los valores de xey.
Ahora hablemos de efectos.
El cuadro pequeño contiene la cuadrícula de la forma descendente actual, por lo que la rotación solo requiere rotar esta cuadrícula.
Girar 90 grados: por ejemplo:
00000 00000
00100 00000
00100->01111
00100 00000
00100 00000
Esto no es demasiado difícil de lograr.
Determinación de colisión
Normalmente esto ocurre sólo cuando hay cajas en movimiento o cajas giratorias: es decir, la red no está vacía.
Es mutuamente excluyente. Cuando el cuadro pequeño se mueve hacia abajo (x++), si la cuadrícula en el cuadro pequeño se superpone con la cuadrícula en el mapa (no
lugar vacío), no puede. moverse hacia abajo (atascado), la forma transformada choca con el mapa al girar.
De repente se abandonó el giro.
Aquí debes tener una comprensión general. En cuanto a cómo dibujarlo en la pantalla, esto
Esto es relativamente simple. El siguiente código se lo explicará lentamente.
*/
/*
Plataforma: DOS+TC2.0
*/
# incluir & ltstdio.h & gt
# include & ltstdlib.h & gt
# include & ltbios.h & gt/*Aquí, debe leer el tiempo de ejecución del sistema como tiempo Dispositivo*/
# include & ltgraphics.h & gt/*Desafortunadamente, los gráficos simples de TC2 me hicieron dejar de usarlo*/
# include & ltconio.h & gt /*win32+ openGL explica. */
#define MAX_X 14 /*Máximo visible X*/
#define MAX_Y 21 /*Máximo visible Y*/
/*Hemos definido Si tenemos los máximos X e Y visibles, ¿hay algo más?
La parte visible es en realidad la izquierda y la derecha (cuadros grandes) en el mapa
Rellena 1 en ambos lados y las dos líneas inferiores, lo que lo simplifica enormemente.
A juzgar por los forasteros, en este caso no es así.
El código se debe a que hay un círculo al lado del 1 para evitar que el cuadro pequeño se haga más grande.
Rango de punzonado de cajas
*/
#Define MAX_C 7 /*Categoría máxima, no es necesario explicar esto*/
#define KEY_UP 'w' /*Definir botones arriba, abajo, izquierda y derecha*/
#Definir tecla abajo
#define KEY_LEFT 'a '
#Define KEY_RIGHT 'd '
#define KEY_ESC 27 /* Salir */
typedef int BOOL
#define false 0
#define TRUE 1 /* No existen tales TC... defínalo usted mismo :)*/
/*Estructura de reloj*/
Estructura Typedef{/*Estructura de reloj*/
BOOL habilitado; /*Si el reloj está encendido*/
Intervalo entero sin signo; /*Intervalo de tiempo*/
Entero sin signo la última vez/*Esto es una variable interna*/
}Temporizador;
/*
*Ahora hemos entrado en la etapa inicial de programación.
*Al principio, escribiré todos los prototipos de funciones y sus funciones.
*La función principal está al final del programa, donde podrás ver la estructura organizativa de todo el juego.
*Muy bueno, sólo unas pocas docenas de líneas y fácil de entender. Por supuesto, primero echemos un vistazo al prototipo de la función.
*Y explicación
*/
/************************ ******* *******************************\
*Prototipo funcional y descripción*
\****************************************** ************ *******/
/*Las siguientes tres funciones pueden referirse a la estructura del temporizador. Después de la declaración de la función */
int GetTickCount() /*Devuelve el tiempo que tarda la computadora o el sistema operativo en ejecutarse*/
/*Windows.h ya incluido en el entorno win32 Medio, 4 bytes*/
/*En un entorno DOS (código), debe escribirlo usted mismo, utilizando el contenido de BIOS.h*/
int setTimer (Temporizador *t, unsigned int intv, BOOL en);
/*Establezca el reloj t, los parámetros son puntero del reloj, intervalo de tiempo y actividad*/
/*Intervalo de tiempo, milisegundos en win32, 1 en DOS /18 segundos (un poco bajo)*/
BOOL test Timer(Timer * t /*Prueba si el reloj t alcanza la hora programada*/
<); p>/*Por ejemplo, el siguiente código: *//*
setTimer(& amp; t, 1, 1); Establece el intervalo de 1 unidad
while(1) {
if(testTimer(&t)) printf("¡Activo!\ n ");
}
¡Activo se imprimirá en la pantalla regularmente (1 unidad)!
En términos generales, testTimer debe ejecutarse repetidamente en un bucle y devolver 1 cuando se activa.
*/
Representación vacía (void); /*Función de dibujo única*/
/*Tenga en cuenta que esta función se basa en la matriz de puntos y el
Dibuje un pequeño cuadro en el lado derecho de la coordenada central del mapa*/
/*Los gráficos de DOS son, por supuesto, muy bajos, pero aquí todavía es posible dibujar en pantalla completa. .
Sí, uso doble buffer para intercambiar dibujos, me hace sentir mejor*/
void init map(void); p>
/*Como se mencionó anteriormente, hay un círculo de 1 en esta matriz bidimensional para evitarlo.
El cuadro pequeño está fuera de límites, esta es la función*/
void new game() /*Crear un nuevo juego*/
/ *Esta función inicializa uno o más relojes y crea el primer cuadro desplegable*/
/*Por supuesto, después de la construcción, la vista previa debe generarse uno por uno*/
void rotateBox(int box 1[5][5], int box 2[5][5]);
/*Miembro de función principal, rotar box1 90 grados en sentido antihorario, guardar en box2 */
void rebidnext();
/*Miembros de la función principal, generan el siguiente cuadro*/
int drop();
/ *Miembros de la función principal, mueven el marco descendente hacia abajo (en realidad aumentan el marco descendente)
El valor y del hijo, por supuesto, debe juzgarse si se superpone con la cuadrícula de textura*/
/*Se superpone con el mapa, no puede completar la operación de colocación. Return 0*/
void putBox();
/*Además de esto, el cuadro desplegable y el mapa son dos dimensiones independientes*/
/ *Cuando la caída falla, el cuadro pequeño debe volver a la parte superior y caer nuevamente. Esto*/
/*Por supuesto, el contenido del cuadro original se convertirá en el contenido de map y putBox.
Se basa en XY */
void clear();
/*Esta función se ejecuta después de que falla la caída y putBox, y escanea todo el map*/
/*Borrar toda la fila de la grilla, los detalles están en la función*/
int move(int dir);
/ *Mueva el cuadro desplegable hacia la izquierda y hacia la derecha, dir significa hacia la izquierda o hacia la derecha, lo mismo que soltar.
Es lo mismo*/
int test(int mx, int my, int box[5][5]);
/*Esto es más importante . Se considera que el cuadro está en las coordenadas MX y My, que son las mismas que en el mapa.
Si las celdas no vacías se superponen. Una función muy común */
int rotate();
/* Gira el cuadro que cae. 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() ;
/*Cree un elemento de arrastrar y soltar y copie el contenido de la vista previa "siguiente" en el cuadro desplegable*/
/*Y mueva el cuadro desplegable al parte superior del mapa. Por supuesto, en este proceso, si el nivel superior
Si hay un conflicto entre departamentos, se devolverá 0, descripción completa... gameOver*/
int main();
/*Finalmente llega a la función principal, donde puedes ver todo el estante del juego*/
/*Estructura, incluido el bucle principal del juego, procesamiento del teclado, etc...*/
/* ******************************************* ********** ***\
*Área variable*
\***************** *********** *******************************/
/ *Puede haber cierta ignorancia en la explicación anterior, porque es posible que no se comprendan las variables reales utilizadas.
*Sí.
*/
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 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 a Phase */
/*El cuadro debería ser... :) */
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}
},
{
{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 es se utiliza para probar el estado de activación del reloj*/
Temporizador tDown/*El intervalo normal del reloj de tiempo de inactividad será mayor*/
Temporizador tFast/*Usar apagado rápido cuando se presiona KEY_DOWN*/
int speed = 13 /*Intervalo de tiempo de inactividad de control*/
#Define fast_INTV 1 /*Intervalo de reloj rápido*/
Int GetTickCount() { /*Leer el reloj del BIOS*/
int ret
r
et = peek(0x0, 0x46e);/*Realmente lee el contenido de la memoria 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->; /p >
t->; intervel = intv
t->; última vez = GetTickCount(); /*lasttime registra la última vez*/
/* ¿Qué? /*tickcount Devuelve */
/* para generar un nuevo recuento de ticks al probar la hora nuevamente.
Resta el último tickcount para obtener un tiempo.
Intervalo, puedes comparar esto con intervel para ver si está
activado
*/
Devuelve 0; >
}
Boolstesttimer (temporizador * t) {/*Explicación de las seis líneas anteriores :)*/
Unsigned int tmp, dt;
Si (!(t->enabled)) devuelve FALSO
tmp = GetTickCount();
dt = tmp-(t->última vez);
if(dt>=t->intervel) {
t->lasttime = tmp
Devuelve VERDADERO
}
Devuelve FALSO
}
/*************************** ****** *********************\
*Parte de renderizado*
\** ****** ******************************************** **/
/*Proporciona renderizado para actualizar toda la pantalla*/
/*Hay mucho que decir sobre esta función para buscar belleza y compilación*/
Flexibilidad Cuando /* esta función es bastante larga de escribir...*/
/*Ahora escribe algunos gráficos sobre este juego...Yo tampoco uso gráficos TC2.
Me encantaría. Al fin y al cabo, está anticuado, pero dada su sencillez y practicidad, todavía se utiliza para la enseñanza.
Es perfecto. Por eso siempre uso TC en la enseñanza. A los profesores no les gusta hacer estudiar a los estudiantes.
Los estudiantes hacen preguntas que les resultan difíciles de dominar...
/*Aquí uso el modo VGAMED en lugar de VGAHI porque hay dos VGAMED.
La página (puede imaginarse como un búfer) se puede utilizar para dibujar imágenes sin parpadear. Es decir, en segundo plano.
Dibuja un gráfico en la página y muéstralo cuando esté completo.
Aquí se utilizan dos funciones:
Los parámetros Setactivepage(1 | 0) solo pueden ser 1 o 0. Seleccione una página de dibujo, por ejemplo, Seleccionar.
Después de seleccionar 1, todas las acciones de dibujo futuras se dibujarán en 1 página.
Setvisualpage(1 | 0) A esto se le llama seleccionar la página visible, es decir, seleccionar en la pantalla.
Mostrar página 1 o 0
*/
renderizado vacío (void) {
int x, y;
Página estática int c = 0; /*Página actual, uso*/
#define STARTX 50 /*Definir varias constantes*/
#Define STARTY 0
#Definir lente 18
setactivepage(cPage=(cPage == 0?1:0));/*Seleccionar página*/
borrar dispositivo(); *Borrar la pantalla*/
establecer color(15);
Rectángulo (STARTX + LEN * 2 - 2,
STARTY + LEN * 3 - 2
INICIOX + LEN * (MAX_X - 2) + 2,
INICIO+LEN *(MAX _ Y-2)+2);
/* Dibuja el contorno en blanco*/
setfillstyle(SOLID_FILL, 5);
for(y = 3; y & ltMAX _ Y-2; Y++) {/*Dibuja el mapa * /
for(x = 2; x & ltMAX _ X-2; x++) {
if(map[y][x]) {
Rectángulo(x*LEN+STARTX,
y*LEN+STARTY,
x*LEN+STARTX+LEN,
y*LEN+STARTY+ LEN );
barra( 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 pantalla de acuerdo con la matriz de puntos en el mapa local*/