PureBasic

Voici un mini tutoriel pour partager mon expérience et vous monter comment il peut être pratique et simple d'utiliser des tableaux.

Dans ce mini tuto, le but va être de faire un petit algorithme pour préparer la création d'un jeu bien connu : Le jeu des trois cartes.

Le but ici n'est pas de vous montrer comment faire le jeu ou de vous donner un jeu dans son intégralité, mais de vous montrer comment gérer un aspect particulier de ce jeu.

Bon, déjà qu'est ce que le jeu des trois cartes ? Il s'agit d'un jeu simple de hasard. Trois cartes se présentent à vous face cachée. Le but sera de trouver parmi les trois cartes où est la Dame de Coeur. Un jeu archi connu, mais qui présente un aspect intéressant concernant la programmation de tirage de carte.

Nous allons nous pencher ici sur le tirage aléatoire des cartes. On pourrait utiliser ici 32 cartes et demander au programme de tirer trois carte et de faire deviner au joueur où est une des trois cartes.

Pour simplifier nous allons partir du principe que nous aurons toujours les trois même cartes. Vous pourrez alors vous concentrer sur l'aspect "tirage aléatoire" du jeu. Comme je l'ai dit au départ, le but n'est pas de vous montrer comment faire le jeu, mais de vous expliquer un algorithme possible pour le tirage des cartes.

Donc Nous avons trois cartes différentes. Que doit il se passer :

1°) l'ordinateur devra mélanger les cartes
2°) Il devra choisir la première, puis la seconde et la troisième en faisant attention de ne pas mettre de doublon. (bah oui, le but est d'avoir à chaque tirage trois cartes différentes, mêmes si au départ on a trois cartes différentes dans le jeu, quand l'ordinateur va faire le tirage, il faut qu'il comprenne qu'il ne doit pas tirer une carte déjà tirée auparavant).

C sur cet aspect que nous allons travailler. Comment faire comprendre à l'ordinateur qu'il a trois cartes différentes, et qu'il doit obligatoirement tirer chaque carte dans un ordre différent à chaque fois et surtout sans doublon.

Pour cela, nous allons utiliser trois tableaux. Attention, ce code n'est peut être pas le plus optimisé mais il permettra à quelques un de comprendre comment ca marche.

Commençons le tutorial tout de suite.

1°) Créer un nouveau fichier Source Purebasic vide. Et commencez par mettre ceci au début du code :

Code : Tout sélectionner

;Initialisation des composants
InitSprite()
InitKeyboard()
InitMouse()
InitSound()
UsePNGImageDecoder()

Petit rappel : Au début du programme il faut initialiser les composants du programme à savoir, l'utilisation des sprites, le clavier, la souris, le son...

UsePNGImageDecoder() nous permet d'utiliser des images au format PNG.

Continuons, nous allons maintenant déclarer les constantes et variables dont nous aurons besoin. Ajoutez ceci au code :

Code : Tout sélectionner

;Initialisation des constantes
  ;Variables Globales
  Global MaFenetre    ;Fenêtre principale

  ;Constantes
  #Obj1 = 2
  #Obj2 = 3
  #Obj3 = 4

Nous commençons par déclarer la variable qui nous servira à la création de la fenêtre principale. Ensuite trois constantes qui représenteront en fait nos trois cartes. Je vous rappelle qu'en Purebasic, chaque sprite est défini par une constante. Au lieu d'utiliser des chiffres directement dans nos instructions, nous donnons à chaque chiffre représentant un sprite un nom. Ici Obj1, Obj2 et Obj3 rien de bien compliqué.

Créons notre fenêtre principale :

Code : Tout sélectionner

