Je programme actuellement un Puissance 4 quand je m'ennuie en cours de maths, et le programme de la journée c'était le test des victoires en diagonales. J'ai trouvé une solution assez ergonomique niveau code, mais qui fait ramer à mort... :/
Je fais ces tests de victoires uniquement apres qu'un nouveau piont ait été joué.
Voici le bout de code qui m'interesse :
Code
4->dim(L1)
4->dim(L2)
4->Dim(L3)
(6,7)->dim([A]) #[A] étant la matrice contenant les valeurs du contenu des cases :
#0 = vide; 1 = X, 2 = O
... #Autres declarations
Lbl A
... #Tetkey avec Goto Bapres selection d'une touche valide
Lbl B
... #Test si case non prise
... #Dessin des points
... #Test des victoires horizontales et verticales
For(X,0,3)
For(Z,0,3)
P-X+Z -> L1(Z+1) #P et Q étant les coordonnées des cases dans la matrice [A]
Q-X+Z -> L2(Z+1)
Q+X-Z -> L3(Z+1)
End
If min(L1)>0 et min(L2)>0 et max(L1)<8 et max(L2)<7 #Que j'ai pas d'erreur avec les dimensions de [A]
Then
If [A](L2(1),L1(1)) != 0 et [A](L2(1),L1(1)) = [A](L2(2),L1(2)) et [A](L2(2),L1(2)) = [A](L2(3),L1(3)) et [A](L2(3),L1(3)) = [A](L2(4),L1(4))
Goto V
End
... #Memes If avec [A](L3,L1)
End
Lbl V
..."Comment t'es trop un génie t'as gagné!"
Vous auriez des suggestions pour accellerer ou améliorer ca, svp? Parce que je trouve pas plus classe comme algo, mais ya certainement plus rapide...
Ah, et aussi, j'ai pas trouvé mieux que :
Code
If [A](L2(1),L1(1)) != 0 et [A](L2(1),L1(1)) = [A](L2(2),L1(2)) et [A](L2(2),L1(2)) = [A](L2(3),L1(3)) et [A](L2(3),L1(3)) = [A](L2(4),L1(4))
pour tester si les 4 valeurs sont identiques... Le langage a pas l'air d'apprécier les formules comme "If X = Y = Z != 0"
Autorisation : Membre
Nb de messages : 3738
Inscrit le : Lun 19 Oct 2009, 21:25
Posté le : Ven 05 Fév 2010, 19:54
Pour les tests d'égalitées tordues, il y a mieux !
représente le joueur actif par une variable (J=1 pour X ou J=2 pour O ; et au changement de joueur fait 3-J->J)
Code
If [A](L2(1),L1(1))*[A](L2(2),L1(2))*[A](L2(3),L1(3))*[A](L2(4),L1(4))=J^3
gotoV
---------------------- ti82statfr: 2008, inscrit: 2009, ti84pocketfr: noël2011, ti30xbmultiview: iut 2012-2014
Perfectionniste, manque tact. Pas le temps de tout publier depuis 2011. Répond toujours aux questions. (rédigé juin 2014)
Oui, j'y avais pensé, à utiliser ce genre de trucs.
Je mettrai certainement en application pour mon morpions qui est geré qu'avec des listes, avec les outils qu'il y a deja implementés ca sera plus ergonomique, et là aussi en fait, c'est toujours mieux
Mais je crois que ce qui ralentit c'est de faire 9 tours de 2 if...
Je me demandais (et j'ai pas trouvé) si yavait pas moyen de réduire le nombre de tour en testant si le nombre de la liste généré correspond aux limites de la matrice avant plutot que pendant la boucle...
Si vous avez une idée... ^^
En tout cas merci pour ton idée linkakro, je vais le faire en fait
Autorisation : Membre
Nb de messages : 765
Inscrit le : Jeu 28 Sep 2006, 18:42
Posté le : Sam 06 Fév 2010, 21:21
Déjà plutôt que de mettre un Goto tu peux donner la valeur qui correspond au joueur à une variable quelconque qui fait sortir de la boucle principale si !=0.
Les Lbl Goto sont les pires boucles je crois niveau lourdeur (à confirmer).
Personnellement j'en ai refais un en 3/4h en début d'année qui est assez rapide. J'ai plus de pile là, mais jme souviens de deux trois trucs.
Déjà X correspondait à -1 et O à 1, du coup y'avait qu'à faire -J pour changer de joueur. Après j'avais pas besoin que d'une liste, qui donnait le nombre de coups joués dans chaque colonne (L1(1)=nombre de coups joués dans 1), qui donnait aussi la coordonnée de l'ordonnée de la matrice. Une autre ligne de code de type ((Positionnement en longueur de la ou on vient de jouer - décalage par rapport à l'abscisse 0)/taille de la case)->V donnait la coordonnée de l'abscisse de la matrice.
Là ou on venait de jouer, [A](L1(V),V), je le foutais dans une variable (on va dire A, et L1(V) dans B, du coup on gagnait pas mal d'octets.
Pour genre deux diagonales ça faisait un truc comme:
Code
:If B>1 et B<5
:Then
:If V<6 et V>1
:Then
:If H=[A](B+1,V+1) et H=[A](B+2,V+2) et H=[A](B-1,V-1)
:J->C
:End
:If V<7 et V>2
:Then
:If H=[A](B+1,V-1) et H=[A](B+2,V-2) et H=[A](B-1,V+1)
:End
...
Y'a encore moyen de gratter (si on utilise la technique de linkakro qui marche pas avec -1 et 1 ça fait plus que :If J^3=H*[A](B+1,V-1)*[A](B+2,V-2)*[A](B-1,V+1) )
