ALGORITHME DE CALCUL DE PROBABILITÉ DU JEU RISK risk, probabilite, jeu, Source N°43735

Information sur la source

Catégorie :Maths & Algorithmes Classé sous : risk, probabilite, jeu Niveau : Débutant Date de création : 11/08/2007 Vu : 2 911

Auteur : vinc1008881

Site perso

Ecrire un message privé

Note :
Aucune note

Commentaire sur cette source (3)

Ajouter un commentaire et/ou une note

Description

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

#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;
}

#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;

}

Sources du même auteur

Toutes les sources de vinc1008881

Sources de la même categorie

Toutes les sources de la catégorie Maths & Algorithmes

Sources en rapport avec celle ci

Commentaires

Commentaire de moulbergui le 15/08/2007 15:23:55

tres encourageant merci .bon courage .
Commentaire de Nicorsaire le 16/08/2007 17:28:58

Marrant et bien pensé, je vais de ce pas le tester avec une vraie partie.
Commentaire de Cyberboy2054 le 21/08/2007 09:47:42

Rigolo, fallait y penser :)
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;

Ajouter un commentaire

Discussions en rapport avec ce code source

Dev d'un jeu à la Age of Empires par jaylin

Empire Warriors par jaylin

Création d'un jeu de stratégie en CPP et DIRECTX ! par DunËsPIdËr

un ptit jeu par BLaFarD

DIRECTX et interface par ELKI

jeu de go par mastergc

Code pour steph par SmallToad

jeu du Réversi par cri54

Bases de données odbc par f1cobra

trie et comparaison dans un tableau pour un jeu par cats