La Red de Conocimientos Pedagógicos - Currículum vitae - papel de caja de idioma c

papel de caja de idioma c

/*Un código fuente del juego escrito en lenguaje C*/

/*Este juego está en modo de caracteres, no lo ejecutes en DOS chino. El juego pasó la depuración en TURBO C */

# include & ltdos.h & gt

# include & ltstdio.h & gt

# include & ltctype.h & gt

# incluir & ltconio.h & gt

# incluir & ltbios.h & gt

# incluir & ltalloc.h & gt

/*Defina una matriz bidimensional para registrar el estado de cada punto en la pantalla.

Donde: 0 significa nada, "b" significa la caja, "w" significa la pared, "m" significa el destino y "I" significa que la caja está en el destino. */

char gho use[20][20];

/*La siguiente función es una función de escritura de pantalla directa, ¡lo cual es genial! Mi amigo me dijo.

*/

char far * screen =(char far *)0xb 8000000;

void putchxy(int y, int x, char ch, char fc, char bc)

{

Pantalla[(x * 160)+(y<<1)+0]= ch;

Pantalla[(x * 160)+( y & lt ;& lt1)+1]=(BC * 16)+fc;

}

/*Defina la estructura de datos para determinar si se gana*/

typedef estructura winer {

int x, y

struct winer * p

} winer

/*posición de caja Datos estructura */

cuadro de estructura typedef {

int x, y;

cuadro de estructura * siguiente

} cuadro cuadrado

p>

/*La función dibuja un muro en coordenadas específicas y registra el estado con una matriz*/

void printwall(int x, int y)

{

putchxy(y-1, x-1, 219, verde, negro);

ghouse[x][y]= ' w ';

}

p>

/*La función dibuja un cuadro en coordenadas específicas y registra el estado con una matriz*/

void printbox(int ​​​​x, int y)

{

putchxy(y-1, x-1, 10, blanco, negro)ghouse[x][y]= ' b '; /p>

}

/*La función dibuja el destino en coordenadas específicas y registra el estado con una matriz*/

void printwhither1(int x, int y, winer **win, winer **pw)

