elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: (TUTORIAL) Aprende a emular Sentinel Dongle By Yapis


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  2048 juego en C, algoritmo para que pierda		0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: 2048 juego en C, algoritmo para que pierda  (Leído 5,304 veces)
damical

Desconectado Desconectado

Mensajes: 8


Ver Perfil
2048 juego en C, algoritmo para que pierda
« en: 27 Mayo 2016, 01:01 am »
tengo el codigo completo en C, del juego 2048, no logro hacer que pierda, es decir, que termine cuando no queden mas movimientos ni celdas vacias!! Necesito ayuda, alguna sugerencia, algo! He estado horas con esto y no logro que me quede, gracias!!!1

Código
  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <time.h>
  5. #define N 4
  6.  
  7.  
  8. void imp_tablero (); 
  9. void random_m ();
  10. //Funciones Movimientos
  11. void MOV_ARRIBA1 (); 
  12. void MOV_ABAJO1 ();
  13. void MOV_IZQ1 ();
  14. void MOV_DER1 ();
  15. void MOV_ARRIBA2 ();
  16. void MOV_ABAJO2();
  17. void MOV_DER2();
  18. void MOV_IZQ2();
  19. void lugares_ARRIBA();
  20. void inicio_juego(); // Imprime tablero, muestra puntaje e indica movimiento.
  21. void movimiento(); // Generar movimiento
  22. void opciones(); //Pregunta al usuario si quiere continuar jugando.
  23. void verificar_mov();
  24. void perder();
  25. int tablero[N][N] = {0};
  26. int aux, aux1=1,aux2=0,aux3=0,aux4=0,aux5=0;
  27. int a,b,ab,mov,no_mov1=0, no_mov2=0,no_mov3=0,no_mov4=0,no_mov5=0,no_mov6=0,no_mov7=0,no_mov8=0;
  28. int b1=0, juego=0;
  29.  int cambio_num=0;
  30. int M=N-2, puntaje;
  31. char decision;
  32.         int main()
  33.         {
  34. printf ("--------------------------------------------------\n");;
  35. printf ("**2222222222**0000000000**444****444**8888888888**\n");;		
  36. printf ("**2222222222**0000000000**444****444**8888888888**\n");;	
  37. printf ("*********222**000****000**444****444**888****888**\n");;	
  38. printf ("**2222222222**000****000**4444444444**8888888888**\n");;	
  39. printf ("**2222222222**000****000**4444444444**8888888888**\n");;	
  40. printf ("**222*********000****000*********444**888****888**\n");;	
  41. printf ("**2222222222**0000000000*********444**8888888888**\n");;	
  42. printf ("**2222222222**0000000000*********444**8888888888**\n");;	
  43. printf ("--------------------------------------------------\n\n\n");;
  44.  
  45.  
  46.  
  47.             time_t t;
  48.             srand((unsigned) time(&t));
  49. 			for(a=0;a<3;a++)
  50.             {
  51.                 random_m();
  52.             }
  53. 			while (juego==0){
  54.             inicio_juego();
  55. 		    imp_tablero();
  56. 			movimiento();
  57. 			}
  58. 			opciones ();
  59.  
  60. 		    return 0;
  61.  
  62.         }
  63. void imp_tablero()
  64. {
  65.     int a,b,c=0,i,j;
  66. 	char borde = '|', piso= '_';
  67. 	printf("\n");
  68. 	for(a=0;a<N;a++)
  69.     {
  70.         for(b=0;b<N;b++)
  71.         {
  72.  
  73.             printf("%c\t%d\t%c",borde, tablero[a][b], borde);
  74.         }
  75. 		printf ("\n");	
  76. 		aux1=1;
  77.     }
  78.  
  79. 	//Indica movimiento realizado.
  80. 	if (mov==1)
  81. 	printf("\nMovimiento hacia arriba\n");
  82. 	if (mov==2)
  83. 	printf ("\nMovimiento hacia abajo\n");
  84. 	if (mov==3)
  85. 	printf ("\nMovimiento hacia la izquierda\n");
  86. 	if (mov==4)
  87. 	printf ("\nMovimiento hacia la derecha\n");
  88.  
  89.  
  90. 	for (i=0; i<N; i++){
  91. 		for (j=0; j<N; j++){
  92. 				puntaje= tablero[i][j]+c;
  93. 				c=puntaje;
  94. 				if (tablero[i][j]==2048){
  95. 					printf ("\nFELICITACIONES, HAS GANADO EL JUEGO!\n");
  96. 					juego=1;}
  97.  
  98. 		}	
  99. 	}
  100.  
  101. 	printf("\nPUNTAJE: %d\n", puntaje);
  102. 	}
  103. void random_m()
  104. {
  105.  int h,g;
  106. do  {
  107.     b1=0;
  108.     h= rand()% N;
  109.     g= rand()% N;
  110.     if(tablero[g][h]==0){    // Alternar para que aparezca '2' y '4'
  111. 	if (cambio_num==0)
  112.         {
  113. 			tablero[g][h] = 2;
  114. 			cambio_num=1;
  115. 			b1 = 1;
  116. 		}
  117. 		else {
  118. 			tablero[g][h] = 4;
  119. 			cambio_num=0;
  120. 			b1 = 1;
  121. 		}
  122. 		}
  123.  } while (b1==0);
  124. }
  125. void MOV_ARRIBA1()
  126.     {
  127.         do{
  128.                 ab=0;
  129.                 for(a=1;a<N;a++)
  130.                     {
  131.                     for(b=0;b<N;b++)
  132.                     {
  133.                         if(tablero[a-1][b]==0&&tablero[a][b]!=0)
  134.                         {
  135.                             tablero[a-1][b]=tablero[a][b];
  136.                             tablero[a][b]=0;
  137.                             ab=1;
  138. 							aux2=0;
  139. 							aux4=0;
  140.  
  141. 						}
  142. 						else {aux2++;
  143. 							if (aux2==12){
  144. 								no_mov3=1;
  145. 								b1=1;
  146.  
  147. 							}
  148. 							else aux2=0;
  149.  
  150.  
  151. 						}
  152. 					}
  153.                 }
  154.  
  155.             }while (ab==1);
  156. 						mov=1;
  157.  
  158.  
  159.     }
  160.     void MOV_ABAJO1()
  161.     {
  162.         do{
  163.             ab=0;
  164.             for(a=M;a>=0;a--)
  165.             {
  166.                 for(b=0;b<N;b++)
  167.                 {
  168.                     if(tablero[a+1][b]==0&&tablero[a][b]!=0)
  169.                     {
  170.                         tablero[a+1][b]=tablero[a][b];
  171.                         tablero[a][b]=0;
  172.                         ab=1;
  173. 						aux2=0;
  174.                     }
  175.  
  176. 					else {
  177. 						aux2++;
  178. 						if (aux2==2){
  179. 							no_mov5=1;
  180. 							b1=1;
  181. 						}
  182. 						else aux2=0;
  183. 					}
  184. 					}
  185.                 }
  186.             }while(ab==1);
  187. 			mov=2;
  188.     }
  189.     void MOV_IZQ1()
  190.     {
  191.         do
  192.         {
  193.             ab=0;
  194.             for (a=0;a<N;a++)
  195.             {
  196.                 for (b=1;b<N;b++)
  197.                 {
  198.                     if(tablero[a][b-1]==0&&tablero[a][b]!=0)
  199.                     {
  200.                         tablero[a][b-1]=tablero[a][b];
  201.                         tablero[a][b]=0;
  202.                         ab=1;
  203. 						aux2=0;
  204.                     }
  205. 					else {aux2++;
  206. 						if (aux2==2){
  207. 							no_mov7=1;
  208. 							b1=1;
  209. 						}
  210. 						else aux2=0;
  211. 					}
  212.                 }
  213.             }
  214.         }while (ab==1);
  215. 		mov=3;
  216.     }
  217.     void MOV_DER1()
  218.         {
  219.             do{
  220.                 ab=0;
  221.                  for (a=0;a<N;a++)
  222.                 {
  223.                     for (b=M;b>=0;b--)
  224.                     {
  225.  
  226.                     if(tablero[a][b+1]==0&&tablero[a][b]!=0)
  227.                     {
  228.                         tablero[a][b+1]=tablero[a][b];
  229.                         tablero[a][b]=0;
  230.                         ab=1;
  231. 						aux2=0;
  232.                     }
  233. 					else {aux2++;
  234. 						if (aux2==2){
  235. 							no_mov1=1;
  236. 							b1=1;
  237. 						}
  238. 						else aux2=0;
  239. 					}
  240.                 }
  241.             }
  242.         }while (ab==1);
  243. 		mov=4;
  244.     }
  245. 	void MOV_ARRIBA2()
  246.         {
  247.         for (a=1;a<N;a++)
  248.                 {
  249.                     for (b=0;b<N;b++)
  250.                     {
  251.                         if (tablero[a-1][b]==tablero[a][b])
  252.                         {
  253.                             tablero[a-1][b]+=tablero[a][b];
  254. 							tablero[a][b]=0;
  255. 							no_mov4=0;
  256. 							aux3=0;
  257. 						}
  258. 						else {
  259. 						aux3++;
  260. 						if (aux3==12)
  261. 						no_mov4=1;
  262.                     }
  263. 					}           
  264. 					}
  265.     }
  266.         void MOV_ABAJO2()
  267.         {
  268.  
  269.         for (a=M;a>=0;a--)
  270.                 {
  271.                     for (b=0;b<N;b++)
  272.                     {
  273.                         if (tablero[a+1][b]==tablero[a][b])
  274.                         {
  275.                             tablero[a+1][b]+=tablero[a][b];
  276.                             tablero[a][b]=0;
  277. 							aux3=0;
  278. 						}
  279. 						else {
  280. 						aux3=1;
  281. 						no_mov6=1;
  282.                     }
  283.                 }	
  284.         }
  285. 		}
  286.        void MOV_DER2 ()
  287.         {
  288.  
  289.             for (a=0;a<N;a++)
  290.                 {
  291.                     for (b=M;b>=0;b--)
  292.                     {
  293.                     if(tablero[a][b+1]==tablero[a][b])
  294.                     {
  295.                         tablero[a][b+1]+=tablero[a][b];
  296.                         tablero[a][b]=0;
  297. 						aux3=0;
  298.                     }
  299. 					else {
  300. 						aux3=1;
  301. 						no_mov2=1;
  302. 					}
  303.  
  304.                 }
  305.             }
  306.         }
  307.         void MOV_IZQ2()
  308.         {
  309.  
  310.             for(a=0;a<N;a++)
  311.             {
  312.                 for(b=1;b<N;b++)
  313.                 {
  314.                     if(tablero[a][b-1]==tablero[a][b])
  315.                     {
  316.                         tablero[a][b-1]+=tablero[a][b];
  317.                         tablero[a][b]=0;
  318. 						aux3=0;
  319. 						}
  320. 						else {
  321. 						aux3=1;
  322. 						no_mov8=1;
  323. 					}
  324.             }
  325.         }
  326. 		}
  327.  
  328.         void inicio_juego()
  329.         {
  330.             printf("Utilice:\nW para arriba\nS para abajo\nD para derecha \nA para izquierda \n\n\n\n");
  331.             printf ("TABLERO DE JUEGO\n\n\n");;
  332.         }
  333.         void movimiento()
  334.         {
  335.  
  336.             int i,h,g,a;
  337.             int band=0;
  338. 			char t1;
  339.             time_t t;
  340.  
  341.             do
  342.             {
  343.  
  344. 			printf ("\n			    ^\n");
  345. 			printf ("			    W\n");
  346. 		    printf ("			<A     D>\n");
  347. 			printf ("			    S    \n");
  348. 			printf ("\n			    v\n\n");
  349.  
  350.  
  351. 			printf ("----> ");
  352.  
  353.  
  354.             char aux[1];
  355. 			 scanf ("%s", &aux);
  356. 			 printf ("\n\n");
  357. 			 t1=aux[0];
  358.  
  359.  
  360.  
  361.                 switch(t1)
  362.                 {
  363.                 case 'w': case 'W':
  364.  
  365. 					MOV_ARRIBA1 ();
  366.                     MOV_ARRIBA2();
  367.                     MOV_ARRIBA1 ();
  368. 					random_m();		
  369.  
  370.  
  371. 				break;
  372.  
  373.                 case 's': case 'S': 
  374.                     MOV_ABAJO1();
  375.                     MOV_ABAJO2();
  376.                     MOV_ABAJO1();
  377. 					random_m();
  378.  
  379.                     break;
  380.  
  381.                 case 'a': case 'A':
  382.                     MOV_IZQ1();
  383.                     MOV_IZQ2();
  384.                     MOV_IZQ1();
  385. 					random_m();
  386.  
  387.                     break;
  388.  
  389.                 case 'd': case 'D':
  390.                     MOV_DER1;
  391.                     MOV_DER2();
  392.                     MOV_DER1();
  393. 					random_m();
  394.  
  395.  
  396.                     break;
  397.  
  398.                 default:
  399.                     {
  400.                      printf("\n\n\n\tTECLA ERRONEA\n\n");
  401.  
  402.                         break;
  403.                     }
  404.                 }
  405.  
  406. 			imp_tablero();
  407.  
  408.  
  409. 			}
  410.  
  411.  
  412.         while(aux1==1);
  413.  
  414. 		 verificar_mov();
  415. 	    printf("TERMINO EL JUEGO");
  416.  
  417. 		}	
  418. 		void opciones()
  419. 		{
  420. 			char decision;
  421.  
  422. 		printf("Desea seguir jugando?\nS = Si\nN = No\n-------> ");
  423. 		scanf ("%c", &decision);
  424. 		if (decision=='s'||decision=='S')
  425. 			juego=0;
  426. 		else 
  427. 			printf ("GRACIAS POR JUGAR! HASTA LA PRÓXIMA..");
  428. 		}
  429.  
  430.  
  431. 		void verificar_mov()
  432. 		{ 
  433. 			if (no_mov1==1&&no_mov2==1){
  434. 		printf ("\nNO PUEDE MOVERSE A LA DERECHA\n");
  435. 		aux2=0;
  436. 		aux3=0;
  437. 		aux4=0;
  438. 		no_mov1=0;
  439. 		no_mov2=0;
  440. 		b1=0;
  441. 			}
  442.  
  443. 			if (no_mov3==1&&no_mov4==1){
  444. 		printf ("\nNO PUEDE MOVERSE HACIA ARRIBA\n");
  445. 		aux2=0;
  446. 		aux3=0;
  447. 		aux4=0;
  448. 		no_mov3=0;
  449. 		no_mov4=0;
  450. 		b1=0;
  451. 			}
  452. 		if (no_mov5==1&&no_mov6==1){
  453. 		printf ("\nNO PUEDE MOVERSE HACIA ABAJO\n");
  454. 		aux2=0;
  455. 		aux3=0;
  456. 		no_mov5=0;
  457. 		no_mov6=0;
  458. 		b1=0;
  459. 			}
  460. 		if (no_mov7==1&&no_mov8==1){
  461. 		printf ("\nNO PUEDE MOVERSE A LA IZQUIERDA\n");
  462. 		aux2=0;
  463. 		aux3=0;
  464. 		no_mov7=0;
  465. 		no_mov8=0;
  466. 		b1=0;
  467. 			}
  468. 			}
  469.  
  470.  
  471.  

