Browse Source

Rédaction du readme et ajout de « const » dans les paramètres des fonctions.

master
Bastien 8 years ago
committed by Squiz
parent
commit
0f423baa08
3 changed files with 92 additions and 9 deletions
  1. +3
    -1
      dummy.c
  2. +6
    -6
      main.c
  3. +83
    -2
      readme

+ 3
- 1
dummy.c View File

@ -1,4 +1,5 @@
#include <stdio.h>
#include <time.h>
#include "api.h"
void InitLibrary(char name[50]) {
@ -8,6 +9,7 @@ void StartGame() {
puts("stratégie start game");
}
void StartMatch(const unsigned int nbJoueur, const enum hole_t couleur) {
srand(time(NULL));
printf("stratégie start match (%d players, color%d)\n", nbJoueur, couleur);
}
void EndMatch() {
@ -18,5 +20,5 @@ void EndGame() {
}
int NextMove(const SGameState * const gameState, int firstMove, SMove *move) {
puts("stratégie next move");
return 0;
return (rand()%2)?0:1;
}

+ 6
- 6
main.c View File

@ -19,7 +19,7 @@ enum api_function_t {ia_lib_init, ia_start_match, ia_start_game, ia_end_game , i
struct player_t {
size_t branch;
unsigned int error;
void *ia_lib_p;
void *ia_lib_p; /* NULL si le joueur n'est pas une stratégie */
};
enum bool char_to_int(char *argv, int *nombre) {
@ -29,7 +29,7 @@ enum bool char_to_int(char *argv, int *nombre) {
return (error!=argv);
}
enum bool ia_call_function(const struct player_t player, enum api_function_t api_function, void *result, ...) {
enum bool ia_call_function(const struct player_t player, const enum api_function_t api_function, void *result, ...) {
va_list ap;
char* error;
enum bool res;
@ -81,7 +81,7 @@ enum bool ia_call_function(const struct player_t player, enum api_function_t api
d = va_arg(ap, struct move_t*);
*((int*) result) = (*(int(*)())ia_function_pf)(c, a, d); /* berk */
break;
default:
default: /* par défaut la fonction est de type void sans paramètres */
(*ia_function_pf)();
break;
}
@ -97,11 +97,11 @@ enum bool ia_call_function(const struct player_t player, enum api_function_t api
}
/* pour associer une branche de l'étoile à un joueur */
size_t star_branch(unsigned int nb_player, size_t index) {
size_t star_branch(const unsigned int nb_player, const size_t index) {
return (nb_player==4)?1+index+(index>=2?1:0):(6/nb_player)*index;
}
ssize_t move_calculation(size_t index, enum direction_t move) {
ssize_t move_calculation(const size_t index, const enum direction_t move) {
size_t index_lines[] = {0, 1, 3, 6, 10, 23, 35, 46, 56, 65, 75, 86, 98, 111, 115, 118, 120};
size_t index_lines_block[] = {0, 10, 65, 111};
size_t line, offset, block;
@ -155,7 +155,7 @@ ssize_t move_calculation(size_t index, enum direction_t move) {
}
}
enum bool search(const size_t *tab, size_t length, size_t value) {
enum bool search(const size_t *tab, const size_t length, const size_t value) {
size_t first, last, middle;
first = 0;
last = length-1;


+ 83
- 2
readme View File

@ -28,8 +28,8 @@ paramètres avec « va_arg() ». Enfin on appelle la fonction de la stratégie.
fonction « star_branch »
========================
La fonction « size_t star_branch(unsigned int nb_player, size_t index) » permet de déterminer sur quelle branche de l'étoile
doit se trouver la position de départ d'un joueur donné.
La fonction « size_t star_branch(const unsigned int nb_player, const size_t index) » permet de déterminer sur quelle branche de
l'étoile doit se trouver la position de départ d'un joueur donné.
On numérote chaque branche de l'étoile :
/ \
@ -52,3 +52,84 @@ fonction « move_calculation »
=============================
La fonction « ssize_t move_calculation(const size_t index, const enum direction_t move) » permet de déterminer l'indice du
voisin d'une case sur le plateau.
La fonction prend deux paramètres. Le premier paramètre, « index » est l'indice de la case dont on veut un voisin. Le second
paramètre « move » permet de préciser quel voisin on souhaite.
La fonction retourne l'indice du voisin ou bien -1 si le voisin demandé n'existe pas (par exemple la case d'indice 0 n'a pas de
voisin à gauche).
La fonction va d'abord déterminer sur quelle ligne se trouve la case dont on cherche le voisin ainsi que sa position sur la
ligne (offset). La fonction détermine aussi dans quel « bloc » de l'étoile, la case se trouve.
Les blocs sont définis comme ceci :
/ \
____/ \____ bloc 0
----------------------
\ / bloc 1
\ /
----------------------
/ \ bloc 2
/ \
----------------------
————\ /———— bloc 3
\ /
Ensuite on applique une formule différente selon le voisin dont on veut déterminer l'indice.
Pour le voisin à gauche : si l'offset est de 0, c'est à dire qu'on est sur la case la plus à gauche de la ligne alors on
renvoie -1 (il n'y a pas de voisin gauche). Sinon on retourne l'indice de la case moins un (puisque les cases sont numérotées
ligne par ligne).
Pour le voisin droit : on retourne l'indice de la case demandée plus un, sauf si cette case est située au début de la ligne
suivante (les indices des cases au situées au début des lignes sont connus).
Pour le voisin « haut gauche » :
On commence par traîter les cas où ce voisin n'existe pas. C'est à dire si on se trouve à la frontière entre le bloc 0 et le
bloc 1 ou sur toute première d'une ligne d'un bloc :
/ \
(**)/ \_(**)
\ /
\ /
(*) \
(*) \
————\ /————
\ /
« (*) » → cases qui n'ont pas de voisin haut gauche.
Si la case ne satisfait pas ces critères (donc elle a un voisin « haut gauche », on récupère l'indice de la case à la ligne
précédente ayant de même offset. On enlève 1 selon si le bloc est impair ou non (car les offsets sont décalés de 1 selon si la
taille des lignes est croissant ou décroissante)
Enfin on peut ajouter 4 ou retirer 5 pour faire le « collage » entre les blocs 0 et 1 et les blocs 2 et 3.
Pour le voisin « haut droit », on fonctionne de la même façon.
On commence par traîter les cases qui n'ont pas ce voisin :
/ \
(**)_/ \(**)
\ /
\ /
/ (*)
/ (*)
————\ /————
\ /
Ensuite la formule est la même que précédemment sauf qu'au lieu d'enlever 1 selon le bloc, on ajoute 1.
Pour les voisins situés en bas, on applique encore ce principe.
fonction « search »
===================
La fonction « enum bool search(const size_t *tab, const size_t length, const size_t value) » est une simple recherche
dichotomique qui permet de vérifier si la valeur « value » se trouve dans le tableau trié « tab » de taille « length ».

Loading…
Cancel
Save