bool play_move(game g, int piece_num, dir d, int distance) {
piece p=g->piece_list[piece_num];
int travel=0;
while (distance!=0) {
move_piece(p, d, 1);
g->nb_moves+=1;
distance--;
travel++;
for (int i=0; i<game_nb_pieces(g); ++i) {
if (p==g->piece_list[i]) {
i++;
if (i>=game_nb_pieces(g))
break;
}
if (intersect(p, game_piece(g, i))) {
fprintf(stderr, "Unauthorized move: Piece %d is preventing %d from moving.\n\n", i, piece_num);
move_piece(p, d, travel*-1);
g->nb_moves-=travel;
return false;
}
if (out_of_grid(p, g)) {
fprintf(stderr, "Unauthorized move: %d would be out of bounds.\n\n", piece_num);
move_piece(p, d, travel*-1);
g->nb_moves-=travel;
return false;
}
if (((d==LEFT||d==RIGHT)&&(!can_move_x(p)))||((d==UP||d==DOWN)&&(!can_move_y(p)))) {
fprintf(stderr, "Unauthorized move: Piece orientation doesn't match move direction.\n\n");
return false;
}
}
}
return true;
}
bool play_move(game g, int piece_num, dir d, int distance){
if ((!can_move_y(g->pieces[piece_num]) && (d == 0 || d == 2))
|| ((!can_move_x(g->pieces[piece_num])) && (d == 1 || d == 3))) return false;
bool move_isAllowed = true;
piece tmp_piece = new_piece(0,0,0,0,true,true); // Initialisation d'une pièce temporaire (mallocs)
copy_piece(g->pieces[piece_num],tmp_piece);
for (int i = 0; i < distance; i++) { // On decompose le mouvement en déplacement de une case
move_piece(g->pieces[piece_num], d, 1);
if ((get_x(g->pieces[piece_num])+get_width(g->pieces[piece_num])-1 >= game_width(g) || get_x(g->pieces[piece_num]) < 0)
|| (get_y(g->pieces[piece_num])+get_height(g->pieces[piece_num])-1 >= game_height(g) || get_y(g->pieces[piece_num]) < 0)) move_isAllowed = false;
for(int p = 0; p < game_nb_pieces(g);++p) { // On verifie si le mouvement est valide (intersect+depassement grille)
if (piece_num != p && intersect(g->pieces[piece_num], g->pieces[p])) move_isAllowed = false;
}
}
if (move_isAllowed) {
for(int p = 0; p < game_nb_pieces(g);++p) {
if (piece_num != p && intersect(g->pieces[piece_num], g->pieces[p])) printf("Erreur\n");
}
g->nb_mouv += distance;
delete_piece(tmp_piece);
return true;
}
// si le mouvement n'est pas valide on remets la piece a sa place initiale
copy_piece(tmp_piece, g->pieces[piece_num]);
delete_piece(tmp_piece);
return false;
}
void erase_game(game newGame, WINDOW *my_win, WINDOW **car, WINDOW *score)
{
destroy_win(my_win); /*Destroy window */
for (int i = 0; i < game_nb_pieces(newGame); i++) /*to create new one */
destroy_win(car[i]); /* */
destroy_win(score); /* */
}
void fillQueue(nodeQueue currentNode, nodeQueue queueTop, map previousState, list listMap, bool* cleared, bool isRH)
{
//crée une map pour currentNode: currentMap si non présente dans la liste, si elle y est, on récupère
//cherche tous les coups possibles
for (int p = 0; p < game_nb_pieces(currentNode->m->g); p++)
{
//for (int dist = 1; dist < 1; dist++)
for (int d = 0; d < 4; d++)
{
map r = createNewState(previousState, p, d, 1);
if (r != NULL)
{
r = checkMapExistence(r, listMap);
if (r != NULL)
{
//drawInterface(r->g, "TEST");
queueTop = newQueueItem(r, queueTop);
if (isCleared(queueTop, isRH))
{
//drawInterface(queueTop->m->g, "TEST");
currentNode = queueTop;
*cleared = true;
return;
}
// queueTop = queueTop->next;
}
}
}
}
//pour chaque coup (donc game), on crée une Map: newMap(newGame, currentMap)
//si la map n'est pas présente dans listMap, alors on l'y insère. On y ajoute un nouveau node dans la file, � partir de top
//et on "incrémente" top (top = top->next or something)
}
int take_piece_num(game g, char* buf, int* piece_num){
while(true){
printf("What piece do you want to move?\n");
read(0, buf, sizeof(char)*100);
if(strcmp(buf, "cancel") == 10)
break;
if(strcmp(buf, "exit") == 10)
return -1;
if(buf[0]<48 || buf[0]>=48+game_nb_pieces(g) || buf[1] != 10)
printf("Write a number between 0 and %dt\tor write cancel or exit.\n",game_nb_pieces(g)-1);
else{
*(piece_num) = atoi(buf);
if(!can_move(g,*(piece_num)))
printf("The piece %d cannot move.\n", *(piece_num));
else
return 1;
}
}
return 0;
}
bool game_equals_not_mov(cgame G1, cgame G2){
bool res = true;
res = res && game_width(G1) == game_width(G2);
res = res && game_height(G1) == game_height(G2);
res = res && game_nb_pieces(G1) == game_nb_pieces(G2);
if(res){
int pieces = 0;
for(int i = 0 ; i<game_nb_pieces(G1) ; i++){
for(int j = 0 ; j<game_nb_pieces(G2) ;j++){
if(piece_equals(game_piece(G1, i), game_piece(G2, j))){
pieces ++;
break;
}
}
if(i+1 != pieces) return false;
}
if(pieces == game_nb_pieces(G1)) return true;
}
return false;
}
game copy_game_for_solver(cgame src){
int nb_pieces = game_nb_pieces(src);
int w = game_width(src);
int h = game_height(src);
piece *tab = malloc(sizeof(piece)*nb_pieces);
for (int i=0;i<nb_pieces;i++){
tab[i] = copy_piece_for_solver(game_piece(src, i));
}
game dst = new_game (w, h, nb_pieces, tab);
delete_pieces_array(tab, nb_pieces);
return dst;
}
int get_car_with_mouse(int x, int y, game tmpGame)
{
int miny, minx, maxx, maxy;
for (int i = 0; i < game_nb_pieces(tmpGame); i++) {
cpiece tmp = game_piece(tmpGame, i);
minx = get_x(tmp) * RATIO;
miny = (game_height(tmpGame) - get_y(tmp) - get_height(tmp)) * RATIO;
maxx = (get_x(tmp) + get_width(tmp)) * RATIO;
maxy = (game_height(tmpGame) - get_y(tmp)) * RATIO;
if (x >= minx && x <= maxx &&
y >= miny && y <= maxy) {
return i;
}
}
return -1;
}
bool compareMap(map m1, map m2)
{
//char* s1 = (char*) malloc(256*sizeof(char));
//char* s2 = (char*) malloc(256*sizeof(char));
//getIdFromGame(m1->g, s1);
//getIdFromGame(m2->g, s2);
//int r = strcmp(s1, s2);
//free(s1);
//free(s2);
for (int i = 0; i < game_nb_pieces(m1->g); i++)
{
if ((get_x(game_piece(m1->g, i)) != get_x(game_piece(m2->g, i))) || (get_y(game_piece(m1->g, i)) != get_y(game_piece(m2->g, i))))
return false;
}
return true;
//return (r == 0); //retourne true si les chaines sont identiques
}
void draw_game(game newGame, int starty, int startx, int MAXROW, int MAXCOL, WINDOW **grid, WINDOW **car, WINDOW **score, int choosenCar, char *message, bool gameOverRh)
{
*grid = create_newgrid(starty, startx, MAXROW, MAXCOL, SIZE, gameOverRh); // Create new grid
wmove(*grid, 0, 0);
//Create each car and highlight the selected one
for (int i = 0; i < game_nb_pieces(newGame); i++) {
if (choosenCar == i) {
car[i] = create_newcar(game_piece(newGame, i), i, true, SIZE, MAXROW); // Create new car and highlight it
continue;
}
car[i] = create_newcar(game_piece(newGame, i), i, false, SIZE, MAXROW); // Create new car
}
wmove(*grid, 0, 0);
//Create score on right of the grid
*score = create_newscore(SIZE * MAXROW + 1, SIZE*MAXCOL, starty, startx + SIZE * MAXCOL * 2 + 1, game_nb_moves(newGame), message);
wmove(*grid, 0, 0);
}
void tableau_1D(int *t, game g){
int taille_tab = game_height(g)*game_width(g);
for (int i = 0; i<taille_tab; ++i){
t[i] = -1;
}
for (int num_piece = 0; num_piece<game_nb_pieces(g); ++num_piece){
cpiece p=game_piece(g, num_piece);
t[get_x(p)+(get_y(p)*6)] = num_piece;
if (get_width(p)>1){
for (int i = 1; i<get_width(p); ++i){
t[get_x(p)+(get_y(p)*6)+i] = num_piece;
}
}
if (get_height(p)>1){
for (int j = 1; j<get_height(p); ++j){
t[get_x(p)+((get_y(p)*6)+(j*6))] = num_piece;
}
}
}
}
// return the number of the piece in (,y) or -1
int is_piece(game g, int x, int y){
for(int i=0; i<game_nb_pieces(g); ++i){
cpiece p = game_piece(g, i);
int x_piece = get_x(p);
int y_piece = get_y(p);
if(x_piece == x && !is_horizontal(p)){
if(y_piece == y || y_piece == y-1)
return i;
if(get_height(p) == 3 && y_piece == y-2)
return i;
}
if(y_piece == y && is_horizontal(p)){
if(x_piece == x || x_piece == x-1)
return i;
if(get_width(p) == 3 && x_piece == x-2)
return i;
}
}
return -1;
}
void play_input(game newGame, int ch, int *choosenCar)
{
if (ch >= '0' && ch <= '9') {
*choosenCar = ch - '0';
}
if (*choosenCar != -1 && *choosenCar < game_nb_pieces(newGame)) {
switch (ch) {
case KEY_LEFT:
play_move(newGame, *choosenCar, LEFT, 1);
break;
case KEY_RIGHT:
play_move(newGame, *choosenCar, RIGHT, 1);
break;
case KEY_DOWN:
play_move(newGame, *choosenCar, DOWN, 1);
break;
case KEY_UP:
play_move(newGame, *choosenCar, UP, 1);
break;
}
}
}
char* convertGame(game newGame)
{
int n = game_nb_pieces(newGame);
cpiece *arrPieces;
arrPieces = malloc(sizeof (piece) * n);
for (int i = 0; i < n; i++) {
arrPieces[i] = game_piece(newGame, i);
}
//Sort
for (int i = 0; i < (n - 1); i++) {
for (int j = 0; j < n - i - 1; j++) {
if (sup(arrPieces[j], arrPieces[j + 1])) {
cpiece swap = arrPieces[j];
arrPieces[j] = arrPieces[j + 1];
arrPieces[j + 1] = swap;
}
}
}
char *parsed = serialize(arrPieces, n);
free(arrPieces);
return parsed;
}
int game_square_piece (game g, int x, int y){
/*for (int p = 0; p < game_nb_pieces(g); ++p) {
for(int i = 0; i < get_height(g->pieces[p]); ++i) {
for(int j = 0; j < get_width(g->pieces[p]); ++j) {
if (get_x(g->pieces[p])+i == x && get_y(g->pieces[p])+j == y) return p;
}
}
}
return -1;*/
int size_x = game_width(g);
int size_y = game_height(g);
int nb_pieces = game_nb_pieces(g);
int **grid = malloc(sizeof(int*)*size_y);
int output;
for (int i = 0; i < size_y; ++i){
grid[i] = malloc(sizeof(int)*size_x);
}
for(int x = 0; x < size_x; ++x){
for(int y = 0; y < size_y; ++y){
grid[y][x] = -1;
}
}
for (int i = 0; i < nb_pieces; i++) {
for (int x = 0; x < get_width(game_piece(g, i)); x++) {
for (int y = 0; y < get_height(game_piece(g, i)); y++) {
grid[get_y(game_piece(g, i))+y][get_x(game_piece(g, i))+x] = i;
}
}
}
output = grid[y][x];
for (int i = 0; i < size_y; ++i){
free(grid[i]);
}
free(grid);
return output;
}
int main(int argc, char *argv[])
{
WINDOW *my_win, *score;
WINDOW **car;
game newGame, tmpGame;
MEVENT event;
int ch = 0, choosenCar = -1, soluce_move = 0;
char message[1024];
bool quit = false;
bool show_solution = false;
gameStruct *resultSolv = NULL;
//INIT
setup();
//END INIT
//Wait for good size
wait_for_size(MINH, MINW);
//Instruction
show_instruction(MINH, MINW);
while (!quit) {
quit = false;
show_solution = false;
soluce_move = 0;
strcpy(message, "Playing");
//Select game
newGame = select_game();
//Check for level file
if (handle_level(&tmpGame)) {
delete_game(newGame);
newGame = tmpGame;
MAXCOL = game_width(newGame);
MAXROW = game_height(newGame);
MINH = MAXROW * SIZE + 2;
MINW = MAXCOL * SIZE;
}
car = malloc(sizeof (WINDOW*) * game_nb_pieces(newGame));
//First draw
draw_game(newGame, 0, 0, MAXROW, MAXCOL, &my_win, car, &score, choosenCar, message, gameOverRh);
//Loop while the game is not finished
while (!game_over(newGame)) {
//Print on bottom of grid
mvprintw(MAXROW * SIZE + 1, 0, "Please choose car :");
ch = getch();
if (ch == 's' && !show_solution) {
show_solution = true;
strcpy(message, "Solution");
resultSolv = solv(newGame, gameOverRh,true);
if(!resultSolv){
strcpy(message, "No solution");
show_solution=false;
}
}
if (show_solution) {
newGame = play_solution(newGame, resultSolv, soluce_move++);
} else {
if (KEY_MOUSE == ch) {
/* Mouse event. */
if (OK == getmouse(&event)) {
choosenCar = get_car_with_mouse(event.y, event.x, car, game_nb_pieces(newGame));
}
} else {
if (ch == 'q') {
quit = true;
break;
}
play_input(newGame, ch, &choosenCar);
}
}
wait_for_size(MINH, MINW);
erase_game(newGame, my_win, car, score);
draw_game(newGame, 0, 0, MAXROW, MAXCOL, &my_win, car, &score, choosenCar, message, gameOverRh);
}
if (!quit) {
display_score(newGame);
}
for (int i = 0; i < game_nb_pieces(newGame); i++) {
destroy_win(car[i]);
}
destroy_win(my_win);
destroy_win(score);
free(car);
delete_game(newGame);
if (resultSolv != NULL) {
delete_game(resultSolv->current);
free(resultSolv->move);
free(resultSolv);
resultSolv = NULL;
}
}
endwin(); /* End curses mode */
return 0;
}
/*
* @brief Show different game and wait for user to choose
* @return game The new game created
*/
static game select_game()
{
int row, col;
int pos = 0;
int ch = 0;
game newGame = NULL;
while (ch != '\n') {
clear();
getmaxyx(stdscr, row, col);
mvprintw(row / 2, col / 2 - 20, "Use arrow key to select your game");
if (pos == 0) {
mvprintw(row / 2 + 1, col / 2 - 20, "-> Rush Hour");
mvprintw(row / 2 + 2, col / 2 - 20, " Ane rouge");
} else {
mvprintw(row / 2 + 1, col / 2 - 20, " Rush Hour");
mvprintw(row / 2 + 2, col / 2 - 20, "-> Ane rouge");
}
ch = getch();
if (ch == KEY_UP) {
if (pos > 0)
pos--;
} else if (ch == KEY_DOWN) {
if (pos < 1)
pos++;
}
refresh();
}
if (pos == 0) {
//Rush hour
piece pieces[4];
pieces[0] = new_piece_rh(3, 3, true, true);
pieces[1] = new_piece_rh(3, 0, true, false);
pieces[2] = new_piece_rh(4, 1, true, true);
pieces[3] = new_piece_rh(5, 3, false, false);
newGame = new_game(6, 6, 4, pieces);
MAXCOL = game_width(newGame);
MAXROW = game_height(newGame);
MINH = MAXROW * SIZE + 2;
MINW = MAXCOL * SIZE;
game_over = game_over_hr;
gameOverRh = true;
for (int i = 0; i < game_nb_pieces(newGame); i++) {
delete_piece(pieces[i]);
}
clear();
refresh();
return newGame;
} else {
//Ane rouge
piece pieces[10];
pieces[0] = new_piece(1, 3, 2, 2, true, true); //Rouge
pieces[1] = new_piece(3, 3, 1, 2, true, true); // 2
pieces[2] = new_piece(3, 1, 1, 2, true, true); // 3
pieces[3] = new_piece(3, 0, 1, 1, true, true); // 4
pieces[4] = new_piece(1, 2, 2, 1, true, true); // 5
pieces[5] = new_piece(2, 1, 1, 1, true, true); // 6
pieces[6] = new_piece(1, 1, 1, 1, true, true); // 7
pieces[7] = new_piece(0, 0, 1, 1, true, true); // 8
pieces[8] = new_piece(0, 1, 1, 2, true, true); // 9
pieces[9] = new_piece(0, 3, 1, 2, true, true); // 10
newGame = new_game(4, 5, 10, pieces);
MAXCOL = game_width(newGame);
MAXROW = game_height(newGame);
MINH = MAXROW * SIZE + 2;
MINW = MAXCOL * SIZE;
game_over = game_over_an;
gameOverRh = false;
for (int i = 0; i < game_nb_pieces(newGame); i++) {
delete_piece(pieces[i]);
}
clear();
refresh();
return newGame;
}
}
void SDL_Display(game g, SDL_Renderer* rdr, TTF_Font* font, int popup){
SDL_Rect rect;
SDL_Color fontColor = {255, 255, 255};
rect.w = (SCREEN_Y/game_height(g));
rect.h = (SCREEN_Y/game_height(g));
SDL_SetRenderDrawColor(rdr, 192,192,192, 255);
SDL_RenderClear(rdr);
SDL_SetRenderDrawColor(rdr, 0,255,127, 255);
if(rules==0){//pour la Sortie des piece de Rush hour
rect.y = (SCREEN_Y/game_height(g))*2;
rect.x = (SCREEN_Y/game_height(g))*game_width(g);
rect.h = (SCREEN_Y/game_height(g));
rect.w = 10;
SDL_RenderFillRect(rdr, &rect);
SDL_SetRenderDrawColor(rdr, 105,105,105, 255);
rect.y = 0;
rect.x = (SCREEN_Y/game_height(g))*game_width(g);
rect.w = 10;
rect.h = ((SCREEN_Y/game_height(g))*2);
SDL_RenderFillRect(rdr, &rect);
rect.y = ((SCREEN_Y/game_height(g))*3);
rect.x = (SCREEN_Y/game_height(g))*game_width(g);
rect.w = 10;
rect.h = ((SCREEN_Y/game_height(g))*3);
SDL_RenderFillRect(rdr, &rect);
rect.y = (SCREEN_Y);
rect.x = 0;
rect.w = SCREEN_X ;
rect.h = 10;
SDL_RenderFillRect(rdr, &rect);
}
else if(rules==1){ //pour la Sortie des piece de Ane rouge
rect.y = SCREEN_Y;
rect.x = (SCREEN_Y/game_height(g));
rect.h = 10;
rect.w = (SCREEN_Y/game_height(g))*2;
SDL_RenderFillRect(rdr, &rect);
SDL_SetRenderDrawColor(rdr, 105,105,105, 255);
rect.y = 0;
rect.x = (SCREEN_Y/game_height(g))*game_width(g);
rect.w = 10;
rect.h = SCREEN_Y;
SDL_RenderFillRect(rdr, &rect);
rect.y = SCREEN_Y;
rect.x = 0;
rect.w = (SCREEN_Y/game_height(g));
rect.h = 10;
SDL_RenderFillRect(rdr, &rect);
rect.y = SCREEN_Y;
rect.x = ((SCREEN_Y/game_height(g))*3);
rect.w = ((SCREEN_Y/game_height(g))*6);
rect.h = 10;
SDL_RenderFillRect(rdr, &rect);
}
//Affichage des pièces
for(int i = 0; i < game_nb_pieces(g); ++i){
SDL_SetRenderDrawColor(rdr, color[i][0],color[i][1],color[i][2], 255);
rect.x = get_x(game_piece(g,i))*(SCREEN_Y/game_height(g));
rect.y = (SCREEN_Y - (get_y(game_piece(g,i))*(SCREEN_Y/game_height(g))));
rect.w = get_width(game_piece(g,i))*(SCREEN_Y/game_height(g));
rect.h = get_height(game_piece(g,i))*(SCREEN_Y/game_height(g));
rect.y -= rect.h;
SDL_RenderFillRect(rdr, &rect);
}
//Affichage du nombre de mouvements
char disp_moves[20]; //contiendra l'affichage du nombre de mouvements
char end_msg[30]; //contiendra le message de fin de partie
sprintf(disp_moves," Mouvements : %d ",game_nb_moves(g));// Convertie le nb_mouv en caractère
drawText(rdr, font, fontColor,SCREEN_X-250 ,SCREEN_Y/2-SCREEN_Y/6 -200 ,disp_moves); //affichage nombre de mouvements
//Affichage des règles
drawText(rdr, font, fontColor,(SCREEN_Y/game_height(g))*game_width(g)+120 ,SCREEN_Y-40 ,"R : Relancer");
drawText(rdr, font, fontColor,SCREEN_X-120 ,SCREEN_Y-40 ,"Q : Quitter");
if (popup != 0){
SDL_SetRenderDrawColor(rdr, 50, 50, 50, 170);
rect.x = 0;
rect.y = SCREEN_Y/4;
rect.w = SCREEN_X;
rect.h = SCREEN_Y/2;
SDL_RenderFillRect(rdr, &rect);
if (popup == 1){
drawText(rdr, font, fontColor,SCREEN_X/2 ,SCREEN_Y/2-SCREEN_Y/8 ,"Voulez-vous lancer une nouvelle partie ?");
} else if (popup == 2){
drawText(rdr, font, fontColor,SCREEN_X/2 ,SCREEN_Y/2-SCREEN_Y/8 ,"Voulez-vous quitter le jeu en cours ?");
} else if (popup == 3){
sprintf(end_msg,"Partie finie en %d mouvements",game_nb_moves(g));
drawText(rdr, font, fontColor,SCREEN_X/2, SCREEN_Y/2-SCREEN_Y/8, end_msg);
drawText(rdr, font, fontColor,SCREEN_X/2, SCREEN_Y/2-SCREEN_Y/17, "Voulez vous rejouer ?");
}
drawText(rdr, font, fontColor,SCREEN_X/6 ,SCREEN_Y/2+SCREEN_Y/8 ,"Echap : Non");
drawText(rdr, font, fontColor,SCREEN_X-SCREEN_X/6 ,SCREEN_Y/2+SCREEN_Y/8 ,"Entree : Oui");
}
SDL_RenderPresent(rdr);
SDL_Delay(50);
}
