dukantic/Sokoban
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
62c97927f7299014bc5b14a4cf9d576ab5edb48f
Sokoban/script/function.c

688 lines
20 KiB
C
Raw Blame History

/**
* \file function.c
* Ce fichier contient toute les fonction utile pour le jeu. Sauf pour
* l'affichage.
*
*/
#include "../include/function.h"
#include "../include/display.h"
#include <SDL2/SDL_events.h>
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_keycode.h>
#include <SDL2/SDL_rect.h>
#include <SDL2/SDL_render.h>
#include <SDL2/SDL_scancode.h>
#include <SDL2/SDL_timer.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
/**
* \brief Cette fonction permet de creer une liste 2D
* \param x Nombre de ligne.
* \param y Nombre de colonne.
* \return Le pointeur du tableau 2D de char (1 octet).
*/
char **creatArea2D (const int x, const int y)
{
char **tab2d;
tab2d = calloc (x, sizeof (char *));
if (tab2d == NULL)
{
return NULL;
}
bool fail = false;
int i;
for (i = 0; i < x && !fail; ++i)
{
tab2d[i] = calloc (y, sizeof (char));
if (tab2d[i] == NULL)
{
fail = true;
}
}
if (fail)
{
int j;
for (j = 0; j < i; ++j)
{
free (tab2d[j]);
}
free (tab2d);
return NULL;
}
return tab2d;
}
/**
* \brief Cette fontion permet de liberer l'espace tu tableau 2D de char.
* \param tab Le tableau 2D.
* \param x Le nombre de ligne.
* \return Void.
*/
void free2D (char **tab, int x)
{
int i;
for (i = 0; i < x; ++i)
{
free (tab[i]);
}
free (tab);
return;
}
/**
* \brief La fontction permet de savoir si le joueur peut ce deplacer dans une
* direction.
* \param valueOfNCase La valeur de la case dans la direction que le joueur
* veut aller.
* \param valueOfNPlusOneCase La valeur de la case dans la direction que le
* joueur veut aller mais une fois de plus.
* \return 0 Si c'est un mur devant le joueur, 1 si c'est vide devant le
* joueur, 2 si c'est une boite mais qu'on peux la pousser ,3 si le joueur
* pousse une boite sur un point d'interer, 4 si le joueur bouge sur un point
* d'interer, 5 si le joueur peux pousser une boite mais le joueur se place sur
* un point d'interer et 6 si le joueur pousse une boite sur un point d'interer
* et que le joueur est aussi sur un point d'interer. 7 si valueOfNCase est un bouton.
*/
char canIGoDirection (char valueOfNCase, char valueOfNPlusOneCase)
{
if (valueOfNCase != WALL)
{
if ((valueOfNCase == BOX && valueOfNPlusOneCase == EMPTY)
|| (valueOfNCase == BOX && valueOfNPlusOneCase == TARGET))
{
if (valueOfNPlusOneCase == TARGET)
{
// Box on target
return 3;
}
// move the box
return 2;
}
if ((valueOfNCase == BOX_ON_TARGET && valueOfNPlusOneCase == EMPTY)
|| (valueOfNCase == BOX_ON_TARGET
&& valueOfNPlusOneCase == TARGET))
{
if (valueOfNPlusOneCase == TARGET)
{
// Box on target and player on target too
return 6;
}
// move the box but player on a target
return 5;
}
if (valueOfNCase == BUTTON)
{
return 7;
}
if (valueOfNCase == TARGET)
{
// move player on target
return 4;
}
if (valueOfNCase == EMPTY)
{
// move player
return 1;
}
}
return 0;
}
/**
* \brief Cette fonction effectue les deplacements du joueur et des boites en
* fonction de la situation.
* \param tab Le tableau 2D du plateau de jeu.
* \param playerpos La position actuel du joueur.
* \param direction La direction que le joueur veut effectuer.
* \param score_user Toutes les données nécessaire pour calculer le score fini
* du joueur.
* \return Void
*
*/
void move (char **tab, vect *playerPos, vect direction, score *score_user)
{
short int valueOfNCase
= tab[playerPos->x + direction.x][playerPos->y + direction.y];
vect add = plusVect (*playerPos, direction);
add = plusVect (add, direction);
short int valueOfNPlusOneCase;
if (add.x < 0 || add.y < 0)
{
valueOfNPlusOneCase = WALL;
}
else
{
valueOfNPlusOneCase = tab[add.x][add.y];
}
short int returnValue
= canIGoDirection (valueOfNCase, valueOfNPlusOneCase);
short int playerState = tab[playerPos->x][playerPos->y];
if (returnValue != 0)
score_user->move_player++;
switch (returnValue)
{
case 0:
break;
case 1:
// move player
tab[playerPos->x + direction.x][playerPos->y + direction.y] = PLAYER;
break;
case 2:
// move player and the box
tab[playerPos->x + direction.x][playerPos->y + direction.y] = PLAYER;
tab[playerPos->x + direction.x * 2][playerPos->y + direction.y * 2]
= BOX;
score_user->move_box++;
break;
case 3:
// move player and the box is well-placed
tab[playerPos->x + direction.x][playerPos->y + direction.y] = PLAYER;
tab[playerPos->x + direction.x * 2][playerPos->y + direction.y * 2]
= BOX_ON_TARGET;
score_user->move_box++;
break;
case 4:
// move player on a target
tab[playerPos->x + direction.x][playerPos->y + direction.y]
= PLAYER_ON_TARGET;
break;
case 5:
// move box and player on a target
tab[playerPos->x + direction.x * 2][playerPos->y + direction.y * 2]
= BOX;
tab[playerPos->x + direction.x][playerPos->y + direction.y]
= PLAYER_ON_TARGET;
score_user->move_box++;
break;
case 6:
// move player on a target and box on a target
tab[playerPos->x + direction.x * 2][playerPos->y + direction.y * 2]
= BOX_ON_TARGET;
tab[playerPos->x + direction.x][playerPos->y + direction.y]
= PLAYER_ON_TARGET;
score_user->move_box++;
break;
case 7:
tab[playerPos->x + direction.x][playerPos->y + direction.y]
= PLAYER_ON_BUTTON;
break;
default:
printf ("Commande inconnue !\n");
}
if (returnValue != 0)
{
if (playerState == PLAYER_ON_TARGET)
{
tab[playerPos->x][playerPos->y] = TARGET;
}
else if (playerState == PLAYER_ON_BUTTON)
{
tab[playerPos->x][playerPos->y] = BUTTON;
}
else
{
tab[playerPos->x][playerPos->y] = EMPTY;
}
playerPos->x = playerPos->x + direction.x;
playerPos->y = playerPos->y + direction.y;
}
}
/**
*
* \brief La fonction permet de faire la boucle de jeu et le menu.
* \param tab2d Le tableau 2d carre.
* \param N LE nombre d'element de tab2d.
* \param playerPos La position de depart du joueur.
* \param targets Le tableau de toutes les positions des points d'interer de la
* maps.
* \param int nbr_targets Le nombre de point d'interer.
* \param display_user Tout les information SDL pour afficher le jeu.
* \param score_user Toute les données nécessaire pour calculer le score fini
* du joueur.
*\param menu True si c'est la loop du menu.
* \return L'indice de la map si c'est un menu, sinon renvoie -1
*/
int inGameLoop (char **tab2d, vect *dim_tab, vect *playerPos, vect *targets,
int nbr_targets, dis *display_user, score *score_user,
bool menu)
{
int fov = -1;
int indice_button = -1;
vect size_menu
= { display_user->size_menu - 10, display_user->size_window / 3 - 10 };
vect coor_time
= { 10, display_user->size_window - display_user->size_menu + 10 };
vect coor_move_player
= { display_user->size_window / 3 + 10,
display_user->size_window - display_user->size_menu + 10 };
vect coor_move_box
= { (display_user->size_window / 3) * 2 + 10,
display_user->size_window - display_user->size_menu + 10 };
if (menu)
fov = 5;
else
{
displayTextSDL (display_user, "MP : 0", coor_move_player, size_menu,
30);
displayTextSDL (display_user, "MB : 0", coor_move_box, size_menu, 30);
}
time_t time_start = time (NULL);
time_t current_time = time (NULL);
time_t delay = 0;
vect direction = { 0, 0 };
char input;
bool finish = false;
SDL_Event event;
screenDisplayGameSDL (tab2d, *dim_tab, display_user, playerPos, fov);
while (!finish)
{
while (SDL_PollEvent (&event))
{
if (event.type == SDL_KEYDOWN)
{
input = event.key.keysym.scancode;
switch (input)
{
case SDL_SCANCODE_ESCAPE:
if(menu) return 0;
return -1000;
finish = true;
break;
case SDL_SCANCODE_D:
direction.y = 1;
direction.x = 0;
break;
case SDL_SCANCODE_A:
direction.y = -1;
direction.x = 0;
break;
case SDL_SCANCODE_W:
direction.x = -1;
direction.y = 0;
break;
case SDL_SCANCODE_S:
direction.x = 1;
direction.y = 0;
break;
case SDL_SCANCODE_RETURN:
if (tab2d[playerPos->x][playerPos->y] == PLAYER_ON_BUTTON)
return indice_button;
break;
default:
direction.x = 0;
direction.y = 0;
}
move (tab2d, playerPos, direction, score_user);
screenDisplayGameSDL (tab2d, *dim_tab, display_user, playerPos,
fov);
if (!menu)
{
char nbr_p[20];
snprintf (nbr_p, 20, "MP : %d", score_user->move_player);
char nbr_b[20];
snprintf (nbr_b, 20, "MB : %d", score_user->move_box);
displayTextSDL (display_user, nbr_p, coor_move_player,
size_menu, 30);
displayTextSDL (display_user, nbr_b, coor_move_box,
size_menu, 30);
if (isWin (tab2d, targets, nbr_targets))
{
return 1;
finish = true;
}
if (islose (tab2d, dim_tab->x))
{
return 0;
finish = true;
}
}
else if (tab2d[playerPos->x][playerPos->y] == PLAYER_ON_BUTTON)
{
vect size_txt = { display_user->size_menu,
display_user->size_window };
char txt_empty[100]
= " "
" ";
displayTextSDL (display_user, txt_empty, coor_time,
size_txt, 30);
char txt_button[70] = "";
indice_button = playerPos->y / 5;
if (indice_button <= 3)
{
snprintf (txt_button, 63,
" - : Niveau %d : - ",
indice_button);
}
else if (indice_button == dim_tab->y / 5)
{
snprintf (txt_button, 63,
" - : Creer un niveau %d : - ",
indice_button - 3);
}
else
{
snprintf (txt_button, 63,
" - : Niveau custom %d : - ",
indice_button - 3);
}
displayTextSDL (display_user, txt_button, coor_time,
size_txt, 30);
}
else
{
vect size_txt = { display_user->size_menu,
display_user->size_window };
char txt_empty[100]
= " - : Echap pour quitter : - ";
displayTextSDL (display_user, txt_empty, coor_time,
size_txt, 30);
}
}
}
current_time = time (NULL);
if (current_time > delay)
{
delay = current_time;
char *char_time = timeToText (time (NULL) - time_start);
if (!menu)
displayTextSDL (display_user, char_time, coor_time, size_menu,
30);
free (char_time);
}
SDL_Delay (16);
}
return -1;
}
/**
* \brief Cette fonction verrifie si la partie est gagnante.
* \param tab2d Le tableau 2D du jeu.
* \param targets Le tableau de toute les positions des points d'interer.
* \param nbr_targets Le nombre de points d'interer.
* \return True si le joueur a remplis tout les points d'interer, false si ce
* n'est pas le cas .
*/
bool isWin (char **tab2d, vect *targets, int nbr_targets)
{
int i;
for (i = 0; i < nbr_targets; ++i)
{
int x = targets[i].x;
int y = targets[i].y;
if (tab2d[x][y] != BOX_ON_TARGET)
{
return false;
}
}
return true;
}
/**
* \brief La fonction renvois si la partie est perdante.
* \param tab2d Le tableau 2d carre du plateau de jeu.
* \param N Le nombre d'éléments dans le tab2d. (zone de jeu est carré)
* \return True si c'est perdu, false si c'est pas perdu a cette instant.
*
*/
bool islose (char **tab2d, const int N)
{
int x = 0, y = 0;
for (x = 0; x < N; ++x)
{
for (y = 0; y < N; ++y)
{
bool isblock = false;
if (tab2d[x][y] == BOX)
{
vect box;
box.x = x;
box.y = y;
isblock = blockBox (tab2d, box);
}
if (isblock)
{
return true;
}
}
}
return false;
}
/**
* \brief La fonction fait une addition de vecteur, (x1+x2, y1+y2).
* \param one Premier vecteur.
* \param two Deuzieme vecteur.
* \return vect Un vecteur de l'addition de one et two.
*/
vect plusVect (vect one, vect two)
{
vect result;
result.x = one.x + two.x;
result.y = one.y + two.y;
return result;
}
/**
* \brief Renvois la longeur Manhattan
*/
int lengthVect (vect vector) { return abs (vector.x) + abs (vector.y); }
/**
* \brief La fonction permet de savoir si une boite est dans une situation ou
* le joueur ne poura pas la debloqué.
* \param tab2d Le tableau 2D carre du plateau de jeu.
* \param box_coor Les corrdonnée de la boite que la fonction test.
* \return True si la la boite est bloquer, sinon false.
*/
bool blockBox (char **tab2d, vect box_coor)
{
int nbr_touch = 0;
vect card[4] = { { 0, -1 }, { 1, 0 }, { 0, 1 }, { -1, 0 } };
int indice_card[4] = { 0 };
int id_box = -1;
int i;
for (i = 0; i < 4; ++i)
{
vect test = plusVect (box_coor, card[i]);
char val = tab2d[test.x][test.y];
if (val == BOX || val == WALL || val == BOX_ON_TARGET)
{
nbr_touch++;
if (val == BOX || val == BOX_ON_TARGET)
{
id_box = nbr_touch - 1;
}
indice_card[nbr_touch - 1] = i;
}
}
if (nbr_touch == 0)
return false;
if (nbr_touch >= 3)
{
if (id_box != -1)
{
vect other1 = card[indice_card[(id_box + 1) % 3]];
vect other2 = card[indice_card[(id_box + 2) % 3]];
vect test_add_other = plusVect (other1, other2);
vect coor_box = plusVect (card[indice_card[id_box]], box_coor);
vect other_plus_box1 = plusVect (other1, coor_box);
vect other_plus_box2 = plusVect (other2, coor_box);
int val1 = tab2d[other_plus_box1.x][other_plus_box1.y];
int val2 = tab2d[other_plus_box2.x][other_plus_box2.y];
if (test_add_other.x == 0 && test_add_other.y == 0)
{
if ((val1 == WALL || val1 == BOX || val1 == BOX_ON_TARGET)
|| (val2 == WALL || val2 == BOX || val2 == BOX_ON_TARGET))
{
return true;
}
return false;
}
}
return true;
}
if (nbr_touch == 2)
{
int id1 = indice_card[0];
int id2 = indice_card[1];
vect add = plusVect (card[id1], card[id2]);
if (lengthVect (add) == 2)
{
if (id_box == -1)
return true;
vect test = plusVect (card[indice_card[id_box]],
card[indice_card[(id_box + 1) % 2]]);
test = plusVect (test, box_coor);
if (tab2d[test.x][test.y] == WALL)
return true;
}
return false;
}
vect normal = card[indice_card[0]];
vect director1 = card[(indice_card[0] + 1) % 4];
vect director2 = card[(indice_card[0] + 3) % 4];
vect dir_test[2] = { director1, director2 };
bool wall = false;
for (int i = 0; i < 2; ++i)
{
wall = false;
vect current = plusVect (box_coor, dir_test[i]);
while (!wall)
{
char val = tab2d[current.x][current.y];
vect cur_nor = plusVect (current, normal);
char val_nor = tab2d[cur_nor.x][cur_nor.y];
if (val == WALL)
wall = true;
else if (val == TARGET)
return false;
if (val_nor != WALL)
{
return false;
}
current = plusVect(current, dir_test[i]);
}
}
return true;
}
/**
* \brief Cette fonction renvois transforme le forma time en texte. (min:sec)
* \param time Le temps qu'on veux convertire.
* \return char Le string du texte.
*/
char *timeToText (time_t time)
{
char *result = calloc (20, sizeof (char));
result[0] = '\0';
unsigned int min = time / 60;
unsigned int sec = time % 60;
snprintf (result, 20, "Time : %02d:%02d", min, sec);
return result;
}
/**
* \brief Mets à 0 le score.
* \param player_score Le score a mettre à 0.
* \return void
*/
void nullScore(score *player_score)
{
player_score->after = 0;
player_score->before = 0;
player_score->move_box = 0;
player_score->move_player = 0;
}
/**
* \brief Fonction de loop pour la win ou la lose.
* \param display_user Tout les information du display de l'utilisateur utile.
* \param win Si on veut un affichage de victoire ou non.
*/
void winOrLoseLoop(dis *display_user,score *score_user, bool win)
{
SDL_Surface *img;
SDL_Texture *texture;
if(win) img = IMG_Load("image/win.png");
else img = IMG_Load("image/lose.png");
texture = SDL_CreateTextureFromSurface (display_user->renderer, img);
vect pos = {0, 0};
displayImage(display_user->renderer, texture, pos, display_user->size_window);
char text[50] = "";
snprintf(text, 50, "Score : %u",scoreCalculator(score_user, win));
vect pos_score = {10, (display_user->size_window*3) / 4};
vect size_score = {display_user->size_window / 4, display_user->size_window - 10};
displayTextSDL(display_user, text , pos_score, size_score, 80);
SDL_RenderPresent (display_user->renderer);
bool finish = false;
SDL_Event event;
SDL_Delay(100);
while(!finish)
{
SDL_PollEvent(&event);
if(event.type == SDL_KEYDOWN && event.key.keysym.scancode == SDL_SCANCODE_RETURN) finish = true;
SDL_Delay(16);
}
SDL_FreeSurface (img);
SDL_DestroyTexture (texture);
return;
}
unsigned int scoreCalculator(score *score_user, bool win)
{
unsigned short int result = 65535; //plus grand nombre
int time = score_user->after - score_user->before;
result -= (score_user->move_box + score_user->move_player) * time;
if (!win)
{
result /= 50;
}
return result;
}
Reference in New Issue View Git Blame Copy Permalink