;Création de la fenêtre principale 
SetRefreshRate(60)
MaFenetre = OpenScreen(800,600,32,"Test")
If MaFenetre  = 0 
  MessageRequester("Erreur", "Impossible d'ouvrir une fenêtre DirectX", #PB_MessageRequester_Ok)
EndIf

Petites instructions toute simple, on paramètre le taux de rafraichissement à 60 et on crée la fenêtre avec OpenScreen. Si jamais le programme n'arrive pas à créer la fenêtre on renvoie un message d'erreur.

Rentrons maintenant dans le vif du sujet. Nous voulons faire notre petit jeu des trois cartes. Pour simplifier un peu plus, et pour se concentrer uniquement sur le code et pas les graphismes, j'ai utiliser trois images qui représente chacune un carré bleu, un carré rouge, et un carré vert. Ces carrés représenteront nos cartes et nous permettront de bien comprendre.

Vous pouvez créer ces graphismes primaires avec n'mporte quel logiciel de dessin. Utilisez le format PNG dans notre exemple.

Parfait, nous avons nos trois images, nous allons maintenant les initialiser par le programme, et les charger :

Code : Tout sélectionner

;Initialisation des images
LoadSprite(#Obj1,"rouge.png")
LoadSprite(#Obj2,"bleu.png")
LoadSprite(#Obj3,"vert.png")

Rien de difficile ici, on charge les images en leur attribuant à chacun une des constantes que nous avons déclarées en début de programme. Pour se repérer nous avons opté pour des noms significatifs.

Et c'est là que nous commençons à coder notre petit algorithme de tirage au sort des trois cartes. Ajoutez ceci :

Code : Tout sélectionner

;Tableau des cartes
Dim Objets(2)
Objets(0) = #Obj1
Objets(1) = #Obj2
Objets(2) = #Obj3

Ici nous déclarons un tableau à une dimension qui aura trois case. Il faut savoir que dans Purebasic, la première case d'un tableau est numérotée 0, puis 1 et puis 2, ce qui fait trois cases. L'instruction DIM permet de déclarer le tableau. Ensuite nous remplissons chaque case du tableau avec les trois cartes. Ce qui donne au final, un tableau qui réunit dans une case, une des trois cartes. Il s'agit en fait d'une sorte de tiroir de rangement, c'est ici que le programme piochera au hasard une des cartes. C'est notre shémas de départ.

Ajoutez maintenant :

Code : Tout sélectionner

Dim Obj_Etat(2)
For x = 0 To 2
  Obj_Etat(x) = 0
Next x

Ici, nous créons un second tableau. Celui ci respecte le même shémas que le premier (donc trois cases). Il permettra de savoir au programme si la carte qu'il a choisi a déjà été utilisé et donc tiré. Le tableau est initialisé par une boucle FOR NEXT qui remplit chaque case du tableau avec une valeur 0. Ce qui signifie que lorsque nous lancerons le programme, si la case qu'il regarde est à 0 c'est que la carte est disponible, si c'est à 1 le carte aura été utilisée et il faudra au programme en tirer une autre. Donc ici pour le moment et au début du programme tout est à 0.

Voici maintenant la plus importante partie du programme, ajoutez ceci :

Code : Tout sélectionner

Dim Obj_Al(2)
For x = 0 To 2
  Repeat
    a = Random(2)
  Until Obj_Etat(a) = 0
  Obj_Al(x) = Objets(a)
  Obj_Etat(a) = 1
Next x

Ici nous créons notre troisième tableau Obj_Al (pour Objet Aléatoire) qui aura également les même dimensions que les précédent. Il s'agira de notre tableau final autrement dit ce que l'ordinateur aura pioché.

La boucle FOR NEXT s'occupe maintenant de la partie aléatoire du jeu.

Nous initialisons la boucle avec X allant de 0 à 2 (pour les trois cases). Tout de suite après suis une autre boucle Repeat Until avec l'instruction Random. En fait le programme va tirer un nombre au hasard allant de 0 à 2. Ensuite il test si la valeur qu'il a pris au hasard n'est pas déjà prise dans le tableau Etat. Si c'est le cas il tire à nouveau un nombre au hasard. Sinon il passe à la suite des instructions.

Ex : Admettons que notre programme tire le nombre 1. Il va regardé dans le tableau Obj_Etat case 1 quelle est la valeur. Si la valeur est égale à 0 il continue ca veut dire que le numero n'a pas été tiré, sinon il recommence un tirage.

Donc si la carte (ou le numéro dans le code) n'a pas été tiré il continue. A ce moment là il attribue à la première case du tableau Obj_Al la carte qu'il a tiré grâce à Obj_Al(x) = Objets(a) en clair au premier tour de boucle FOR NEXT x sera égal à 0 donc ca sera notre première case du tableau Obj_Al ensuite Il prend la carte tiré dans le tableau Objets que vous avons défini au départ. Par ex si il tire le numéro 1, nous avons dit en début de programme que la case 1 (et donc la seconde) c'était #obj2 soit notre carré bleu.

Le programme va faire ceci jusqu'à qu'il est rempli le tableau Obj_Al et évidemment les trois cartes seront tirées grâce à ce procédé de manière aléatoire et sans doublon.

Il ne nous reste plus qu'à afficher le résultat du tirage, mais là rien de bien difficile : Ajoutez d'un coup :

Code : Tout sélectionner

posx = O

For x = 0 To 2
    DisplaySprite(Obj_Al(x),posx,10)
    posx = posx + 100
Next x

FlipBuffers()
Repeat
  ExamineKeyboard()
Until KeyboardPushed(#PB_Key_Escape)

La variable posx nous permet de faire varier la coordonnée de chaque sprite en X. Ensuite une boucle FOR NEXT pour afficher le résultat du tableau Obj_Al sous forme de sprite.

On rafraichit avec Flipbuffer() et enfin une petite boucle REPEAT UNTIL pour que le programme tourne indéfiniement jusqu'à qu'on appuie sur ECHAP.

Pour bien voir que ca marche lancez le programme plusieurs fois, vous verrez que l'ordre du tirage est toujours différent !

Voilà pour ce petit tut, si il y a des choses pas claires, je me tiens à votre disposition.

Génial , la seule chose que l'on peut regrétter c'est qu'il y en ait trop peu souvent

merci

en tout cas il n'a pas l'air d'avoir beaucoup de succès

je croyait que mon message avais pris mais aparement non

je le reposte :
Bon boulot crystal!!! on te voit pas souvent sur le forum, mais quand t'es la, c'est pas pour rien!

mais que veux tu que l'on dise, on en est tous resté bouche bé

PS : j'ai mis ton post en annonce

oui j'ai vu merci

Non pas grand chose, juste savoir si ca en interesse quelques uns surtout :p

Tiens à ce sujet, je te vois plus Soldat sur ma messagerie.

ah, oui, tiens c'est vrai, je te vois plus aussi

La communauté Pure à besoin de ce genre d'action, surtout les débutants pour qui pure n'est pas forcement le plus facile à aborder.

Alors déjà si on défriche les bases qui sont primordiales pour la compréhension c'est vraiment bien.

Bravo.

Merci pour vos encouragements, ca fait très plaisir

Coucou.

Ce tuto existe depuis un moment, mais il me chaffouine.

Non pas dans la démonstration qu'il fait de l'usage que l'on peut tirer des tableaux, mais du côté aléatoire utilisé pour le tirage des 3 carrés.

Une manière simple de vérifier que le nombre de tirages nécessaires pour obtenir enfin toutes les cartes dans un ordre quelconque est très variable, est d'ajouter un debug dans la boucle principale.

Code : Tout sélectionner

Dim Obj_Al(2)
For x = 0 To 2
  Debug "x=" + Str(x) 
  Repeat
    a = Random(2)
    Debug "count="+Str(count)
    count+1
  Until Obj_Etat(a) = 0
  count=0
  Obj_Al(x) = Objets(a)
  Obj_Etat(a) = 1  
Next x

Facilitez-vous la vie en commentant les 3 dernières lignes du code de départ :

Code : Tout sélectionner

;Repeat
;  ExamineKeyboard()
;Until KeyboardPushed(#PB_Key_Escape)

Ainsi vous verrez plus rapidment où je veux en venir. Vous savez que le code fonctionne et affiche 2 carrés de couleur, maintenant voyons combien de tirages sont nécessaires pour cette affichage.

-Lors du premier passage dans cette boucle, le repeat until Obj_Etat(a) = 0 trouve immédiatement une réponse positive, puisque tout le tableau a été initialisé.
-Lors du deuxième passage, l'utilisation du random donne 2 chances sur 3 de trouver une réponse positive.
-Lors du troisième passage, on sera à 1 chance sur 3 de trouver enfin la dernière carte ... Comme on boucle jusqu'à trouver cette carte, on peut se trouver dans une situation de malchance qui fera répéter beaucoup de fois le tirage.

J'ai testé 10 fois, il m'a fallu entre 5 et 12 tirages pour obtenir les 3 cartes.

Dans un paquet de 52 cartes, sans tenir compte des 51 premières cartes qui ont sûrement déjà pris beaucoup de temps à être tirées aléatoirement, il vous reste 1/52 chance de tomber sur la dernière. Faites le test en prenant une carte au hasard dans le paquet. Vous voulez l'as de pique. Tant que vous ne l'avez pas trouvé, vous remélangez tout le paquet ... Autant jouer au loto.

Mais bien sûr ce tuto est là pour expliquer les tableaux ... pas les stats ni les probas.

Le sujet PureBasic Index du Forum -> Jeux -> pour 50 entitées détaille la commande Swap pour un réel mélange de tableau.

Il y a un bout de temps que je me suis procuré PureBasic, mais je m'y met seulement maintenant à cause d'une maladie.

Merci pour ce tuto sur les tableaux.
Très pratique et efficace. Il montre aussi comment structuré le début du programme.

PureBasic

[TUTO] Les Tableaux : Jeu des 3 cartes

[TUTO] Les Tableaux : Jeu des 3 cartes

Re: [TUTO] Les Tableaux : Jeu des 3 cartes