{

winer * qw

putchxy(y-1, x-1, ' * ', amarillo, negro

ghouse[x ][y]= ' m ';

if(*win==NULL)

{

* win = * pw = qw =(winer * )malloc(sizeof(winer));

(* pw)->x = x(* pw)->y = y( * pw)->p = NULL

}

Otros

{

qw =(winer *)malloc(sizeof( winer));

qw-& gt;

}

/*La función dibuja el destino en coordenadas específicas y registra el estado con una matriz*/

void printwithhither(int x, int y)

{

putchxy(y-1, x-1, ' * ', amarillo, negro);

ghouse[x][y]= ' m ' ;

}

/*Función para dibujar personas en coordenadas específicas*/

void printman(int x, int y)

{

gotoxy(y,x);

_ AL = 02_ CX = 01; = 0xa

gen interrupt(0x 10);

}

/*Dibuja un cuadro en las coordenadas específicas del destino y usa

Función de estado de grabación de matriz */

void printboxin(int x, int y)

{

patchxy(y-1, x-1, 10, Yellow , negro);

ghouse[x][y]= ' I ';

}

/*Función de inicialización, inicializar matriz y pantalla*/

inicialización nula()

{

int i, j

for(I = 0; i<20;i++)

for(j = 0;j & lt20;j++)

ghouse[I][j]= 0;

_ AL = 3;

p>

_ AH = 0;

interrupción gen(0x 10);

gotoxy(40, 4);

printf(" ¡Bienvenido al mundo de las cajas ");

gotoxy(40,6);

printf("Presiona arriba, abajo, izquierda, derecha para jugar.");

gotoxy(40, 8);

printf("Presione la tecla Esc para salir.");

gotoxy(4010);

printf("Presiona la barra espaciadora para restablecer el juego. ");

gotoxy(4012);

printf("Productor: Wang Dehao.");

gotoxy(4014);

printf("30 de marzo de 2003.");

}

/*Inicialización de imagen de primer nivel*/

winer *inithouse1()

{

int x, y;

winer *win=NULL, * pw

for( x=1, y = 5; y & lt=9; y++)

printwall(x+4, y+10);

for(y=5 , x = 2 ;x & lt=5;x++)

printwall(x+4,y+10);

for(y=9,x=2;x<= 5; x++)

printwall(x+4, y+10);

for(y=1, x = 3; x & lt=8;x++)

imprimirmuro(x+4, y+10);

for(x=3, y = 3; x & lt=5;x++)

imprimirmuro(x +4 , y+10);

for(x=5, y = 8; x & lt=9;x++)

printwall(x+4, y+10) ;

for(x=7, y = 4; x & lt=9;x++)

printwall(x+4, y+10);

for (x=9, y = 5; y & lt=7; y++)

printwall(x+4, y+10);

for(x=8, y = 2;y<=3;y++)

imprimirmuro(x+4, y+10);

imprimirmuro(5+4, 4+10);

imprimirmuro(5+4, 7+10);

imprimirmuro(3+4, 2+10);

imprimircuadro(3+4, 6+10);

imprimircuadro(3+4, 7+10);

imprimircuadro(4+4, 7+10);

imprimir donde1(4+4, 2); +10 y ganó.

pw);

imprimirdonde1(5+4, 2+10, & won. pw);

imprimirdonde1(6+4, 2+10, & won. pw);

printwhither1(6+4, 2+10, & won. pw);

printman(2+4, 8+10);

Recuperar;

}

/*Inicialización de imagen de tercer nivel */

winer *inithouse3()

{int x, y ;

winer *win=NULL, * pw

for(x=1, y = 2; y & lt=8;y++)

printwall( x+4, y+10);

for(x=2 , y = 2; x & lt=4; x++)

printwall(x+4, y+10 );

for(x=4, y = 1; y & lt=3;y++)

printwall(x+4, y+10);

for(x=5, y = 1; x & lt=8;x++)

printwall(x+4, y+10);

for(x=8 , y = 2; y & lt=5;y++)

imprimirmuro (x+4, y+10);

for(x=5, y = 5; x & lt=7;x++)

printwall(x+4, y+ 10);

for(x=7, y = 6; y & lt=9;y++)

imprimirmuro(x+4, y+10);

for(x=3, y = 9; x & lt=6;x++)

imprimirmuro( x+4, y+10);

for(x= 3, y = 6; y & lt=8; y++)

printwall(x+4, y+10 );

imprimirmuro(2+4, 8+10);

imprimirmuro(5+4, 7+10);

imprimircuadro(6+4); , 3+10);

imprimircuadro(4+4, 4 +10);

imprimircuadro(5+4, 6+10);

imprimirdonde1 (2+4, 5+10 y ganó. pw);

imprimirdonde1(2+4, 6+10 y amp won. pw);

imprimirdonde1(2+) 4, 7+10 y amp ganaron.

pw);

printman(2+4, 4+10);

Recuperar;

}

/*Segundo nivel inicialización de imagen */

winer *inithouse2()

{int x, y;

winer *win=NULL, * pw

for(x=1, y = 4; y & lt=7;y++)

printwall(x+4, y+10);

for(x=2, y = 2; y & lt=4; y++)

imprimirmuro(x+4, y+10);

for(x=2, y = 7; x & lt =4;x++)

printwall(x+4, y+10);

for(x=4, y = 1; x & lt=8;x++)< / p>

imprimirmuro(x+4, y+10);

for(x=8, y = 2; y & lt=8;y++)

imprimirmuro ( x+4, y+10);

for(x=4, y = 8; x <=8;x++)

printwall(x+4, y+ 10);

for(x=4, y = 6; x & lt=5;x++)

printwall(x+4, y+10);

for(x=3, y = 2; x & lt=4;x++)

printwall(x+4, y+10);

for(x= 4, y = 4; x & lt=5; x++)

imprimirmuro(x+4, y+10);

imprimirmuro(6+4, 3+10); >

cuadro de impresión(3+4, 5+10);

cuadro de impresión(6+4, 6+10);

cuadro de impresión(7+4, 3 +10); ;

imprimirdonde1(5+4, 7+10, & won. pw);

imprimirdonde1(6+4, 7+10, & won.pw);

imprimirdonde1(7+4, 7+10 y ganó.

pw);

printman(2+4, 6+10);

Recuperar;

}

