Gauche centre droit (LCR) golf

10

Lors d'une soirée, j'ai découvert le jeu LCR. Maintenant, ce n'est pas un grand jeu car il n'y a aucune compétence mais seulement une chance aléatoire. Mais ça m'a fait réfléchir, je pouvais coder cela, et j'ai fait un programme rapide en R pour modéliser le jeu.

Règles du jeu modifiées à partir de Wikipedia pour correspondre à la façon dont nous avons joué:

Chaque joueur reçoit au moins 3 jetons. Les joueurs à leur tour lancent trois dés à six faces, chacun étant marqué d'un "L", "C", "R" d'un côté et d'un seul point des trois côtés restants. Pour chaque "L" ou "R" lancé, le joueur doit passer une puce au joueur à sa gauche ou à sa droite, respectivement. Un "C" indique une puce au centre (pot). Un point n'a aucun effet.

S'il reste moins de trois jetons à un joueur, il est toujours dans le jeu mais son nombre de jetons est le nombre de dés qu'il lance à son tour, plutôt que de lancer les trois. Lorsqu'un joueur n'a aucun jeton, il passe les dés à son tour, mais peut recevoir des jetons des autres et prendre son prochain tour en conséquence. Le gagnant est le dernier joueur à avoir placé des jetons au centre.

Concours: écrivez un programme dans la langue de votre choix qui prend en compte le nombre de joueurs et le nombre de jetons de départ et simule un jeu de LCR, montrant l'état du jeu après que chaque joueur a lancé.

Par exemple, un jeu peut être sorti en tant que:

[[[3,3,3,3],0],[[1,4,3,4],0],[[1,4,3,4],0],[[1,4,1,4],2],[[1,4,1,2],4],
[[0,4,1,3],4],[[0,3,2,3],4],[[0,3,0,3],6],[[0,3,1,1],7],[[0,3,1,1],7],
[[2,0,1,1],8],[[2,0,0,1],9],[[2,0,0,0],10],[[0,1,0,0],11],
[[1,0,0,0],11],[[1,0,0,0],11],[[1,0,0,0],11],[[0,0,0,0],12]]

ht: JonathanAllan

La sortie ne doit pas ressembler exactement à ceci, mais il devrait être facile de discerner le lancer de dés, le nombre de jetons que chaque joueur a et le nombre de jetons que le centre a pour chaque tour.

C'est le golf de code, donc le code le plus court gagne.

CT Hall
la source
3
"il devrait être facile de discerner le lancer de dés" - c'est implicite (donc facile à discerner) des états des jetons, tout comme le joueur qui a lancé, car c'est au tour par tour. Je dirais que cet exemple de sortie a tout ce qu'il faut: [[[3,3,3,3],0],[[1,4,3,4],0],[[1,4,3,4],0],[[1,4,1,4],2],[[1,4,1,2],4],[[0,4,1,3],4],[[0,3,2,3],4],[[0,3,0,3],6],[[0,3,1,1],7],[[0,3,1,1],7],[[2,0,1,1],8],[[2,0,0,1],9],[[2,0,0,0],10],[[0,1,0,0],11],[[1,0,0,0],11],[[1,0,0,0],11],[[1,0,0,0],11],[[0,0,0,0],12]]- est-ce le cas?
Jonathan Allan
1
@JonathanAllan, cela fonctionne pour moi.
CT Hall
1
@KevinCruijssen, bonne question, je suppose que je permettrai de toute façon.
CT Hall
1
@CTHall Dans ce cas, j'ai édité mes deux réponses (Java et 05AB1E) et inclus à la fois avec et sans. :)
Kevin Cruijssen
1
Je veux presque le faire sur Runic où chaque pointeur d'instruction agit comme un joueur donné. Je ne sais pas si je peux (même en ignorant le nombre de joueurs saisis), mais ce serait bien si je le pouvais.
Draco18s ne fait plus confiance au SE le

