diff --git a/azar.c b/azar.c deleted file mode 100644 index fd47323..0000000 --- a/azar.c +++ /dev/null @@ -1,27 +0,0 @@ -// Este fichero se le da al alumno -#include // time() -#include // rand(), srand() -#include // printf() -#include "azar.h" - -/* - * inicializar_azar() se tiene que ejecutar una vez al principio del main - * para inicializar la generación de números aleatorios - */ -//void inicializar_azar() { - /* - * Para que la sequencia de numeros aleatorios sea igual en cada - * ejecucion usad el srand (0) en lugar del srand(time). - */ - //srand(0); -// srand( (unsigned)time( NULL ) ); -//} - -/* - * numero_al_azar(max) devuelve un número entero al azar entre 0 y max-1 - */ -int numero_al_azar(int max) { - srand(time(NULL)); - return ( rand() % max); -} - diff --git a/azar.h b/azar.h deleted file mode 100644 index b535198..0000000 --- a/azar.h +++ /dev/null @@ -1,9 +0,0 @@ -// Este fichero se le da al alumno -#ifndef AZAR_H -#define AZAR_H - -void inicializar_azar(); -int numero_al_azar(int max); - -#endif /* AZAR_H */ - diff --git a/duerme.c b/duerme.c deleted file mode 100644 index 9347255..0000000 --- a/duerme.c +++ /dev/null @@ -1,47 +0,0 @@ -// Este fichero se le da al alumno -#include -#include "duerme.h" - -#define UN_RATO_SEGUNDOS 1 // 1 segundo -#define UN_RATO_NANOSEGUNDOS 500000000 // 0.5 segundos - -/* - * Hace que la ejecucion del programa se detenga durante - * el numero de segundos que se le pasa por parametro - */ -void duerme_n_segundos(long segundos) { - struct timespec tim, tim2; - tim.tv_sec = segundos; - tim.tv_nsec = 0; - - nanosleep(&tim , &tim2); -} - -/* - * Hace que la ejecucion del programa se detenga durante - * el numero de nanosegundos que se le pasa por parametro - */ -void duerme_n_nanosegundos(long nanosegundos) { - struct timespec tim, tim2; - tim.tv_sec = 0; - tim.tv_nsec = nanosegundos; - - nanosleep(&tim , &tim2); -} - -/* - * Hace que la ejecucion del programa se detenga durante - * un numero de segundos predeterminado - */ -void duerme_un_rato() { - duerme_n_segundos(UN_RATO_SEGUNDOS); -} - -/* - * Hace que la ejecucion del programa se detenga durante - * un numero de nanosegundos predeterminado - */ -void duerme_un_nano_rato() { - duerme_n_nanosegundos(UN_RATO_NANOSEGUNDOS); -} - diff --git a/duerme.h b/duerme.h deleted file mode 100644 index c3024d0..0000000 --- a/duerme.h +++ /dev/null @@ -1,11 +0,0 @@ -// Este fichero se le da al alumno -#ifndef DUERME_H -#define DUERME_H - -void duerme_n_segundos(long segundos); -void duerme_n_nanosegundos(long nanosegundos); -void duerme_un_rato(); -void duerme_un_nano_rato(); - -#endif /* DUERME_H */ - diff --git a/ficha.c b/ficha.c deleted file mode 100644 index 4998af2..0000000 --- a/ficha.c +++ /dev/null @@ -1,37 +0,0 @@ -#include -typedef struct{ - int num1, num2; -}t_ficha; - -void inicializar_ficha (t_ficha *ficha, int i, int j); -void imprimir_ficha (t_ficha f, int visible); -void girar_ficha (t_ficha *ficha); -int doble(); - -void imprimir_ficha(t_ficha ficha, int visible){ - - printf("%d:%d|", ficha.num1, ficha.num2); -} - -void girar_ficha(t_ficha *ficha){ // num1 es canvia per num2 i al contrari - int aux, i; - - aux=ficha->num1; - ficha->num1=ficha->num2; - ficha->num2=aux; - -} - -int doble() -{ t_ficha ficha[28]; - int i; - - if(ficha[i].num1==ficha[i].num2) //Si es un doble num1=num2 - return(1); - else return(0); -} - -void inicializar_ficha (t_ficha *ficha, int i, int j) { - ficha->num2=j; - ficha->num1=i; - } diff --git a/ficha.h b/ficha.h deleted file mode 100644 index f2cf234..0000000 --- a/ficha.h +++ /dev/null @@ -1,18 +0,0 @@ -#ifndef FICHA_H -#define FICHA_H - -#define FALSE 0 -#define TRUE 1 - -#define NUM_FICHAS_DOMINO 28 - -typedef struct{ - int num1, num2; -}t_ficha; - -void inicializar_ficha(t_ficha *p_f, int a, int b); -void girar_ficha(t_ficha *p_f); -void imprimir_ficha(t_ficha f, int visible); - -#endif // FICHA_H - diff --git a/game.c b/game.c new file mode 100644 index 0000000..7d704dc --- /dev/null +++ b/game.c @@ -0,0 +1,330 @@ +#include +#include +#include "player.h" +#include "table.h" +#include "stack.h" +#include "move.h" +#include "questions.h" +#include "sleep.h" +#include "random.h" + +#define TRUE 1 +#define FALSE 0 +typedef struct +{ + t_players js; + t_table m; // Tiles played. + t_stack pi; // Tiles not played and not belonging to any player. + int visible; // Stack of tiles and visible tiles from a bot. + int dim; // See table in 2D (versus 1D). + // visible and table_2d can be TRUE o FALSE. + int pasadas; // Consecutive times a player passes turn. + // if pasadas == n_players the game ends. +} t_game; + +void initialize_game(t_game *p_pa); +void print_game_state(t_game pa); +void make_play(t_game *p_pa); +int has_the_game_ended(t_game pa); + +void initialize_game(t_game *p_pa) +{ + int i, j, p, k, nj, nf; + + char s1[50] = "¿Numero de jugadores?", s2[50] = "¿Un jugador humano?", s3[50] = "¿Quieres omnisciencia?", s4[50] = "¿Quieres ver la mesa en 2D?"; + + p_pa->pasadas = 0; + + p_pa->js.n_players = ask_n_in_range(&s1[0], 2, 4); // Ask the questions. + + p_pa->js.a_human = ask_yes_or_no(&s2[0]); + + p_pa->visible = ask_yes_or_no(&s3[0]); + + p_pa->dim = ask_yes_or_no(&s4[0]); + + printf("\n"); + + initialize_stack(&(p_pa->pi)); + + for (i = 0; i < p_pa->js.n_players; i++) // Distribute tiles randomly + for (j = 0; j < 7; j++) + p_pa->js.j[i].f[j] = pick_from_stack(&(p_pa->pi)); + + if (p_pa->js.a_human == TRUE) + { // Initialize players. + p_pa->js.j[0].type = T_HUMAN; + p_pa->js.j[0].n_tiles = 7; + for (i = 1; i < p_pa->js.n_players; i++) + { + p_pa->js.j[i].type = T_ROBOT; + p_pa->js.j[i].n_tiles = 7; + } + } + else + { + for (i = 0; i < p_pa->js.n_players; i++) + { + p_pa->js.j[i].type = T_ROBOT; + p_pa->js.j[i].n_tiles = 7; + } + } + who_has_higher_doble(p_pa->js, &nj, &nf); // Which player starts the game. + + initialize_table(&(p_pa->m)); + print_stack(p_pa->pi, p_pa->visible); + + play_from_left(&(p_pa->m), p_pa->js.j[nj].f[nf]); + print_table(p_pa->m, p_pa->dim); + printf("\n"); + + for (i = nf; i < p_pa->js.j[nj].n_tiles; i++) + p_pa->js.j[nj].f[i] = p_pa->js.j[nj].f[i + 1]; + p_pa->js.j[nj].n_tiles--; + + p_pa->js.turn = nj; + print_players(p_pa->js, p_pa->visible); + skip_turn(&(p_pa->js)); + print_turn(p_pa->js); +} + +void print_game_state(t_game pa) +{ + int i; + print_stack(pa.pi, pa.visible); + print_table(pa.m, pa.dim); + printf("\n"); + print_players(pa.js, pa.visible); + print_turn(pa.js); +} +void print_final_game_state(t_game pa) +{ // Prints the game at the time of the ending move. + int i; + sleep_a_bit(10); + printf("\tFINAL STATE OF THE GAME:\n\n"); + pa.visible = TRUE; + + print_stack(pa.pi, pa.visible); + print_table(pa.m, pa.dim); + printf("\n"); + print_players(pa.js, pa.visible); + printf("\n"); +} + +void make_play(t_game *p_pa) +{ + int tirada = -1, i, v; + t_tiradas ts; + + ts = calculate_possible_moves(p_pa->js.j[p_pa->js.turn], p_pa->m); // We calculate the possible moves. + + while (ts.n_moves == 0 && p_pa->pi.n_tiles != 0) + { // If the player cannot move, he has to pick a tile from the stack. + p_pa->js.j[p_pa->js.turn].f[p_pa->js.j[p_pa->js.turn].n_tiles] = pick_from_stack(&(p_pa->pi)); + + if (p_pa->visible == TRUE) + { // Omniscience active. + if (p_pa->js.j[p_pa->js.turn].type == T_HUMAN) // If it is human, the tile is shown. + printf("You pick from the stack! Picked a %d:%d ;P\n", p_pa->js.j[p_pa->js.turn].f[p_pa->js.j[p_pa->js.turn].n_tiles].num1, p_pa->js.j[p_pa->js.turn].f[p_pa->js.j[p_pa->js.turn].n_tiles].num2); + else + printf("He picks from the stack! Picked a %d:%d ;)\n", p_pa->js.j[p_pa->js.turn].f[p_pa->js.j[p_pa->js.turn].n_tiles].num1, p_pa->js.j[p_pa->js.turn].f[p_pa->js.j[p_pa->js.turn].n_tiles].num2); // Si es robot muestra la tile + p_pa->js.j[p_pa->js.turn].n_tiles++; + ts = calculate_possible_moves(p_pa->js.j[p_pa->js.turn], p_pa->m); + } + if (p_pa->visible == FALSE) + { + if (p_pa->js.j[p_pa->js.turn].type == T_HUMAN) // If it is human, the tile is shown. + printf("You pick from the stack! Picked a %d:%d ;P\n", p_pa->js.j[p_pa->js.turn].f[p_pa->js.j[p_pa->js.turn].n_tiles].num1, p_pa->js.j[p_pa->js.turn].f[p_pa->js.j[p_pa->js.turn].n_tiles].num2); + else + printf("He picks from the stack! ;)\n"); // If it is a bot, the tile is not shown. + p_pa->js.j[p_pa->js.turn].n_tiles++; + ts = calculate_possible_moves(p_pa->js.j[p_pa->js.turn], p_pa->m); + } + } + + print_moves(ts, p_pa->js.j[p_pa->js.turn]); + + if (p_pa->js.j[p_pa->js.turn].type == T_HUMAN) + { // Human plays. + if (ts.n_moves == 0 && p_pa->pi.n_tiles == 0) + { // Human cannot move and passes turn. + printf("You pass turn! :(\n\n"); + p_pa->pasadas++; + } + + if (ts.n_moves > 0) + { + p_pa->pasadas = 0; + if (ts.count_dobles > 1) + v = ts.n_moves; //Si se dobledobla cuenta esa tirada como extra + else + v = ts.n_moves - 1; + printf("¿Which move will you do [0-%d]?: ", v); + scanf("%d", &tirada); + while (tirada < 0 || tirada > v) + { + printf("¡%d is not an option!\n", tirada); + printf("¿Which move will you do [0-%d]?: ", v); + scanf("%d", &tirada); + } + printf("\n"); + if ((ts.count_dobles > 1) && (tirada == ts.n_moves)) + { //Se dobledobla cuando el contador tiene 2 tiradas con dobles y el player la escoje + play_from_right(&(p_pa->m), p_pa->js.j[p_pa->js.turn].f[ts.t[ts.dobleleft].n_tile]); //doble por la derecha + play_from_left(&(p_pa->m), p_pa->js.j[p_pa->js.turn].f[ts.t[ts.dobleright].n_tile]); //doble por la izquierda + for (i = ts.t[ts.dobleright].n_tile; i < p_pa->js.j[p_pa->js.turn].n_tiles - 1; i++) // Eliminar un doble del vector de tiles del player + p_pa->js.j[p_pa->js.turn].f[i] = p_pa->js.j[p_pa->js.turn].f[i + 1]; + p_pa->js.j[p_pa->js.turn].n_tiles--; + if (ts.t[ts.dobleleft].n_tile > ts.t[ts.dobleright].n_tile) + { // Eliminar el otro doble del vector de tiles dependiendo de donde se encuentre respecto al primer doble + for (i = ts.t[ts.dobleleft - 1].n_tile; i < p_pa->js.j[p_pa->js.turn].n_tiles - 1; i++) + p_pa->js.j[p_pa->js.turn].f[i] = p_pa->js.j[p_pa->js.turn].f[i + 1]; + p_pa->js.j[p_pa->js.turn].n_tiles--; + } + else + { + for (i = ts.t[ts.dobleleft - 1].n_tile; i < p_pa->js.j[p_pa->js.turn].n_tiles - 1; i++) + p_pa->js.j[p_pa->js.turn].f[i] = p_pa->js.j[p_pa->js.turn].f[i + 1]; + p_pa->js.j[p_pa->js.turn].n_tiles--; + } + } + if (tirada != ts.n_moves) + { //Si no se dobledobla + if (ts.t[tirada].rotated == TRUE) //Gira la tile si debe hacerlo + turn_tile(&(p_pa->js.j[p_pa->js.turn].f[ts.t[tirada].n_tile])); + if (ts.t[tirada].corner == 'd') + { + play_from_right(&(p_pa->m), p_pa->js.j[p_pa->js.turn].f[ts.t[tirada].n_tile]); //Coloca por la derecha + } + else + { + play_from_left(&(p_pa->m), p_pa->js.j[p_pa->js.turn].f[ts.t[tirada].n_tile]); //Coloca por la izquierda + } + for (i = ts.t[tirada].n_tile; i < p_pa->js.j[p_pa->js.turn].n_tiles - 1; i++) + p_pa->js.j[p_pa->js.turn].f[i] = p_pa->js.j[p_pa->js.turn].f[i + 1]; + p_pa->js.j[p_pa->js.turn].n_tiles--; + } + } + } + else + { /*TIRA UN ROBOT*/ + if (ts.n_moves == 0 && p_pa->pi.n_tiles == 0) + { + printf("Pasa! :)\n\n"); //Si no puede tirar pasa turn + p_pa->pasadas++; + } + //Robot no puede tirar y pasa turn + + if (ts.n_moves > 0) + { + p_pa->pasadas = 0; + if (ts.count_dobles > 1) + ts.n_moves++; // dobledoblarse cuenta como una tirada más + tirada = random_number(ts.n_moves); // Escoge una tirada al azar + if ((ts.count_dobles > 1) && (tirada == ts.n_moves)) + { //Se dobledobla cuando el contador tiene 2 tiradas con dobles y el player la escoje + play_from_right(&(p_pa->m), p_pa->js.j[p_pa->js.turn].f[ts.t[ts.dobleleft].n_tile]); // doble por la derecha + play_from_left(&(p_pa->m), p_pa->js.j[p_pa->js.turn].f[ts.t[ts.dobleright].n_tile]); // doble por la izquierda + for (i = ts.t[ts.dobleright].n_tile; i < p_pa->js.j[p_pa->js.turn].n_tiles - 1; i++) // Eliminar un doble del vector de tiles del robot + p_pa->js.j[p_pa->js.turn].f[i] = p_pa->js.j[p_pa->js.turn].f[i + 1]; + p_pa->js.j[p_pa->js.turn].n_tiles--; + if (ts.t[ts.dobleleft].n_tile > ts.t[ts.dobleright].n_tile) + { //Eliminar el otro doble dependiendo de su posición respecto al primero + for (i = ts.t[ts.dobleleft - 1].n_tile; i < p_pa->js.j[p_pa->js.turn].n_tiles - 1; i++) + p_pa->js.j[p_pa->js.turn].f[i] = p_pa->js.j[p_pa->js.turn].f[i + 1]; + p_pa->js.j[p_pa->js.turn].n_tiles--; + } + else + { + for (i = ts.t[ts.dobleleft - 1].n_tile; i < p_pa->js.j[p_pa->js.turn].n_tiles - 1; i++) + p_pa->js.j[p_pa->js.turn].f[i] = p_pa->js.j[p_pa->js.turn].f[i + 1]; + p_pa->js.j[p_pa->js.turn].n_tiles--; + } + } + else + { + if (ts.t[tirada].rotated == TRUE) //Gira la tile si debe hacerlo + turn_tile(&(p_pa->js.j[p_pa->js.turn].f[ts.t[tirada].n_tile])); + print_move(ts.t[tirada], p_pa->js.j[p_pa->js.turn]); + if (ts.t[tirada].corner == 'd') + { + play_from_right(&(p_pa->m), p_pa->js.j[p_pa->js.turn].f[ts.t[tirada].n_tile]); //Coloca por la derecha + } + else + { + play_from_left(&(p_pa->m), p_pa->js.j[p_pa->js.turn].f[ts.t[tirada].n_tile]); //Coloca por la izquierda + } + for (i = ts.t[tirada].n_tile; i < p_pa->js.j[p_pa->js.turn].n_tiles - 1; i++) //Elimina la tile del vector + p_pa->js.j[p_pa->js.turn].f[i] = p_pa->js.j[p_pa->js.turn].f[i + 1]; + p_pa->js.j[p_pa->js.turn].n_tiles--; + } + sleep_a_bit(4); + } + } + + skip_turn(&(p_pa->js)); +} + +int has_the_game_ended(t_game pa) +{ + int aux = FALSE, minweight = 200, i, j, jugminweight, empate = FALSE; + + if (pa.js.turn > 0) // Como has_the_game_ended se coloca despues de skip_turn, pa.js.turn debe ser un numero menos + pa.js.turn = pa.js.turn - 1; + + else // NO puede ser -1, asi que vuelve a n_players-1 (maximo) + pa.js.turn = pa.js.n_players - 1; + + if (pa.js.j[pa.js.turn].n_tiles == 0) + { // Condición de ganador + if (pa.js.j[pa.js.turn].type == T_HUMAN) + { // Gana el humano + printf("===>>> HAS GANADO! :) <<<===\n\n"); + } + else + { //Gana el robot + printf("===>>> HA GANADO EL J%d! :/ <<<===\n\n", pa.js.turn); + } + aux = TRUE; + return (aux); + } + else if (pa.pasadas >= pa.js.n_players) + { //Ganador en bloqueo + printf("===>>> JUEGO BLOQUEADO <<<===\n\n"); + aux = TRUE; + for (i = 0; i < pa.js.n_players; i++) + { // Calcula el weight de las tiles + pa.js.j[i].weight = 0; + for (j = 0; j < pa.js.j[i].n_tiles; j++) + { + pa.js.j[i].weight = pa.js.j[i].weight + pa.js.j[i].f[j].num1 + pa.js.j[i].f[j].num2; + } + printf("weight J%d=%d\n", i, pa.js.j[i].weight); + } + for (i = 0; i < pa.js.n_players; i++) + { //weight minimo con su player + if (minweight > pa.js.j[i].weight) + { + minweight = pa.js.j[i].weight; + jugminweight = i; + } + } + for (i = 0; i < pa.js.n_players; i++) + { // Caso de empate (tablas) + if (minweight == pa.js.j[i].weight && i != jugminweight) + { + empate = TRUE; + } + } + if (empate == TRUE) + { // Tablas + printf("\n===>>> TABLAS ENTRE J%d Y J%d CON MINIMO weight(%d de weight) <<<===\n\n\n", jugminweight, i, minweight); + } + else + { // Ganador + printf("\n===>>> HA GANADO EL J%d POR MINIMO weight(%d de weight) <<<===\n\n\n", jugminweight, minweight); + } + } + else + return (aux); +} diff --git a/game.h b/game.h new file mode 100644 index 0000000..d8e4720 --- /dev/null +++ b/game.h @@ -0,0 +1,27 @@ +#ifndef GAME_H +#define GAME_H + +#include "player.h" +#include "table.h" +#include "stack.h" +#include "move.h" + +typedef struct +{ + t_players js; + t_table m; // tiles jugadas + t_stack pi; // tiles no jugadas y que no tiene nadie + int visible; // Pila y tiles de robots visibles + int table_2d; // Ver mesa en 2D (versus 1D) + // visible y table_2d pueden valer TRUE o FALSE + int pasadas; // Veces consecutivas que un player pasa + // si pasadas == n_player se acaba el juego. +} t_game; + +void initialize_game(t_game *p_pa); +void print_game_state(t_game pa); +void print_final_game_state(t_game pa); +void make_play(t_game *p_pa); +int has_the_game_ended(t_game pa); + +#endif // GAME_H diff --git a/jugador.c b/jugador.c deleted file mode 100644 index ad04bc7..0000000 --- a/jugador.c +++ /dev/null @@ -1,112 +0,0 @@ -#include "ficha.h" -#include - -#define MIN_JUGADORES 2 -#define MAX_JUGADORES 4 - -#define T_HUMANO 1 -#define T_ROBOT 2 - -#define TRUE 1 -#define FALSE 0 - -typedef struct -{ - int n_fichas; - t_ficha f[NUM_FICHAS_DOMINO]; // Fichas que tiene - int tipo; - int peso; -} t_jugador; - -typedef struct -{ - int n_jugadores; - int un_humano; // TRUE or FALSE - int turno; - t_jugador j[MAX_JUGADORES]; // Fichas que tiene y otras cosas -} t_jugadores; - -void imprimir_jugador(t_jugador j, int visible); -void imprimir_jugadores(t_jugadores js, int visible); -void que_jugador_tiene_doble_mas_alto(t_jugadores js, int *p_nj, int *p_nf); -void pasar_turno(t_jugadores *p_js); -void imprimir_turno(t_jugadores _js); - -void imprimir_jugador(t_jugador j, int visible) -{ - int i; - t_ficha f; - - if (j.tipo == T_ROBOT) - { // Robot - if (visible == FALSE) - { // Omnisciencia apagada - for (i = 0; i < j.n_fichas; i++) - { - printf("?:?|"); - } - } - else - { // Omnisciencia encendida - for (i = 0; i < j.n_fichas; i++) - { - printf("%d:%d|", j.f[i].num1, j.f[i].num2); - } - } - } - else - { // Humano - for (i = 0; i < j.n_fichas; i++) - { - printf("%d:%d|", j.f[i].num1, j.f[i].num2); - } - } -} -void imprimir_jugadores(t_jugadores js, int visible) -{ - int i; - for (i = 0; i < js.n_jugadores; i++) - { //Ejecuta el codigo para cada jugador - printf("J%d ", i); - imprimir_jugador(js.j[i], visible); - if (js.j[i].tipo == T_ROBOT) - { //Robot - printf("Robot\n"); - } - else - { //Humano - printf("Humano\n"); - } - } -} -void que_jugador_tiene_doble_mas_alto(t_jugadores js, int *p_nj, int *p_nf) -{ - int i, j, max = 0, encontrado = 0; - - for (i = 0; i < js.n_jugadores; i++) - { //Comprueba que jugador tiene el doble mas alto - for (j = 0; j < js.j[i].n_fichas; j++) - { - if (js.j[i].f[j].num1 == js.j[i].f[j].num2 && js.j[i].f[j].num1 > max) - { - max = js.j[i].f[j].num1; - *p_nj = i; - *p_nf = j; - encontrado = 1; - } - } - } - if (encontrado == 0) - { - *p_nj = 0; - *p_nf = 0; - } -} -void pasar_turno(t_jugadores *p_js) -{ - p_js->turno = ((p_js->turno) + 1) % (p_js->n_jugadores); // Suma 1 al turno a menos que sea máximo, entonces vuelve al inicial (0) -} -void imprimir_turno(t_jugadores js) -{ - printf("Turno: %d\n", js.turno); -} diff --git a/jugador.h b/jugador.h deleted file mode 100644 index 78766ee..0000000 --- a/jugador.h +++ /dev/null @@ -1,33 +0,0 @@ -#ifndef JUGADOR_H -#define JUGADOR_H - -#include "ficha.h" - -#define MIN_JUGADORES 2 -#define MAX_JUGADORES 4 - -#define T_HUMANO 1 -#define T_ROBOT 2 - -typedef struct { - int n_fichas; - t_ficha f[NUM_FICHAS_DOMINO]; // Fichas que tiene - int tipo; - int peso; -} t_jugador; - -typedef struct { - int n_jugadores; - int un_humano; // TRUE or FALSE - int turno; - t_jugador j[MAX_JUGADORES]; // Fichas que tiene y otras cosas -} t_jugadores; - -void imprimir_jugador(t_jugador j, int visible); -void imprimir_jugadores(t_jugadores js, int visible); -void que_jugador_tiene_doble_mas_alto(t_jugadores js, int *p_nj, int *p_nf); -void pasar_turno(t_jugadores *p_js); -void imprimir_turno(t_jugadores _js); - -#endif // JUGADOR_H - diff --git a/main.c b/main.c index e0c3a22..ebd3bb8 100644 --- a/main.c +++ b/main.c @@ -1,21 +1,21 @@ -#include "partida.h" -//incloure totes les llibreries +#include "game.h" #define TRUE 1 #define FALSE 0 -int main(){ - int acabado; - t_partida partida; - inicializar_partida(&partida); - realizar_jugada(&partida); - acabado=FALSE; // Inicialitzem "acabado" a 0 perque la partida comença i ha d'entrar al while - while(acabado==FALSE) // Entra sempre que es pugui seguint jugar - { - imprimir_estado_partida(partida); - realizar_jugada(&partida); - acabado=se_ha_acabado_la_partida(partida); +int main() +{ + int end; + t_game game; + initialize_game(&game); + make_play(&game); + end = FALSE; // Inicialitzem "end" a 0 perque la game comença i ha d'entrar al while + while (end == FALSE) // Entra sempre que es pugui seguint jugar + { + print_game_state(game); + make_play(&game); + end = has_the_game_ended(game); } - - imprimir_estado_final_partida(partida); // Printf de la partida en la jugada final + + print_final_game_state(game); // Printf de la game en la jugada final } diff --git a/mesa.c b/mesa.c deleted file mode 100644 index 51e21c9..0000000 --- a/mesa.c +++ /dev/null @@ -1,98 +0,0 @@ -#include -#include "ficha.h" -#define NUM_FICHAS_DOMINO 28 - -typedef struct -{ - int n_fichas; - t_ficha f[NUM_FICHAS_DOMINO]; -} t_mesa; - -void inicializar_mesa(t_mesa *p_m) -{ - p_m->n_fichas = 0; // Inicialmente no hay fichas en la mesa -} - -void imprimir_mesa(t_mesa m, int dim) -{ - int i, pos2; - - printf("\nMesa: "); - if (dim == FALSE) - { //sense 2d - for (i = 0; i < m.n_fichas; i++) - printf("%d:%d|", m.f[i].num1, m.f[i].num2); - } - else - { //con 2d - printf("\n"); - - for (i = 0; i < m.n_fichas; i++) - { - if (m.f[i].num1 == m.f[i].num2) - { //es doble, poner vertical - printf("%d|", m.f[i].num1); - } - else - { - printf("___ "); - } - } - printf("\n"); - for (i = 0; i < m.n_fichas; i++) - { - if (m.f[i].num1 == m.f[i].num2) - { //es doble, poner vertical - printf("-|"); - } - else - { - printf("%d:%d|", m.f[i].num1, m.f[i].num2); //es normal, se imprime normal - } - } - printf("\n"); - for (i = 0; i < m.n_fichas; i++) - { - if (m.f[i].num1 == m.f[i].num2) - { //es doble, poner vertical - printf("%d|", m.f[i].num1); - } - else - { - printf(" "); - } - } - printf("\n"); - } -} - -void pon_en_mesa_por_la_derecha(t_mesa *p_m, t_ficha f) -{ - int i; - - p_m->f[p_m->n_fichas] = f; // Posición de la derecha: n_fichas porque es la primera posición vacia en el vector - p_m->n_fichas++; -} -void pon_en_mesa_por_la_izquierda(t_mesa *p_m, t_ficha f) -{ - int i; - p_m->n_fichas++; - for (i = p_m->n_fichas; i > 0; i--) - { // Desplaza toda la mesa un lugar a la derecha - p_m->f[i] = p_m->f[i - 1]; - } - p_m->f[0] = f; // Introduce en la posición 0 la nueva ficha -} - -int extremo_izquierdo_mesa(t_mesa m) -{ - int izquierdo; - izquierdo = m.f[0].num1; - return (izquierdo); -} -int extremo_derecho_mesa(t_mesa m) -{ - int derecho; - derecho = m.f[m.n_fichas - 1].num2; - return (derecho); -} diff --git a/mesa.h b/mesa.h deleted file mode 100644 index 6fc068e..0000000 --- a/mesa.h +++ /dev/null @@ -1,20 +0,0 @@ -#ifndef MESA_H -#define MESA_H - -#include "ficha.h" - -typedef struct { - int n_fichas; - t_ficha f[NUM_FICHAS_DOMINO]; -} t_mesa; - -void inicializar_mesa(t_mesa *p_m); -void imprimir_mesa(t_mesa m, int dim); - -void pon_en_mesa_por_la_derecha(t_mesa *p_m, t_ficha f); -void pon_en_mesa_por_la_izquierda(t_mesa *p_m, t_ficha f); - -int extremo_izquierdo_mesa(t_mesa m); -int extremo_derecho_mesa(t_mesa m); - -#endif // MESA_H diff --git a/move.c b/move.c new file mode 100644 index 0000000..ebddaf8 --- /dev/null +++ b/move.c @@ -0,0 +1,122 @@ +#define MOVE_H + +#include +#include "tile.h" +#include "player.h" +#include "table.h" + +#define MAX_MOVES_PLAYER NUM_TILES_DOMINO + +typedef struct +{ + int n_tile; // Number of tiles in the tiles vector of the player + char corner; // Left or right + int rotated; // True or false + int dobledobla; +} t_tirada; + +typedef struct +{ + int n_moves; + t_tirada t[MAX_MOVES_PLAYER]; + int count_dobles, dobleleft, dobleright; + +} t_tiradas; + +void print_move(t_tirada t, t_player j) +{ // Always visible independent of omniscience + int aux; + aux = t.n_tile; + if (j.type == T_ROBOT) + printf("Move: %c|%d:%d|\n\n", t.corner, j.f[aux].num1, j.f[aux].num2); +} + +void print_moves(t_tiradas ts, t_player j, int visible) +{ + int i; + + if ((visible == TRUE && j.type == T_ROBOT) || j.type == T_HUMAN) + { // Visible if omniscience is active or the player is human + printf("Possible moves: "); + if (ts.n_moves > 0) + { // If the player can move + for (i = 0; i < ts.n_moves; i++) + { + printf("%d(%c%d:%d) ", i, ts.t[i].corner, j.f[ts.t[i].n_tile].num1, j.f[ts.t[i].n_tile].num2); + } + + if ((ts.count_dobles > 1) && (j.f[ts.t[ts.dobleleft].n_tile].num1 != j.f[ts.t[ts.dobleright].n_tile].num2)) + { + i = ts.n_moves; + printf("%d(%c%d:%d|%c%d:%d) ", i, ts.t[ts.dobleleft].corner, j.f[ts.t[ts.dobleleft].n_tile].num1, j.f[ts.t[ts.dobleleft].n_tile].num2, ts.t[ts.dobleright].corner, j.f[ts.t[ts.dobleright].n_tile].num1, j.f[ts.t[ts.dobleright].n_tile].num2); + } + printf("\n"); + } + else + printf("There are no possible movements!\n"); // If the player cannot move + } +} + +t_tiradas calculate_possible_moves(t_player j, t_table m) +{ + t_tiradas ts; + int izq, der, i, k = 0, doble; + izq = table_leftmost(m); // Gets the leftmost tile on the table + der = table_rightmost(m); // Gets the rightmost tile on the table + ts.count_dobles = 0; + for (i = 0; i < j.n_tiles; i++) + { + doble = 0; + if (j.f[i].num1 == j.f[i].num2) + doble = TRUE; // Check if it is a double + + if (j.f[i].num2 == izq) + { // Move from the left without rotating + if (doble == TRUE) + { + ts.count_dobles++; + ts.dobleleft = k; + } + ts.t[k].n_tile = i; + ts.t[k].corner = 'i'; + ts.t[k].rotated = 0; + k++; + } + if (j.f[i].num1 == izq) + { // Move from the left rotating + if (doble == FALSE) + { + ts.t[k].n_tile = i; + ts.t[k].corner = 'i'; + ts.t[k].rotated = 1; + k++; + } + } + if (j.f[i].num1 == der) + { // Move from the right without rotating + if (doble == TRUE) + { + ts.count_dobles++; + ts.dobleright = k; + } + ts.t[k].n_tile = i; + ts.t[k].corner = 'd'; + ts.t[k].rotated = 0; + k++; + } + if (j.f[i].num2 == der) + { // Move from the right rotating + if (doble == FALSE) + { + ts.t[k].n_tile = i; + ts.t[k].corner = 'd'; + ts.t[k].rotated = 1; + k++; + } + } + + ts.n_moves = k; // Number of movements + } + + return (ts); +} diff --git a/move.h b/move.h new file mode 100644 index 0000000..4e7bfda --- /dev/null +++ b/move.h @@ -0,0 +1,29 @@ +#ifndef MOVE_H +#define MOVE_H + +#include "tile.h" +#include "player.h" +#include "table.h" + +#define MAX_MOVES_PLAYER NUM_TILES_DOMINO + +typedef struct +{ + int n_tile; // Number of tiles in the tiles vector of the player + char corner; // Left or right + int rotated; // True or false + int dobledobla; +} t_tirada; + +typedef struct +{ + int n_moves; + t_tirada t[MAX_MOVES_PLAYER]; + int count_dobles, dobleright, dobleleft; +} t_tiradas; + +void print_move(t_tirada ts, t_player j); +void print_moves(t_tiradas ts, t_player j); +t_tiradas calculate_possible_moves(t_player j, t_table m); + +#endif // MOVE_H diff --git a/partida.c b/partida.c deleted file mode 100644 index 693a7e1..0000000 --- a/partida.c +++ /dev/null @@ -1,327 +0,0 @@ -#include -#include -#include "jugador.h" -#include "mesa.h" -#include "pila.h" -#include "tirada.h" -#include "preguntas.h" -#include "duerme.h" -#include "azar.h" - -#define TRUE 1 -#define FALSE 0 -typedef struct -{ - t_jugadores js; - t_mesa m; // Fichas jugadas - t_pila pi; // Fichas no jugadas y que no tiene nadie - int visible; // Pila y fichas de robots visibles - int dim; // Ver mesa en 2D (versus 1D) - // visible y mesa_2d pueden valer TRUE o FALSE - int pasadas; // Veces consecutivas que un jugador pasa - // si pasadas == n_jugadores se acaba el juego. -} t_partida; - -void inicializar_partida(t_partida *p_pa); -void imprimir_estado_partida(t_partida pa); -void realizar_jugada(t_partida *p_pa); -int se_ha_acabado_la_partida(t_partida pa); - -void inicializar_partida(t_partida *p_pa) -{ - int i, j, p, k, nj, nf; - char s1[50] = "¿Numero de jugadores?", s2[50] = "¿Un jugador humano?", s3[50] = "¿Quieres omnisciencia?", s4[50] = "¿Quieres ver la mesa en 2D?"; - - p_pa->pasadas = 0; - - p_pa->js.n_jugadores = preguntar_n_en_rango(&s1[0], 2, 4); //Realizamos las preguntas - p_pa->js.un_humano = preguntar_si_o_no(&s2[0]); - p_pa->visible = preguntar_si_o_no(&s3[0]); - p_pa->dim = preguntar_si_o_no(&s4[0]); - printf("\n"); - - inicializar_pila(&(p_pa->pi)); - - for (i = 0; i < p_pa->js.n_jugadores; i++) //Repartir fichas aleatoriamente - for (j = 0; j < 7; j++) - p_pa->js.j[i].f[j] = coger_ficha_de_la_pila(&(p_pa->pi)); - - if (p_pa->js.un_humano == TRUE) - { // Inicializamos los jugadores - p_pa->js.j[0].tipo = T_HUMANO; - p_pa->js.j[0].n_fichas = 7; - for (i = 1; i < p_pa->js.n_jugadores; i++) - { - p_pa->js.j[i].tipo = T_ROBOT; - p_pa->js.j[i].n_fichas = 7; - } - } - else - { - for (i = 0; i < p_pa->js.n_jugadores; i++) - { - p_pa->js.j[i].tipo = T_ROBOT; - p_pa->js.j[i].n_fichas = 7; - } - } - que_jugador_tiene_doble_mas_alto(p_pa->js, &nj, &nf); // Que jugador empieza la partida - - inicializar_mesa(&(p_pa->m)); - imprimir_pila(p_pa->pi, p_pa->visible); - - pon_en_mesa_por_la_izquierda(&(p_pa->m), p_pa->js.j[nj].f[nf]); - imprimir_mesa(p_pa->m, p_pa->dim); - printf("\n"); - - for (i = nf; i < p_pa->js.j[nj].n_fichas; i++) - p_pa->js.j[nj].f[i] = p_pa->js.j[nj].f[i + 1]; - p_pa->js.j[nj].n_fichas--; - - p_pa->js.turno = nj; - imprimir_jugadores(p_pa->js, p_pa->visible); - pasar_turno(&(p_pa->js)); - imprimir_turno(p_pa->js); -} - -void imprimir_estado_partida(t_partida pa) -{ - int i; - imprimir_pila(pa.pi, pa.visible); - //POSAR MESA EN NEGRETA - imprimir_mesa(pa.m, pa.dim); - printf("\n"); - imprimir_jugadores(pa.js, pa.visible); - imprimir_turno(pa.js); -} -void imprimir_estado_final_partida(t_partida pa) -{ // Printf de la partida en el momento del final de la partida - int i; - duerme_un_rato(10); - printf("\tESTADO FINAL DE PARTIDA:\n\n"); - pa.visible = TRUE; - - imprimir_pila(pa.pi, pa.visible); - //POSAR MESA EN NEGRETA - imprimir_mesa(pa.m, pa.dim); - printf("\n"); - imprimir_jugadores(pa.js, pa.visible); - printf("\n"); -} - -void realizar_jugada(t_partida *p_pa) -{ - int tirada = -1, i, v; - t_tiradas ts; - - ts = calcular_tiradas_posibles(p_pa->js.j[p_pa->js.turno], p_pa->m); //Calculamos si hay tiradas posibles - - while (ts.n_tiradas == 0 && p_pa->pi.n_fichas != 0) - { // Si no puede tirar tiene que robar ficha - p_pa->js.j[p_pa->js.turno].f[p_pa->js.j[p_pa->js.turno].n_fichas] = coger_ficha_de_la_pila(&(p_pa->pi)); - - if (p_pa->visible == TRUE) - { // Omnisciencia activada - if (p_pa->js.j[p_pa->js.turno].tipo == T_HUMANO) // Si es humano muestra la ficha - printf("Vas a la pila! Pillas un %d:%d ;P\n", p_pa->js.j[p_pa->js.turno].f[p_pa->js.j[p_pa->js.turno].n_fichas].num1, p_pa->js.j[p_pa->js.turno].f[p_pa->js.j[p_pa->js.turno].n_fichas].num2); - else - printf("Va a la pila! Pilla un %d:%d ;)\n", p_pa->js.j[p_pa->js.turno].f[p_pa->js.j[p_pa->js.turno].n_fichas].num1, p_pa->js.j[p_pa->js.turno].f[p_pa->js.j[p_pa->js.turno].n_fichas].num2); // Si es robot muestra la ficha - p_pa->js.j[p_pa->js.turno].n_fichas++; - ts = calcular_tiradas_posibles(p_pa->js.j[p_pa->js.turno], p_pa->m); - } - if (p_pa->visible == FALSE) - { - if (p_pa->js.j[p_pa->js.turno].tipo == T_HUMANO) //Si es humano muestra la ficha - printf("Vas a la pila! Pillas un %d:%d ;P\n", p_pa->js.j[p_pa->js.turno].f[p_pa->js.j[p_pa->js.turno].n_fichas].num1, p_pa->js.j[p_pa->js.turno].f[p_pa->js.j[p_pa->js.turno].n_fichas].num2); - else - printf("Va a la pila! ;)\n"); //Si es robot no muestra la ficha - p_pa->js.j[p_pa->js.turno].n_fichas++; - ts = calcular_tiradas_posibles(p_pa->js.j[p_pa->js.turno], p_pa->m); - } - } - - imprimir_tiradas(ts, p_pa->js.j[p_pa->js.turno]); - - if (p_pa->js.j[p_pa->js.turno].tipo == T_HUMANO) - { //tira humano - if (ts.n_tiradas == 0 && p_pa->pi.n_fichas == 0) - { //HUMANO no puede tirar y pasa turno - printf("Pasas! :(\n\n"); - p_pa->pasadas++; - } - - if (ts.n_tiradas > 0) - { - p_pa->pasadas = 0; - if (ts.cont_dobles > 1) - v = ts.n_tiradas; //Si se dobledobla cuenta esa tirada como extra - else - v = ts.n_tiradas - 1; - printf("¿Que tirada juegas[0-%d]?: ", v); - scanf("%d", &tirada); - while (tirada < 0 || tirada > v) - { - printf("¡%d no es una opcion!\n", tirada); - printf("¿Que tirada juegas[0-%d]?: ", v); - scanf("%d", &tirada); - } - printf("\n"); - if ((ts.cont_dobles > 1) && (tirada == ts.n_tiradas)) - { //Se dobledobla cuando el contador tiene 2 tiradas con dobles y el jugador la escoje - pon_en_mesa_por_la_derecha(&(p_pa->m), p_pa->js.j[p_pa->js.turno].f[ts.t[ts.dobleizquierda].n_ficha]); //Doble por la derecha - pon_en_mesa_por_la_izquierda(&(p_pa->m), p_pa->js.j[p_pa->js.turno].f[ts.t[ts.doblederecha].n_ficha]); //Doble por la izquierda - for (i = ts.t[ts.doblederecha].n_ficha; i < p_pa->js.j[p_pa->js.turno].n_fichas - 1; i++) // Eliminar un doble del vector de fichas del jugador - p_pa->js.j[p_pa->js.turno].f[i] = p_pa->js.j[p_pa->js.turno].f[i + 1]; - p_pa->js.j[p_pa->js.turno].n_fichas--; - if (ts.t[ts.dobleizquierda].n_ficha > ts.t[ts.doblederecha].n_ficha) - { // Eliminar el otro doble del vector de fichas dependiendo de donde se encuentre respecto al primer doble - for (i = ts.t[ts.dobleizquierda - 1].n_ficha; i < p_pa->js.j[p_pa->js.turno].n_fichas - 1; i++) - p_pa->js.j[p_pa->js.turno].f[i] = p_pa->js.j[p_pa->js.turno].f[i + 1]; - p_pa->js.j[p_pa->js.turno].n_fichas--; - } - else - { - for (i = ts.t[ts.dobleizquierda - 1].n_ficha; i < p_pa->js.j[p_pa->js.turno].n_fichas - 1; i++) - p_pa->js.j[p_pa->js.turno].f[i] = p_pa->js.j[p_pa->js.turno].f[i + 1]; - p_pa->js.j[p_pa->js.turno].n_fichas--; - } - } - if (tirada != ts.n_tiradas) - { //Si no se dobledobla - if (ts.t[tirada].girada == TRUE) //Gira la ficha si debe hacerlo - girar_ficha(&(p_pa->js.j[p_pa->js.turno].f[ts.t[tirada].n_ficha])); - if (ts.t[tirada].extremo == 'd') - { - pon_en_mesa_por_la_derecha(&(p_pa->m), p_pa->js.j[p_pa->js.turno].f[ts.t[tirada].n_ficha]); //Coloca por la derecha - } - else - { - pon_en_mesa_por_la_izquierda(&(p_pa->m), p_pa->js.j[p_pa->js.turno].f[ts.t[tirada].n_ficha]); //Coloca por la izquierda - } - for (i = ts.t[tirada].n_ficha; i < p_pa->js.j[p_pa->js.turno].n_fichas - 1; i++) - p_pa->js.j[p_pa->js.turno].f[i] = p_pa->js.j[p_pa->js.turno].f[i + 1]; - p_pa->js.j[p_pa->js.turno].n_fichas--; - } - } - } - else - { /*TIRA UN ROBOT*/ - if (ts.n_tiradas == 0 && p_pa->pi.n_fichas == 0) - { - printf("Pasa! :)\n\n"); //Si no puede tirar pasa turno - p_pa->pasadas++; - } - //Robot no puede tirar y pasa turno - - if (ts.n_tiradas > 0) - { - p_pa->pasadas = 0; - if (ts.cont_dobles > 1) - ts.n_tiradas++; // Dobledoblarse cuenta como una tirada más - tirada = numero_al_azar(ts.n_tiradas); // Escoge una tirada al azar - if ((ts.cont_dobles > 1) && (tirada == ts.n_tiradas)) - { //Se dobledobla cuando el contador tiene 2 tiradas con dobles y el jugador la escoje - pon_en_mesa_por_la_derecha(&(p_pa->m), p_pa->js.j[p_pa->js.turno].f[ts.t[ts.dobleizquierda].n_ficha]); // Doble por la derecha - pon_en_mesa_por_la_izquierda(&(p_pa->m), p_pa->js.j[p_pa->js.turno].f[ts.t[ts.doblederecha].n_ficha]); // Doble por la izquierda - for (i = ts.t[ts.doblederecha].n_ficha; i < p_pa->js.j[p_pa->js.turno].n_fichas - 1; i++) // Eliminar un doble del vector de fichas del robot - p_pa->js.j[p_pa->js.turno].f[i] = p_pa->js.j[p_pa->js.turno].f[i + 1]; - p_pa->js.j[p_pa->js.turno].n_fichas--; - if (ts.t[ts.dobleizquierda].n_ficha > ts.t[ts.doblederecha].n_ficha) - { //Eliminar el otro doble dependiendo de su posición respecto al primero - for (i = ts.t[ts.dobleizquierda - 1].n_ficha; i < p_pa->js.j[p_pa->js.turno].n_fichas - 1; i++) - p_pa->js.j[p_pa->js.turno].f[i] = p_pa->js.j[p_pa->js.turno].f[i + 1]; - p_pa->js.j[p_pa->js.turno].n_fichas--; - } - else - { - for (i = ts.t[ts.dobleizquierda - 1].n_ficha; i < p_pa->js.j[p_pa->js.turno].n_fichas - 1; i++) - p_pa->js.j[p_pa->js.turno].f[i] = p_pa->js.j[p_pa->js.turno].f[i + 1]; - p_pa->js.j[p_pa->js.turno].n_fichas--; - } - } - else - { - if (ts.t[tirada].girada == TRUE) //Gira la ficha si debe hacerlo - girar_ficha(&(p_pa->js.j[p_pa->js.turno].f[ts.t[tirada].n_ficha])); - imprimir_tirada(ts.t[tirada], p_pa->js.j[p_pa->js.turno]); - if (ts.t[tirada].extremo == 'd') - { - pon_en_mesa_por_la_derecha(&(p_pa->m), p_pa->js.j[p_pa->js.turno].f[ts.t[tirada].n_ficha]); //Coloca por la derecha - } - else - { - pon_en_mesa_por_la_izquierda(&(p_pa->m), p_pa->js.j[p_pa->js.turno].f[ts.t[tirada].n_ficha]); //Coloca por la izquierda - } - for (i = ts.t[tirada].n_ficha; i < p_pa->js.j[p_pa->js.turno].n_fichas - 1; i++) //Elimina la ficha del vector - p_pa->js.j[p_pa->js.turno].f[i] = p_pa->js.j[p_pa->js.turno].f[i + 1]; - p_pa->js.j[p_pa->js.turno].n_fichas--; - } - duerme_un_rato(4); - } - } - - pasar_turno(&(p_pa->js)); -} - -int se_ha_acabado_la_partida(t_partida pa) -{ - int aux = FALSE, minpeso = 200, i, j, jugminpeso, empate = FALSE; - - if (pa.js.turno > 0) // Como se_ha_acabado_la_partida se coloca despues de pasar_turno, pa.js.turno debe ser un numero menos - pa.js.turno = pa.js.turno - 1; - - else // NO puede ser -1, asi que vuelve a n_jugadores-1 (maximo) - pa.js.turno = pa.js.n_jugadores - 1; - - if (pa.js.j[pa.js.turno].n_fichas == 0) - { // Condición de ganador - if (pa.js.j[pa.js.turno].tipo == T_HUMANO) - { // Gana el humano - printf("===>>> HAS GANADO! :) <<<===\n\n"); - } - else - { //Gana el robot - printf("===>>> HA GANADO EL J%d! :/ <<<===\n\n", pa.js.turno); - } - aux = TRUE; - return (aux); - } - else if (pa.pasadas >= pa.js.n_jugadores) - { //Ganador en bloqueo - printf("===>>> JUEGO BLOQUEADO <<<===\n\n"); - aux = TRUE; - for (i = 0; i < pa.js.n_jugadores; i++) - { // Calcula el peso de las fichas - pa.js.j[i].peso = 0; - for (j = 0; j < pa.js.j[i].n_fichas; j++) - { - pa.js.j[i].peso = pa.js.j[i].peso + pa.js.j[i].f[j].num1 + pa.js.j[i].f[j].num2; - } - printf("Peso J%d=%d\n", i, pa.js.j[i].peso); - } - for (i = 0; i < pa.js.n_jugadores; i++) - { //Peso minimo con su jugador - if (minpeso > pa.js.j[i].peso) - { - minpeso = pa.js.j[i].peso; - jugminpeso = i; - } - } - for (i = 0; i < pa.js.n_jugadores; i++) - { // Caso de empate (tablas) - if (minpeso == pa.js.j[i].peso && i != jugminpeso) - { - empate = TRUE; - } - } - if (empate == TRUE) - { // Tablas - printf("\n===>>> TABLAS ENTRE J%d Y J%d CON MINIMO PESO(%d de peso) <<<===\n\n\n", jugminpeso, i, minpeso); - } - else - { // Ganador - printf("\n===>>> HA GANADO EL J%d POR MINIMO PESO(%d de peso) <<<===\n\n\n", jugminpeso, minpeso); - } - } - else - return (aux); -} diff --git a/partida.h b/partida.h deleted file mode 100644 index e58e5f5..0000000 --- a/partida.h +++ /dev/null @@ -1,27 +0,0 @@ -#ifndef PARTIDA_H -#define PARTIDA_H - -#include "jugador.h" -#include "mesa.h" -#include "pila.h" -#include "tirada.h" - -typedef struct -{ - t_jugadores js; - t_mesa m; // Fichas jugadas - t_pila pi; // Fichas no jugadas y que no tiene nadie - int visible; // Pila y fichas de robots visibles - int mesa_2d; // Ver mesa en 2D (versus 1D) - // visible y mesa_2d pueden valer TRUE o FALSE - int pasadas; // Veces consecutivas que un jugador pasa - // si pasadas == n_jugadores se acaba el juego. -} t_partida; - -void inicializar_partida(t_partida *p_pa); -void imprimir_estado_partida(t_partida pa); -void imprimir_estado_final_partida(t_partida pa); -void realizar_jugada(t_partida *p_pa); -int se_ha_acabado_la_partida(t_partida pa); - -#endif // PARTIDA_H diff --git a/pila.c b/pila.c deleted file mode 100644 index 77aa00d..0000000 --- a/pila.c +++ /dev/null @@ -1,74 +0,0 @@ -#include -#include "azar.h" -#include "ficha.h" -#define NUM_FICHAS_DOMINO 28 -#define FALSE 0 -#define TRUE 1 - -typedef struct -{ - int n_fichas; - t_ficha f[NUM_FICHAS_DOMINO]; -} t_pila; - -void imprimir_pila(t_pila pi, int visible); -void inicializar_pila(t_pila *pi); -int esta_la_pila_vacia(t_pila pi); -t_ficha coger_ficha_de_la_pila(t_pila *pi); - -void inicializar_pila(t_pila *pi) -{ - int i = 0, j, k; - - pi->n_fichas = NUM_FICHAS_DOMINO; // Al inicio todas las fichas estan en la pila - for (j = 0; j < 7; j++) - for (k = j; k < 7; k++) - { - inicializar_ficha(&pi->f[i], j, k); //Inicializa las 28 fichas - i++; - } -} - -void imprimir_pila(t_pila pi, int visible) -{ - int i; - - if (visible == TRUE) - { // Omnisciencia activada - printf("Pila:\t"); - for (i = 0; i < pi.n_fichas; i++) - imprimir_ficha(pi.f[i], visible); - } - - else - { // Omnisciencia apagada - printf("Pila:\t"); - for (i = 0; i < pi.n_fichas; i++) - printf("?:?|"); - } - if (pi.n_fichas == 0) - printf("La pila esta vacia"); -} - -int esta_la_pila_vacia(t_pila pi) -{ - if (pi.n_fichas == 0) - return (TRUE); - - else - return (FALSE); -} - -t_ficha coger_ficha_de_la_pila(t_pila *pi) -{ - int i, pos; - t_pila aux; - pos = numero_al_azar(pi->n_fichas); // Escoge una ficha aleatoria - aux.f[pos] = pi->f[pos]; // Guarda esta ficha aleatoria en un auxiliar - for (i = pos; i < (pi->n_fichas - 1); i++) - { // Elimina la ficha robada del vector de la pila - pi->f[i] = pi->f[i + 1]; - } - pi->n_fichas--; - return (aux.f[pos]); // El return devuelve la ficha robada -} diff --git a/pila.h b/pila.h deleted file mode 100644 index 1b15937..0000000 --- a/pila.h +++ /dev/null @@ -1,17 +0,0 @@ -#ifndef PILA_H -#define PILA_H - -#include "ficha.h" - -typedef struct -{ - int n_fichas; - t_ficha f[NUM_FICHAS_DOMINO]; -} t_pila; - -void inicializar_pila(t_pila *pi); -void imprimir_pila(t_pila pi, int visible); -t_ficha coger_ficha_de_la_pila(t_pila *pi); -int esta_la_pila_vacia(t_pila pi); - -#endif // PILA_H diff --git a/player.c b/player.c new file mode 100644 index 0000000..edd706c --- /dev/null +++ b/player.c @@ -0,0 +1,112 @@ +#include "tile.h" +#include + +#define MIN_PLAYERS 2 +#define MAX_PLAYERS 4 + +#define T_HUMAN 1 +#define T_ROBOT 2 + +#define TRUE 1 +#define FALSE 0 + +typedef struct +{ + int n_tiles; + t_tile f[NUM_TILES_DOMINO]; // tiles que tiene + int type; + int weight; +} t_player; + +typedef struct +{ + int n_players; + int a_human; // TRUE or FALSE + int turn; + t_player j[MAX_PLAYERS]; // tiles que tiene y otras cosas +} t_players; + +void print_player(t_player j, int visible); +void print_players(t_players js, int visible); +void who_has_higher_doble(t_players js, int *p_nj, int *p_nf); +void skip_turn(t_players *p_js); +void print_turn(t_players _js); + +void print_player(t_player j, int visible) +{ + int i; + t_tile f; + + if (j.type == T_ROBOT) + { // Robot + if (visible == FALSE) + { // Omnisciencia apagada + for (i = 0; i < j.n_tiles; i++) + { + printf("?:?|"); + } + } + else + { // Omnisciencia encendida + for (i = 0; i < j.n_tiles; i++) + { + printf("%d:%d|", j.f[i].num1, j.f[i].num2); + } + } + } + else + { // Humano + for (i = 0; i < j.n_tiles; i++) + { + printf("%d:%d|", j.f[i].num1, j.f[i].num2); + } + } +} +void print_players(t_players js, int visible) +{ + int i; + for (i = 0; i < js.n_players; i++) + { //Ejecuta el codigo para cada player + printf("J%d ", i); + print_player(js.j[i], visible); + if (js.j[i].type == T_ROBOT) + { //Robot + printf("Robot\n"); + } + else + { //Humano + printf("Humano\n"); + } + } +} +void who_has_higher_doble(t_players js, int *p_nj, int *p_nf) +{ + int i, j, max = 0, encontrado = 0; + + for (i = 0; i < js.n_players; i++) + { //Comprueba que player tiene el doble mas alto + for (j = 0; j < js.j[i].n_tiles; j++) + { + if (js.j[i].f[j].num1 == js.j[i].f[j].num2 && js.j[i].f[j].num1 > max) + { + max = js.j[i].f[j].num1; + *p_nj = i; + *p_nf = j; + encontrado = 1; + } + } + } + if (encontrado == 0) + { + *p_nj = 0; + *p_nf = 0; + } +} +void skip_turn(t_players *p_js) +{ + p_js->turn = ((p_js->turn) + 1) % (p_js->n_players); // Suma 1 al turn a menos que sea máximo, entonces vuelve al inicial (0) +} +void print_turn(t_players js) +{ + printf("turn: %d\n", js.turn); +} diff --git a/player.h b/player.h new file mode 100644 index 0000000..b505f49 --- /dev/null +++ b/player.h @@ -0,0 +1,34 @@ +#ifndef PLAYER_H +#define PLAYER_H + +#include "tile.h" + +#define MIN_PLAYERS 2 +#define MAX_PLAYERS 4 + +#define T_HUMAN 1 +#define T_ROBOT 2 + +typedef struct +{ + int n_tiles; + t_tile f[NUM_TILES_DOMINO]; // tiles que tiene + int type; + int weight; +} t_player; + +typedef struct +{ + int n_players; + int a_human; // TRUE or FALSE + int turn; + t_player j[MAX_PLAYERS]; // tiles que tiene y otras cosas +} t_players; + +void print_player(t_player j, int visible); +void print_players(t_players js, int visible); +void who_has_higher_doble(t_players js, int *p_nj, int *p_nf); +void skip_turn(t_players *p_js); +void print_turn(t_players _js); + +#endif // PLAYER_H diff --git a/preguntas.h b/preguntas.h deleted file mode 100644 index 2cc6da6..0000000 --- a/preguntas.h +++ /dev/null @@ -1,15 +0,0 @@ -// Este fichero se le da al alumno -#ifndef PREGUNTAS_H -#define PREGUNTAS_H - -#include - -#define TRUE 1 -#define FALSE 0 - -int fuera_de_rango(int n, int min, int max); -void convertir_a_minusculas(char *c); -int preguntar_n_en_rango(char *s, int min, int max); -int preguntar_si_o_no(char *s); - -#endif // PREGUNTAS_H diff --git a/preguntas.c b/questions.c similarity index 56% rename from preguntas.c rename to questions.c index a5911f8..219a53d 100644 --- a/preguntas.c +++ b/questions.c @@ -1,12 +1,11 @@ -// Este fichero se le da al alumno #include -int fuera_de_rango(int n, int min, int max) +int out_of_range(int n, int min, int max) { return ((n < min) || (n > max)); } -void convertir_a_minusculas(char *c) +void to_lower_caps(char *c) { if ((*c >= 'A') && (*c <= 'Z')) { @@ -14,7 +13,7 @@ void convertir_a_minusculas(char *c) } } -int preguntar_n_en_rango(char *s, int min, int max) +int ask_n_in_range(char *s, int min, int max) { int n; @@ -22,12 +21,12 @@ int preguntar_n_en_rango(char *s, int min, int max) { printf("%s [%d-%d]: ", s, min, max); scanf("%d%*c", &n); - } while (fuera_de_rango(n, min, max)); + } while (out_of_range(n, min, max)); return n; } -int preguntar_si_o_no(char *s) +int ask_yes_or_no(char *s) { char c; @@ -35,7 +34,7 @@ int preguntar_si_o_no(char *s) { printf("%s [s/n]: ", s); scanf("%c%*c", &c); - convertir_a_minusculas(&c); + to_lower_caps(&c); } while (c != 's' && c != 'n'); return (c == 's'); diff --git a/questions.h b/questions.h new file mode 100644 index 0000000..cceaacc --- /dev/null +++ b/questions.h @@ -0,0 +1,15 @@ +// Este fichero se le da al alumno +#ifndef QUESTIONS_H +#define QUESTIONS_H + +#include + +#define TRUE 1 +#define FALSE 0 + +int out_of_range(int n, int min, int max); +void to_lower_caps(char *c); +int ask_n_in_range(char *s, int min, int max); +int ask_yes_or_no(char *s); + +#endif // QUESTIONS_H diff --git a/random.c b/random.c new file mode 100644 index 0000000..fc3f9fc --- /dev/null +++ b/random.c @@ -0,0 +1,26 @@ +#include // time() +#include // rand(), srand() +#include // printf() +#include "random.h" + +/* + * initialize_random() has to be executed once at the beginning of main + * to start the generation of random numbers + */ +//void initialize_random() { +/* + * To ensure that the sequence of random numbers is the samePara que la sequencia de numeros aleatorios sea igual en cada + * in each execution use srand(0) instead srand(time). + */ +//srand(0); +// srand( (unsigned)time( NULL ) ); +//} + +/* + * random_number(max) returna a random integer number between 0 and max-1. + */ +int random_number(int max) +{ + srand(time(NULL)); + return (rand() % max); +} diff --git a/random.h b/random.h new file mode 100644 index 0000000..1e77968 --- /dev/null +++ b/random.h @@ -0,0 +1,7 @@ +#ifndef RANDOM_H +#define RANDOM_H + +void initialize_random(); +int random_number(int max); + +#endif /* RANDOM_H */ diff --git a/sleep.c b/sleep.c new file mode 100644 index 0000000..af4b6bd --- /dev/null +++ b/sleep.c @@ -0,0 +1,49 @@ +#include +#include "sleep.h" + +#define ONE_SECOND 1 // 1 second +#define HALF_SECOND 500000000 // 0.5 seconds + +/* + * Makes the execution of the program paused for + * the number of seconds passed as parameter. + */ +void sleep_n_seconds(long segundos) +{ + struct timespec tim, tim2; + tim.tv_sec = segundos; + tim.tv_nsec = 0; + + nanosleep(&tim, &tim2); +} + +/* + * Makes the execution of the program paused for + * the number of nanoseconds passed as parameter. + */ +void sleep_n_nanoseconds(long nanosegundos) +{ + struct timespec tim, tim2; + tim.tv_sec = 0; + tim.tv_nsec = nanosegundos; + + nanosleep(&tim, &tim2); +} + +/* + * Makes the execution of the program paused for + * a fixed number of seconds defined as constant. + */ +void sleep_a_bit() +{ + sleep_n_seconds(ONE_SECOND); +} + +/* + * Makes the execution of the program paused for + * a fixed number of nanoseconds defined as constant. + */ +void sleep_a_nano_bit() +{ + sleep_n_nanoseconds(HALF_SECOND); +} diff --git a/sleep.h b/sleep.h new file mode 100644 index 0000000..dfd39f2 --- /dev/null +++ b/sleep.h @@ -0,0 +1,9 @@ +#ifndef SLEEP_H +#define SLEEP_H + +void sleep_n_seconds(long segundos); +void sleep_n_seconds(long nanosegundos); +void sleep_a_bit(); +void sleep_a_nano_bit(); + +#endif /* SLEEP_H */ diff --git a/stack.c b/stack.c new file mode 100644 index 0000000..a6d1e67 --- /dev/null +++ b/stack.c @@ -0,0 +1,74 @@ +#include +#include "random.h" +#include "tile.h" +#define NUM_TILES_DOMINO 28 +#define FALSE 0 +#define TRUE 1 + +typedef struct +{ + int n_tiles; + t_tile f[NUM_TILES_DOMINO]; +} t_stack; + +void print_stack(t_stack pi, int visible); +void initialize_stack(t_stack *pi); +int is_stack_empty(t_stack pi); +t_tile pick_from_stack(t_stack *pi); + +void initialize_stack(t_stack *pi) +{ + int i = 0, j, k; + + pi->n_tiles = NUM_TILES_DOMINO; // Al inicio todas las tiles estan en la pila + for (j = 0; j < 7; j++) + for (k = j; k < 7; k++) + { + initialize_tile(&pi->f[i], j, k); //Inicializa las 28 tiles + i++; + } +} + +void print_stack(t_stack pi, int visible) +{ + int i; + + if (visible == TRUE) + { // Omnisciencia activada + printf("Pila:\t"); + for (i = 0; i < pi.n_tiles; i++) + print_tile(pi.f[i], visible); + } + + else + { // Omnisciencia apagada + printf("Pila:\t"); + for (i = 0; i < pi.n_tiles; i++) + printf("?:?|"); + } + if (pi.n_tiles == 0) + printf("La pila esta vacia"); +} + +int is_stack_empty(t_stack pi) +{ + if (pi.n_tiles == 0) + return (TRUE); + + else + return (FALSE); +} + +t_tile pick_from_stack(t_stack *pi) +{ + int i, pos; + t_stack aux; + pos = random_number(pi->n_tiles); // Escoge una tile aleatoria + aux.f[pos] = pi->f[pos]; // Guarda esta tile aleatoria en un auxiliar + for (i = pos; i < (pi->n_tiles - 1); i++) + { // Elimina la tile robada del vector de la pila + pi->f[i] = pi->f[i + 1]; + } + pi->n_tiles--; + return (aux.f[pos]); // El return devuelve la tile robada +} diff --git a/stack.h b/stack.h new file mode 100644 index 0000000..f83688a --- /dev/null +++ b/stack.h @@ -0,0 +1,17 @@ +#ifndef STACK_H +#define STACK_H + +#include "tile.h" + +typedef struct +{ + int n_tiles; + t_tile f[NUM_TILES_DOMINO]; +} t_stack; + +void initialize_stack(t_stack *pi); +void print_stack(t_stack pi, int visible); +t_tile pick_from_stack(t_stack *pi); +int is_stack_empty(t_stack pi); + +#endif // STACK_H diff --git a/table.c b/table.c new file mode 100644 index 0000000..1730881 --- /dev/null +++ b/table.c @@ -0,0 +1,98 @@ +#include +#include "tile.h" +#define NUM_TILES_DOMINO 28 + +typedef struct +{ + int n_tiles; + t_tile f[NUM_TILES_DOMINO]; +} t_table; + +void initialize_table(t_table *p_m) +{ + p_m->n_tiles = 0; // Inicialmente no hay tiles en la mesa +} + +void print_table(t_table m, int dim) +{ + int i, pos2; + + printf("\nTable: "); + if (dim == FALSE) + { //sense 2d + for (i = 0; i < m.n_tiles; i++) + printf("%d:%d|", m.f[i].num1, m.f[i].num2); + } + else + { //con 2d + printf("\n"); + + for (i = 0; i < m.n_tiles; i++) + { + if (m.f[i].num1 == m.f[i].num2) + { //es doble, poner vertical + printf("%d|", m.f[i].num1); + } + else + { + printf("___ "); + } + } + printf("\n"); + for (i = 0; i < m.n_tiles; i++) + { + if (m.f[i].num1 == m.f[i].num2) + { //es doble, poner vertical + printf("-|"); + } + else + { + printf("%d:%d|", m.f[i].num1, m.f[i].num2); //es normal, se imprime normal + } + } + printf("\n"); + for (i = 0; i < m.n_tiles; i++) + { + if (m.f[i].num1 == m.f[i].num2) + { //es doble, poner vertical + printf("%d|", m.f[i].num1); + } + else + { + printf(" "); + } + } + printf("\n"); + } +} + +void play_from_right(t_table *p_m, t_tile f) +{ + int i; + + p_m->f[p_m->n_tiles] = f; // Posición de la derecha: n_tiles porque es la primera posición vacia en el vector + p_m->n_tiles++; +} +void play_from_left(t_table *p_m, t_tile f) +{ + int i; + p_m->n_tiles++; + for (i = p_m->n_tiles; i > 0; i--) + { // Desplaza toda la mesa un lugar a la derecha + p_m->f[i] = p_m->f[i - 1]; + } + p_m->f[0] = f; // Introduce en la posición 0 la nueva tile +} + +int table_leftmost(t_table m) +{ + int left; + left = m.f[0].num1; + return (left); +} +int table_rightmost(t_table m) +{ + int right; + right = m.f[m.n_tiles - 1].num2; + return (right); +} diff --git a/table.h b/table.h new file mode 100644 index 0000000..d37b217 --- /dev/null +++ b/table.h @@ -0,0 +1,21 @@ +#ifndef TABLE_H +#define TABLE_H + +#include "tile.h" + +typedef struct +{ + int n_tiles; + t_tile f[NUM_TILES_DOMINO]; +} t_table; + +void initialize_table(t_table *p_m); +void print_table(t_table m, int dim); + +void play_from_right(t_table *p_m, t_tile f); +void play_from_left(t_table *p_m, t_tile f); + +int table_leftmost(t_table m); +int table_rightmost(t_table m); + +#endif // TABLE_H diff --git a/tile.c b/tile.c new file mode 100644 index 0000000..ca486a9 --- /dev/null +++ b/tile.c @@ -0,0 +1,42 @@ +#include + +typedef struct +{ + int num1, num2; +} t_tile; + +void initialize_tile(t_tile *tile, int i, int j); +void print_tile(t_tile f, int visible); +void turn_tile(t_tile *tile); +int doble(); + +void print_tile(t_tile tile, int visible) +{ + printf("%d:%d|", tile.num1, tile.num2); +} + +void turn_tile(t_tile *tile) +{ // Here num1 is swapped for num2 and vice versa. + int aux, i; + + aux = tile->num1; + tile->num1 = tile->num2; + tile->num2 = aux; +} + +int doble() +{ + t_tile tile[28]; + int i; + + if (tile[i].num1 == tile[i].num2) // If it is a doble, then num1 == num 2. + return (1); + else + return (0); +} + +void initialize_tile(t_tile *tile, int i, int j) +{ + tile->num2 = j; + tile->num1 = i; +} diff --git a/tile.h b/tile.h new file mode 100644 index 0000000..7c16760 --- /dev/null +++ b/tile.h @@ -0,0 +1,18 @@ +#ifndef tile_H +#define tile_H + +#define FALSE 0 +#define TRUE 1 + +#define NUM_TILES_DOMINO 28 + +typedef struct +{ + int num1, num2; +} t_tile; + +void initialize_tile(t_tile *p_f, int a, int b); +void turn_tile(t_tile *p_f); +void print_tile(t_tile f, int visible); + +#endif // tile_H diff --git a/tirada.c b/tirada.c deleted file mode 100644 index ce398d8..0000000 --- a/tirada.c +++ /dev/null @@ -1,122 +0,0 @@ -#define TIRADA_H - -#include -#include "ficha.h" -#include "jugador.h" -#include "mesa.h" - -#define MAX_TIRADAS_JUGADOR NUM_FICHAS_DOMINO - -typedef struct -{ - int n_ficha; // numero de ficha en el vector de fichas del jugador - char extremo; // IZQUIERDA o DERECHA (de n_ficha(1)) - int girada; // TRUE o FALSE - int dobledobla; -} t_tirada; - -typedef struct -{ - int n_tiradas; - t_tirada t[MAX_TIRADAS_JUGADOR]; - int cont_dobles, dobleizquierda, doblederecha; - -} t_tiradas; - -void imprimir_tirada(t_tirada t, t_jugador j) -{ //Siempre es visible independiente de omnisciencia - int aux; - aux = t.n_ficha; - if (j.tipo == T_ROBOT) - printf("Tira: %c|%d:%d|\n\n", t.extremo, j.f[aux].num1, j.f[aux].num2); -} - -void imprimir_tiradas(t_tiradas ts, t_jugador j, int visible) -{ - int i; - - if ((visible == TRUE && j.tipo == T_ROBOT) || j.tipo == T_HUMANO) - { // Muestra si omnisciencia está activada o el jugador es humano - printf("Tiradas posibles: "); - if (ts.n_tiradas > 0) - { // Si puede tirar - for (i = 0; i < ts.n_tiradas; i++) - { - printf("%d(%c%d:%d) ", i, ts.t[i].extremo, j.f[ts.t[i].n_ficha].num1, j.f[ts.t[i].n_ficha].num2); - } - - if ((ts.cont_dobles > 1) && (j.f[ts.t[ts.dobleizquierda].n_ficha].num1 != j.f[ts.t[ts.doblederecha].n_ficha].num2)) - { - i = ts.n_tiradas; - printf("%d(%c%d:%d|%c%d:%d) ", i, ts.t[ts.dobleizquierda].extremo, j.f[ts.t[ts.dobleizquierda].n_ficha].num1, j.f[ts.t[ts.dobleizquierda].n_ficha].num2, ts.t[ts.doblederecha].extremo, j.f[ts.t[ts.doblederecha].n_ficha].num1, j.f[ts.t[ts.doblederecha].n_ficha].num2); - } - printf("\n"); - } - else - printf("No hay tiradas posibles!!\n"); // Si no puede tirar - } -} - -t_tiradas calcular_tiradas_posibles(t_jugador j, t_mesa m) -{ - t_tiradas ts; - int izq, der, i, k = 0, doble; - izq = extremo_izquierdo_mesa(m); // Calcula el extremo izquierdo de la mesa - der = extremo_derecho_mesa(m); // Calcula el extremo derecho de la mesa - ts.cont_dobles = 0; - for (i = 0; i < j.n_fichas; i++) - { - doble = 0; - if (j.f[i].num1 == j.f[i].num2) - doble = TRUE; // Comprueba si es un doble - - if (j.f[i].num2 == izq) - { // Tirada por la izquierda sin girar - if (doble == TRUE) - { - ts.cont_dobles++; - ts.dobleizquierda = k; - } - ts.t[k].n_ficha = i; - ts.t[k].extremo = 'i'; - ts.t[k].girada = 0; - k++; - } - if (j.f[i].num1 == izq) - { // Tirada por la izquierda girando - if (doble == FALSE) - { - ts.t[k].n_ficha = i; - ts.t[k].extremo = 'i'; - ts.t[k].girada = 1; - k++; - } - } - if (j.f[i].num1 == der) - { // Tirada por la derecha sin girar - if (doble == TRUE) - { - ts.cont_dobles++; - ts.doblederecha = k; - } - ts.t[k].n_ficha = i; - ts.t[k].extremo = 'd'; - ts.t[k].girada = 0; - k++; - } - if (j.f[i].num2 == der) - { // Tirada por la derecha girando - if (doble == FALSE) - { - ts.t[k].n_ficha = i; - ts.t[k].extremo = 'd'; - ts.t[k].girada = 1; - k++; - } - } - - ts.n_tiradas = k; // Numero de tiradas - } - - return (ts); -} diff --git a/tirada.h b/tirada.h deleted file mode 100644 index c13c7f6..0000000 --- a/tirada.h +++ /dev/null @@ -1,29 +0,0 @@ -#ifndef TIRADA_H -#define TIRADA_H - -#include "ficha.h" -#include "jugador.h" -#include "mesa.h" - -#define MAX_TIRADAS_JUGADOR NUM_FICHAS_DOMINO - -typedef struct -{ - int n_ficha; // numero de ficha en el vector de fichas del jugador - char extremo; // IZQUIERDA o DERECHA (de n_ficha(1)) - int girada; // TRUE o FALSE - int dobledobla; -} t_tirada; - -typedef struct -{ - int n_tiradas; - t_tirada t[MAX_TIRADAS_JUGADOR]; - int cont_dobles, doblederecha, dobleizquierda; -} t_tiradas; - -void imprimir_tirada(t_tirada ts, t_jugador j); -void imprimir_tiradas(t_tiradas ts, t_jugador j); -t_tiradas calcular_tiradas_posibles(t_jugador j, t_mesa m); - -#endif // TIRADA_H