/*Cuarto nivel inicialización de imagen */

winer *inithouse4()

{

int x, y;

winer *win=NULL, * pw

for(x=1, y = 1; y & lt=6; y++)

printwall(x+4, y+10);

for(x=2, y = 7; y & lt=8;y++)

printwall(x+4, y+10);

for(x=2, y = 1; x & lt=7; x++)

imprimirmuro(x+4, y+10);

for(x=7, y = 2; y & lt =4;y++)

printwall(x+4, y+10);

for(x=6, y = 4;y & lt=9;y++)< / p>

imprimirmuro(x+4, y+10);

for(x=3, y = 9; x & lt=5;x++)

imprimirmuro ( x+4, y+10);

for(x=3, y = 3; y & lt=4;y++)

printwall(x+4, y+ 10) ;

imprimirmuro(3+4, 8+10);

imprimircuadro(3+4, 5+10);

imprimircuadro(4+ 4, 4+10);

printbox(4+4, 6+10);

printbox(5+4, 5+10);

printbox( 5+4, 3+10);

imprimirdonde1(3+4, 7+10, & amp won. pw); & ganó. pw);

imprimirdonde1(5+4,7+10, & ganó. pw);

imprimirdonde1(4+4,8 +10, & ganó. pw); );

imprimir donde1(5+4, 8+10 y ganado.

pw);

printman(2+4, 2+10);

Recuperar;

}

/* será vacío Mueve la caja en el suelo al espacio abierto*/

movebox(int ​​​​x, int y, char a)

{

Cambiar ( a)

{

caso ' u ':ghouse[x-1][y]= 0; printf(" ");

printbox(x -2, y); printman(x-1, y);

ghouse[x-2][y]= ' b '; casa gho[x+1 ][y]= 0; printf(" ");

printbox(x+2, y); printman(x+1, y);

ghouse[x+2 ][y]= ' b '; romper;

caso ' l ':ghouse[x][y-1]= 0; printf(" ");

printbox( x, y-2); printman (x, y-1);

ghouse[x][y-2]= ' b '; p>case ' r ' :ghouse[x][y+1]= 0; printf(" "

printbox(x, y+2);

ghouse[x][y+2]= ' b '; romper

Predeterminado: romper

}

}

/*Mueve el cuadro del destino al espacio abierto*/

moveinbox(int ​​​​x, int y, char a)

{

Interruptor (a)

{

caso ' u ':ghouse[x-1][y]= ' m ';printf(" ");

printbox(x -2, y); printman (x-1, y);

ghouse[x-2][y]= ' b '; >

caso ' d ': ghouse[x+1][y]= ' m '; printf(" "

printbox(x+2, y); , y);

ghouse[x+2][y]= ' b '; romper

case ' l ':ghouse[x][y-1]= ' m '; printf(" ");

printbox(x, y-2); printman(x, y-1); = ' b '; romper;

p>

case ' r ':ghouse[x][y+1]= ' m '; >printbox(x, y+2); printman(x, y+1);

ghouse[x][y+2]= ' b '; : break

}

}

/*Mover el cuadro en el espacio abierto al destino*/

moveboxin(int x , int y, char a)

{

Interruptor (a)

{

caso ' u ':ghouse[x- 1][y]= 0; printf(" ");

printboxin(x-2, y); printman(x-1, y); 2][y]= ' I '; romper;

Caso "d": casa gho[x+1][y]= 0;

");

printboxin(x+2, y); printman(x+1, y);

ghouse[x+2][y]= ' I '; romper ;

caso ' l ':ghouse[x][y-1]= 0; printf(" ");

printboxin(x, y-2); , y-1);

ghouse[x][y-2]= ' I '; romper

caso ' r ':ghouse[x][y+1] = 0; printf(" ");

printboxin(x, y+2); printman(x, y+1); = ' I '; break;

Predeterminado: break

}

}

/*Mueve el cuadro del objetivo al objetivo */

moveinboxin(int x, int y, char a)

