Browse Source

Merge branch 'master' of ssh://ssh.confais.org/git/dames_chinoises

master
Bastien 8 years ago
committed by Squiz
parent
commit
23703720f9
1 changed files with 15 additions and 15 deletions
  1. +15
    -15
      readme

+ 15
- 15
readme View File

@ -23,14 +23,14 @@ fonction « char_to_int »
========================
La fonction « enum bool char_to_int(char *argv, int *nombre) » permet de convertir un nombre contenu dans une chaîne de
caractères en un entier. La fonction retourne « true » si la conversion a réussie et « false » si la conversion a échouée.
caractères en un entier. La fonction retourne « true » si la conversion a réussi et « false » si la conversion a échoué.
Le nombre converti est stocké à l'adresse pointée par le paramètre « nombre ».
fonction « number_length »
==========================
La fonction « unsigned int number_length(int n) » retourne le nombre de caractères nécessaires pour convertir ce nombre en
une chaîne de caractères. Ainsi number_length(-100) retourne 4.
une chaîne de caractères en base 10. Ainsi number_length(-100) retourne 4.
fonction « ia_call_function »
=============================
@ -44,7 +44,7 @@ Les arguments suivants sont les arguments attendus par la fonction de la straté
La fonction va d'abord affecter à la variable « function_name » la chaîne de caractères correspondant au nom de la fonction à
appeler. Ce nom est déduit de la valeur du paramètre « api_function ».
Ensuite on essaie de récupérer un pointeur vers la fonction en question grâce à l'utilisation de « dlsym ». Si cela échoue la
Ensuite on essaie de récupérer un pointeur vers la fonction en question grâce à l'utilisation de « dlsym ». Si cela échoue, la
fonction « ia_call_function » retourne « false » et se termine. Sinon, selon la fonction demandée, on lit éventuellement les
paramètres avec « va_arg() ». Enfin on appelle la fonction de la stratégie.
@ -69,8 +69,8 @@ ____/ 1 \____
Ainsi quand le nombre de joueurs est égal à 2, le joueur 0 doit être placé sur la branche 1 et le joueur 1 sur la branche 4.
On a donc dans ce cas « star_branch(2,0) = 0 » et « star_branch(2,1) = 3 ».
Avec trois joueurs, on place les joueurs sur les branches 1, 3 et 5
Avec quatre joueurs, on les place sur les branches 1, 2, 4 et 5
Avec trois joueurs, on place les joueurs sur les branches 1, 3 et 5.
Avec quatre joueurs, on les place sur les branches 1, 2, 4 et 5.
Avec six joueurs, on utilise chaque branche.
fonction « move_calculation »
@ -173,7 +173,7 @@ triangle d'aile, mais pas d'y stationner. »
fonction « distance_to_branch »
===============================
La fonction « int distance_to_branch(const enum hole_t branch, const size_t index) » permet d'évaluer la distance entre deux cases du plateau. La distance est calculée comme le nombre de lignes séparant les deux cases plusS la différence d'indice sur la ligne .
La fonction « int distance_to_branch(const enum hole_t branch, const size_t index) » permet d'évaluer la distance entre deux cases du plateau. La distance est calculée comme le nombre de lignes séparant les deux cases plus la différence d'indice sur la ligne .
Cependant comme les lignes n'ont pas toutes la même longueur, on accentue le décalage sur les lignes ayant peu d'éléments.
fonction « must_move »
@ -184,7 +184,7 @@ atteindre le joueur d'en face en un coup (composé de plusieurs mouvement). Si i
resté dans sa branche de départ, alors le joueur bloque le joueur en face de lui. Il doit donc sortir de sa branche de départ.
must_move retourne vrai si le joueur doit sortir de sa branche avec res qui correspond à la liste des pions qui gênent, sinon must_move retourne faux.
Cette fonction est utilisée dans la fonction « valid_move » afin de vérifier la règle « Un pion doit obligatoirement quitter son triangle de départ quand le joueur situé vis-à-vis n'a plus, comme seul coup lui permettant de progresser, que la rentrée : on doit
alors laisser la place libre, même si on a un meilleur autre coup.(Il est interdit de bloquer un autre joueur.) »
alors laisser la place libre, même si on a un meilleur autre coup. (Il est interdit de bloquer un autre joueur.) »
fonction « valid_move »
=======================
@ -192,18 +192,18 @@ fonction « valid_move »
La fonction « enum validation_movement_t valid_move(const int start_pos_first_move, const struct move_t move, const struct move_t previous_move, const struct player_t player, const struct game_state_t game, const size_t start_position[6][10], const enum bool
last_move) » permet de vérifier si le coup « move » est un coup valide ou non.
Le paramètre « fist_move » est le point de départ du premier mouvement d'un coup.
Le paramètre « first_move » est le point de départ du premier mouvement d'un coup.
Le paramètre « move » est le mouvement dont on veut vérifier la validité
Le paramètre « previous_move » est le mouvement précédent. Cela permet ainsi de vérifier que pendant un même tour, on ne déplace qu'un seul pion. Si c'est le premier mouvement d'un tour, ce mouvement doit comporter (-1,-1).
Le paramètre « player » est le joueur qui effectue le déplacement. Cela permet de vérifier que le joueur déplace un pion qui lui appartient
Le paramètre « game » est le plateau du jeu
Le paramètre « player » est le joueur qui effectue le déplacement. Cela permet de vérifier que le joueur déplace un pion qui lui appartient.
Le paramètre « game » est le plateau du jeu.
Le paramètre « start_position » est un tableau qui contient les indices des cases formant les branches de l'étoile.
Le paramètre « last_move » permet d'indiquer qu'il s'agit du dernier mouvement d'un tour. Ces deux derniers paramètres permettent de vérifier que le joueur ne s'arrête pas sur une branche de l'étoile.
La fonction retourne « jump », « jump_valid », « neighbour_valid » ou « invalid ».
La fonction va d'abord vérifier si le joueur n'est pas bloqué. Si le joueur est bloqué alors si il a mis n'importe quoi dans « move » et que « next_move » a retourné 0, on considère qu'il passe son tour.
Ensuite on vérifie que le joueur ne bloque pas le joueur en face de lui. Si il peut le bloquer, on regarde que le pion qu'il déplace est bien un pion qui gène (retourné par must_move). Si ce n'est pas le cas, le mouvement est invalide.
Ensuite on vérifie que le joueur ne bloque pas le joueur en face de lui. Si il peut le bloquer, on regarde que le pion qu'il déplace est bien un pion qui gêne (retourné par must_move). Si ce n'est pas le cas, le mouvement est invalide.
Ensuite, si c'est le dernier mouvement alors on vérifie que le joueur n'est pas stationné sur une branche. Si c'est bon, on retourne « jump_valid ». Ce retour permet à la fonction main de ne pas tenir compte du coup.
Ensuite on vérifie que la case du début du mouvement comporte bien un pion appartenant au joueur.
@ -212,9 +212,9 @@ Si ce n'est pas le premier mouvement d'un tour, on vérifie que la case au dépa
Ensuite, si il s'agit du dernier mouvement d'un tour, on vérifie que la case de la fin du mouvement ne corresponde pas à la branche d'un joueur.
Ensuite on regarde chaque case située autour de la case au départ du mouvement. On a trois cas :
Si la case est vide et que c'est là qu'on veut aller, le coup est autorisé
Si la case est occupée et que c'est là qu'on veut aller, le coup est invalide
Si la case est occupée et que ce n'est pas la qu'on veut aller, on refait ce test (uniquement les deux conditions précédentes )avec la case située après le
Si la case est vide et que c'est là qu'on veut aller, le coup est autorisé.
Si la case est occupée et que c'est là qu'on veut aller, le coup est invalide.
Si la case est occupée et que ce n'est pas la qu'on veut aller, on refait ce test (uniquement les deux conditions précédentes) avec la case située après le
pion voisin.
Une fois qu'on a regardé tous les voisins, si on n'a satisfait aucune condition, on considère naturellement que le coup est invalide.
@ -245,4 +245,4 @@ fonction « main »
=================
La fonction main gère le déroulement de la partie.
La partie s'arrete si un seul joueur gagne ou si tous les joueurs sauf un ont perdus (un joueur ne va pas jouer tout seul).
La partie s'arrête si un seul joueur gagne ou si tous les joueurs sauf un ont perdu (un joueur ne va pas jouer tout seul).

Loading…
Cancel
Save