Forum Linux.debian/ubuntu Jeu de poker pour Linux.

Posté par Linuxator (site web personnel) le 20 janvier 2015 à 08:57. Licence CC By‑SA.

Étiquettes :

jan.

2015

Salut les Linuxiens,

je viens de publier sur mon site, mon premier jeu créer avec la library SDL2 (simple directmedia layer), écrit en C, pour OS Linux de famille debian.

Il s'agit d'un jeu de Poker pour Linux:

CPocker est un jeu de poker contre l'ordinateur, pour Linux:

Vous pouvez sélectionner le nombre de tours a jouer dans l'écran d’accueil avec les flèches haut et bas, en augmentant ou diminuant le nombre de tours a jouer par défaut: 20 tours par défaut.

Le joueur, soit vous, soit l'ordinateur qui remporte le plus de tours gagne le jeu.

Un tour se fait en 6 étapes:

1) Distribution des cartes.
2) Jetez les cartes que ne désirez pas garder.
3) L’ordinateur jettes les cartes qu'il ne souhaite pas garder.
4) Distribution de nouvelles cartes remplaçant les cartes jetées.
5) Détermination du vainqueur du tour.
6) Ramassage des cartes afin de pouvoir jouer un nouveau tour.

L'ordre étant implémenté sous forme de boutons a cliquer en fonction de l'avancement du jeu.

Vous trouverez la hiérarchie des différentes combinaisons du poker dans le README accompagnant le jeu dans le dossier /usr/share/CPoker/README/ ainsi que la notice et les règles du jeu (car il existe diverses variantes du poker.) et quelques informations supplémentaires.

Dans CPocker l'algorithme de sélection des cartes a jetées de l'ordinateur et donc sa stratégie de jeu est implémenter de manière comme son créateur joue au poker.:

**C'est comme si vous jouiez au poker contre moi !!!**

J'ai implémenter ce jeu en faisant attention au respect du joueur dans le sens ou l'ordinateur ne sait jamais ce que avez en mains malgré que les cartes peuvent vous être présentées de manière découvertes avant la comparaison das mains.

Et l'ordinateur ne sait pas les cartes qui vont venir du tas pour en tirer partie afin de gagner.

J'ai également fait attention a:

Implémenter un bon algorithme de mixage des cartes avant chaque tour, qui est en faites l'exécution séquentiel de 3 algorithmes de mixages différents répéter un nombre aléatoire de fois.
- Un algorithme qui prend une carte au hasard et le remet dans le jeu a un emplacement aléatoire, répéter 32 fois (le nombre de cartes du jeu: de 7 a AS).
- Un algorithme qui génère 5 tas de cartes aléatoirement et les superposent après afin de reconstituer le jeu.
- Un algorithme qui divise le jeu en 2 tas puis reforme le jeu en ajoutant alternativement une carte de chaque tas.
Respecter l'ordre de distribution des cartes qui s'inverse a chaque tour.
Bien mettre les cartes jetées sur le tas des cartes jeter après ramassage des cartes. Puis remis dans le jeu afin de le mixer.

Soyez assuré que le jeu est honnête avec vous. Comme je suis dans la vie comme tout le monde devrai.

Le jeu est assez intuitif a prendre en mains et vous pouvez jouer a votre guise.

En espérant que vous prendrez autant de plaisir a jouer a CPoker que j'en ai eu a le programmer,

et qu'il vous procurera de grandes montés d'adrénaline.

Note: si vous avez besoin d'images d'un jeu de carte, j'ai retoucher un peu un set trouver sur internet, juste pour que les bordures soit égales. Je vous l'ai mis a disposition sous forme d'archive *.zip dans l'index de mon site.

Si vous avez un problème avec le format de fichier du programme: paquetage deb.
Il existe un tarball de CPoker disponible dans l'index de mon site.

Je vous invite donc, si le cœurs vous en dit, de voir un peu mon programme.

Si vous voulez simplement le tester: essayer de le crasher pour voir si une erreur de segmentation se produit.
Ou pour tester si un dysfonctionnement se produit.

Si vous voulez aller plus loin et jeter un coup d'œil au code source, vous pourrez me dire ce que vous en pensez, car en tant qu'autodidacte l'on est livré a soit-même et l'on ne connaît pas forcément les bonnes manières appris dans une école ou centre de formation.

