begin process at 2010 03 21 20:32:12
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Maths & Algorithmes

 > ALGORITHME DE CALCUL DE PROBABILITÉ DU JEU RISK

ALGORITHME DE CALCUL DE PROBABILITÉ DU JEU RISK


 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

Source avec Zip ASM INLINE AVEC GCC EN SYNTAXE INTEL
Source avec Zip COMMENT PROGRAMMER UN OS SIMPLE EN C ET SOUS WINDOWS

 Sources de la même categorie

Source avec Zip TRANSFORMER UN ENTIER EN DEUX NOMBRES COMPOSÉ DES MEMES CHIF... par thebroyeur
CALCULE LOG(X) par tagtog
Source avec Zip Source avec une capture ALGORITHME DE TRI D'UN TABLEAU PAR ORDRE CROISSANT OU DÉCROI... par Thuzhen
Source avec une capture CALCUL DE VARIANCE par Minilogus
Source avec une capture GÉNÉRATEUR DE CLÉS SUR 26 DIGITS AU FORMAT HEXADÉCIMAL par besilent

 Sources en rapport avec celle ci

JEU DU PENDU !!!! VERSION SIMPLIFIÉE ET FACILE par seyidleite
Source avec Zip Source avec une capture PLUS OU MOINS par antho974
Source avec Zip JEU DE DAMES 3D par vbclaude
Source avec Zip JEU: MARIO SOKOBAN par astro53
Source avec Zip JEU PUISSANCE IV par ElendilAranwe

Commentaires et avis

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 dans le forum

Dev d'un jeu à la Age of Empires [ par jaylin ] Si vous êtes intéressez par le développement d'un jeu à la Age of Empires mais en plus réaliste contactez moi sur ICQ: 108283779 ou mailez moi: jaylin Empire Warriors [ par jaylin ] Je pourrais savoir pourquoi la partie du forum consacré au jeu a été supprimé??Le site du jeu www.empire-warriors.fr.st Création d'un jeu de stratégie en CPP et DIRECTX ! [ par DunËsPIdËr ] SalUt à tOuS! Nous sommes actuellement 4 programmeurs et 1 infographiste. Nous voulons créer un jeu de stratégie en temps réel sous Win utilisant di un ptit jeu [ par BLaFarD ] euh, je viens de me pondre un petit moteur 3d de merde en opengldonc, si qlqun veut me filer des model 3d k'il a fait (sous 3dsmax si possible), bah, DIRECTX et interface [ par ELKI ] je suis en train de concevoir un jeu d'echec et j'aurai voulu savoir comment je pouurai faire pour associer des pièce d'un jeu d'echec avec mon interf jeu de go [ par mastergc ] je suis en train de réaliser un projet de jeu de go en C ms jai qqes pblèmes pr la réalisation alors si jamais qq'un pouvait me donner des tuyaux ou d Code pour steph [ par SmallToad ] Voici le code, 222 lignes. ca va etre moin lour que sur le chat, .#include &lt;stdlib.h&gt;#include &lt;iostream.h&gt;#include &lt;iomanip.h&gt;#inclu jeu du Réversi [ par cri54 ] Hello everybody!Je suis nouvelle sur ce site, et je suis à la recherche du programme sur le jeu du Réversi.Vous ne saurez pas où je pourrais le trouve Bases de données odbc [ par f1cobra ] Bonjour, Comment gérer le mode du jeu d'enregistrement pour une base de donnees access odbc ?J'essaie d'enregistrer des données a partir d'une boite d trie et comparaison dans un tableau pour un jeu [ par cats ] J'ai un devoir à faire et j'ai besoin d'aide. Mon programme est un petit jeu des Maîtres de la Lande. En gros voici mon problème! Dans le jeu, il a de


Nos sponsors


Sondage...

Comparez les prix

CalendriCode

Mars 2010
LMMJVSD
1234567
891011121314
15161718192021
22232425262728
293031    

Consulter la suite du CalendriCode

 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 1,326 sec (4)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales