Game of Life

[Clément.7]

Voici un petit jeu que j'ai créé pendant un cours de maths un peu trop long ( )
J'ai nommé : Game of Life.

Le principe est simple : Vous disposez des cellules sur une grille (ici, 8x16). Si une cellule est en contact (y compris en diagonale) avec deux ou trois autres, elle survit. Sinon elle meurt. Si une case vide est en contact avec trois cellules, une nouvelle cellule s'y crée.

Je préfère prévenir tout de suite, même après beaucoup d'optimisations et de recherches de solutions (additions de matrices, conversions en liste et sommes, chaînes de caractères...) le programme reste très lent. Comptez environ 10 secondes par phase (testé sur une TI-83+.fr) .

Lorsque vous lancez le programme, vous disposez d'un éditeur de plateau de jeu. Appuyez sur ou bien pour ajouter/supprimer une cellule. Le curseur sera un gros "+" si vous la case contient une cellule et un petit "+" si elle est vide.
Une fois le tableau prêt, appuyez sur pour lancer la simulation en mode texte, et pour le mode graphique.
Les deux modes font la même chose, mais vous pouvez choisir d'afficher le plateau de jeu en grosse lettres ou en plus petites

L'éditeur utilise une matrice 8x16 qui prend ~ 1.6 Ko de mémoire RAM. Pour réduire cela vous pouvez exporter le plateau de jeu en appuyant sur dans l'éditeur. Pour charger le plateau depuis le fichier exporté, appuyez sur . Vous pouvez dès lors transférer le fichier de plateau (la liste GOLSV pour Game of Life Save) à une autre calculatrice sans pour autant supprimer de matrices

Attention : Le jeu efface le contenu des matrices [A], [B] et [C] !

Enfin, le programme ne pèse que 1 Ko ! (pile-poil, avant que je ne renomme le programme il faisait 999 octets )

Si quelqu'un est intéressé....

[Ti64CLi++]

J'adore ce jeu. Par contre, jamais réussi à en programmer un

[Clément.7]

Moi aussi je ne pensais pas pouvoir en programmer mais en fait c'est relativement simple. J'ai un plateau de jeu de 8 lignes par 16 colonnes, je crée une matrice de 10 lignes par 18 colonnes.
Lorsque je veux calculer une étape de l'évolution cellulaire, je copie la matrice [A] dans [B]. Ainsi, si je dois modifier certaines cases, cela n'affectera pas la matrice d'origine qui est en cours de traitement, ce qui aurait pour effet de fausser les résultats.
Je fais une boucle :

Code: Select all

For(Y,2,9)
For(X,2,17)
"Le code est ici
End:End

Je calcule ensuite la somme des cases qui entoure la case actuelle. Soit les cases de coordonnées (Y-1;X-1) (Y-1;X) (Y-1;X+1) / (Y;X-1) (Y;X+1) / (Y+1;X-1) (Y+1;X) (Y+1;X+1) -> 8 cases en tout. L'avantage d'avoir fait une plus grande matrice que le plateau de jeu, c'est que si je regarde la matrice aux coordonnées (Y-1;X-1) cela ne générera pas d'erreurs. Sinon j'aurais dû vérifier que X > 1.... ce qui aurait considérablement ralenti le jeu ! Alors certes cela prend (légèrement) plus de RAM mais permet de beaucoup gagner en vitesse
Si je reprends le code de tout à l'heure :

Code: Select all

For(Y,2,9)
For(X,2,17)
[A](Y-1;X-1)+[A](Y-1;X)+[A](Y-1;X+1)+[A](Y;X-1)+[A](Y;X+1)+[A](Y+1;X-1)+[A](Y+1;X)+[A](Y+1;X+1)->S
If [A](Y,X):Then // Il y a une cellule dans cette case
If S≠2 or S≠3 // Ni 2 ni 3 cellules avoisinantes ? Destruction de la cellule
0->[B](Y,X)
Else // Aucune cellule dans cette case
If S=3 // 3 cellules ? Création d'une cellule dans cette case vide
1->[B](Y,X)
End:End:End

Ensuite, si la case de la matrice (Y;X) vaut 1 (il y a une cellule), s'il la somme des cellules avoisinantes est différente de deux ou trois (condition nécessaire à la survie de la cellule), je mets 0 (pas de cellule) dans la matrice [B] aux coordonnées (Y;X).
Si la case vaut 0 (pas de cellule), si la somme des cellules avoisinantes est de trois (condition nécessaire à la création d'une cellule), je mets 1 (cellule) dans la matrice [B], toujours aux mêmes coordonnées.

Ensuite, je mets [B] dans [A] et le tour est joué ! Il n'y a plus qu'à afficher. Voici l'algorithme d'affiche le plus rapide faisable en TI-Basic z80 :

Code: Select all

ClrHome
For(Y,1,8)
For(X,1,16)
If [A](Y+1,X+1)
Output(Y,X,"o
End:End

Et voilà !

[Ti64CLi++]

J'ai utilisé la meme technique (la matrice plus grande que le plateau de jeu) pour un démineur (que je n'ai pas publié ^^).
En tout cas, encore bravo, il n'y en a pas beaucoup sur TI Planet

[Clément.7]

Merci mais le programme est vraiment trop lent (P.S. j'ai édité mon dernier message)
EDIT: *lent, pas long

[grosged]

Tu es sur que l'utilisation de liste n'optimiserait pas ? En optant pour une liste, ça n'est plus 2 variables X,Y mais 1 seule comme coordonnée, tout de même.
Sinon, les " If...Then" sont très souvent à l'origine de ralentissements.

Si j'ai bien compris, 3 cellules voisines donneront naissance/laisseront en vie la cellule centrale, et 2 cellules voisines laisseront la cellule centrale en l'état actuel.
Pour le reste, la cellule centrale sera morte.
Avec E=état de la cellule centrale , et V=nb de cellules voisines...
le nouvel état sera :
(V=3) or (E and (V=2
ou encore...
(V=3)+ E*(V=2

[Clément.7]

Malheureusement je n'ai pas réussi à faire plus rapide
Et pour les listes non je pense au contraire que ça empirerait car bien non seulement une liste prend plus de place en mémoire mais en plus il faut écrire plusieurs tokens et la calculatrice doit comprendre qu'on veut accéder à tel index de la liste et pas juste à une variable. D'où une plus grande lenteur je pense.

[randlog]

J'avoue que c'est très très lent.... j'espère que tu trouveras une solution mais c'est déjà pas mal...

[Clément.7]

En fait à mon avis, il est impossible de faire plus rapide (ou presque), à moins de le recoder en un autre langage plus rapide... Je vais peut-être essayer en Axe avec la liste L1 pour stocker les données, ça devrait passer sans problème...

[Ti64CLi++]

Bonne chance pour l'Axe, je veux bien t'aider