{

Interruptor (a)

{

case ' u ':ghouse[x-1][y]= ' m '; printf(" "); printboxin(x-2, y); 1 , y);

ghouse[x-2][y]= ' I '; romper;

caso ' d ':ghouse[x+1][y]= ' m ';printf(" ");

printboxin(x+2, y); printman(x+1, y);

ghouse[x+2][y); ] = ' I '; romper;

case ' l ':ghouse[x][y-1]= ' m '; printf(" ");

printboxin(x , y-2); printman(x, y-1);

ghouse[x][y-2]= ' I '; casa [x][y+1]= ' m '; printf(" ");

printboxin(x, y+2); p >ghouse[x][y+2]= ' I '; romper

Predeterminado: romper

}

}

/*Determinar el estado en coordenadas específicas*/

int Judge(int x, int y)

{

int I;

Switch(ghouse[x][y])

{

Caso 0: I = 1;

Caso "w": I = 0; romper;

Caso "b": I = 2;

Caso "I": I = 4; ":I = 3; romper;

Predeterminado: romper

}

Devolver I;

}

/*La función principal de manejar el movimiento de los caracteres después de presionar el teclado*/

move(int x, int y, char a)

{

Cambiar ( a)

{

caso 'u':if(! juez(x-1, y)) {gotoxy(y, x); break;}

else if(juez(x-1, y)==1||juez(x-1, y) )==3)

{if(juez(x, y)==3)

{ printwhither(x, y); printman(x-1, y); ;}

Otros

{ prin

tf(" "); printman(x-1, y); romper }

}

else if(juez(x-1, y)==2)

{ if(juez(x-2, y)==1)

{movebox(x, y, 'u');

if(juez( x, y)= = 3)imprimir blanco donde(x, y); gotoxy(y, x-1);

}

else if(judge(x-2, y)==3)

{ moveboxin(x,y,' u ');

if(judge(x,y)== 3)imprimir blanco donde(x, y); gotoxy(y, x-1);

}

else gotoxy(y, x

Romper; >}

si no(juez(x-1,y)==4)

{ si(juez(x-2,y)==1)

{moveinbox(x,y,' u ');

if(judge(x,y)== 3)imprimir blanco donde(x,y);gotoxy(y,x-1 );

}

else if(juez(x-2, y)==3)

{ moveinboxin(x, y, ' u ') ;

if(juez(x, y)== 3)imprimir blanco donde(x, y) gotoxy(y, x-1);

}

else gotoxy(y, x);

Romper;

}

case 'd':if(! juez(x+1, y )) {gotoxy(y, x); break;}

si no(juez(x+1, y)==1||juez(x+1, y)==3)

{if(juez(x, y)==3)

{ imprimirdonde(x, y); printman(x+1, y);}

Otro

{ printf(" "); printman(x+1, y); break }

}

else if(juez(x); +1,y)==2)

{ if(juez(x+2,y)==1)

{movebox(x,y,' d');

if(juez(x, y)== 3)imprimir blanco donde(x, y) gotoxy(y, x+1); p>else if(juez(x+2,y)==3)

{moveboxin(x,y,' d');

if(juez(x,y )= = 3)imprimir blanco donde(x, y); gotoxy(y, x+1);

}

else gotoxy(y, x);

Romper;

}

si no(juez(x+1,y)==4)

{ if(juez(x+2 , y)==1)

{moveinbox(x,y,' d');

if(judge(x,y)== 3)imprimir blanco donde(x , y); gotoxy(y, x+1);

}

else if(juez(x+2, y)==3)

{moveinboxin(x,y,' d ');

if(juez(x,

y)= = 3)imprimir blanco donde(x, y); gotoxy(y, x+1);

}

else gotoxy(y, x);

Romper;

}

case 'l':if(! juez(x, y-1)) {gotoxy(y, x); romper;}

si no(juez(x,y-1)==1||juez(x,y-1)==3)

{if(juez(x,y) ==3)

{ printwhhither(x, y); printman(x, y-1); break }

Otro

{ printf(" "); printman(x, y-1); break;}

}

si no(juez(x, y-1)==2)

{ if(juez(x,y-2)==1)

{movebox(x,y,' l ');

if(juez(x,y )= = 3)imprimir blanco donde(x,y);gotoxy(y-1,x);

}

else if(judge(x,y-2)= =3)

{moveboxin(x,y,' l ');

if(juez(x,y)= = 3)imprimir blanco donde(x,y); gotoxy(y-1,x);

}

si no gotoxy(y,x);

Romper;

}

si no(juez(x,y-1)==4)

{si(juez(x,y-2)==1)

{moveinbox(x,y,' l ');

if(judge(x,y)== 3)print white donde(x,y);gotoxy(y-1,x);

}

else if(judge(x,y-2)==3)

{moveinboxin(x,y,' l '); p>

if(juez(x,y)== 3)imprimir blanco donde(x,y);gotoxy(y-1,x);

}

else gotoxy(y, x);

Romper;

}

case 'r':if(! juez(x,y+1)) {gotoxy(y,x);break;}

si no(juez(x,y+1)==1||juez(x,y+1) )==3)

{if(juez(x,y)==3)

{printwhither(x,y);printman(x,y+1);break ;}

Otro

{ printf(" "); printman(x, y+1;}

}

si no(juez(x,y+1)==2)

{si(juez(x,y+2)==1)

{movebox(x, y, 'r');

if (juez (x, y) = = 3)imprimir blanco donde (x, y) (y+1, x); >}

else if(judge(x,y+2)==3)

{moveboxin(x,y,' r ');

if (juez (x, y) = = 3) print blanco donde (x, y); gotoxy (y + 1, x

);

}

else gotoxy(y, x);

Romper;

}

else if(juez(x, y+1)==4)

{ if(judge(x, y+2)==1)

{moveinbox(x, y, ' r '); /p>

if(juez(x,y)== 3)imprimir blanco donde(x,y);gotoxy(y+1,x);

}

else if(juez(x,y+2)==3)

{moveinboxin(x,y,' r ');

if(juez(x,y) = = 3)imprimir blanco donde(x,y);gotoxy(y+1,x);

}

si no gotoxy(y,x);

Pausa;

}

Predeterminado: pausa

}

}

