• Sábado 9 de Noviembre de 2024, 03:29
« anterior próximo »
Páginas: [1]

Autor Tema:  Gracias!! Ayuda  (Leído 2309 veces)

gdan_m

  • Nuevo Miembro
  • *
  • Mensajes: 13
    • Ver Perfil
Gracias!! Ayuda
« en: Viernes 2 de Diciembre de 2005, 07:32 »
0
Hola!! gracias por la ayuda, creo que lo que seguiria seria agregar la funcion jugar, y ahi poner las listas de apuntadores asi:

void jugar()
{
q=nvoele();
cin>>q->num;
q->izq=NULL;
q->der=NULL;



if(inicio->izq==q->der || inicio->izq==q->izq)
{
inicio->izq=q;
q->der=inicio || q->izq=inicio;
inicio=q;
q->izq=NULL;
}
else
{
if(fin->izq==q->der || fin->izq==q->izq)
{
p->der=q;
q->izq=p;
p=q;
q->der=NULL;
}
else
cout<<"No encuentra combinacion\n";
}

inicio=q; p=q;
while (resp=='s')
{
q=nvoele();
cin>>q->num;
p->der=q;
q->izq=p;
q->der=NULL;
p=q;
}
}


crees que esto sea bueno, porque necesito ocupar las listas.

pitukilloloco

  • Miembro MUY activo
  • ***
  • Mensajes: 104
    • Ver Perfil
Re: Gracias!! Ayuda
« Respuesta #1 en: Viernes 2 de Diciembre de 2005, 08:00 »
0
Disculpame por tardar en contestarte, es que estaba contestandole a otro compañero en otro foro. Bueno ahora ya viene lo interesante, pues el hacer que la maquina "juegue" no es algo trivial y tiene que ver con la teoria de juegos en computacion. Si lo que quieres es que la maquina solo tire las fichas sin ver si es la mejor jugada entonces es facil y solo hay que escoger aleatoreamente una ficha que encaje en cualquier extremo
esto es lo que quieres?

gdan_m

  • Nuevo Miembro
  • *
  • Mensajes: 13
    • Ver Perfil
Re: Gracias!! Ayuda
« Respuesta #2 en: Viernes 2 de Diciembre de 2005, 09:09 »
0
ESTARIA GENIAL!

PERO NO SE EXACTAMENTE COMO HACERLO, PORQUE LO QUE TE PUSE EN LE MENSAJE ANTERIOR SI CORRE PERO NO HACE NADA.. si me podrias ayudar??

pitukilloloco

  • Miembro MUY activo
  • ***
  • Mensajes: 104
    • Ver Perfil
Re: Gracias!! Ayuda
« Respuesta #3 en: Viernes 2 de Diciembre de 2005, 21:17 »
0
gdan_m, se me olvidó decirte ayer (bueno en realidad no sé si donde estás ya se acabó el día, aca en esta parte del planeta donde me encuentro son en este momento las 1:10pm) que siguieras contestando en la misma liga donde iniciaste la discusión, porque proseguir la misma en distintas ligas confunde a la gente que ve el foro; me imagino que sí sabes donde presionar el botón para contestar ¿no? Si quieres mantengámonos en esta donde te estoy escribiendo.

   Bueno, con respecto a tu programa, no sé cual es la manera en que juegan el dominó allá. Acá lo jugamos generalmente cuatro personas, se reparten las 28 fichas entre ellos (por lo que no quedan fichas en el montón, y por lo tanto, cuando una persona no tiene ficha que sacar pasa su turno a la siguiente persona) y se juega de parejas, donde cada pareja se coloca una frente a la otra y al comenzar el juego el que tiene la ficha 6|6 es el que sale y los jugadores van colocando las fichas por turno por mano derecha, o sea, el que está a la derecha del que colocó la última ficha es al que le corresponde jugar. El juego se acaba cuando una de las parejas coloca su última ficha o cuando el juego está cerrado por los dos extremos. En caso de que el juego quede cerrado se suman los puntos de cada pareja y gana el que tenga menos puntos y en caso de que esta suma sea igual gana la pareja que haya sacado la ficha al principio. El encuentro se pacta a 100 puntos, de modo que cuando una pareja gana un juego, los puntos de la pareja contraria se le suman a la pareja ganadora y se vuelven a repartir las fichas pero en este caso, al comenzar, ya no se saca la ficha 6|6 al principio, sino que la pareja ganadora es la que decide qué ficha sacar. Gana el encuentro la primera pareja que rebase los 100 puntos. Las reglas es que las parejas no se deben de hablar ni hacer señas y la única vez en que se les permite hablar es cuando tienen la mano y les corresponde sacar al comienzo del juego y uno al otro se preguntan solamente si saca uno o saca el otro. Generalmente se juega de apuesta pero aún sin jugar de apuesta el juego es muy adictivo.

   Como al comienzo escribiste que van a ser dos jugadores entonces voy a suponer que se reparten 7 fichas a cada uno, para más simplicidad voy a elegir un jugador al azar para que comienze la partida y también al azar este jugador va a sacar su primera ficha. Después, por turno, cada jugador va poniendo una ficha que esté en los extremos de las que están en la mesa; caso de que un jugador no tenga ficha que sacar, escoge fichas del montón hasta encontrar alguna que cuadre en la mesa y de no ser así cede el turno al otro jugador. El juego acaba cuando un jugador termine de tirar su última ficha o cuando el juego está cerrado. Por cierto aquí voy a tener que cambiar el tamaño de las fichas que los jugadores puedan tener, el cual lo voy a poner a 28 - 7 = 21, que son el máximo que en teoría un jugador puede tener, al jugar de dos uno en contra del otro.

   La lista la voy a utilizar cuando un jugador tira una ficha. En este caso la inserto al comienzo o al final, con lo cual cambiarán los apuntadores cabeza o cola.

   Te paso el programa, al final de cuentas no resultó tan fácil; bueno fácil si, lo que fue es laborioso, aparte que para las pruebas tuve que usar las funciones clrscr() que limpia la pantalla, la función gotoxy (x, y) que mueve el cursor a la coordenada (x, y) de la pantalla y la función getch() que espera a que el usuario presione una tecla sin hacer "eco" en la pantalla, para poder ver el resultado anterior junto con el actual y no se corriera la pantalla. Además de estas funciones que son propias del compilador use la función random (num), que me regresa un número pseudo-aleatoreo entre 0 y num - 1. El programa lo corrí con el Turbo C v2.0, pero si usas otro compilador y no reconoce estas funciones me dices para ver como lo podemos cambiar para que corra en él.

   Córrelo, haz varias pruebas y si no entiendes algo del programa me dices para explicártelo.
