tp8 ej4b

[bleite12]

Hola, queria consultar cual era la forma de hacer que el usuario diga cuando parar de jugar, tambien queria saber si estan bien hechas las funciones con punteros a structs, porque lo habia hecho pasando el struct completo pero cuando estaba por terminar me acorde que nunca la iba a poder modificar.

#define DIM 52
#define CARTAS 13
#define PALOS 4
#define MANOS 5
#define PAR 2
#define PIERNA 3
#define POKER 4

typedef struct  {
    int palos; //va del 1 al 4.
    int tipo; //va del 1 al 13.
}baraja;

typedef struct resultado{
    int repeticiones;
    int figura;
} tipoResultado;

typedef struct jugador{
    baraja mano[MANOS];
    tipoResultado resultado;
    int puntos;
} tipoJugador;

void poker();
void leoEimprimo3erversion(tipoJugador * j1 ,tipoJugador * j2);
void cargarpuntos(tipoJugador * j1 ,tipoJugador * j2);
void imprimirMano(tipoJugador * j);
void barajar(baraja * cartas);
void crearbaraja(baraja * cartas);

int main() {
    srand(time(NULL));  

    printf("Comenzando el juego...\n");
    poker();  
    return 0;
}

void poker() {
    baraja *cartas = malloc(DIM * sizeof(baraja));  // Asignar memoria para 52 cartas.

    crearbaraja(cartas);  // Crear la baraja con todas las cartas.
    barajar(cartas);      // Mezclar la baraja.

    tipoJugador jugador1;
    tipoJugador jugador2;
    jugador1.puntos=0;
    jugador2.puntos=0;

    int indice = 0;  // Índice para repartir cartas desde la baraja.

       while (indice + (2 * MANOS) <= DIM) {  
        // Asegurarse de que queden suficientes cartas para repartir a ambos jugadores.
        printf("---- Ronda ------\n");
        // Repartir 5 cartas únicas a cada jugador para esta ronda.
        for (int i = 0; i < MANOS; i++) {
            jugador1.mano[i] = cartas[indice++];
            jugador2.mano[i] = cartas[indice++];
        }

        // Comparar los jugadores y mostrar resultados al final de cada ronda.
        leoEimprimo3erversion(&jugador1, &jugador2);
    }

    free(cartas);
}

void leoEimprimo3erversion(tipoJugador * j1 ,tipoJugador * j2) {

    int mimano1=0, mimano2=0;
    int Apariciones[CARTAS]={0};
    int Apariciones2[CARTAS]={0};

    // Contar las repeticiones de cada carta en ambas manos.
    for(int i = 0; i < MANOS; i++) {
        Apariciones[j1->mano[i].tipo]++;
        Apariciones2[j2->mano[i].tipo]++;
    }

    for(int i = 0; i < CARTAS; i++) {
        if(Apariciones[i] > mimano1) mimano1 = Apariciones[i];
        if(Apariciones2[i] > mimano2) mimano2 = Apariciones2[i];
    }

    j1->resultado.repeticiones = mimano1;
    j2->resultado.repeticiones = mimano2;

        cargarpuntos(j1 ,j2);

}

void cargarpuntos(tipoJugador * j1 ,tipoJugador * j2){
    //voy a recibir las estructuras de tipojugador, ir a resultados, comparar y cargar los puntos en tipojugador.
    if(j1->resultado.repeticiones>j2->resultado.repeticiones){
        j1->puntos++;
    }else if(j2->resultado.repeticiones>j1->resultado.repeticiones){
        j2->puntos++;
    }else if(j1->resultado.figura==j2->resultado.figura){
        j1->puntos++;
        j2->puntos++;
    }else{
        (j1->resultado.figura >j2->resultado.figura ? j1->puntos++ : j2->puntos++);
    }
    char * salida[]={"carta alta","par","pierna", "poker" };
    printf("el j1 tenia %s \n", salida[(j1->resultado.repeticiones)]);

    imprimirMano(j1);

    printf("el j2 tenia %s \n", salida[(j2->resultado.repeticiones)]);

    imprimirMano(j2);

}

void imprimirMano(tipoJugador * j){//esta es copiada
    static char * cPalo[] = {"♦", "♣", "♥", "♤"};
    static char * cNum[] = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "1"};

    printf("Su mano es: ");
    for(int i = 0; i < MANOS; i++){
        printf("%s%s ", cNum[j->mano[i].tipo], cPalo[j->mano[i].palos]);
    }
    putchar('\n');
    printf("tiene: %d puntos \n", j->puntos);
}

void barajar(baraja * cartas){
baraja temp;
    for(int i = (DIM-1) ; i>0 ; i-- ){

        int j = (rand() % (i+1));

        temp = cartas[i];
        cartas[i] = cartas[j];
        cartas[j]= temp;

    }

}

void crearbaraja(baraja * cartas){

    for(int i = 0 ; i<DIM ; i++  ){
        cartas[i].tipo = (i % 13); //(0-12)
        cartas[i].palos = (i / 13);//(0-3)
    }

}

[marcelogarberoglio]

Para decidir que se terminó, podría ser cuando no quedan suficientes cartas para repartir. Así que está bien como lo hiciste Está bastante bien modularizado y el código es claro, pero se podrían hacer algunas mejoras.

-No es necesario que cartas sea un vector deinámico, ya que sabés exactamente cuántos elementos va a tener. Si lo hiciste para practicar está bien, pero sinó, en este caso es más adecuado un vector estático -CargarPuntos: hace cosas de back y de front. La parte de calcular los puntos podría estar en una función auxiliar de back -salida podría ser static (como bien hiciste con cPalo y cNum) -En crearBaraja usás el magic number 13 -leoEimprimo3erversion: tiene el código repetido para los dos jugadores. Podrías hacer una función que haga los cálculos para un jugador, y la llamás primero con jugador1 y después con jugador2

[bleite12]

perfecto, gracias.