Je suis ouvert a toutes formes de critiques: bonne ou mauvaise. Commentaires, impression, goût de mes graphismes, etc…

Merci pour vos réponses.

# et les mises ?

Posté par NeoX le 20 janvier 2015 à 09:00. Évalué à 4.

parce que ce qui fait le suspens du poker, c'est le fait de miser ou de se coucher
je ne vois pas cette partie là dans tes 6 etapes ?
- [^] # Re: et les mises ?
  
  Posté par Linuxator (site web personnel) le 21 janvier 2015 à 08:13. Évalué à -3.
  
  Bonjours,
  Comme c'est mon premier jeu en C j'ai pas pousser le jeu trop loin, implémenter un système de mise.
  
  C'est un jeu de chance suivant les cartes qu'ont jettes ou que l'on gardes.
  Mais les cartes sont présenté de manière retourner et il y a une animation de retournement de carte donc ont découvre les cartes de départ au fur et a mesure que l'on retourne ses cartes et ses nouvelles cartes aussi.
  
  L'on peut même laisser ses cartes retournés après redistribution et demander a l'ordinateur montré ses cartes.
  C'est juste un question de découverte des cartes, de l'ordinateur ou des siennes ce qui peut provoquer des montés d'adrénaline.
  
  Par exemple après redistribution ont a déjà une paire que l'on a garder et un AS et l'on laisse les 2 nouvelles cartes retourner et l'on demande a l'ordinateur de montrer ses cartes, sous forme d'animation, et il s'avère qui a deux paires alors l'on clique sur ses 2 cartes pour voir si l'on peut battre les 2 paires de l'ordinateur.
  
  Merci pour vos commentaires.
  - [^] # Re: et les mises ?
    
    Posté par NeoX le 21 janvier 2015 à 23:01. Évalué à 2.
    
    tu coup c'est plus un jeux de blackjack amelioré avec une gestion de 5 cartes maxi ?
# Mélange des cartes

Posté par copapa le 20 janvier 2015 à 09:50. Évalué à 2.

Ton algo de mélange de carte me parait bien complexe. Si le but est d'obtenir un mélange équiprobable, l'algorithme de Fisher-Yates-Knuth http://fr.wikipedia.org/wiki/Permutation_al%C3%A9atoire#Algorithme_de_Fisher-Yates (ta première étape semble s'en rapprocher) semble suffisant et plus sur car étudié. Bon si le but est de simuler un mélange imparfait tel qu'un humain le ferait je ne dit pas.
- [^] # Re: Mélange des cartes
  
  Posté par arnaudus le 20 janvier 2015 à 13:12. Évalué à 1.
  
  Je pense que l'algo, tel que décrit, est daubé. Les deux dernières étapes ne servent à rien, et si je comprends bien la première, elle est daubée aussi (parce qu'une proportion conséquente des cartes n'est pas mélangée). Même sans l'élégance et la rapidité des algorithmes utilisés en pratique, il aurait suffi de réassigner un nouvel ordre : on tire 32 nombres aléatoires ente 0 et 1, et on utilise l'ordre du vecteur pour réordonner le paquet (on doit être en O(n log n)).
  - [^] # Re: Mélange des cartes
    
    Posté par Linuxator (site web personnel) le 21 janvier 2015 à 07:59. Évalué à -3.
    Merci pour vos critiques,
    
    en faîte j'ai implémenter les algorithmes de mélange comme nous ont mélanges les cartes quand ont joue au cartes en famille.
    
    C.A.D il n'y a aucune base mathématique, afin d'obtenir une dispersion des cartes efficace.
    Donc oui j'ai simuler comment un humains mélange les cartes.
    
    Les 3 algorithmes sont issue de techniques de mélange que je connaît ou que j'ai inventer pour le programme.
    
    il aurait suffi de réassigner un nouvel ordre : on tire 32 nombres aléatoires ente 0 et 1, et on utilise l'ordre du vecteur pour réordonner le paquet
    
    J'ai pas bien compris si vous avez lus le code ou pas, mais le jeu de carte est basé sur une structure de donnée de type FILO (Stack) et les algorithmes de mélange utilisent aussi en complément une structure de type FIFO (Queue), issue de l'étude de ce bouquin.
    
    Je vous invite simplement a lire le code:
