Algorithme de calcul de probabilité du jeu risk
0/5 (3 avis)
Snippet vu 14 315 fois - Téléchargée 19 fois
Contenu du snippet
Tout le monde connaît le célèbre jeu de stratégie RISK, où le but est de conquérir le monde. Ce jeu bien que stratégique contient une part de chance lors des combats notamment. Ce programme calcule la probabilité de victoire de l'attaquant pour les différentes configuration possibles (un contre deux, trois contre deux). La méthode employée repose sur l'équiprobabilité des lancés de dés. La fonction "bataille()" prend en argument la configuration de la bataille x soldats contre y, ainsi que les lancés de dés de chaque camps. Cette fonction renvoie l'issue de la bataille. La fonction "main()" appelle la fonction bataille pour toutes les combinaisons de des possibles, et ainsi donne les probabilités.
Source / Exemple :
#include <stdio.h>
#include <string.h>
typedef enum
{ UN_CONTRE_UN = 0,
DEUX_CONTRE_UN = 1,
TROIS_CONTRE_UN = 2,
UN_CONTRE_DEUX = 3,
DEUX_CONTRE_DEUX = 4,
TROIS_CONTRE_DEUX = 5
} config; /*les differentes configuration */
typedef enum
{ DEUX_ATTAQUANTS_MORTS = 0,
UN_ATTAQUANT_MORT = 1,
UN_CHACUN = 2,
UN_DEFENSEUR_MORT = 3,
VICTOIRE_ATTAQUANT = 4,
VICTOIRE_DEFENSEUR = 5
} issue; /*les differentes issues de la bataille */
typedef struct
{
char d1;
char d2;
char d3;
} da; /*les des de l'attaqquant : max 3 dès */
typedef struct
{
char d1;
char d2;
} dd; /*les des du deffenseur max 2 des */
issue
bataille (config c, da a, dd d)
{
switch (c)
{
case UN_CONTRE_UN:
if (a.d1 > d.d1)
return VICTOIRE_ATTAQUANT;
else
return VICTOIRE_DEFENSEUR;
case DEUX_CONTRE_UN:
if (a.d1 > d.d1 || a.d2 > d.d1)
return VICTOIRE_ATTAQUANT;
else
return UN_ATTAQUANT_MORT;
case TROIS_CONTRE_UN:
if (a.d1 > d.d1 || a.d2 > d.d1 || a.d3 > d.d1)
return VICTOIRE_ATTAQUANT;
else
return UN_ATTAQUANT_MORT;
case UN_CONTRE_DEUX:
if (d.d1 >= a.d1 || d.d2 >= a.d2)
return VICTOIRE_DEFENSEUR;
else
return UN_DEFENSEUR_MORT;
case TROIS_CONTRE_DEUX:
a.d1 = (a.d1 > a.d2) ? a.d1 : a.d2; //on selectionne les meilleurs dés attaquant
a.d2 = (a.d2 > a.d3) ? a.d2 : a.d3; //on selectionne les meilleurs dés attaquant
goto DEUX_CONTRE_DEUXbis;
case DEUX_CONTRE_DEUX:
DEUX_CONTRE_DEUXbis:;
if ((d.d1 >= a.d1 && d.d2 >= a.d2) || (d.d2 >= a.d1 && d.d1 >= a.d2))
return DEUX_ATTAQUANTS_MORTS;
if ((a.d1 > d.d1 && a.d2 > d.d2) || (a.d2 > d.d1 && a.d1 > d.d2))
return VICTOIRE_ATTAQUANT;
else
return UN_CHACUN;
}
}
int
main (int argc, char **argv)
{
da a;
dd d;
int tmp[6]; //résultat temporaire
float proba_victoire_attaquant[6]; //résultat définitif
memset (tmp, 0x0, (sizeof (int) * 6));
for (a.d1 = 1; a.d1 <= 6; a.d1++)
for (d.d1 = 1; d.d1 <= 6; d.d1++)
tmp[bataille (UN_CONTRE_UN, a, d)]++;
proba_victoire_attaquant[UN_CONTRE_UN] =
(float) tmp[VICTOIRE_ATTAQUANT] / (tmp[VICTOIRE_ATTAQUANT] +
tmp[VICTOIRE_DEFENSEUR]);
memset (tmp, 0x0, (sizeof (int) * 6));
for (a.d1 = 1; a.d1 <= 6; a.d1++)
for (a.d2 = 1; a.d2 <= 6; a.d2++)
for (d.d1 = 1; d.d1 <= 6; d.d1++)
tmp[bataille (DEUX_CONTRE_UN, a, d)]++;
proba_victoire_attaquant[DEUX_CONTRE_UN] =
(float) (tmp[VICTOIRE_ATTAQUANT] +
tmp[UN_ATTAQUANT_MORT] *
proba_victoire_attaquant[UN_CONTRE_UN]) /
(tmp[VICTOIRE_ATTAQUANT] + tmp[UN_ATTAQUANT_MORT]);
memset (tmp, 0x0, (sizeof (int) * 6));
for (a.d1 = 1; a.d1 <= 6; a.d1++)
for (a.d2 = 1; a.d2 <= 6; a.d2++)
for (a.d3 = 1; a.d3 <= 6; a.d3++)
for (d.d1 = 1; d.d1 <= 6; d.d1++)
tmp[bataille (TROIS_CONTRE_UN, a, d)]++;
proba_victoire_attaquant[TROIS_CONTRE_UN] =
(float) (tmp[VICTOIRE_ATTAQUANT] +
tmp[UN_ATTAQUANT_MORT] *
proba_victoire_attaquant[DEUX_CONTRE_UN]) /
(tmp[VICTOIRE_ATTAQUANT] + tmp[UN_ATTAQUANT_MORT]);
memset (tmp, 0x0, (sizeof (int) * 6));
for (a.d1 = 1; a.d1 <= 6; a.d1++)
for (d.d1 = 1; d.d1 <= 6; d.d1++)
for (d.d2 = 1; d.d2 <= 6; d.d2++)
tmp[bataille (UN_CONTRE_DEUX, a, d)]++;
proba_victoire_attaquant[UN_CONTRE_DEUX] =
(float) tmp[UN_DEFENSEUR_MORT] / (tmp[UN_DEFENSEUR_MORT] +
tmp[VICTOIRE_DEFENSEUR]) *
proba_victoire_attaquant[UN_CONTRE_UN];
memset (tmp, 0x0, (sizeof (int) * 6));
for (a.d1 = 1; a.d1 <= 6; a.d1++)
for (a.d2 = 1; a.d2 <= 6; a.d2++)
for (d.d1 = 1; d.d1 <= 6; d.d1++)
for (d.d2 = 1; d.d2 <= 6; d.d2++)
tmp[bataille (DEUX_CONTRE_DEUX, a, d)]++;
proba_victoire_attaquant[DEUX_CONTRE_DEUX] =
(float) (tmp[VICTOIRE_ATTAQUANT] +
tmp[UN_CHACUN] * proba_victoire_attaquant[UN_CONTRE_UN]) /
(tmp[VICTOIRE_ATTAQUANT] + tmp[UN_CHACUN] + tmp[DEUX_ATTAQUANTS_MORTS]);
memset (tmp, 0x0, (sizeof (int) * 6));
for (a.d1 = 1; a.d1 <= 6; a.d1++)
for (a.d2 = 1; a.d2 <= 6; a.d2++)
for (a.d3 = 1; a.d3 <= 6; a.d3++)
for (d.d1 = 1; d.d1 <= 6; d.d1++)
for (d.d2 = 1; d.d2 <= 6; d.d2++)
tmp[bataille (TROIS_CONTRE_DEUX, a, d)]++;
proba_victoire_attaquant[TROIS_CONTRE_DEUX] =
(float) (tmp[VICTOIRE_ATTAQUANT] +
tmp[UN_CHACUN] * proba_victoire_attaquant[DEUX_CONTRE_UN] +
tmp[DEUX_ATTAQUANTS_MORTS] *
proba_victoire_attaquant[UN_CONTRE_DEUX]) /
(tmp[VICTOIRE_ATTAQUANT] + tmp[UN_CHACUN] + tmp[DEUX_ATTAQUANTS_MORTS]);
printf
("Probabilité de victoire du jeu RISK pour l'attaquant\n--------------------------------------------------------------------------------\n*Un attaquant contre un defenseur : %.1f%%\n*Deux attaquants contre un defenseur : %.1f%%\n*Trois attaquants contre un defenseur : %.1f%%\n*Un attaquant contre deux défenseurs : %.1f%%\n*Deux attaquants contre deux defenseurs : %.1f%%\n*Trois attaquants contre deux defenseurs : %.1f%%\n\n\n",
proba_victoire_attaquant[UN_CONTRE_UN] * 100,
proba_victoire_attaquant[DEUX_CONTRE_UN] * 100,
proba_victoire_attaquant[TROIS_CONTRE_UN] * 100,
proba_victoire_attaquant[UN_CONTRE_DEUX] * 100,
proba_victoire_attaquant[DEUX_CONTRE_DEUX] * 100,
proba_victoire_attaquant[TROIS_CONTRE_DEUX] * 100);
return 0;
}
A voir également
- Algorithme de calcul de probabilité du jeu risk
- Probabilité keno - Forum Visual Basic
- Calcul de puissance de 10 - Forum Visual Basic
- Calcul du tri ✓ - Forum Visual Basic 6
- Algorithme de kruskal en c ✓ - Forum C
- Buzzers jeu - Forum C
21 août 2007 à 09:47
Juste pour pinailler, tes enum:
# typedef enum
# { UN_CONTRE_UN = 0,
# DEUX_CONTRE_UN = 1,
# TROIS_CONTRE_UN = 2,
# UN_CONTRE_DEUX = 3,
# DEUX_CONTRE_DEUX = 4,
# TROIS_CONTRE_DEUX = 5
# } config;
Pas besoin de donner les valeurs, le principe de l'enumeration c'est que les valeurs sont données automatiquement a partir de la premiere :
# typedef enum
# { UN_CONTRE_UN = a, // a un entier quelconque, ici 0
# DEUX_CONTRE_UN, // DEUX_CONTRE_UN a+1 1
# TROIS_CONTRE_UN, // TROIS_CONTRE_UN = a+2= 2
# UN_CONTRE_DEUX, // etc.
# DEUX_CONTRE_DEUX,
# TROIS_CONTRE_DEUX
# } config;
16 août 2007 à 17:28
15 août 2007 à 15:23
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.