Salut,

Et bien pour commencer il faut que tu déclare toutes tes variables sans en oublier.
Ensuite il faut que tu demande un "si...alors" après tu mets afficher message et tu dis ce que tu veux afficher.
Tu fais cela pour chacune de tes conditions.
Et au final tu entre un autre message pour dire que le jeu se termine lorsque l'on atteint une case "gagné ou perdu".

Bonjour, tu es sûr que ça n'est pas
-Si on obtient 5 ou 6, on déplace le pion d'une case vers la droite ?

L'idée est de repérer la position courante du jeton avec les variables X et Y
Puis de tirer un nombre aléatoire et faire évoluer X et Y suivant les résultats.
Puis tester si on est sur des cases gagnantes ou perdantes.
Pour que l'on puisse suivre le parcourt du jeton, j'ai fait afficher l'évolution de X;Y
La boucle Tant Que s'exécute tant que l'on est pas sur une case gagnante ou perdante.

S'il y a des choses que tu ne comprends pas, demande.

Ça donne ça (que tu peux copier/coller en mode d'édition "éditeur de texte" dans Algobox si tu veux) :

VARIABLES
X EST_DU_TYPE NOMBRE
Y EST_DU_TYPE NOMBRE
Termine EST_DU_TYPE NOMBRE
P EST_DU_TYPE NOMBRE
V EST_DU_TYPE CHAINE
DEBUT_ALGORITHME
Termine PREND_LA_VALEUR 0
X PREND_LA_VALEUR 0
Y PREND_LA_VALEUR 0
TANT_QUE (Termine == 0) FAIRE
DEBUT_TANT_QUE
P PREND_LA_VALEUR ALGOBOX_ALEA_ENT(1,6)
SI (P==1 OU P==2) ALORS
DEBUT_SI
X PREND_LA_VALEUR X-1
FIN_SI
SI (P==3 OU P==4) ALORS
DEBUT_SI
Y PREND_LA_VALEUR Y+1
FIN_SI
SI (P==5 OU P==6) ALORS
DEBUT_SI
X PREND_LA_VALEUR X+1
FIN_SI
SI ((X==2 ET Y==0) OU (X==-2 ET Y==0) OU (X==0 ET Y==2)) ALORS
DEBUT_SI
V PREND_LA_VALEUR "Gagné"
Termine PREND_LA_VALEUR 1
FIN_SI
SI ((X==1 ET Y==1) OU (X==-1 ET Y==1)) ALORS
DEBUT_SI
V PREND_LA_VALEUR "Perdu"
Termine PREND_LA_VALEUR 1
FIN_SI
AFFICHER X
AFFICHER ";"
AFFICHER* Y
FIN_TANT_QUE
AFFICHER V
FIN_ALGORITHME

Oui tu à tout à fait raison c'est bien 5 ou 6.
De plus j'ai bien compris ta démarche mais pas trop le fait que tu marque "Termine PREND_LA_VALEUR 1" ainsi que "AFFICHER ";"
Pourrais tu m'éclairer un peu ?

Termine est une variable qui vaut 0 au début et qui le reste tant que les tests qui montrent que le jeton a atteint une case terminale sont faux. Puis dès que l'une des conditions d'arrêt est remplie, la variable Termine passe à 1 et ça permet de sortir de la boucle TANT QUE. C'est juste une astuce pour alléger l'écriture. Il faut bien que le jeton continue son périple tant que l'on est pas sur une case gagné ou Perdu.

AFFICHER X
AFFICHER ";"
AFFICHER* Y

Ça sert juste à afficher la position du jeton sous la forme X;Y histoire que l'on voit par quel chemin il est passé et quelle case il a atteinte (mais c'est optionnel, si tu enlèves ces instructions, tu sauras si c'est gagné ou perdu mais sans savoir sur quelle case.
AFFICHER ";" c'est afficher la chaîne de caractère ;
AFFICHER* ça veut dire qu'il y a un retour à la ligne après alors que AFFICHER tout court, on reste sur la même ligne.

Donc ça donne par exemple :
***Algorithme lancé***
1;0
1;1
Perdu
***Algorithme terminé***

Mais fait le tourner l'algorithme dans Algobox, et même en mode pas à pas,tu te rendras mieux compte par toi même de ce que fait chaque instruction.

Ah d'accord merci bien.

Cependant n'y a t-il pas un problème ici :
TANT_QUE (Termine == 0) FAIRE
DEBUT_TANT_QUE
  P PREND_LA_VALEUR ALGOBOX_ALEA_ENT(1,6)
  SI (P==1 OU P==2) ALORS

Car dans l'algorithme lorsque nous entrons Tant que: En dessous de P Prend la valeur algobox Alea ent (1,6) est présent FIN tant que

Désoler je n'est rien dit j'ai compris par moi même.
Encore merci

Une dernière petite question comment dois-je faire pour simuler 1000 parties ? En modifiant ce programme ?

J'y suis parvenu par contre je n'arrive pas a lui demander d'afficher la proportion de gagné une idée ?

Pour simuler 1000 parties, tu encadres le programme par une boucle POUR I allant de 1 à 1000
tu enlèves les instructions qui affichent les X;Y et tu remplaces l'instruction AFFICHER V par une instruction qui incrémente une variable si c'est gagné, par exemple Mettre Z+1 dans Z
Et puis à la fin, en sortie de la boucle POUR I allant de 1 à 1000, tu affiches Z/1000

VARIABLES
X EST_DU_TYPE NOMBRE
Y EST_DU_TYPE NOMBRE
Termine EST_DU_TYPE NOMBRE
P EST_DU_TYPE NOMBRE
I EST_DU_TYPE NOMBRE
Z EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
Z PREND_LA_VALEUR 0
POUR I ALLANT_DE 1 A 1000
DEBUT_POUR
Termine PREND_LA_VALEUR 0
X PREND_LA_VALEUR 0
Y PREND_LA_VALEUR 0
TANT_QUE (Termine == 0) FAIRE
DEBUT_TANT_QUE
P PREND_LA_VALEUR ALGOBOX_ALEA_ENT(1,6)
SI (P==1 OU P==2) ALORS
DEBUT_SI
X PREND_LA_VALEUR X-1
FIN_SI
SI (P==3 OU P==4) ALORS
DEBUT_SI
Y PREND_LA_VALEUR Y+1
FIN_SI
SI (P==5 OU P==6) ALORS
DEBUT_SI
X PREND_LA_VALEUR X+1
FIN_SI
SI ((X==2 ET Y==0) OU (X==-2 ET Y==0) OU (X==0 ET Y==2)) ALORS
DEBUT_SI
Z PREND_LA_VALEUR Z+1
Termine PREND_LA_VALEUR 1
FIN_SI
SI ((X==1 ET Y==1) OU (X==-1 ET Y==1)) ALORS
DEBUT_SI
Termine PREND_LA_VALEUR 1
FIN_SI
FIN_TANT_QUE
FIN_POUR
Z PREND_LA_VALEUR Z/1000
AFFICHER Z
FIN_ALGORITHME