[MOD] Usar las etiquetas GeShi, para publicar código.
« Última modificación: 27 Mayo 2016, 02:44 am por simorg » En línea
HardForo

Desconectado Desconectado

Mensajes: 219


HardForo.com


Ver Perfil WWW
Re: 2048 juego en C, algoritmo para que pierda
« Respuesta #1 en: 27 Mayo 2016, 01:08 am »
void verificar_mov()

deberia ser

int verificar_mov()

O sea... debes devolver un boolean (o un entero) que te permita tomar una accion en consecuencia.
En línea
HardForo:  foro de Hardware y programación

Se buscan Mods y colaboradores *
damical

Desconectado Desconectado

Mensajes: 8


Ver Perfil
Re: 2048 juego en C, algoritmo para que pierda
« Respuesta #2 en: 27 Mayo 2016, 01:16 am »
Cita de: HardForo en 27 Mayo 2016, 01:08 am
void verificar_mov()

deberia ser

int verificar_mov()

O sea... debes devolver un boolean (o un entero) que te permita tomar una accion en consecuencia.

Pero, la logica que use en esa funcion esta bien?
no entendi muy bien lo que me quisiste decir, perdon pero soy bastante lenta ja.
En línea
damical

Desconectado Desconectado

Mensajes: 8


Ver Perfil
Re: 2048 juego en C, algoritmo para que pierda
« Respuesta #3 en: 27 Mayo 2016, 01:20 am »
Tambien pasa, que cuando un movimiento no esta permitido (por ejemplo si no quedan mas movs a la derecha), el juego queda colgado.
En línea
HardForo