/*Presione espacio Después pulsando la tecla se vuelve a la función del inicio de este nivel*/

Reset no válido (int i)

{

Interruptor (uno)

{

Caso 0:init();

init casa 1(); roto;

caso 1:init();

init casa 2(); romper

Caso 2: init();

iniciar casa 3(); Caso 3: init ();

init casa 4(); break;

Predeterminado: break

}

}

/*Función principal main */

void main()

{

int key, x, y, s, I = 0 ;

winer *win, * pw

_ AL = 3; _ AH = 0;

interrupción de generación (0x 10); p>init( );

win = init casa 1();

hacer {

_ AH = 3;

gen interrumpir(0x 10 );

x = _ DH+1; y = _ DL+1;

mientras(clave BIOS(1)= = 0);

tecla = tecla BIOS(0);

interruptor(tecla)

{

Caso 0x4800: mover(x, y, 'u') ; break; / *Después de presionar la tecla arriba*/

Caso 0x5000: move(x, y, ' d'); >case 0x4b00: move(x,y,' l '); /* después de presionar el botón izquierdo*/

Caso 0x4d00: move(x, y, 'r'); *presiona el botón derecho después de la flecha*/

Caso 0x3920: Restablecer (1); romper /*Después de presionar la barra espaciadora*/

Predeterminado: romper

}

s = 0;

pw = ganar

mientras(pw)

{

if(g casa[ pw-& gt; >

If (s==0)

{

Gratis (ganar);

gotoxy (25, 2);

printf("¡Felicitaciones! ¡Hiciste un gran trabajo! ”);

getch();

i++;

Conmutador (1)

{

caso 1:init();

win = init casa 2(); break;

Caso 2: init();

win = init casa 3(); >

Caso tres: init();

win = init house 4(); roto;

Caso cuatro: gotoxy(15, 21);

printf("Mi querido amigo, ¡eres tan inteligente! ¡Bienvenido a jugar de nuevo!");

key = 0x 011b; break;

Predeterminado: break

}

}

}mientras(clave!= 0x 011b);

_ AL = 3;

_ AH = 0;

interrupción gen(0x 10);

}