Código fuente de 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#define true 1
# define falso 0/* - Variable global.
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 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->x;
mientras (min 1-1 >= 0 & amp& ampboard[min 1-1][c 1->y][0]= = 0)min 1-;
mientras(min 2 -1> = 0&&board[min 2-1][C2->y][0]= = 0)min 2-;
left=max(min1,min 2) ;/*margen izquierdo*/
while(max 1+1 <ancho y tamaño del tablero.& ampboard[max 1+1][c 1->y][0]= = 0 )max 1++;
while(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*/ *); ¡Compruebe si existe una conexión vertical común entre dos líneas horizontales! */
/*Se puede conectar en el borde*/
if(left==0)
{
/* Conexión del borde izquierdo */
dibujar ruta(c 1->x,c 1->y,-1,c 1->y,-1,C2->y,C2- & gt ;x, c2->y, color de línea);
Retraso (6000);
dibujar ruta(c 1->;x, c 1->;y ,-1 ,c 1->y,-1,C2->y,C2->x,c2->y,BkGndColor);/*¡Tachar! */
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->x, c2->y, BkGndColor); /* ¡Tachado! */
Devuelve verdadero
} for(I =left;i<=right;i++)
{
ruta = 0; /*¡Calcule la longitud de las líneas verticales de uso común! */
for(j = min(c 1->;y,C2->y)+1;j & ltmax(c 1->;y,C2->y) ;j++ )
{
ruta+= Tablero[I][j][0];
si (ruta>0) está rota;
}
if (ruta==0)
{
dibujar ruta(c 1->x, c 1->y, I, c 1-> ;y, I, C2->y, C2->x, c2->y, color de línea);
Retraso (6000);
p>dibujar ruta( c 1->x,c 1->y,I,c 1->y,I,C2->y,C2->x,c2- >y,BkGndColor);/*¡Tachado! */
Devuelve verdadero
}
}/* - (2) ¡Encuentra el área pública * * * vertical! - */
mín 1 = máx 1 = c 1->;y;
mín 2 = máx 2 = C2->y;
mientras (min 1-1>= 0&&& tablero[c 1->;x][min 1-1][0]= = 0)min 1-;
mientras(min 2-1>= 0&&board [C2->x][min 2-1][0]= = 0)min 2-;
arriba=max(min1,min 2 );
mientras(max 1+1 & lt; altura del tablero y altura & tablero[c 1->x][max 1+1][0]= = 0)max 1+ +;
mientras(max 2+). 1 & lt; altura y altura del tablero.
& ampboard[C2->x][max 2+1][0]= = 0)max 2++
bottom=min(max1,max 2);/*Marque dos verticales ¿Hay? ¿Conexiones verticales comunes entre las líneas? */
/*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->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->x,-1,C2->x,c2->y,BkGndColor);/*¡Tachado! */
Devuelve verdadero
}
if(bottom = =(board height-1))
{
dibujar ruta(c 1->x,c 1->y,c 1->x,altura del tablero,C2->x,altura del tablero,C2->x,c2-> y, color de línea);
Retraso (6000);
dibujar ruta(c 1->; x, c 1->; y, c 1->; x, Altura del tablero, C2->x , Altura del tablero, C2->x, c2->y, BkGndColor); /* ¡Tachado! */
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<max(c 1->x, c2->x); i++)
{
ruta+= Tablero[I][j][0];
si (ruta>0) está rota;
}
Si (ruta==0)
{
/*Línea vertical común horizontal*/
dibujar ruta(c 1- >x,c 1- >y,c 1->x,j,C2->x,j,C2->x,c2->y,color de línea);
Retraso(6000);
dibujar ruta(c 1->x,c 1->y,c 1->x,j,C2->x,j, C2->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)
{
setcolor(color);
mover a(BoardX+CellSize/2+CellSize * x 1, BoardY+CellSize/2+CellSize
* y 1);
línea a(tablero 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 * y3);
línea a(tablero x+CellSize/2+CellSize * x4, tablero 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 información de texto anterior*/
gettextsettings(& textInfos);
setcolor(gris oscuro);
setfillstyle(SOLID_FILL, azul);
setfillstyle(SOLID_FILL, azul);
p>/*Centro de texto*/
Rectángulo (cx-102, cy-22, cx+102, cy+22); gris oscuro);
Rectángulo (cx-100, cy-20, cx+100, cy+20);
settextjustify(CENTER_TEXT, CENTER_TEXT);
p>
setcolor(azul claro);
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 externo seleccionado con el color especificado */
void DrawBorderRect(celda*c, color interno)
{
setcolor(color);
Rectángulo (BoardX+( c->x)*CellSize+1, BoardY+(c->y)*CellSize+1, board >y+1)* cell size-2);
Rectángulo (BoardX+(c ->x)*tamaño de celda, BoardY+(c->y)*CellSize, tablero x+(c-& gt;x+1)*CellSize-1, BoardY+(c->y+1)* tamaño de celda -1);
}/*Usar en xey Dibujar la celda con la clave del color especificado La clave está aleatoriamente entre 2, 3, 4, 5, 6, 7, 8, 9. , 10, 11*/
void DrawCell(int key, int x, int y, int color)
{
setcolor(color);
Rectángulo (TableroX+x*Tamaño de celda+2, TableroY+y*Tamaño de celda+2, TableroX+(x+1)*Tamaño de celda-3, TableroY+(y+1)* Celda
Tamaño-3);
setfillstyle(clave, color);
floodfill(BoardX+x*CellSize+3, BoardY+y*CellSize+3, color);
}/*Borrar celda*/
void EraseCell(int x, int y)
{
setcolor(era color); p>
Rectángulo (TableroX+x*Tamaño de celda+2, TableroY+y*Tamaño de celda+2, TableroX+(x+1)*Tamaño de celda-3, TableroY+(y+1)* Tamaño de celda-3
p>
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);
Rectangle(BoardX-2 , PbY- 2. BoardX+width+2, PbY+Pb height+2); /*Dibujar un valor = 100% barra de progreso*/
establecer color(Pb color);
Rectángulo (BoardX, PbY, BoardX+ancho, PbY+Pb alto);
setfillstyle(SOLID_FILL, Pb color
floodfill(BoardX+1, PbY+1, Color Pb) ;
}