Código: Text
  1.  
  2. #include &#60;stdio.h&#62;
  3. #include &#60;stdlib.h&#62;
  4. #include &#60;time.h&#62;
  5. #include &#60;conio.h&#62;
  6.  
  7. #define MAXFICHASXJUGADOR 21
  8.  
  9. struct ficha {
  10.    int numder;
  11.    struct ficha *der;
  12.    int numizq;
  13.    struct ficha *izq;
  14. };
  15. typedef struct ficha FICHA;
  16. typedef struct ficha *PTRFICHA;
  17.  
  18. FICHA Ficha[28];
  19. PTRFICHA Jugador[4][MAXFICHASXJUGADOR], Monton[28], cabeza, cola;
  20.  
  21. void InicializaFichas ()
  22. {
  23.    int i, j;
  24.  
  25.    for (i = 0; i &#60; 7; i++)
  26.       for (j = i; j &#60; 7; j++) {
  27.          int k, m;
  28.          for (k = m = 0; m &#60; i; m++)
  29.             k += 7 - m;
  30.          Ficha[k + j - i].numder = i;
  31.          Ficha[k + j - i].numizq = j;
  32.          Ficha[k + j - i].der = Ficha[k + j - i].izq = NULL;
  33.       }
  34.    randomize ();
  35. }
  36.  
  37. void NuevoJuego ()
  38. {
  39.    int i, j;
  40.  
  41.    for (i = 0; i &#60; 28; i++) {
  42.        Ficha[i].der = Ficha[i].izq = NULL;
  43.       Monton[i] = Ficha + i;
  44.    }
  45.    for (i = 0; i &#60; 4; i++)
  46.       for (j = 0; j &#60; 7; j++)
  47.          Jugador[i][j] = NULL;
  48.    cabeza = cola = NULL;
  49. }
  50.  
  51. PTRFICHA EscogeFicha ()
  52. {
  53.    int i, bandera;
  54.    PTRFICHA p;
  55.  
  56.    for (bandera = i = 0; i &#60; 28; i++)
  57.       if (Monton[i] != NULL) {
  58.          bandera = 1;
  59.          break;
  60.       }
  61.    if (!bandera)   /* no hay fichas en el monton */
  62.       return NULL;
  63.  
  64.    while (1) {
  65.       i = random (28);
  66.       if (Monton[i] != NULL) {
  67.          p = Monton[i];
  68.          Monton[i] = NULL;
  69.          return p;
  70.       }
  71.    }
  72. }
  73.  
  74. void ReparteFichas (int numjugador)
  75. {
  76.    int i;
  77.    for (i = 0; i &#60; 7; i++)
  78.       Jugador[numjugador][i] = EscogeFicha ();
  79. }
  80.  
  81. void ImprimeFichasJugador (int numjugador, int pantalla)
  82. {
  83.    int i, startcol;
  84.  
  85.    startcol = !pantalla ? 1 : 41;
  86.    gotoxy (startcol + 11, 5 + numjugador*4);
  87.    for (i = 0; i &#60; MAXFICHASXJUGADOR; i++)
  88.       if (Jugador[numjugador][i] != NULL)
  89.          printf (&#34;%d &#34;, Jugador[numjugador][i]-&#62;numizq);
  90.    gotoxy (startcol, 5 + numjugador*4 + 1);
  91.    printf (&#34;Jugador #%d &#34;, numjugador + 1);
  92.    for (i = 0; i &#60; MAXFICHASXJUGADOR; i++)
  93.       if (Jugador[numjugador][i] != NULL)
  94.          printf (&#34;- &#34;);
  95.    gotoxy (startcol + 11, 5 + numjugador*4 + 2);
  96.    for (i = 0; i &#60; MAXFICHASXJUGADOR; i++)
  97.       if (Jugador[numjugador][i] != NULL)
  98.          printf (&#34;%d &#34;, Jugador[numjugador][i]-&#62;numder);
  99. }
  100.  
  101. void ImprimeMonton (int pantalla)
  102. {
  103.    int i, startcol;
  104.  
  105.    startcol = !pantalla ? 1 : 41;
  106.    gotoxy (startcol + 11, 21);
  107.    for (i = 0; i &#60; 28; i++)
  108.       if (Monton[i] != NULL)
  109.          printf (&#34;%d &#34;, Monton[i]-&#62;numizq);
  110.    gotoxy (startcol, 22);
  111.    printf (&#34;Mont¢n     &#34;);
  112.    for (i = 0; i &#60; 28; i++)
  113.       if (Monton[i] != NULL)
  114.          printf (&#34;- &#34;);
  115.    gotoxy (startcol + 11, 23);
  116.    for (i = 0; i &#60; 28; i++)
  117.       if (Monton[i] != NULL)
  118.          printf (&#34;%d &#34;, Monton[i]-&#62;numder);
  119. }
  120.  
  121. void ImprimeJuego ()
  122. {
  123.    int i;
  124.    PTRFICHA ptr;
  125.  
  126.    gotoxy (12, 1);
  127.    for (ptr = cabeza; ptr != NULL; ptr = ptr-&#62;der)
  128.       printf (&#34;%d &#34;, ptr-&#62;numizq);
  129.    gotoxy (1, 2);
  130.    printf (&#34;Juego      &#34;);
  131.    for (ptr = cabeza; ptr != NULL; ptr = ptr-&#62;der)
  132.       printf (&#34;- &#34;);
  133.    gotoxy (12, 3);
  134.    for (ptr = cabeza; ptr != NULL; ptr = ptr-&#62;der)
  135.       printf (&#34;%d &#34;, ptr-&#62;numder);
  136. }
  137.  
  138. void ImprimeEstadoDelJuego (int numjugadores, int paso)
  139. {
  140.    int i, j, startcol;
  141.    static int mitad_pantalla = 0;
  142.  
  143.    for (i = 3; i &#60; 24; i++) {
  144.       gotoxy (40, i + 1);
  145.       printf (&#34;³&#34;);
  146.    }
  147.    startcol = !mitad_pantalla ? 1 : 41;
  148.    for (i = 3; i &#60; 24; i++) {
  149.       gotoxy (startcol, i + 1);
  150.       for (j = 0; j &#60; 39; j++) printf (&#34; &#34;);
  151.    }
  152.    gotoxy (startcol, 4);
  153.    for (i = 0; i &#60; 14; i++) printf (&#34;#&#34;);
  154.    printf (&#34; Paso: %3d &#34;, paso);
  155.    for (i = 0; i &#60; 14; i++) printf (&#34;#&#34;);
  156.    if (numjugadores &#60; 4)
  157.       ImprimeMonton (mitad_pantalla);
  158.    for (i = 0; i &#60; numjugadores; i++)
  159.       ImprimeFichasJugador (i, mitad_pantalla);
  160.    ImprimeJuego ();
  161.    mitad_pantalla = !mitad_pantalla;
  162.    gotoxy (1, 25);
  163.    printf (&#34;&#092;tpresiones una tecla para continuar...&#34;);
  164.    getch ();
  165. }
  166.  
  167. int Ganador (int numjugadores)
  168. {
  169.    int i, j, bandera;
  170.  
  171.    for (i = 0; i &#60; numjugadores; i++) {
  172.       for (bandera = j = 0; j &#60; MAXFICHASXJUGADOR; j++)
  173.          if (Jugador[i][j] != NULL) {
  174.             bandera = 1;
  175.             break;
  176.          }
  177.       if (!bandera)
  178.          return i + 1;
  179.    }
  180.    return 0;
  181. }
  182.  
  183. int JuegoCerrado ()
  184. {
  185.    int contador;
  186.    PTRFICHA ptr;
  187.  
  188.    if (cabeza == NULL || cabeza-&#62;numizq != cola-&#62;numder)
  189.       return 0;
  190.    contador = 0;
  191.    for (ptr = cabeza; ptr != NULL; ptr = ptr-&#62;der) {
  192.       if (ptr-&#62;numizq == cabeza-&#62;numizq)
  193.          contador++;
  194.       if (ptr-&#62;numder == cabeza-&#62;numizq)
  195.          contador++;
  196.    }
  197.    return contador == 8;
  198. }
  199.  
  200. void Juega (int jugadoractual)
  201. {
  202.    int i;
  203.    PTRFICHA ptr;
  204.  
  205.    /* El juego va a comenzar. El jugador tiene 7 fichas iniciales   */
  206.    /* se toma la £ltima ficha de las 7 como la que va a comenzar la */
  207.    /* partida. Se pod¡a haber escogido una al azar pero se hace as¡ */
  208.    /* por simplicidad. Los apuntadores cabeza y cola apuntan a este */
  209.    /* elemento                                                      */
  210.    if (cabeza == NULL) {
  211.       cola = cabeza = Jugador[jugadoractual][6];
  212.       Jugador[jugadoractual][6] = NULL;
  213.       return;
  214.    }
  215.  
  216.    /* Si el flujo del programa contin£a hasta aqu¡ es que ya comenz¢ */
  217.    /* la partida. Se recorren las fichas del jugador actual para ver */
  218.    /* si alguna de ellas encaja en uno de los extremos. En caso de   */
  219.    /* que si, entonces se escoje esta ficha y se inserta en la lista */
  220.    for (i = 0; i &#60; MAXFICHASXJUGADOR; i++)
  221.       if (Jugador[jugadoractual][i]-&#62;numder == cabeza-&#62;numizq ||
  222.           Jugador[jugadoractual][i]-&#62;numizq == cabeza-&#62;numizq) {
  223.          if (Jugador[jugadoractual][i]-&#62;numizq == cabeza-&#62;numizq) {
  224.             int intercambio = Jugador[jugadoractual][i]-&#62;numizq;
  225.             Jugador[jugadoractual][i]-&#62;numizq = Jugador[jugadoractual][i]-&#62;numder;
  226.             Jugador[jugadoractual][i]-&#62;numder = intercambio;
  227.          }
  228.          cabeza-&#62;izq = Jugador[jugadoractual][i];
  229.          Jugador[jugadoractual][i]-&#62;der = cabeza;
  230.          cabeza = Jugador[jugadoractual][i];
  231.          Jugador[jugadoractual][i] = NULL;
  232.          return;
  233.       } else if (Jugador[jugadoractual][i]-&#62;numizq == cola-&#62;numder ||
  234.                  Jugador[jugadoractual][i]-&#62;numder == cola-&#62;numder) {
  235.          if (Jugador[jugadoractual][i]-&#62;numder == cola-&#62;numder) {
  236.             int intercambio = Jugador[jugadoractual][i]-&#62;numder;
  237.             Jugador[jugadoractual][i]-&#62;numder = Jugador[jugadoractual][i]-&#62;numizq;
  238.             Jugador[jugadoractual][i]-&#62;numizq = intercambio;
  239.          }
  240.          cola-&#62;der = Jugador[jugadoractual][i];
  241.          Jugador[jugadoractual][i]-&#62;izq = cola;
  242.          cola = Jugador[jugadoractual][i];
  243.          Jugador[jugadoractual][i] = NULL;
  244.          return;
  245.       }
  246.  
  247.    /* No se encontraron fichas en el jugador actual que encajaran, */
  248.    /* entonces se escogen fichas del mont¢n hasta que una de ellas */
  249.    /* encaje en la lista o hasta que se agote el mont¢n            */
  250.    while (1) {
  251.       if ((ptr = EscogeFicha ()) == NULL)
  252.          return;
  253.       if (ptr-&#62;numder == cabeza-&#62;numizq || ptr-&#62;numizq == cabeza-&#62;numizq) {
  254.          if (ptr-&#62;numizq == cabeza-&#62;numizq) {
  255.             int intercambio = ptr-&#62;numizq;
  256.             ptr-&#62;numizq = ptr-&#62;numder;
  257.             ptr-&#62;numder = intercambio;
  258.          }
  259.          cabeza-&#62;izq = ptr;
  260.          ptr-&#62;der = cabeza;
  261.          cabeza = ptr;
  262.          return;
  263.       } else if (ptr-&#62;numizq == cola-&#62;numder || ptr-&#62;numder == cola-&#62;numder) {
  264.          if (ptr-&#62;numder == cola-&#62;numder) {
  265.             int intercambio = ptr-&#62;numder;
  266.             ptr-&#62;numder = ptr-&#62;numizq;
  267.             ptr-&#62;numizq = intercambio;
  268.          }
  269.          cola-&#62;der = ptr;
  270.          ptr-&#62;izq = cola;
  271.          cola = ptr;
  272.          return;
  273.       }
  274.       for (i = 0; i &#60; MAXFICHASXJUGADOR; i++)
  275.          if (Jugador[jugadoractual][i] == NULL) {
  276.             Jugador[jugadoractual][i] = ptr;
  277.             break;
  278.          }
  279.    }
  280. }
  281.  
  282. int main ()
  283. {
  284.    int i, paso = 0, jugadoractual, numjugadores = 2;
  285.  
  286.    clrscr ();
  287.    InicializaFichas ();
  288.    NuevoJuego ();
  289.  
  290.    for (i = 0; i &#60; numjugadores; i++)
  291.       ReparteFichas (i);
  292.    ImprimeEstadoDelJuego (numjugadores, paso);
  293.    jugadoractual = random (numjugadores);
  294.    while (1) {
  295.       if (Ganador(numjugadores) || JuegoCerrado())
  296.          break;
  297.       Juega (jugadoractual);
  298.       if (jugadoractual &#60; numjugadores - 1)
  299.          jugadoractual++;
  300.       else
  301.          jugadoractual = 0;
  302.       paso++;
  303.       ImprimeEstadoDelJuego (numjugadores, paso);
  304.    }
  305.    if (Ganador(numjugadores))
  306.       printf (&#34;&#092;nEl ganador es el jugador #%d&#34;, Ganador(numjugadores));
  307.    else if (JuegoCerrado())
  308.       printf (&#34;&#092;nEl juego se cerr¢&#34;);
  309. }
  310.  
  311.  

gdan_m

  • Nuevo Miembro
  • *
  • Mensajes: 13
    • Ver Perfil
Re: Gracias!! Ayuda
« Respuesta #4 en: Domingo 4 de Diciembre de 2005, 15:21 »
0
Hola!ya revise el programa y al codigo si entendi todo, pero no corre porque no reconoce las funciones clrscr(), random() que esa no se si la podemos cambiar por rand, esa si la reconoce y gotoxy, dice que no estan declaradas.

los dos compiladores que tengo son visual basic y dev-c++, y en ninguno corre, no se que podemos hacer. voy a checar a ver si encuentro otras funciones que hagan lo mismo pero en estos programas, si encuentro te aviso vale. Y si tu encuentras como me avisarias por favor?

pitukilloloco

  • Miembro MUY activo
  • ***
  • Mensajes: 104
    • Ver Perfil
Re: Gracias!! Ayuda
« Respuesta #5 en: Domingo 4 de Diciembre de 2005, 18:27 »
0
Hola gdan_m. Modifiqué un poco el programa para que corriera en el Dev C++. Tenía un error en la función Juega que el compilador Turbo C no me lo detectaba pero en el Dev C++ abortaba el programa. Ya lo corregí. Puse unas líneas de comentarios para indicar cual código modifiqué o agregué.
Código: Text
  1.  
  2. #include &#60;stdio.h&#62;
  3. #include &#60;stdlib.h&#62;
  4. #include &#60;time.h&#62;
  5. /******************************************************************************/
  6. /******************* Se sustituyó &#60;conio.h&#62; por este encabezado ***************/
  7. #include &#60;windows.h&#62;
  8. /******************************************************************************/
  9. /******************************************************************************/
  10.  
  11. #define MAXFICHASXJUGADOR 21
  12.  
  13. struct ficha {
  14.   int numder;
  15.   struct ficha *der;
  16.   int numizq;
  17.   struct ficha *izq;
  18. };
  19. typedef struct ficha FICHA;
  20. typedef struct ficha *PTRFICHA;
  21.  
  22. FICHA Ficha[28];
  23. PTRFICHA Jugador[4][MAXFICHASXJUGADOR], Monton[28], cabeza, cola;
  24.  
  25. /******************************************************************************/
  26. /******************* Código que se agregó *************************************/
  27. HANDLE hConsoleOut, hConsoleIn;
  28.  
  29. void randomize ()
  30. {
  31.   srand (time (NULL));
  32. }
  33.  
  34. int random (int num)
  35. {
  36.   return rand () % num;
  37. }
  38.  
  39. void clrscr ()
  40. {
  41.   /* Obtiene una consola para esta aplicación */
  42.   AllocConsole();
  43.   /* Obtiene manejadores para la entrada y salida de la consola */
  44.   hConsoleOut = GetStdHandle(STD_OUTPUT_HANDLE);
  45.   hConsoleIn = GetStdHandle(STD_INPUT_HANDLE);
  46. }
  47.  
  48. void gotoxy (int x, int y)
  49. {
  50.   COORD coordScreen;
  51.   coordScreen.X = x - 1;
  52.   coordScreen.Y = y - 1;
  53.   SetConsoleCursorPosition (hConsoleOut, coordScreen);
  54. }
  55.  
  56. /*****************************************************************************/
  57. /******************************************************************************/
  58.  
  59. void InicializaFichas ()
  60. {
  61.   int i, j;
  62.  
  63.   for (i = 0; i &#60; 7; i++)
  64.      for (j = i; j &#60; 7; j++) {
  65.         int k, m;
  66.         for (k = m = 0; m &#60; i; m++)
  67.            k += 7 - m;
  68.         Ficha[k + j - i].numder = i;
  69.         Ficha[k + j - i].numizq = j;
  70.         Ficha[k + j - i].der = Ficha[k + j - i].izq = NULL;
  71.      }
  72.   randomize ();
  73. }
  74.  
  75. void NuevoJuego ()
  76. {
  77.   int i, j;
  78.  
  79.   for (i = 0; i &#60; 28; i++) {
  80.       Ficha[i].der = Ficha[i].izq = NULL;
  81.      Monton[i] = Ficha + i;
  82.   }
  83.   for (i = 0; i &#60; 4; i++)
  84.      for (j = 0; j &#60; 7; j++)
  85.         Jugador[i][j] = NULL;
  86.   cabeza = cola = NULL;
  87. }
  88.  
  89. PTRFICHA EscogeFicha ()
  90. {
  91.   int i, bandera;
  92.   PTRFICHA p;
  93.  
  94.   for (bandera = i = 0; i &#60; 28; i++)
  95.      if (Monton[i] != NULL) {
  96.         bandera = 1;
  97.         break;
  98.      }
  99.   if (!bandera)   /* no hay fichas en el monton */
  100.      return NULL;
  101.  
  102.   while (1) {
  103.      i = random (28);
  104.      if (Monton[i] != NULL) {
  105.         p = Monton[i];
  106.         Monton[i] = NULL;
  107.         return p;
  108.      }
  109.   }
  110. }
  111.  
  112. void ReparteFichas (int numjugador)
  113. {
  114.   int i;
  115.   for (i = 0; i &#60; 7; i++)
  116.      Jugador[numjugador][i] = EscogeFicha ();
  117. }
  118.  
  119. void ImprimeFichasJugador (int numjugador, int pantalla)
  120. {
  121.   int i, startcol;
  122.  
  123.   startcol = !pantalla ? 1 : 41;
  124.   gotoxy (startcol + 11, 5 + numjugador*4);
  125.   for (i = 0; i &#60; MAXFICHASXJUGADOR; i++)
  126.      if (Jugador[numjugador][i] != NULL)
  127.         printf (&#34;%d &#34;, Jugador[numjugador][i]-&#62;numizq);
  128.   gotoxy (startcol, 5 + numjugador*4 + 1);
  129.   printf (&#34;Jugador #%d &#34;, numjugador + 1);
  130.   for (i = 0; i &#60; MAXFICHASXJUGADOR; i++)
  131.      if (Jugador[numjugador][i] != NULL)
  132.         printf (&#34;- &#34;);
  133.   gotoxy (startcol + 11, 5 + numjugador*4 + 2);
  134.   for (i = 0; i &#60; MAXFICHASXJUGADOR; i++)
  135.      if (Jugador[numjugador][i] != NULL)
  136.         printf (&#34;%d &#34;, Jugador[numjugador][i]-&#62;numder);
  137. }
  138.  
  139. void ImprimeMonton (int pantalla)
  140. {
  141.   int i, startcol;
  142.  
  143.   startcol = !pantalla ? 1 : 41;
  144.   gotoxy (startcol + 11, 21);
  145.   for (i = 0; i &#60; 28; i++)
  146.      if (Monton[i] != NULL)
  147.         printf (&#34;%d &#34;, Monton[i]-&#62;numizq);
  148.   gotoxy (startcol, 22);
  149.   printf (&#34;Mont¢n     &#34;);
  150.   for (i = 0; i &#60; 28; i++)
  151.      if (Monton[i] != NULL)
  152.         printf (&#34;- &#34;);
  153.   gotoxy (startcol + 11, 23);
  154.   for (i = 0; i &#60; 28; i++)
  155.      if (Monton[i] != NULL)
  156.         printf (&#34;%d &#34;, Monton[i]-&#62;numder);
  157. }
  158.  
  159. void ImprimeJuego ()
  160. {
  161.   int i;
  162.   PTRFICHA ptr;
  163.  
  164.   gotoxy (12, 1);
  165.   for (ptr = cabeza; ptr != NULL; ptr = ptr-&#62;der)
  166.      printf (&#34;%d &#34;, ptr-&#62;numizq);
  167.   gotoxy (1, 2);
  168.   printf (&#34;Juego      &#34;);
  169.   for (ptr = cabeza; ptr != NULL; ptr = ptr-&#62;der)
  170.      printf (&#34;- &#34;);
  171.   gotoxy (12, 3);
  172.   for (ptr = cabeza; ptr != NULL; ptr = ptr-&#62;der)
  173.      printf (&#34;%d &#34;, ptr-&#62;numder);
  174. }
  175.  
  176. void ImprimeEstadoDelJuego (int numjugadores, int paso)
  177. {
  178.   int i, j, startcol;
  179.   static int mitad_pantalla = 0;
  180.  
  181.   for (i = 3; i &#60; 24; i++) {
  182.      gotoxy (40, i + 1);
  183.      printf (&#34;³&#34;);
  184.   }
  185.   startcol = !mitad_pantalla ? 1 : 41;
  186.   for (i = 3; i &#60; 24; i++) {
  187.      gotoxy (startcol, i + 1);
  188.      for (j = 0; j &#60; 39; j++) printf (&#34; &#34;);
  189.   }
  190.   gotoxy (startcol, 4);
  191.   for (i = 0; i &#60; 14; i++) printf (&#34;#&#34;);
  192.   printf (&#34; Paso: %3d &#34;, paso);
  193.   for (i = 0; i &#60; 14; i++) printf (&#34;#&#34;);
  194.   if (numjugadores &#60; 4)
  195.      ImprimeMonton (mitad_pantalla);
  196.   for (i = 0; i &#60; numjugadores; i++)
  197.      ImprimeFichasJugador (i, mitad_pantalla);
  198.   ImprimeJuego ();
  199.   mitad_pantalla = !mitad_pantalla;
  200.   gotoxy (1, 25);
  201.   printf (&#34;&#092;tpresiones una tecla para continuar...&#34;);
  202. /******************************************************************************/
  203. /******************* Código que se modificó ***********************************/
  204.   getchar ();
  205. /******************************************************************************/
  206. /******************************************************************************/
  207. }
  208.  
  209. int Ganador (int numjugadores)
  210. {
  211.   int i, j, bandera;
  212.  
  213.   for (i = 0; i &#60; numjugadores; i++) {
  214.      for (bandera = j = 0; j &#60; MAXFICHASXJUGADOR; j++)
  215.         if (Jugador[i][j] != NULL) {
  216.            bandera = 1;
  217.            break;
  218.         }
  219.      if (!bandera)
  220.         return i + 1;
  221.   }
  222.   return 0;
  223. }
  224.  
  225. int JuegoCerrado ()
  226. {
  227.   int contador;
  228.   PTRFICHA ptr;
  229.  
  230.   if (cabeza == NULL || cabeza-&#62;numizq != cola-&#62;numder)
  231.      return 0;
  232.   contador = 0;
  233.   for (ptr = cabeza; ptr != NULL; ptr = ptr-&#62;der) {
  234.      if (ptr-&#62;numizq == cabeza-&#62;numizq)
  235.         contador++;
  236.      if (ptr-&#62;numder == cabeza-&#62;numizq)
  237.         contador++;
  238.   }
  239.   return contador == 8;
  240. }
  241.  
  242. void Juega (int jugadoractual)
  243. {
  244.   int i;
  245.   PTRFICHA ptr;
  246.  
  247.   /* El juego va a comenzar. El jugador tiene 7 fichas iniciales   */
  248.   /* se toma la £ltima ficha de las 7 como la que va a comenzar la */
  249.   /* partida. Se pod¡a haber escogido una al azar pero se hace as¡ */
  250.   /* por simplicidad. Los apuntadores cabeza y cola apuntan a este */
  251.   /* elemento                                                      */
  252.   if (cabeza == NULL) {
  253.      cola = cabeza = Jugador[jugadoractual][6];
  254.      Jugador[jugadoractual][6] = NULL;
  255.      return;
  256.   }
  257.  
  258.   /* Si el flujo del programa contin£a hasta aqu¡ es que ya comenz¢ */
  259.   /* la partida. Se recorren las fichas del jugador actual para ver */
  260.   /* si alguna de ellas encaja en uno de los extremos. En caso de   */
  261.   /* que si, entonces se escoje esta ficha y se inserta en la lista */
  262.   for (i = 0; i &#60; MAXFICHASXJUGADOR; i++)
  263. /******************************************************************************/
  264. /******************* Código que se agregó *************************************/
  265.      if (Jugador[jugadoractual][i] == NULL)
  266.         continue;
  267. /******************************************************************************/
  268. /******************************************************************************/
  269.      else if (Jugador[jugadoractual][i]-&#62;numder == cabeza-&#62;numizq ||
  270.          Jugador[jugadoractual][i]-&#62;numizq == cabeza-&#62;numizq) {
  271.         if (Jugador[jugadoractual][i]-&#62;numizq == cabeza-&#62;numizq) {
  272.            int intercambio = Jugador[jugadoractual][i]-&#62;numizq;
  273.            Jugador[jugadoractual][i]-&#62;numizq = Jugador[jugadoractual][i]-&#62;numder;
  274.            Jugador[jugadoractual][i]-&#62;numder = intercambio;
  275.         }
  276.         cabeza-&#62;izq = Jugador[jugadoractual][i];
  277.         Jugador[jugadoractual][i]-&#62;der = cabeza;
  278.         cabeza = Jugador[jugadoractual][i];
  279.         Jugador[jugadoractual][i] = NULL;
  280.         return;
  281.      } else if (Jugador[jugadoractual][i]-&#62;numizq == cola-&#62;numder ||
  282.                 Jugador[jugadoractual][i]-&#62;numder == cola-&#62;numder) {
  283.         if (Jugador[jugadoractual][i]-&#62;numder == cola-&#62;numder) {
  284.            int intercambio = Jugador[jugadoractual][i]-&#62;numder;
  285.            Jugador[jugadoractual][i]-&#62;numder = Jugador[jugadoractual][i]-&#62;numizq;
  286.            Jugador[jugadoractual][i]-&#62;numizq = intercambio;
  287.         }
  288.         cola-&#62;der = Jugador[jugadoractual][i];
  289.         Jugador[jugadoractual][i]-&#62;izq = cola;
  290.         cola = Jugador[jugadoractual][i];
  291.         Jugador[jugadoractual][i] = NULL;
  292.         return;
  293.      }
  294.  
  295.   /* No se encontraron fichas en el jugador actual que encajaran, */
  296.   /* entonces se escogen fichas del mont¢n hasta que una de ellas */
  297.   /* encaje en la lista o hasta que se agote el mont¢n            */
  298.   while (1) {
  299.      if ((ptr = EscogeFicha ()) == NULL)
  300.         return;
  301.      if (ptr-&#62;numder == cabeza-&#62;numizq || ptr-&#62;numizq == cabeza-&#62;numizq) {
  302.         if (ptr-&#62;numizq == cabeza-&#62;numizq) {
  303.            int intercambio = ptr-&#62;numizq;
  304.            ptr-&#62;numizq = ptr-&#62;numder;
  305.            ptr-&#62;numder = intercambio;
  306.         }
  307.         cabeza-&#62;izq = ptr;
  308.         ptr-&#62;der = cabeza;
  309.         cabeza = ptr;
  310.         return;
  311.      } else if (ptr-&#62;numizq == cola-&#62;numder || ptr-&#62;numder == cola-&#62;numder) {
  312.         if (ptr-&#62;numder == cola-&#62;numder) {
  313.            int intercambio = ptr-&#62;numder;
  314.            ptr-&#62;numder = ptr-&#62;numizq;
  315.            ptr-&#62;numizq = intercambio;
  316.         }
  317.         cola-&#62;der = ptr;
  318.         ptr-&#62;izq = cola;
  319.         cola = ptr;
  320.         return;
  321.      }
  322.      for (i = 0; i &#60; MAXFICHASXJUGADOR; i++)
  323.         if (Jugador[jugadoractual][i] == NULL) {
  324.            Jugador[jugadoractual][i] = ptr;
  325.            break;
  326.         }
  327.   }
  328. }
  329.  
  330. int main ()
  331. {
  332.   int i, paso = 0, jugadoractual, numjugadores = 2;
  333.  
  334.   clrscr ();
  335.   InicializaFichas ();
  336.   NuevoJuego ();
  337.  
  338.   for (i = 0; i &#60; numjugadores; i++)
  339.      ReparteFichas (i);
  340.   ImprimeEstadoDelJuego (numjugadores, paso);
  341.   jugadoractual = random (numjugadores);
  342.   while (1) {
  343.      if (Ganador(numjugadores) || JuegoCerrado())
  344.         break;
  345.      Juega (jugadoractual);
  346.      if (jugadoractual &#60; numjugadores - 1)
  347.         jugadoractual++;
  348.      else
  349.         jugadoractual = 0;
  350.      paso++;
  351.      ImprimeEstadoDelJuego (numjugadores, paso);
  352.   }
  353.   if (Ganador(numjugadores))
  354.      printf (&#34;&#092;nEl ganador es el jugador #%d&#34;, Ganador(numjugadores));
  355.   else if (JuegoCerrado())
  356.      printf (&#34;&#092;nEl juego se cerr¢&#34;);
  357. /******************************************************************************/
  358. /******************* Código que se agregó *************************************/
  359.   getchar();
  360. /******************************************************************************/
  361. /******************************************************************************/
  362. }
  363.  
  364.  

gdan_m

  • Nuevo Miembro
  • *
  • Mensajes: 13
    • Ver Perfil
Re: Gracias!! Ayuda
« Respuesta #6 en: Miércoles 7 de Diciembre de 2005, 22:21 »
0
hola me podrias poner un ejemplo de como declarar esto :

printf ("%d ", Jugador[numjugador]->numder);

con cout???

pitukilloloco

  • Miembro MUY activo
  • ***
  • Mensajes: 104
    • Ver Perfil
Re: Gracias!! Ayuda
« Respuesta #7 en: Miércoles 7 de Diciembre de 2005, 23:45 »
0
La función printf está declarada en el encabezado <stdio.h> y pertence a la librería estándar de entrada y salida, y la puedes encontrar tanto en el lenguaje C como en C++.
   El flujo estándar de salida cout es parte de los flujos de entrada y salida, y las clases donde viene definido este flujo están declaradas en el archivo de encabezado <iostream.h>. Sólo está soportado en el lenguaje C++, por lo que en C es imposible usarlo.
   En las clases donde viene definido este flujo, el operador << está sobrecargado con los tipos básicos del lenguaje C++, por lo que si quieres escribir a la salida estándar (que puede ser la pantalla o un redireccionamiento hacia un archivo) cualquiera de estos tipos sólo tienes, por ejemplo en el caso de un tipo entero, que ponerlo así
Código: Text
  1.  
  2. int d;
  3. cout &#60;&#60; d;
  4.  
  5.  
como Jugador[numjugador]->numder está declarado como un entero, entonces
Código: Text
  1.  
  2. cout &#60;&#60; Jugador[numjugador][i]-&#62;numder;
  3.  
  4.  
es equivalente a
Código: Text
  1.  
  2. printf (&#34;%d &#34;, Jugador[numjugador][i]-&#62;numder);
  3.  
  4.  
Páginas: [1]
« anterior próximo »