From 03a05739abfc76350d228d8bb4d3476c18b9f440 Mon Sep 17 00:00:00 2001 From: Shunya Date: Tue, 3 Nov 2020 20:48:25 +0100 Subject: [PATCH] Changed language to english Originally the scrip had all the variables and function names in spanish. I have modified everything to make it easier to understand for everyone who wants to use/modify it. --- azar.c | 27 --- azar.h | 9 - duerme.c | 47 ------ duerme.h | 11 -- ficha.c | 37 ----- ficha.h | 18 -- game.c | 330 +++++++++++++++++++++++++++++++++++++ game.h | 27 +++ jugador.c | 112 ------------- jugador.h | 33 ---- main.c | 30 ++-- mesa.c | 98 ----------- mesa.h | 20 --- move.c | 122 ++++++++++++++ move.h | 29 ++++ partida.c | 327 ------------------------------------ partida.h | 27 --- pila.c | 74 --------- pila.h | 17 -- player.c | 112 +++++++++++++ player.h | 34 ++++ preguntas.h | 15 -- preguntas.c => questions.c | 13 +- questions.h | 15 ++ random.c | 26 +++ random.h | 7 + sleep.c | 49 ++++++ sleep.h | 9 + stack.c | 74 +++++++++ stack.h | 17 ++ table.c | 98 +++++++++++ table.h | 21 +++ tile.c | 42 +++++ tile.h | 18 ++ tirada.c | 122 -------------- tirada.h | 29 ---- 36 files changed, 1051 insertions(+), 1045 deletions(-) delete mode 100644 azar.c delete mode 100644 azar.h delete mode 100644 duerme.c delete mode 100644 duerme.h delete mode 100644 ficha.c delete mode 100644 ficha.h create mode 100644 game.c create mode 100644 game.h delete mode 100644 jugador.c delete mode 100644 jugador.h delete mode 100644 mesa.c delete mode 100644 mesa.h create mode 100644 move.c create mode 100644 move.h delete mode 100644 partida.c delete mode 100644 partida.h delete mode 100644 pila.c delete mode 100644 pila.h create mode 100644 player.c create mode 100644 player.h delete mode 100644 preguntas.h rename preguntas.c => questions.c (56%) create mode 100644 questions.h create mode 100644 random.c create mode 100644 random.h create mode 100644 sleep.c create mode 100644 sleep.h create mode 100644 stack.c create mode 100644 stack.h create mode 100644 table.c create mode 100644 table.h create mode 100644 tile.c create mode 100644 tile.h delete mode 100644 tirada.c delete mode 100644 tirada.h 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