Código fuente de la herramienta Vertx
*Código fuente en lenguaje C del juego Lianliankan
*/# include lt; stdio.h gt
# include ltgraphics.h gt
# incluir ltstdlib.h gt
# incluir ltmath.h gt
# incluir ltdos.h gt#definir verdadero 1
# definir falso 0 /* - Variables globales.
int BkGndColor = NEGRO
int BorderColor = GRIS CLARO
int LineColor = AZUL CLARO/*Color de conexión al eliminar un par de cajas*/
/* Pb - ProgressBar */
int PbColor = VERDE CLARO
int PbY = 4
int Pb altura = 4; p>int PbValue/*El porcentaje de la barra de progreso, el valor inicial es 100.
*/
El tiempo de inicio es largo /*El tiempo de inicio en segundos, solo se calculan minutos y segundos*/
El tiempo total es largo /*El número máximo de; segundos para todo el juego* * *! ,*//* BoardDatas: tablero pequeño*/
/* Tablero[x][y][0] - 0: vacío, 1: lleno*/
/* Tablero [x][y][1] - clave de la celda */
Tablero de caracteres sin firmar[10][10][2];
int CellSize = 30
int BoardX = 20
int BoardY = 60
int ancho del tablero = 10
int alto del tablero = 10;
int BoardY = 60
int ancho del tablero = 10;
int altura del tablero = 10;
p>
int CellColor = blanco;
int SelColor = BLUE/*El color del rectángulo del borde de la celda*/
int CurColor = RED/*El color del rectángulo del borde de curCell* /
int EraColor = cyan; /*¡El color utilizado para borrar celdas! */
int PairsCount/*Cuántos pares colocamos en el tablero*/*Se utiliza para almacenar coordenadas lógicas (índice)*/
typedef estructura_marca unidad
{
char x;
char y;
} cell; cell selCell, curCell/*¡Guarda en caché la última posición seleccionada y la posición actual! *//*Definición del código de escaneo*/
Código de clave de enumeración
{
K_ESC =0x011b,
K_UP =0x4800, / *Flecha arriba*/
K_LEFT =0x4b00,
K_DOWN =0x5000,
K_RIGHT =0x4d00,
K_SPACE =0x3920,
K_P =0x1970,
K_RETURN =0x1c0d, /* Enter */
} /* -Lista de funciones*/
void init game(char * bgi path);
void play game();
void quit game();
void InitProgressBar();
p>
void UpdateProgressBar(int porcentaje);
void DrawCell(int key, int x, int y, int color);
void EraseCell(int x, int y );
void DrawBorderRect(CELL *c, int color);
void DrawGameOver(char * info);
int obtener código clave ();
int FindPath(CELL *c1, CELL * C2);
/*¡La ruta de conexión al dibujar el cuadro de eliminación! , ¡usa el color especificado! */
void DrawPath(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, int color); /* - Implementación de la función */.
* Primero determine la dirección horizontal y encuentre el rango de actividad en línea recta horizontal de los dos puntos.
*¡Calcula la * * * misma área de estos dos segmentos de recta en dirección vertical! ! ! ,
*Atraviesa el área y determina si se puede establecer una línea vertical común entre los dos segmentos de línea. Si es así, conecta los dos puntos;
*Luego se determina la dirección vertical. , similar a . Este algoritmo se puede utilizar independientemente de si los dos puntos están en línea recta, ya que dos puntos colineales son solo un caso especial de dos puntos que son puntos diagonales de un rectángulo.
*//*Se encontró la ruta entre las dos celdas y se devolvió verdadero correctamente */
int FindPath(cell *c1, cell *c2)
p>{
int i, j, path, min1, max1, min2, max2, izquierda, derecha, arriba, abajo
/* - (0) Determina si se hizo clic en la misma pieza! - */
if (Tablero[c1->x][c1->y][1]! = Tablero[c2->x][C2->y][ 1])
Devuelve falso
/* - (1) ¡Encuentra el área horizontal! - */
min 1 = max 1 = c 1->;x;
min 2 = max 2 = C2- gt;x;
mientras (min 1-1 gt;= placa amplificadora de 0 amperios[min 1-1][c 1->y][0]= = 0)min 1-;
mientras(min 2-1 gt ; = Placa amplificadora de 0 amperios[min 2-1][C2->y][0]= = 0)min 2-;
left=max(min1,min 2);/*Margen izquierdo */
mientras(max 1 1 lt; ancho y tamaño cartón. ampboard[max 1 1][c 1->;y][0]= = 0)max 1;
mientras(max 2 1 lt; ancho y tamaño del cartón.
ampboard[max 2 1][C2->y][0]= = 0)max 2;
right=min(max1, max 2); /*borde derecho*/*marque dos ¿Hay? ¿Líneas verticales comunes entre las líneas horizontales? */
/*Se puede conectar en el borde*/
if(left==0)
{
/* Conexión de borde izquierdo*/
dibujar ruta(c 1->; x, c 1->; y, -1, c 1- gt; y, -1, C2- gt; y, C2- gt; x, c2->y, color de línea);
Retraso (6000);
dibujar ruta(c 1->; x, c 1->; y, - 1, c 1- gt; y, -1, C2- gt; y, C2- gt; x, c2->y, BkGndColor); */
Devuelve verdadero
}
if(right==(BoardWidth-1))
{
dibujar ruta(c 1->x,c 1->y,ancho del tablero,c 1->y,ancho del tablero,c2->y,C2->x,c2->y,color de línea
Retraso (6000);
dibujar ruta(c 1->; x, c 1->; y, ancho del tablero, c 1->; y, ancho del tablero, c2-> y, C2- gt; x, c2->y, BkGndColor); /* ¡Tachado! */
Devuelve verdadero
} for(I =left;ilt=right;i)
{
ruta = 0; /*¡Calcule la longitud de las líneas verticales de uso común! */
for(j = min(c 1->;y,C2- gt;y) 1;j ltmax(c 1->;y,C2- gt;y);j )
{
ruta = Board[I][j][0];
si (ruta gt0) está rota;
}
Si (ruta==0)
{
dibujar ruta(c 1->x,c 1->y,I,c 1- gt ; y, I, C2- gt; y, C2- gt; x, c2->y, color de línea (6000); ->x, c 1-> y, I, c 1- gt y, I, C2- gt y, C2- gt; */
Devuelve verdadero
}
}/* - (2) ¡Encuentra el área pública * * * vertical! - */
min 1 = max 1 = c 1->;y;
min 2 = max 2 = C2- gt;y;
mientras (min 1-1 gt;= placa 0 amp[c 1->;x][min 1-1][0]= = 0)min 1-;
mientras(min 2-1 gt ;= Placa amplificadora de 0 amperios[C2->;x][min 2-1][0]= = 0)min 2-;
top=max(min1,min 2);
mientras(max 1 1 lt; altura del tablero y altura.
placa amplificadora[c 1->
ampboard[C2->; ¡Hay una conexión vertical común! */
/*Se puede conectar en el borde*/
if(top==0)
{
/* En la parte superior Eliminar */
dibujar ruta(c 1->; x, c 1->; y, c 1->; x, -1, C2- gt; x, -1, C2 - gt; x, c2->y, color de línea);
Retraso (6000);
dibujar ruta(c 1->; x, c 1->; y, c 1 ->; x, -1, C2-gt; */
Devuelve verdadero
}
if(bottom = =(board height-1))
{
dibujar ruta(c 1->x, c 1-> y, c 1-> x, altura del tablero, C2- gt; x, altura del tablero, C2- gt; x, c2-> y, color de línea) ;
Retraso (6000);
dibujar ruta(c 1->; x, c 1->; y, c 1->; x, altura del tablero, C2- gt ; x, altura del tablero, C2- gt; x, c2->y, BkGndColor); */
Devuelve verdadero
} for(j = top; j lt=bottom; j)
{
ruta = 0 ;/* ¡La longitud de las líneas verticales de uso común a nivel estadístico! */
for(I = min(c 1->x, c2->x) 1; i ltmax(c 1->x, c2->x); i )
{
ruta = Board[I][j][0];
si (ruta gt0) está rota;
}
if (ruta == 0)
{
/*línea vertical común horizontal*/
dibujar ruta(c 1->;x, c 1->y, c 1->x, j, C2- gt; x, j, C2- gt; x, c2->y, color de línea
Retraso (6000);
dibujar ruta(c 1->; x, c 1->; y, c 1->; x, j, C2- gt; x, j, C2- gt; x, c2->y ,BkGndColor);/*¡Tachado! */
Devuelve verdadero
}
}/*Esto significa que no hay ruta*/
Devuelve falso
}
/*Obtener código clave*/
int GetKeyCode()
{
int clave = 0 ;
if(bioskey(1))
{
clave = clave BIOS(0);
}
Introducir clave;
}/*¡La ruta de conexión al dibujar el cuadro de eliminación! , ¡usa el color especificado! , ¡las coordenadas son las coordenadas lógicas de la celda! */
void DrawPath(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, int color)
{
conjunto
color(color);
mover a(BoardX CellSize/2 CellSize * x 1, BoardY CellSize/2 CellSize * y 1);
línea a(board x CellSize/2 CellSize * x2, tablero y CellSize/2 CellSize * y2);
línea a (tablero x CellSize/2 CellSize * x3, tablero y CellSize/2 CellSize *
línea); to(board x CellSize/2 CellSize * x4, board y CellSize/2 CellSize * y4);
}
/*Mensaje de felicitación, ¡el usuario ha completado con éxito el juego! */
void DrawGameOver(char* info)
{
/*Calcular el punto central del tablero*/
int CX = BoardX CellSize * ancho del tablero/2;
int cy = BoardY CellSize * alto del tablero/2
estructura de configuración de texto tipo textInfos
/* Obtener la información de texto anterior*/
gettextsettings(amp; textInfos);
setcolor(dark grey);
setfillstyle(SOLID_FILL, blue);
/*Centro de texto*/
Rectángulo (cx-102, cy-22, cx 102, cy 22);
Sobrelleno (cx, cy, gris oscuro); ) ;
Rectángulo (cx-100, cy-20, cx 100, cy 20);
settextjustify(CENTER_TEXT, CENTER_TEXT);
setcolor( claro blue);
outtextxy(cx, cy, info);
/*Restaurar configuración de texto original*/
settextjustify(textInfos.horiz, textinfos . vert );
}/*Dibuja el rectángulo de enfoque en la celda con color */
/*Dibuja el borde exterior seleccionado con el color especificado*/
void DrawBorderRect(celda *c, color interno)
{
setcolor(color);
Rectangle(BoardX (c- gt; x)*CellSize 1 , TableroY (c- gt; y)*Tamaño de celda 1, tablero x (c- gt; x 1)*Tamaño de celda-2, TableroY (c- gt; y 1)* tamaño de celda-2); >Rectángulo (TableroX (c- gt; x)*tamaño de celda, TableroY (c- gt; y)*Tamaño de celda, tablero x (c- gt; - gt;y 1)* tamaño de celda-1);
}/*Dibujar celdas en xey con claves de colores específicos, claves aleatoriamente en 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
Entre */
void DrawCell(int key, int x, int y, int color)
{
setcolor(color);
Rectángulo (BoardX x*CellSize 2, BoardY y*CellSize 2, BoardX (x 1)*CellSize-3, BoardY (y 1)* CellSize-3);
setfillstyle(clave, color) ;
floodfill(BoardX x*CellSize 3, BoardY y*CellSize 3, color
}/*Borrar celdas*/
void EraseCell(int); x, int y)
{
setcolor(era color);
Rectangle(BoardX x*CellSize 2, BoardY y*CellSize 2, BoardX (x 1)*CellSize-3, BoardY (y 1)* CellSize-3);
setfillstyle(SOLID_FILL, BkGndColor);
floodfill(BoardX x*CellSize 3, BoardY y* CellSize 3, color de era);
establecer color(BkGndColor);
Rectángulo (BoardX x*CellSize 2, BoardY y*CellSize 2, BoardX (x 1)* CellSize-3 , BoardY (y 1)* CellSize-3);
}
/*Barra de progreso de inicialización*/
void InitProgressBar()
{
int width = CellSize * BoardWidth
/*Rectángulo del borde de la barra de progreso*/
establecer color (color del borde);
p >Rectángulo (BoardX-2, PbY-2, BoardX ancho 2, PbY Pb alto 2); /*Dibujar un valor = 100 barra de progreso*/
establecer color (color Pb); /p>
Rectangle(BoardX, PbY, ancho de BoardX, altura de PbY Pb
setfillstyle(SOLID_FILL, color de Pb
floodfill(BoardX 1, PbY 1 , color pb);
}