```
int get_rand(int modulo) {

  /** Simply random function. **/

  struct timeval tv ;
  gettimeofday(&tv,NULL) ;

    return (int) ((rand_r((unsigned int *) &tv.tv_usec) % modulo) < 0) ? 0 : (rand_r((unsigned int *) &tv.tv_usec) % modulo) ;
}
```
```
void mix_card_game_classic(Stack *card_game) {

  /** Mix the card game by taken an random card from the game and reinsert in the game at an random position. **/ 

  int c ;

  for (c=0 ; c < 32 ; c++) {


      int cc ;

      ListElt *card_to_rm  = list_head(card_game) ;
      ListElt *card_to_add = list_head(card_game) ; 

      /** Compute an random card taking position. **/
      for (cc=0 ; cc < get_rand(32) ; cc++ ) {
    card_to_rm=list_next(card_to_rm) ;
      }

      /** Taken one card from the game. **/
      Card *card_datas = malloc(sizeof(Card)) ;
      if (list_remove_next((List *) card_game,card_to_rm,(void *) &card_datas) !=  0) {
    /** This should never append. **/
    continue ;
      }

      usleep(get_rand(25)) ;  /** For random utils. **/

      /** Compute an random insert position. **/
      for (cc=0 ; cc < get_rand(32) ; cc++ ) {
    card_to_add=list_next(card_to_add) ;
      }

      /** Reinsert the card in the game. **/
      if (list_insert_next((List *) card_game,card_to_add,card_datas) != 0) {
    /** This should never append. **/
    exit(EXIT_FAILURE) ;
      }

      usleep(get_rand(25)) ; /** For random utils. **/

  }

  return ;
}


void mix_card_game_heaps(Stack *card_game) {

  /** Mix algorithm which construct 5 cards heaps randomly and push it in an different order to reconstruct the card game. **/

  Queue mix_heaps[5] ;

  uint8_t c  ;

  uint8_t sum=0 ;

  uint8_t sizes[5] ;

  for (c=0 ; c < 5 ; c++) {
    init_queue(&mix_heaps[c],NULL) ;
  }


  for (c=0 ; c < 5 ; c++) {

    int cc, limit ;

    if (c != 4) {
      limit=get_rand(8) ;
    }
    else {
      limit= (32-sum < 0) ? 0 : 32-sum ;
    }

    if (limit == 0 && c != 4) {
      limit=2 ;
    }

    sizes[c]=limit ;

    sum += limit ;



    for (cc=0 ; cc < limit ; cc++) {

      Card *card = malloc(sizeof(Card)) ;

      /** Take a card from the card game. **/
      if (stack_pop(card_game,(void *) &card) != 0) {
    /** This should not append. **/
    continue ;
      }

      /** Push the taken card on the current stack. **/
      enqueue(&mix_heaps[c],card) ;

    }
    usleep(get_rand(55)) ;
  }



  for (c=0 ; c < sizes[4] ; c++) {
    /** Flush the heap 5 and put it content inn the card game. **/

    Card *card ;

    /** Take a card from the heap. **/
    dequeue(&mix_heaps[4],(void *) &card) ;


    /** Set card in the game. **/
    stack_push(card_game,card) ;

  }

  for (c=0 ; c < sizes[2] ; c++) {
    /** Flush the heap 3 and put it content inn the card game. **/

    Card *card ;

    /** Take a card from the heap. **/
    dequeue(&mix_heaps[2],(void *) &card) ;


    /** Set the card in the game. **/
    stack_push(card_game,card) ;

  }

  for (c=0 ; c < sizes[0] ; c++) {
    /** Flush the heap 1 and put it content inn the card game. **/

    Card *card ;

    /** Take a card from the heap. **/
    dequeue(&mix_heaps[0],(void *) &card) ;


    /** Set card in the game. **/
    stack_push(card_game,card) ;

  }

  for (c=0 ; c < sizes[3] ; c++) {
    /** Flush the heap 4 and put it content inn the card game. **/

    Card *card ;

    /** Take a card from the heap. **/
    dequeue(&mix_heaps[3],(void *) &card) ;


    /** Set the card in the game. **/
    stack_push(card_game,card) ;

  }

  for (c=0 ; c < sizes[1] ; c++) {
    /** Flush the heap 2 and put it content inn the card game. **/
    Card *card ;

    /** Take a card from the heap. **/
    dequeue(&mix_heaps[1],(void *) &card) ;


    /** Set the card in the game. **/
    stack_push(card_game,card) ;

  }

  return ;
}
 void mix_card_game_alternate(Stack *card_game) {

  /** Mix algorithm wich construct 2 heaps from the card game
    *  and alterantively take an card from an heap, and put it in the card game.
    ****************************************************************************/ 

  Queue *half_game_1 = malloc(sizeof(Queue)) ;
  Queue *half_game_2 = malloc(sizeof(Queue)) ;

  init_queue(half_game_1,NULL) ;
  init_queue(half_game_2,NULL) ;

  uint8_t c ;

  for (c=0 ; c < 32 ; c++) {
    /** Loop to construct the two heaps. **/
    Card *card ;

    /** Take an card from the card game. **/
    stack_pop(card_game,(void *) &card) ;

    if (c % 2 == 0) {
      /** push the card on the first heap. **/
      enqueue(half_game_1,card) ;
    }
    else {
      /** push the card on the second heap. **/
      enqueue(half_game_2,card) ;
    }
  }


  for (c=0 ; c < 32 ; c++) {
    Card *card ;

    if (c % 2 == 0) {
      /** Take a card from the heap one. **/
      dequeue(half_game_2,(void *) &card) ;
    }
    else {
      /** Take a card from the heap two. **/
      dequeue(half_game_1,(void *) &card) ;
    }

    /** Push the card on the card game. **/
    stack_push(card_game,card) ;
  }

  free(half_game_1) ;
  free(half_game_2) ;

  return ;
}
```
    Après je suis assez fiers de mes algorithmes, malgré vos critiques sévères.
    
    En fin de compte les cartes sont mélangés car en début le jeu de cartes est générer de manière ordonner et puis après le mélange elle sont mélangées (les cartes ne se suivent plus du tout.).
    
    Concernant la rapidité et l'optimisation, j'ai bien fait attention pour que les animations s'exécute de manière optimisée, mais a part les animations le jeu n'a pas besoin d'être optimiser en matière de rapidité d'exécution comme cela doit l'être pour la plupart des jeux.
    
    Merci pour vos critiques.
    - [^] # Re: Mélange des cartes
      
      Posté par Marotte ⛧ le 21 janvier 2015 à 09:16. Évalué à 4. Dernière modification le 21 janvier 2015 à 09:17.
      
      Après je suis assez fiers de mes algorithmes, malgré vos critiques sévères.
      
      Tu peux être fier de tes algorithmes mais ils ne servent absolument à rien…
      
      en début le jeu de cartes est générer de manière ordonner et puis après le mélange elle sont mélangées (les cartes ne se suivent plus du tout.).
      
      Pourquoi ne pas simplement « générer » de manière aléatoire ?
      
      PS : Fait attention à l'orthographe de tes participes passés…
    - [^] # Re: Mélange des cartes
      
      Posté par chimrod (site web personnel) le 21 janvier 2015 à 09:44. Évalué à 6.
      
      Bon, on va essayer de sortir un peu du débat…
      
      Je pense que pour un jeu de poker qui ne cherche pas à gérer de l'argent, on s'en fout un peu de l'algorithme de mélange. Il n'y a pas besoin d'être vraiment aléatoire, vu qu'il n'y a pas de sécurité là dessus. C'est un jeu, le but c'est de prendre du plaisir.
      
      Mais comme tu es parti dans les explications techniques dans ton annonce, les commentaires sont partis sur la technique et une fois que c'est lancé, difficile de les arrêter… (et vu que ton site est toujours inaccessible, on ne risque pas de voir le code pour l'instant, et les réponses se font sur ce dont on dispose, ça n'aide pas).
      
      Au final, c'est courageux de ta part de t'être lancé dans le projet, et courageux de ta part d'être venu l'annoncer ici. Ne te focalise pas trop sur les réponses techniques négative, l'important c'est de prendre du plaisir dans ce que tu fais !
      
      Faire un jeu de poker est compliqué, ça demande des notions en intelligence artificielle, statistiques, algorithmie, combinatoire et d'après ce que tu sembles dire, le jeu est loin d'être terminé, mais l'initiative et louable et n'abandonne pas pour si peu !
      - [^] # Re: Mélange des cartes
        
        Posté par arnaudus le 21 janvier 2015 à 10:38. Évalué à 3.
        
        Je pense que pour un jeu de poker qui ne cherche pas à gérer de l'argent, on s'en fout un peu de l'algorithme de mélange
        
        Il est évident que dans ce contexte précis, en effet, on s'en fout pas mal. Mais c'est du code libre ; il peut être réutilisé par les distributions, éventuellement inclus dans des CD de jeux libres, et réutilisé dans des contextes différents, y compris peut-être des cas où il y a un enjeu un peu plus important. Évidemment, on peut toujours dire qu'il faut relire le code en fonction de l'enjeu, mais c'est un argument foireux : on ne relit pas le code de libreoffice même quand on calcule ses impôts dans le tableur, parce qu'on fait quand même confiance au gars qui l'a programmé.
        
        D'une manière générale, bricoler un algo à la va-vite, on l'a tous fait. La réinvention de la roue est un processus très important dans l'apprentissage de la programmation, et je ne pense pas qu'on puisse devenir un bon programmeur sans avoir réécrit dans l'ignorance la plus totale des algos naïfs de tri, d'échantillonnage, etc. Mais ça, c'est l'étape n°1. On ne va pas rester toute sa vie avec son algo de tri en O(n^2). La partie intéressante commence quand on étudie les "vrais" algorithmes, quand on comprend leur logique, et quand on les réimplémente. On s'aperçoit de ses progrès quand on relit son vieux code et qu'on voit à quel point on était mauvais et naïf 10 ans avant. Et ça ne s'arrête jamais, on doit chercher à progresser toute sa vie.
        
        Du coup, je pense qu'il n'y a aucune honte à avoir sur du code pourri. Évidemment, on peut se moquer gentiment des gens qui réintentent tout tous seuls, surtout quand il existe du pseudo-code partout : c'est une forme de naïveté de ne pas imaginer que d'autres avant ont pu rencontrer le même problème et consacrer du temps à le résoudre. Par contre, je pense que c'est une erreur de ne pas vouloir apprendre, et d'avoir une position arrogante face aux critiques. Ici, non seulement l'implémentation est pourrie, mais en plus elle est est bugguée (les cartes ne sont pas mélangées correctement). Quand on pond 200 lignes de code pour faire quelque chose qui devrait tenir en 3 lignes, et qu'en plus ça fait n'importe quoi, on a quand même de la marge de progression.
        
        Sans blague, je ne pense pas que Linuxator sache ce que "for (cc=0 ; cc < get_rand(32) ; cc++ )" fait. Si c'est volontaire, il manque un commentaire sur la loi sous-jacente (binomiale négative?). En tout cas, il existe une différence entre "mélanger les cartes" et "faire n'importe quoi avec le paquet", même si le résultat final pourrait ne pas être totalement différent…
        
        [^] # Re: Mélange des cartes
        
        Posté par Linuxator (site web personnel) le 23 janvier 2015 à 02:28. Évalué à -4.
        
        (et vu que ton site est toujours inaccessible, on ne risque pas de voir le code pour l'instant, et les réponses se font sur ce dont on dispose, ça n'aide pas).
        
        Je ne comprends j'ai toujours accès a mon site en tant que client de n'importe poste ou je me trouve et ca m'étonnerai que mes IPS s'activent quand ont clique sur un lien menant a la fiche descriptive de mon programme et si vous y êtes il y a un gros bouton télécharger. Ou vers mon index.
        Si vous avez une réponse 403 c'est que vous avez violer une règle de sécurité que j'ai écrit au niveau de la configuration du serveur.
        
        […] On s'aperçoit de ses progrès quand on relit son vieux code et qu'on voit à quel point on était mauvais et naïf 10 ans avant. Et ça ne s'arrête jamais, on doit chercher à progresser toute sa vie.
        
        Ça ne fait que 2 ans pile (début au mois de janvier 2013) que je pratique le C et j'ai débuter la programmation avec python sous Ubuntu 10.04. Donc je n'ai pas autant d'expérience que vous.
        
        Coté algorithmes et structures de données je suis pas bien fort je suis en train de lire Maîtrise des algorithmes en C et au début je faisait mes propres implémentations des structures de données que j'ai corriger avec le code du bouquin (Dont il faut dire que la théorie est excellemment expliquée, par contre les codes sources sont écrit de manière très complexe et pas du tout explicite.).
        Arriver au chapitre compression de données je n'arrive plus a suivre.
        
        Je regrette de ne pas avoir attendus plus longtemps avant de lire ce livre la, vue la complexité, car ce n'est pas la première fois que je ces algorithmes et ces structures de données.
        
        Sans blague, je ne pense pas que Linuxator sache ce que "for (cc=0 ; cc < get_rand(32) ; cc++ )" fait.
        
        Si et ce n'est pas fait exprès: a chaque itération c est incrémenter de 1 et get_rand(32) est appelée et donc l'arrêt dépend de la valeur de c et de la valeur renvoyer.
        Il aurai fallut assigner le retour de get_rand(32) a une variable et la mettre comme valeur de sortie de la boucle.
        
        [^] # Re: Mélange des cartes
        
        Posté par Linuxator (site web personnel) le 23 janvier 2015 à 02:42. Évalué à -4.
        
        En tout cas, il existe une différence entre "mélanger les cartes" et "faire n'importe quoi avec le paquet", même si le résultat final pourrait ne pas être totalement différent…
        
        Je voulais implémenter des algorithmes de mélange de cartes simulant les techniques de mélange que je connaît (donc comme un humain mélange les cartes) et ne sont basé sur aucun dogme mathématique sur la répartition finale des cartes.
        Ce n'est pas n'importe quoi pour autant mais ils font exactement ce que j'ai dit dans la description des algorithmes au premier poste.
        Après il faut dire que se sont mes techniques de mélange et c'est tout.
        
        [^] # Re: Mélange des cartes
        
        Posté par arnaudus le 23 janvier 2015 à 09:42. Évalué à 3.
        
        Bon, on ne va pas épiloguer pendant des siècles ; tes arguments ne peuvent pas convaincre d'autres que toi. 1) la description des algorithmes ne correspond pas à un mélange aléatoire des cartes (en fait, tu fais des substitutions déterministes en enchaînant plusieurs algorithmes dans l'espoir que l'ensemble n'est pas trop cyclique. Comme on a essayé de te l'expliquer, il y a beaucoup plus simple et beaucoup plus efficace), 2) l'implémentation des algorithmes est bugguée (ils ne font pas ce que tu crois qu'ils font, ce qui justifie ma remarque sur la différence entre "mélanger" et "faire n'importe quoi"), et 3) l'implémentation est terriblement complexe et inefficace, et tu ne peux pas progresser si tu ne te remets pas en question. Par exemple, pour ta dernière fonction, il y a moyen de faire le mélange "en place" (sans rien "malloc-er") avec une seule boucle for: les cartes 0 et 31 restent en place, les autres peuvent être substitutées dans un ordre précis avec juste un pointeur pour stocker une valeur temporaire.
        
        [^] # Re: Mélange des cartes
        
        Posté par Linuxator (site web personnel) le 25 janvier 2015 à 14:17. Évalué à -5.
        
        tu ne peux pas progresser si tu ne te remets pas en question.
        
        Je prend note mais personnellement je n'ai pas envie de copier un algorithmes qui existe déjà inventé par un grand mathématicien, et je ne veut pas réinventer la roue.
        Surtout que je ne suis pas fort en math.
        J'ai un niveau seconde générale, je lis beaucoup, mais ça a ses limites, surtout quand ont a pas assez de bases pour apprendre des notions que je n'ai même pas eu le temps de voir a l'école, surtout que l'école est loin maintenant, mais ma soif de savoir ne s'est pas arrêter a la fin de ma scolarité bien au contraire.
        
        J'apprends beaucoup de choses en lisant et essayer d'implémenter les notions apprise est mon sport favoris en C.
        
        Sinon j'aurai pu faire le jeu avec python (dont j'ai 4 et demie d'expérience) mais je voulais une difficulté supplémentaire alors imaginer mon n'importe quoi en python, car en faisant n'importe quoi en python l'on arrive assez facilement a ses fins.
        
        Je comprend ou vous voulez en venir il est vrai que itérer 2 fois sur 32 cartes pour échanger la position d'une seule carte n'est pas très efficace mais ce que vous ne pouviez pas savoir est que les structures de type Stack et Queue sont basé sur des liste chaînées, issue du bouquin mentionner, a moi l'erreur d'itérer sur une liste chaînée au lieu de d'échanger plusieurs pointeurs a la fois, sur 32 cartes.
        
        Finalement j'ai pris du plaisir a programmer ce jeu et dans un jeu de cartes la rapidité d'exécution n'est pas requise contrairement a la plupart des jeux.
        
        l'implémentation des algorithmes est bugguée (ils ne font pas ce que tu crois qu'ils font, ce qui justifie ma remarque sur la différence entre "mélanger" et "faire n'importe quoi")
        
        Alors la je ne comprends pas du tout…
        Mais algorithmes sont peut être inefficace mais ce sont les miens.
        
        Alors si je ne sais pas dire a l'ordinateur ce que je veux qu'il fasse c'est que je ne sais pas programmer (surtout qu'en C ça se discute: qui sait programmer).
        Mais apparemment l'ordinateur comprends le n'importe quoi que je veux lui faire faire.
        
        Pour finir j'ai corriger quelques bugs du jeu et mis une nouvelle version sur le serveur, le jeu de carte fonctionne maintenant sans bug connus et j'ai même fait une version Windows.