Réponses:

4

Emacs Lisp , 279 octets

(defmacro n(i)`(incf(nth ,i c)))
(defun f(p s)(g(let((a'(0)))(dotimes(i p)(push s a))(princ a))0 p))
(defun g(c v p)(dotimes(i(min(nth v c)3))(decf(nth v c))(case(random 6)(0(n(mod(1- v)p)))(1(n(mod(1+ v)p)))(2(n p))(t(n v))))(princ c)(or(eq(-sum c)(nth p c))(g c(mod(1+ v)p)p)))

Utilisez cette fonction comme (f 4 3).

Meilleure version lisible:

(defmacro n (i) `(incf (nth ,i c)))

(defun f(p s)
  (g
   (let ((a '(0)))
     (dotimes (i p)
       (push s a))
     (princ a))
   0
   p))

(defun g (c v p)
  (dotimes (i (min (nth v c) 3))
    (decf (nth v c))
    (case (random 6)
      (0 (n (mod (1- v) p)))
      (1 (n (mod (1+ v) p)))
      (2 (n p))
      (t (n v))))
    (princ c)
    (or (eq (-sum c) (nth p c))
    (g c (mod (1+ v) p) p)))

Exemple de sortie:

(3 3 3 3 0)(1 4 3 4 0)(2 2 4 4 0)(2 2 2 5 1)(4 2 2 3 1)(2 2 2 4 2)(2 1 3 4 2)(2 2 0 4 4)(2 2 0 4 4)(1 2 0 4 5)(2 1 0 4 5)(2 1 0 4 5)(2 1 1 3 5)(0 1 1 3 7)(1 0 1 3 7)(1 0 1 3 7)(1 0 3 1 7)(1 0 3 1 7)(1 0 3 1 7)(1 1 2 1 7)(1 1 3 0 7)(0 1 3 0 8)(1 0 3 0 8)(1 1 1 1 8)(1 1 2 0 8)(0 1 2 1 8)(0 1 2 1 8)(0 1 1 1 9)(0 1 1 1 9)(0 1 1 1 9)(0 1 1 1 9)(0 1 1 1 9)(0 1 1 0 10)(0 1 1 0 10)(0 0 1 0 11)(0 0 1 0 11)(0 0 1 0 11)(0 0 1 0 11)(0 0 1 0 11)(0 0 0 0 12)
adl
la source
3

Java 8, 281 277 275 274 253 octets

Version qui affiche le même état lorsqu'un joueur au tour n'a plus de jetons:

p->n->{java.util.Arrays A=null;int c[]=new int[p],i=0,t,r,s=1,u,f=9;for(A.fill(c,n);s>0;f=0,System.out.print(A.toString(c)))for(t=c[++i%p],t=t>3?3:t;t-->f;r*=Math.random(),c[i%p]-=1-r/3,s=c[u=(i+r-1+p)%p]+=1-r&1-r/4,c[u]=s<0?0:s,s=A.stream(c).sum())r=6;}

Commence avec le troisième joueur du tableau.

Essayez-le en ligne.

Version qui saute les joueurs avec 0 jeton restant (274 octets):

p->n->{java.util.Arrays A=null;int c[]=new int[p],i=p,t,r,s=1,u,f=9;for(A.fill(c,n);s>0;f=0,System.out.print(A.toString(c))){for(t=c[i%p],t=t>3?3:t;t-->f;r*=Math.random(),c[i%p]-=1-r/3,s=c[u=(i+r-1+p)%p]+=1-r&1-r/4,c[u]=s<0?0:s)r=6;for(s=A.stream(c).sum();s>0&c[++i%p]<1;);}}

Commence par le premier joueur du tableau.

Essayez-le en ligne.

-7 octets grâce à @ OlivierGrégoire .

Explication (de la deuxième version):

p->n->{                      // Method with two integer parameters and no return-type
  java.util.Arrays A=null;   //  Create a static Arrays-object to save bytes
  int c[]=new int[p],        //  Integer-array with chips of each player (0 by default)
      i=p,                   //  Index integer, starting at the amount of players
      t,                     //  Temp integer to roll 3 dice
      r,                     //  Temp integer for the dice-result
      s=1,u,                 //  Temp integers (and `s` is also the total-sum integer)
      f=9;                   //  Flag integer, starting at a single digit above 3
  for(A.fill(c,n);           //  Give each player in the array the chips
      s>0                    //  Loop as long as the total-sum is not 0 yet
      ;                      //    After every iteration:
       f=0,                  //     Set the flag to 0
       System.out.print(A.toString(c))){
                             //     Print the current state
    for(t=c[i%p],            //   Set `t` to the current player's chips
        t=t>3?3:t;           //   If this is larger than 3: set it to 3 instead
        t-->f                //   Loop that many times (1, 2, or 3)
                             //   (the flag is used to skip this loop the first iteration,
                             //   so we can print the initial state)
        ;                    //     After every iteration:
         r*=Math.random(),   //      Roll the dice in the range [0,5]
         c[i%p]-=r<3?        //      If the dice-roll is 0, 1 or 2:
                  1          //       Remove a chip from this player
                 :0,         //      Else: Leave the chip-amount the same
         s=c[u=(i+r-1+p)%p]  //      If the dice-roll is 0, go to the player left
                             //      If the dice-roll is 2, go to the player right
             +=1-r&1-r/4,    //       And add a chip to this player
         c[u]=s<0?0:s)       //      Change negative amount of chips to 0
      r=6;                   //    Reset the dice-roll to 6 so we can roll again
    for(s=A.stream(c).sum(); //   Calculate the total sum of the chips of the players
        s>0&                 //   If this sum is larger than 0:
         c[++i%p]<1;);}}     //    Determine the next player in line with at least 1 chip
Kevin Cruijssen
la source
1
Pourrait laisser mon vote positif sans (minuscule) golf: D s=0;for(int C:c)s+=C;(21 octets) peut être remplacé par s=A.stream(c).sum();(20 octets)
Olivier Grégoire
Aussi, je ne sais pas si tout à fait correct: c[i%p]-=r<3?1:0c[i%p]-=1-r/3. Cela permettrait d'économiser 2 octets.
Olivier Grégoire
1
@ OlivierGrégoire Ah, une façon intelligente de réutiliser le Afrom java.util.Arrays. : D Et en le mettant dans la boucle pour économiser sur le point-virgule, c'est -2 octets. Et 1-r/3c'est en effet correct ( voir ici ). Merci.
Kevin Cruijssen
Belle astuce avec la comparaison de boucle décrémentant. Je pourrais voler ça.
Stackstuck
1
Ignorez mon commentaire supprimé précédent: ma table de vérité était éteinte. C'est le fixe: s=c[u=(i+r-1+p)%p]+=1-r&1-r/4(économise 2 octets, par rapport à s=c[u=(i+r%2*2-1+p)%p]+=r<2?1:0)
Olivier Grégoire
2

Python 2 , 159 148 octets

from random import*
n,c=input()
g=[c]*n;i=0
while sum(g):exec"r=randrange(6);g[i]-=1;g[i-[0,1,~-n][max(0,r-3)]]+=r>0;"*min(3,g[i]);i=(i+1)%n;print g

Essayez-le en ligne!

Imprime tous les jetons des joueurs après chaque lancer

TFeld
la source
Bonne tentative, mais le code n'affiche pas la quantité de jetons au centre.
CT Hall le
3
@CTHall Les jetons au centre sont toujours égaux à n*c - sum(players). Si je dois l'écrire explicitement, je le ferai
TFeld
c'est vrai. Je vais le permettre.
CT Hall
2

Gelée , 39 octets

+2 pour corriger le comportement de répétition ( ¡doit être précédé d'un nilad donc «3Ḣ$-> ⁸FḢ«3)

Si nous pouvons définir les listes de sortie à faire tourner pour avoir les jetons appartenant au joueur qui a agi précédemment à gauche, nous pouvons supprimer le plus à droite 6 octets pour 33 octets (cependant, à mon avis, il est quelque peu gênant de lire cela).

ẋµ’1¦‘.,2ŻX¤¦$¹Ø.X¤?⁸FḢ«3¤¡ṙ1µSпṙ"JC$$

Un lien dyadique acceptant les jetons par joueur à gauche et le nombre de joueurs à droite qui donne une liste de jetons comptant les joueurs au début de la partie et après chaque tour (y compris les tours où 0 jeton force une passe) .

Essayez-le en ligne!

Comment?

Chaque joueur à son tour, jusqu'à trois fois, en fonction de son nombre de jetons, lance une pièce. Lorsqu'un joueur retourne la tête , ils ne font que si elles queues à feuilles mobiles , ils roulent alors un dé à trois côtés perdre une puce à L, C ou R. (Notez que 0 flips lorsqu'un joueur a 0 jetons est équivalent à passer.)
Cette opération est répétée jusqu'à ce que la somme des jetons des joueurs soit de 0.
L'implémentation fait tourner les joueurs à gauche d'une place à chaque tour, puis fait pivoter les états résultants pour qu'ils soient tous alignés comme s'ils ne l'étaient pas.

ẋµ’1¦‘.,2ŻX¤¦$¹Ø.X¤?⁸«3Ḣ¤¡ṙ1µSпṙ"JC$$ - Link: chipsPerPlayer, C; numberOfPlayers, P
ẋ                                      - repeat C P times (making a list of P Cs)
                              п       - collect up results in a list while...
                             S         - ...п condition: sum (while players have chips)
 µ                          µ          - ...п do: the monadic chain:
                         ¡             -   repeat...
                        ¤              -   ...¡ number of times: nilad and link(s) as a nilad:
                    ⁸                  -     chain's left argument (the chip list)
                     «3                -     minimum with three (vectorises)
                       Ḣ               -     head -- i.e. min(left-most player's chips, 3)
                   ?                   -   ...¡ action: if...
                  ¤                    -     ...? clause: nilad and link(s) as a nilad:
               Ø.                      -       the list [0,1]
                 X                     -       random choice (0 is falsey while 1 is truthy)
             $                         -     ...? then: last two links as a monad:
    ¦                                  -       sparsely apply...
   1                                   -       ...¦ to indices: one (the left-most)
  ’                                    -       ...¦ action: decrement (player lost a chip)
            ¦                          -       sparsely apply...
           ¤                           -       ...¦ to indices: nilad and link(s) as a nilad:
      .,2                              -         literal pair of literals .5 and two = [.5,2]
         Ż                             -         prepend a zero = [0,0.5,2]
          X                            -         random choice
                                       -         -- Note application to index .5 is a no-op
                                       -                 index 0 is the right-most entry (L) 
                                       -                 index 2 is the second entry (R) 
                          ṙ1           -   rotate the list left by one for the next п loop
                                     $ - last two links as a monad:
                                    $  -   last two links as a monad:
                                  J    -     range of length -- i.e. [1,2,3,...,turns+1]
                                   C   -     complement = 1-x        [0,-1,-2,...,-turns]
                                 "     -   zipped-appliction of:
                                ṙ      -     rotate left by
                                       -   -- i.e. rotate 1st left by 0, 2nd left by -1, ...)
Jonathan Allan
la source
Je suis un peu impressionné par la façon dont les gens codent dans ces langages qui ressemblent à du bruit de ligne. :) Mais alors je ne connais que quelques langues, donc peut-être qu'avec plus d'expérience ça viendra.
CT Hall
2
Vous pouvez consulter le tutoriel sur le wiki, c'est plutôt bien. Une fois que j'aurai posté la décomposition du code, vous pourrez, espérons-le, suivre ce que j'ai fait ...
Jonathan Allan
... c'est un comportement subtilement incorrect, cependant? Par spécification, vous devez lancer les trois dés, pas seulement un lancer de pièce. Sauf si la description est erronée et que le code est correct.
Stackstuck
@Stackstuck - l'aperçu de la description est légèrement trompeur, la pièce est retournée à chaque fois; Je vais le réparer - merci. FWIW la description de répartition de code est juste - le coin flip Ramification Ø.X¤?, est imbriqué dans la répétition-up à 3 fois l' instruction, ⁸«3Ḣ¤¡.
Jonathan Allan
Ah ok. Heureux d'avoir pu aider.
Stackstuck
1

C #, 356? +13? Octets

Requiert using System;un total de +13 octets pour le code ci-dessous, si je suis tenu de le compter. Sinon, plonk juste dans n'importe quelle classe et appelez L(players, starting chips);.

static int i,j,k,l;public static void L(int p,int s){var r=new Random();var x=new int[p];for(i=0;i<p;i++)x[i]=s;
for(i=0;i<s*p;){for(j=0;j<p;j++){for(l=0;l<x[j]&l<3;l++){k=r.Next(-1,5);if(k<2){if(k==0){x[j]--;i++;}else{x[(p+j+k)%p]++;x[j]--;}}}Console.Write(a(x)+i);}}}public static string a(int[] x){var n="|";for(l=0;l<x.Length;)n+=x[l++]+" ";
return n;}

Exemple de sortie pour un jeu 2,2:

|1 3 0|2 2 0|1 3 0|1 3 0|0 4 0|0 3 1|0 3 1|2 1 1|1 2 1|1 2 1|0 3 1|0 3 1|0 3 1|1 1 2|1 1 2|1 1 2|0 2 2|1 1 2|0 1 3|1 0 3|0 1 3|0 1 3|0 1 3|1 0 3|1 0 3|1 0 3|0 1 3|1 0 3|0 1 3|0 0 4

Version moins golfée:

using System;
//class omitted.
static int i,j,k,l;
public static void LCR(int pl, int sc){
var r=new Random();
var state = new int[pl];
for(i=0;i<pl;i++)state[i]=sc;
for(i=0;i<sc*pl;){
    for(j=0;j<pl;j++){
        for(l=0;l<state[j] && l<3;l++){
            k=r.Next(-1,5);
            if(k<2){
                if(k==0){state[j]--;i++;}else{state[(pl+j+k)%pl]++;state[j]--;}
            }
        }
        Console.Write(a(state)+i);
    }
}
}
public static string a(int[] x){
    var n="|";
    for(l=0;l<x.Length;)n+=x[l++]+" ";
    return n;
}
Stackstuck
la source
Eh bien, c'est ma première réponse ici. S'il te plaît, ne me mange pas.
Stackstuck
Ah, drat. J'ai confondu mon comportement d'impression de tableau avec Java. Je serai juste ... de retour avec une révision.
Stackstuck
D'accord, c'est fixe, la sortie devrait définitivement fonctionner.
Stackstuck
... oh, non, il y a encore une erreur.
Stackstuck
Les gens qui disent modulo alors que le comportement est réellement inchangé ne devraient pas faire ça. Là, je suis sûr à 90% que cela fonctionne maintenant.
Stackstuck
1

C # (Visual C # Interactive Compiler) , 201 199 octets

n=>m=>{var r=new Random();var j=Enumerable.Repeat(n,m).ToList();for(int i=0;j.Any(c=>c>0);i++,Print(j))for(int k=0,x=r.Next(6);k++<Math.Min(j[i%m],3);j[((x<1?-1:1)+i+m)%m]+=x<2?1:0,j[i%m]-=x<3?1:0);}

Essayez-le en ligne!

startingChips=>playerNum=>{
//Instantiate a new random number generator
var rng = new Random();
//Create a list of chips
var players = Enumerable.Repeat(startingChips, playerNum ).ToList();
//Loop as long any player still has chips
for(int turnNum = 0;players.Any(c=>c>0);
//And print the result every iteration
i++,Print(j))
//Get a random number within the range of 0-5 and loop for...
for(int k = 0,randomNum = rng.Next(6);
//either 3 or the amount of chips we have, whichever is smaller
k++<Math.Min(players[turnNum % playerNum ],3);
//Increment either the right player if the random number is 1, else increment the right player if it is 0
players[((randomNum<1?-1:1)+ turnNum + playerNum ) % playerNum ]+=x<2?1:0,
//Decrement current player if the die roll is under 3
players[ turnNum % playerNum ]-=x<3?1:0);}
Incarnation de l'ignorance
la source
1

Fusain , 61 octets

≔⁰ηWΣθ«≔Eθ⭆⌊⟦κ׳⁼λη⟧‽⁶ιUMθ⁻⁺⁺κ№§ι⊕λ3№§ι⊖λ5LΦ§ιλ›μ2≔﹪⊕ηLθη⟦⪫θ,

Essayez-le en ligne! Le lien est vers la version détaillée du code. Alternance entre la sortie des dés et des jetons restants (ni le nombre initial de jetons ni le nombre de jetons au centre ne sont inclus dans la sortie). Explication:

≔⁰η

Commencez avec le premier joueur.

WΣθ«

Répétez jusqu'à ce qu'il ne reste plus de jetons.

≔Eθ⭆⌊⟦κ׳⁼λη⟧‽⁶ι

Lancez jusqu'à trois dés pour le joueur actuel. Ces dés sont étiquetés 0-5, où 0-2 représente le point, 3 est passé à gauche, 4 est au centre, 5 est à droite.

UMθ⁻⁺⁺κ№§ι⊕λ3№§ι⊖λ5LΦ§ιλ›μ2

Additionnez le nombre de jetons que le joueur de droite a passé à gauche et le nombre de jetons que le joueur de gauche a passé à droite, mais soustrayez le nombre de jetons que le joueur lui-même a transmis.

≔﹪⊕ηLθη

Passez au joueur suivant.

⟦⪫θ,

Sortez le nouveau nombre de jetons détenus par les joueurs.

Il est en fait plus simple pour tout le monde de lancer leurs dés simultanément, ce qui peut être fait en 50 octets, y compris l'impression des rouleaux de dés ainsi que des jetons restants:

WΣθ«≔Eθ⭆⌊⟦κ³⟧‽⁶ιUMθ⁻⁺⁺κ№§ι⊕λ3№§ι⊖λ5LΦ§ιλ›μ2⟦⪫ι,⪫θ,

Essayez-le en ligne! Le lien est vers la version détaillée du code.

Neil
la source
Je ne suis pas sûr, mais il ne semble pas que cela explique le nombre de jetons détenus après chaque rôle, pas chaque tour.
CT Hall
@CTHall Oh, vous voulez dire que chaque joueur lance individuellement, puis le nombre de jetons est mis à jour? Désolé, j'ai oublié ça. Je mettrai à jour ma réponse dès que j'aurai le temps.
Neil
1

05AB1E (hérité) , 58 50 49 52 octets

Version qui affiche le même état quand un joueur au tour n'a plus de jetons ( 50 49 52 octets ):

и[=ÐO_#¾è3‚Ws\F5ÝΩ©3‹iε¾¹%NQ-}®≠iε®<¾+¹%NQ+}}}}D0›*¼

Essayez-le en ligne.

Version qui saute les joueurs avec 0 jeton restant ( 58 57 60 octets ):

и[=DO_#[D¾èDĀ#\¼}3‚Ws\F5ÝΩ©3‹iε¾¹%NQ-}®≠iε®<¾+¹%NQ+}}}}D0›*¼

Essayez-le en ligne.

Les deux octets +3 en utilisant la version héritée, car la nouvelle version 05AB1E a un bug bizarre. Il devrait fonctionner avec Ws\(push minimum sans popping; swap; discard list) remplacé par ß(pop list and push minimum) et 0›(vérifier si supérieur à 0) remplacé par d(vérifier si non négatif / supérieur ou égal à 0) dans le nouvelle version, mais pour une raison quelconque, l'ordre de la liste est modifié après la fin ¼! .. : S (et la nouvelle version est également extrêmement lente et expire après 60 secondes avant de terminer le résultat ..>.>)

La première entrée est la quantité de joueurs, la deuxième entrée la quantité de jetons par joueur.

Explication (de la deuxième version):

и                    # Create a list with a size of the (first) implicit input,
                     # filled with the second (implicit) input
[                    # Start an infinite loop:
 =                   #  Print the list with trailing newline, without popping the list
 DO_#                #  If the total amount of chips is 0: stop the infinite loop
 [                   #  Start an inner infinite loop:
  D¾è                #   Get the chips of the I'th player (I is 0 by default)
     D               #   Duplicate this
      Ā#             #   If it is NOT 0: stop the inner infinite loop
        \            #   Remove the duplicated chips for the next iteration
         ¼           #   And increase I by 1
 }                   #  After the inner infinite loop:
 3Ws\               #  If the amount of chips is larger than 3: use 3 instead
      F              #  Loop that many times:
       5ÝΩ           #   Roll a random dice in the range [0,5]
       ©3i          #   If the dice-roll is 0, 1, or 2:
           ε¾¹%NQ-}  #    Remove a chip from the I'th player
           ®≠i       #    If the dice-roll is NOT 1:
              ε®<¾+  #     Go to the player left if 0; or right if 2
              ¹%NQ+} #     And increase that player's chips by 1
      }}}            #  Close both if-statements and the loop
         D0›*        #  Make any negative amount of chips 0
             ¼       #  Increase I by 1
Kevin Cruijssen
la source
Je ne suis pas sûr que cela fonctionne correctement. Il semble que les joueurs puissent gagner des jetons à leur tour, ce qui ne devrait pas se produire.
CT Hall
@CTHall Êtes-vous sûr? Dans laquelle des quatre versions de TIO avez-vous vu cela? Je n'ai vérifié que le dernier (version héritée qui saute les joueurs avec 0 jetons), mais la seule fois où cela augmente un joueur, c'est quand un autre joueur est à son tour. Voici cette dernière avec une ligne de débogage ajoutée afin que vous puissiez voir quel joueur (indexé 0) est à son tour.
Kevin Cruijssen
1
Les héritages semblent être corrects, mais le non-héritage semble avoir l'erreur que j'ai mentionnée.
CT Hall
@CTHall Ah, vous avez bien raison. Je vois une ligne [2, 3, 3, 3]suivie de [2, 2, 2, 6]..: S Je vais voir si je peux trouver la cause et la corriger. Sinon, je peux toujours le supprimer et n'utiliser que l'héritage, car il sort beaucoup plus de toute façon .. La nouvelle version est assez lente avec des boucles complexes pour une raison quelconque.>.>
Kevin Cruijssen
@CTHall J'ai pu identifier le problème, mais je n'ai pas pu le résoudre. Pour une raison quelconque, l'ordre de la liste a changé juste après l'augmentation du global counter_variable.. J'ai essayé de reproduire le problème dans un exemple plus simple, mais je ne peux pas. Cela a quelque chose à voir avec les instructions if et les cartes imbriquées à l'intérieur de la boucle infinie, mais c'est vraiment bizarre .. Quoi qu'il en soit, j'ai supprimé cette version et maintenant il ne reste que la version héritée (et plus rapide), qui fonctionne comme prévu.
Kevin Cruijssen