Desconectado Desconectado

Mensajes: 219


HardForo.com


Ver Perfil WWW
Re: 2048 juego en C, algoritmo para que pierda
« Respuesta #4 en: 27 Mayo 2016, 01:33 am »
Veo... tienes un montón de variables aux, no es por criticar pero es dificil saber que hace cada una, deberias empezar definiendo bien los nombres de tus variables, que tus metodos del tipo quedan_movimientos() devuelvan "booleanos" (0 ó 1) y que no hagan nada mas! no imprimas nada dentro... no enredes el código, manten clara la funcionalidad de cada "módulo" (función)

Si re-organizas tu codigo, yo te ayudo...sino... es algo para mártires
« Última modificación: 27 Mayo 2016, 02:13 am por HardForo » En línea
HardForo:  foro de Hardware y programación

Se buscan Mods y colaboradores *
damical

Desconectado Desconectado

Mensajes: 8


Ver Perfil
Re: 2048 juego en C, algoritmo para que pierda
« Respuesta #5 en: 27 Mayo 2016, 01:36 am »
Si, es verdad esta bastante entreverado, voy a ver si puedo arreglarlo un poco
En línea
damical

Desconectado Desconectado

Mensajes: 8


Ver Perfil
Re: 2048 juego en C, algoritmo para que pierda
« Respuesta #6 en: 27 Mayo 2016, 01:49 am »
Cita de: HardForo en 27 Mayo 2016, 01:33 am
Veo... tienes un montón de variables aux, no es por criticar pero es dificil saber que hace cada una, deberias empezar definiendo bien los nombres de tus variables, que tus metodos devuelvan "booleanos" (0 ó 1) y que no hagan nada mas! no imprimas nada dentro... no enredes el código, manten clara la funcionalidad de cada "módulo" (función)