# Erreur 403

Posté par chimrod (site web personnel) le 20 janvier 2015 à 10:01. Évalué à 3.

Ton serveur IIS ne semble pas aimer python :

You don't have permission to access /Home.py on this server.
# Accès au site impossible

Posté par Marotte ⛧ le 20 janvier 2015 à 10:21. Évalué à 2.

À part la page d'accueil je ne peux pas accéder à ton site : Accès interdit.
# mélange

Posté par hervé Couvelard le 20 janvier 2015 à 13:40. Évalué à 1.

au poker tu es sur que l'on mélange les cartes ? une fois au début, puis ensuite les coupes, mais j'avais l'impression que l'on ne mélangeait pas en cours de parti.
- [^] # Re: mélange
  
  Posté par Pouetpouet le 20 janvier 2015 à 18:18. Évalué à 3.
  
  Tu confondrais pas avec une règle officieuse du tarot amateur ?
  - [^] # Re: mélange
    
    Posté par Linuxator (site web personnel) le 21 janvier 2015 à 08:01. Évalué à -3.
    
    Bonjours,
    en faîtes ce sont les règles du poker comme j'ai appris a jouer et la hiérarchie des combinaisons des cartes sont issue du wiki le relatant.
- [^] # Re: mélange
  
  Posté par Marotte ⛧ le 21 janvier 2015 à 09:13. Évalué à 2.
  
  Oui elles sont mélangées à chaque donne.
  - [^] # Re: mélange
    
    Posté par Lutin le 21 janvier 2015 à 11:09. Évalué à 2.
    
    Ça évite les compteurs de cartes.
  - [^] # Re: mélange
    
    Posté par hervé Couvelard le 21 janvier 2015 à 21:34. Évalué à 1.
    
    alors on joue mal à la maison, j'ai appris un truc… mais comme c'est juste histoire de passer le temps en grignotant…
# jeu de poker

Posté par YRAM le 15 février 2015 à 07:17. Évalué à 2.

Bonjour

J'ai également fait un jeu de poker mais (Texas hold'em) comme ça pour me marrer. En fait le mélange des cartes est ce que j'ai trouvé de plus facile à faire.
Comment j'ai procédé ? c'est tout simple.
Dans un tableau numérique à 2 dimensions je mets les 52 cartes puis j'affecte à chaque carte une valeur unique aléatoire.
Je tri ensuite le tableau par valeurs aléatoires et j'obtiens un jeu de cartes parfaitement mélangé et différent à chaque fois. Avec cette façon de faire je suis à des années lumières des mêmes flops turns rivers qui reviennent sans cesse dans les jeux de poker sur internet.

La plus grosse difficulté pour moi est de gérer le gagnant au kicker,rien d'autre.

a+

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.