Si re-organizas tu codigo, yo te ayudo...sino... es algo para mártires

Borré todo lo que estaba de mas, y quedo funcionando el jueguito (se mueve y suma), borre todo lo que habia intentado para que pierda, porque ni yo me entendia.. a ver si ahi esta un poco mejor:

Código
  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <time.h>
  5. #define N 4
  6.  
  7.  
  8. void imp_tablero (); 
  9. void random_m ();
  10. //Funciones Movimientos
  11. void MOV_ARRIBA1 (); 
  12. void MOV_ABAJO1 ();
  13. void MOV_IZQ1 ();
  14. void MOV_DER1 ();
  15. void MOV_ARRIBA2 ();
  16. void MOV_ABAJO2();
  17. void MOV_DER2();
  18. void MOV_IZQ2();
  19. void inicio_juego(); // Imprime tablero, muestra puntaje e indica movimiento.
  20. void movimiento(); // Generar movimiento
  21. void opciones(); //Pregunta al usuario si quiere continuar jugando.
  22. int tablero[N][N] = {0};
  23. int aux, aux1=1,aux2=0,aux3=0,aux4=0,aux5=0;
  24. int a,b,ab,mov;
  25. int b1=0, juego=0;
  26.  int cambio_num=0;
  27. int M=N-2, puntaje;
  28. char decision;
  29.         int main()
  30.         {
  31. printf ("--------------------------------------------------\n");;
  32. printf ("**2222222222**0000000000**444****444**8888888888**\n");;		
  33. printf ("**2222222222**0000000000**444****444**8888888888**\n");;	
  34. printf ("*********222**000****000**444****444**888****888**\n");;	
  35. printf ("**2222222222**000****000**4444444444**8888888888**\n");;	
  36. printf ("**2222222222**000****000**4444444444**8888888888**\n");;	
  37. printf ("**222*********000****000*********444**888****888**\n");;	
  38. printf ("**2222222222**0000000000*********444**8888888888**\n");;	
  39. printf ("**2222222222**0000000000*********444**8888888888**\n");;	
  40. printf ("--------------------------------------------------\n\n\n");;
  41.  
  42.  
  43.  
  44.             time_t t;
  45.             srand((unsigned) time(&t));
  46. 			for(a=0;a<3;a++)
  47.             {
  48.                 random_m();
  49.             }
  50. 			while (juego==0){
  51.             inicio_juego();
  52. 		    imp_tablero();
  53. 			movimiento();
  54. 			}
  55. 			opciones ();
  56.  
  57. 		    return 0;
  58.  
  59.         }
  60. void imp_tablero()
  61. {
  62.     int a,b,c=0,i,j;
  63. 	char borde = '|', piso= '_';
  64. 	printf("\n");
  65. 	for(a=0;a<N;a++)
  66.     {
  67.         for(b=0;b<N;b++)
  68.         {
  69.  
  70.             printf("%c\t%d\t%c",borde, tablero[a][b], borde);
  71.         }
  72. 		printf ("\n");	
  73.  
  74.     }
  75.  
  76.  
  77. 	//Indica movimiento realizado.
  78. 	if (mov==1)
  79. 	printf("\nMovimiento hacia arriba\n");
  80. 	if (mov==2)
  81. 	printf ("\nMovimiento hacia abajo\n");
  82. 	if (mov==3)
  83. 	printf ("\nMovimiento hacia la izquierda\n");
  84. 	if (mov==4)
  85. 	printf ("\nMovimiento hacia la derecha\n");
  86.  
  87.  
  88. 	for (i=0; i<N; i++){
  89. 		for (j=0; j<N; j++){
  90. 				puntaje= tablero[i][j]+c;
  91. 				c=puntaje;
  92. 				if (tablero[i][j]==2048){
  93. 					printf ("\nFELICITACIONES, HAS GANADO EL JUEGO!\n");
  94. 					juego=1;}
  95.  
  96. 		}	
  97. 	}
  98.  
  99. 	printf("\nPUNTAJE: %d\n", puntaje);
  100. 	}
  101. void random_m()
  102. {
  103.  int h,g;
  104. do  {
  105.     b1=0;
  106.     h= rand()% N;
  107.     g= rand()% N;
  108.     if(tablero[g][h]==0){    // Alternar para que aparezca '2' y '4'
  109. 	if (cambio_num==0)
  110.         {
  111. 			tablero[g][h] = 2;
  112. 			cambio_num=1;
  113. 			b1 = 1;
  114. 		}
  115. 		else {
  116. 			tablero[g][h] = 4;
  117. 			cambio_num=0;
  118. 			b1 = 1;
  119. 		}
  120. 		}
  121.  } while (b1==0);
  122. }
  123. void MOV_ARRIBA1()
  124.     {
  125.         do{
  126.                 ab=0;
  127.                 for(a=1;a<N;a++)
  128.                     {
  129.                     for(b=0;b<N;b++)
  130. 						{
  131.                         if(tablero[a-1][b]==0&&tablero[a][b]!=0) 
  132. 							{
  133.                             tablero[a-1][b]=tablero[a][b];
  134.                             tablero[a][b]=0;
  135.                             ab=1;
  136.  
  137. 							}
  138. 						}
  139.  
  140. 					}
  141.          }while (ab==1);
  142. 				mov=1; 
  143. 	}
  144.  
  145. 		void MOV_ARRIBA2()
  146.         {
  147.         for (a=1;a<N;a++)
  148.                 {
  149.                     for (b=0;b<N;b++)
  150.                     {
  151.                         if (tablero[a-1][b]==tablero[a][b])
  152.                         {
  153.                             tablero[a-1][b]+=tablero[a][b];
  154. 							tablero[a][b]=0;
  155.  
  156. 						}
  157.  
  158. 					}           
  159. 				}
  160. 		}
  161.  
  162.     void MOV_ABAJO1()
  163.     {
  164.         do{
  165.             ab=0;
  166.             for(a=M;a>=0;a--)
  167.             {
  168.                 for(b=0;b<N;b++)
  169.                 {
  170.                     if(tablero[a+1][b]==0&&tablero[a][b]!=0)
  171.                     {
  172.                         tablero[a+1][b]=tablero[a][b];
  173.                         tablero[a][b]=0;
  174.                         ab=1;
  175.                     }
  176.  
  177. 					}
  178.                 }
  179.             }while(ab==1);
  180. 			mov=2;
  181.     }
  182.  
  183. 	void MOV_ABAJO2()
  184.         {
  185.  
  186.         for (a=M;a>=0;a--)
  187.                 {
  188.                     for (b=0;b<N;b++)
  189.                     {
  190.                         if (tablero[a+1][b]==tablero[a][b])
  191.                         {
  192.                             tablero[a+1][b]+=tablero[a][b];
  193.                             tablero[a][b]=0;
  194. 						}
  195.  
  196. 					}	
  197. 				}
  198. 		}
  199.  
  200.  
  201.     void MOV_IZQ1()
  202.     {
  203.         do
  204.         {
  205.             ab=0;
  206.             for (a=0;a<N;a++)
  207.             {
  208.                 for (b=1;b<N;b++)
  209.                 {
  210.                     if(tablero[a][b-1]==0&&tablero[a][b]!=0)
  211.                     {
  212.                         tablero[a][b-1]=tablero[a][b];
  213.                         tablero[a][b]=0;
  214.                         ab=1;
  215. 					}
  216. 				}
  217.             }
  218.         }while (ab==1);
  219. 		mov=3;
  220.     }
  221.  
  222. 	   void MOV_IZQ2()
  223.         {
  224.  
  225.             for(a=0;a<N;a++)
  226.             {
  227.                 for(b=1;b<N;b++)
  228.                 {
  229.                     if(tablero[a][b-1]==tablero[a][b])
  230. 						{
  231.                         tablero[a][b-1]+=tablero[a][b];
  232.                         tablero[a][b]=0;
  233.  
  234. 						}
  235. 				}
  236. 			}
  237. 		}
  238.  
  239.     void MOV_DER1()
  240.         {
  241.             do{
  242.                 ab=0;
  243.                  for (a=0;a<N;a++)
  244.                 {
  245.                     for (b=M;b>=0;b--)
  246.                     {
  247.  
  248.                     if(tablero[a][b+1]==0&&tablero[a][b]!=0)
  249. 						{
  250.                         tablero[a][b+1]=tablero[a][b];
  251.                         tablero[a][b]=0;
  252.                         ab=1;
  253.  
  254. 						}
  255.  
  256. 					}
  257. 				}
  258. 			}while (ab==1);
  259. 		mov=4;
  260.     }
  261.  
  262.  
  263.        void MOV_DER2 ()
  264.         {
  265.  
  266.             for (a=0;a<N;a++)
  267.                 {
  268.                     for (b=M;b>=0;b--)
  269.                     {
  270.                     if(tablero[a][b+1]==tablero[a][b])
  271. 						{
  272.                         tablero[a][b+1]+=tablero[a][b];
  273.                         tablero[a][b]=0;
  274.  
  275. 						}
  276.  
  277.  
  278. 					}
  279. 				}
  280.         }
  281.  
  282.  
  283.         void inicio_juego()
  284.         {
  285.             printf("Utilice:\nW para arriba\nS para abajo\nD para derecha \nA para izquierda \n\n\n\n");
  286.             printf ("TABLERO DE JUEGO\n\n\n");;
  287.         }
  288.         void movimiento()
  289.         {
  290.  
  291.             int i,h,g,a;
  292.             int band=0;
  293. 			char t1;
  294.             time_t t;
  295.  
  296.             do
  297.             {
  298.  
  299. 			printf ("\n			    ^\n");
  300. 			printf ("			    W\n");
  301. 		    printf ("			<A     D>\n");
  302. 			printf ("			    S    \n");
  303. 			printf ("\n			    v\n\n");
  304.  
  305.  
  306. 			printf ("----> ");
  307.  
  308.  
  309.             char aux[1];
  310. 			 scanf ("%s", &aux);
  311. 			 printf ("\n\n");
  312. 			 t1=aux[0];
  313.  
  314.  
  315.  
  316.                 switch(t1)
  317.                 {
  318.                 case 'w': case 'W':
  319.  
  320. 					MOV_ARRIBA1 ();
  321.                     MOV_ARRIBA2();
  322.                     MOV_ARRIBA1 ();
  323. 					random_m();		
  324.  
  325.  
  326. 				break;
  327.  
  328.                 case 's': case 'S': 
  329.                     MOV_ABAJO1();
  330.                     MOV_ABAJO2();
  331.                     MOV_ABAJO1();
  332. 					random_m();
  333.  
  334.                     break;
  335.  
  336.                 case 'a': case 'A':
  337.                     MOV_IZQ1();
  338.                     MOV_IZQ2();
  339.                     MOV_IZQ1();
  340. 					random_m();
  341.  
  342.                     break;
  343.  
  344.                 case 'd': case 'D':
  345.                     MOV_DER1;
  346.                     MOV_DER2();
  347.                     MOV_DER1();
  348. 					random_m();
  349.  
  350.  
  351.                     break;
  352.  
  353.                 default:
  354.                     {
  355.                      printf("\n\n\n\tTECLA ERRONEA\n\n");
  356.  
  357.                         break;
  358.                     }
  359.                 }
  360.  
  361. 			imp_tablero();
  362.  
  363.  
  364. 			}
  365.  
  366.  
  367.         while(aux1==1);
  368.  
  369.  
  370. 		}	
  371.  
  372. 		void opciones()
  373. 		{
  374. 			char decision;
  375.  
  376. 		printf("Desea seguir jugando?\nS = Si\nN = No\n-------> ");
  377. 		scanf ("%c", &decision);
  378. 		if (decision=='s'||decision=='S')
  379. 			juego=0;
  380. 		else 
  381. 			printf ("GRACIAS POR JUGAR! HASTA LA PRÓXIMA..");
  382. 		}
  383.  
  384.  

[MOD] Para publicar código, usar etiquetas GeShi. Segundo aviso.
« Última modificación: 27 Mayo 2016, 02:46 am por simorg » En línea
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Balas con GPS para que la policía no pierda la pista de coches fugitivos
Noticias 		wolfbcn 7 2,587 Último mensaje 1 Mayo 2014, 04:29 am
por Gh057
Algoritmo de búsqueda en juego de adivinanza
Foro Libre 		JonaLamper 8 4,720 Último mensaje 2 Febrero 2015, 00:57 am
por @synthesize
Crear juego de 2048 en lenguaje C con Codeblocks
Programación C/C++ 		Carlos.Martinez 2 3,751 Último mensaje 18 Noviembre 2015, 03:36 am
por furciorifa
Problemas en este programa (Juego de 2048 en C) No responde a comandos W,A,S,D
Programación C/C++ 		Carlos.Martinez 4 2,465 Último mensaje 20 Mayo 2016, 21:19 pm
por damical
PROGRAMAR EN C EL JUEGO "2048"
Programación C/C++ 		damical 2 3,195 Último mensaje 17 Mayo 2016, 15:35 pm
por damical
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines