Jeu de la vie en bash

**Ezzmazz** · 26/12/2018, 14h41

Bonjour,

Je suis en BTS ISO en alternance afin de devenir administrateur système linux. Afin d'être " opérationnel " et pour commencer à faire des choses intéressantes, mon tuteur me fait apprendre le bash. D'abord via de simple exerce, puis maintenant via un Morpion avec un tableau à multi-dimenssion afin de finir sur le jeu de la vie de John Horton Conway.

Je suis actuellement à l'étape du jeu de la vie, puisque j'ai terminé le morpion. Voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
#!/bin/bash
 
declare -A tab
 
num_lines=3
num_columns=3
 
 
########## ARRAY FUNCTION ##########
init_array_function()
{
for ((x=1;x<=num_lines;x++)) 
do
        for ((y=1;y<=num_columns;y++))
	do 	tab[$x,$y]="";
 
        done
done
 
}
 
 
 
########## END OR RESTART FUNCTION  ##########
end_restart_function()
{
display_function
echo ""
echo " + What do you want to do ? "
echo " ---------------------------- "
echo ""
echo " [1] - Leave "
echo " [2] - Start again "
echo ""
echo -n " > "
read CHOIX
 
case $CHOIX in
	1) exit ;;
	2) start_function ;;
	*) echo " Error ! Retry ! "
	end_restart_function ;;
esac
}
 
########## GAME START FUNCTION  ##########
start_function()
{
init_array_function
echo -n " + Player 1 name : "
read P1
echo -e " > The first player is : $P1 ! Good Luck !\n "
 
echo -n " + Player 2 name : "
read P2
 
if [[ "$P2" = "$P1"  ]]
then
	echo " + Error ! Retry ! "
	echo -n " + Player 2 name : > "
	read P2
 	echo " > The second player is : $P2 ! Good Luck ! "	   
else
echo -e " > The second player is : $P2 ! Good Luck !\n "
fi
display_function
player_choice_function
}
 
########## GAMER CHOICE ##########
player_choice_function()
{
if [[ $Player < 2 ]]
then	
	P1_function
else
	P2_function
fi
}
 
########## DISPLAY FUNCTION ##########
display_function()
{
 
f1="%$((${#num_lines}+1))s"
f2="%9s"
 
printf "$f1"
for ((x=1;x<=num_lines;x++))
do
	printf "$f2" $x
done
echo
 
for ((y=1;y<=num_columns;y++)) 
do
	printf "$f1" $y
	for ((x=1;x<=num_lines;x++)) 
	do
		printf "$f2" ${tab[$x,$y]}
	done
	echo
done
}
 
########## PLAYERS WIN FUNCTION ##########
win_function()
{
########## - J1 - ##########
if [ "${tab[1,1]}" = "x" ] && [ "${tab[2,1]}" = "x" ] && [ "${tab[3,1]}" = "x" ] ; then echo "" ; echo "" ; echo " $P1 won the game ! " ; echo ; end_restart_function ; fi
if [ "${tab[1,2]}" = "x" ] && [ "${tab[2,2]}" = "x" ] && [ "${tab[3,2]}" = "x" ] ; then echo "" ; echo "" ; echo " $P1 won the game ! " ; echo ; end_restart_function ; fi
if [ "${tab[1,3]}" = "x" ] && [ "${tab[2,3]}" = "x" ] && [ "${tab[3,3]}" = "x" ] ; then echo "" ; echo "" ; echo " $P1 won the game ! " ; echo ; end_restart_function ; fi
 
if [ "${tab[1,1]}" = "x" ] && [ "${tab[1,2]}" = "x" ] && [ "${tab[1,3]}" = "x" ] ; then echo "" ; echo "" ; echo " $P1 won the game ! " ; echo ; end_restart_function ; fi
if [ "${tab[2,1]}" = "x" ] && [ "${tab[2,2]}" = "x" ] && [ "${tab[2,3]}" = "x" ] ; then echo "" ; echo "" ; echo " $P1 won the game ! " ; echo ; end_restart_function ; fi
if [ "${tab[3,1]}" = "x" ] && [ "${tab[3,2]}" = "x" ] && [ "${tab[3,3]}" = "x" ] ; then echo "" ; echo "" ; echo " $P1 won the game ! " ; echo ; end_restart_function ; fi
 
if [ "${tab[1,1]}" = "x" ] && [ "${tab[2,2]}" = "x" ] && [ "${tab[3,3]}" = "x" ] ; then echo "" ; echo "" ; echo " $P1 won the game ! " ; echo ; end_restart_function ; fi
if [ "${tab[1,3]}" = "x" ] && [ "${tab[2,2]}" = "x" ] && [ "${tab[3,1]}" = "x" ] ; then echo "" ; echo "" ; echo " $P1 won the game ! " ; echo ; end_restart_function ; fi
 
########## - J2 - ##########
if [ "${tab[1,1]}" = "o" ] && [ "${tab[2,1]}" = "o" ] && [ "${tab[3,1]}" = "o" ] ; then echo "" ; echo "" ; echo " $P2 won the game ! " ; echo ; end_restart_function ; fi
if [ "${tab[1,2]}" = "o" ] && [ "${tab[2,2]}" = "o" ] && [ "${tab[3,2]}" = "o" ] ; then echo "" ; echo "" ; echo " $P2 won the game ! " ; echo ; end_restart_function ; fi
if [ "${tab[1,3]}" = "o" ] && [ "${tab[2,3]}" = "o" ] && [ "${tab[3,3]}" = "o" ] ; then echo "" ; echo "" ; echo " $P2 won the game ! " ; echo ; end_restart_function ; fi
 
if [ "${tab[1,1]}" = "o" ] && [ "${tab[1,2]}" = "o" ] && [ "${tab[1,3]}" = "o" ] ; then echo "" ; echo "" ; echo " $P2 won the game ! " ; echo ; end_restart_function ; fi
if [ "${tab[2,1]}" = "o" ] && [ "${tab[2,2]}" = "o" ] && [ "${tab[2,3]}" = "o" ] ; then echo "" ; echo "" ; echo " $P2 won the game ! " ; echo ; end_restart_function ; fi
if [ "${tab[3,1]}" = "o" ] && [ "${tab[3,2]}" = "o" ] && [ "${tab[3,3]}" = "o" ] ; then echo "" ; echo "" ; echo " $P2 won the game ! " ; echo ; end_restart_function ; fi
 
if [ "${tab[1,1]}" = "o" ] && [ "${tab[2,2]}" = "o" ] && [ "${tab[3,3]}" = "o" ] ; then echo "" ; echo "" ; echo " $P2 won the game ! " ; echo ; end_restart_function ; fi
if [ "${tab[1,3]}" = "o" ] && [ "${tab[2,2]}" = "o" ] && [ "${tab[3,1]}" = "o" ] ; then echo "" ; echo "" ; echo " $P2 won the game ! " ; echo ; end_restart_function ; fi
display_function
player_choice_function
}
 
########## GAMERS FUNCTION ##########
########## - P1 - ##########
P1_function()
{
Player=2
echo " + $P1, it's your turn ! "
echo -n " > "
read VALUE1
 
case $VALUE1 in
	1,1) if [ "${tab[1,1]}" = "x" ] || [ "${tab[1,1]}" = "o" ] ; then echo " The cell is already used ! Retry ! " ; P1_function ; else  tab[1,1]="x" ; fi ;;
	2,1) if [ "${tab[2,1]}" = "x" ] || [ "${tab[2,1]}" = "o" ] ; then echo " The cell is already used ! Retry ! " ; P1_function ; else  tab[2,1]="x" ; fi ;;
	3,1) if [ "${tab[3,1]}" = "x" ] || [ "${tab[3,1]}" = "o" ] ; then echo " The cell is already used ! Retry ! " ; P1_function ; else  tab[3,1]="x" ; fi ;;
	1,2) if [ "${tab[1,2]}" = "x" ] || [ "${tab[1,2]}" = "o" ] ; then echo " The cell is already used ! Retry ! " ; P1_function ; else  tab[1,2]="x" ; fi ;;
	2,2) if [ "${tab[2,2]}" = "x" ] || [ "${tab[2,2]}" = "o" ] ; then echo " The cell is already used ! Retry ! " ; P1_function ; else  tab[2,2]="x" ; fi ;;
	3,2) if [ "${tab[3,2]}" = "x" ] || [ "${tab[3,2]}" = "o" ] ; then echo " The cell is already used ! Retry ! " ; P1_function ; else  tab[3,2]="x" ; fi ;;
        1,3) if [ "${tab[1,3]}" = "x" ] || [ "${tab[1,3]}" = "o" ] ; then echo " The cell is already used ! Retry ! " ; P1_function ; else  tab[1,3]="x" ; fi ;;
        2,3) if [ "${tab[2,3]}" = "x" ] || [ "${tab[2,3]}" = "o" ] ; then echo " The cell is already used ! Retry ! " ; P1_function ; else  tab[2,3]="x" ; fi ;;
        3,3) if [ "${tab[3,3]}" = "x" ] || [ "${tab[3,3]}" = "o" ] ; then echo " The cell is already used ! Retry ! " ; P1_function ; else  tab[3,3]="x" ; fi ;;
 
	*) echo " Error ! Retry ! " ; P1_function ;;
esac
win_function
}
########## - P2 - ##########
P2_function()
{
Player=1
echo " + $P2, it's your turn ! "
echo -n " > "
read VALUE2
 
case $VALUE2 in
	1,1) if [ "${tab[1,1]}" = "o" ] || [ "${tab[1,1]}" = "x" ] ; then echo " The cell is already used ! Retry ! " ; P2_function ; else  tab[1,1]="o" ; fi ;;
        2,1) if [ "${tab[2,1]}" = "o" ] || [ "${tab[2,1]}" = "x" ] ; then echo " The cell is already used ! Retry ! " ; P2_function ; else  tab[2,1]="o" ; fi ;;
        3,1) if [ "${tab[3,1]}" = "o" ] || [ "${tab[3,1]}" = "x" ] ; then echo " The cell is already used ! Retry ! " ; P2_function ; else  tab[3,1]="o" ; fi ;;
        1,2) if [ "${tab[1,2]}" = "o" ] || [ "${tab[1,2]}" = "x" ] ; then echo " The cell is already used ! Retry ! " ; P2_function ; else  tab[1,2]="o" ; fi ;;
        2,2) if [ "${tab[2,2]}" = "o" ] || [ "${tab[2,2]}" = "x" ] ; then echo " The cell is already used ! Retry ! " ; P2_function ; else  tab[2,2]="o" ; fi ;;
        3,2) if [ "${tab[3,2]}" = "o" ] || [ "${tab[3,2]}" = "x" ] ; then echo " The cell is already used ! Retry ! " ; P2_function ; else  tab[3,2]="o" ; fi ;;
        1,3) if [ "${tab[1,3]}" = "o" ] || [ "${tab[1,3]}" = "x" ] ; then echo " The cell is already used ! Retry ! " ; P2_function ; else  tab[1,3]="o" ; fi ;;
        2,3) if [ "${tab[2,3]}" = "o" ] || [ "${tab[2,3]}" = "x" ] ; then echo " The cell is already used ! Retry ! " ; P2_function ; else  tab[2,3]="o" ; fi ;;
        3,3) if [ "${tab[3,3]}" = "o" ] || [ "${tab[3,3]}" = "x" ] ; then echo " The cell is already used ! Retry ! " ; P2_function ; else  tab[3,3]="o" ; fi ;;
 
	*) echo " Error ! Retry !  " ; P2_function ;;
esac
win_function
}
 
 
echo ""
echo " + --------------------------------------------- + "
echo " +                <<< MORPION >>>                + "
echo " + --------------------------------------------- + "
echo ""
 
start_function

Mon code n'est peut-être pas parfait, mail il est opérationnel. Maintenant, le but est de récupérer quelques fonctions apprises avec le morpion et de les intégrer dans le code du jeu de la vie. Du coup, je compte récupérer les fonctions " init_array_function " et " display_array ".

Le fonctionnement du jeu de la vie fait que :

Si une cellule morte est entourée de trois cellules voisines vivantes, cette cellule devient vivante.
Une cellule vivante entourée par deux ou trois cellules vivantes reste vivante, sinon elle meurt.

En tenant compte de ces informations, j'imagine le jeu de la manière suivante :

Pouvoir changer, dès le lancement du script, la taille du tableau en modifiant les variables num_lines et num_columns du code de mon Morpion, afin d'avoir un tableau aussi grand que souhaité.
Remplir un tableau à plusieurs dimensions de manière aléatoire, avec des 0 et des 1. Le 0 étant une cellule morte et le 1 une cellule vivante.
Que l'utilisateur puisse déplacer le curseur comme il le souhaite dans le tableau avec les flèches du clavier afin de pouvoir placer des cellules vivantes là où il le souhaite.

De ce fait, voilà où j'en suis :

Ce qui donne :

Nom : 1545831239-3.png
Affichages : 1190
Taille : 4,8 Ko

Donc super, pour le moment tout fonctionne. Mais je ne sais pas faire certaines choses et c'est là que j'aimerai votre aide :

Comment faire en sorte que les 0 et les 1 qui remplissent le tableau soient cachés pour ne laisser apparaître que ce que l'utilisateur va saisir ?
Comment faire en sorte que, une fois le script lancé et le nombres de lignes et de colonnes donnés, le curseur soit placé en 1;1 sur le tableau afin de pouvoir le déplacer comme on le veut avec les flèches du clavier ?

Merci d'avance !

**Flodelarab** · 26/12/2018, 15h53

Bonjour

Allez, c'est noël. Voici la boucle principale d'un sudoku que j'avais fait en bash.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
while read -sn1 ligne
do
    # Pour les flèches, la détection prend 3 caractères consécutifs:
    # "\e" ou "\033" puis "[" puis "A" ou "B" ou "C" ou "D"
    # Afin que les monolettres réagissent, il n'y a pas de "read -sn 3"
 
    if [ "$ligne" = "q" ]; then
        exit 0
    elif [[ "$ligne" =~ [0-9] ]]; then
        #blablabla
    elif [ "$ligne" = "n" ]; then
        nouvelle_grille
        reafficher
 
        #........
 
    elif [ "$ligne" = "A" ]; then
        curseur_y=$((curseur_y-1))
        curseur_adapt
    elif [ "$ligne" = "B" ]; then
        curseur_y=$((curseur_y+1))
        curseur_adapt
    elif [ "$ligne" = "C" ]; then
        curseur_x=$((curseur_x+1))
        curseur_adapt
    elif [ "$ligne" = "D" ]; then
        curseur_x=$((curseur_x-1))
        curseur_adapt
    fi
 
done </dev/tty # entrée au clavier

Et la fonction d'affichage du curseur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
curseur_adapt()                                                                                                                                                                                                                                                                   
{                                                                                                                                                                                                                                                                                 
    if [ "$curseur_x" -gt 9 ]; then curseur_x=1;fi                                                                                                                                                                                                                                
    if [ "$curseur_x" -lt 1 ]; then curseur_x=9;fi                                                                                                                                                                                                                                
    if [ "$curseur_y" -gt 9 ]; then curseur_y=1;fi                                                                                                                                                                                                                                
    if [ "$curseur_y" -lt 1 ]; then curseur_y=9;fi                                                                                                                                                                                                                                
 
    indice=$((curseur_x-1+(curseur_y-1)*9))                                                                                                                                                                                                                                       
 
    printf "\033[%u;%uH" $((curseur_y+((curseur_y-1)/3)+1)) $((2*curseur_x+2*((curseur_x-1)/3)+1))                                                                                                                                                                                
}

Tu comprends donc que les commandes sont composées d'une seule lettre minuscule, et les 4 dernières alternatives A B C D traitent l'appui des flèches.

**Christophe** · 26/12/2018, 16h03

Pour le déplacement avec les flèches du clavier, je pensais à la bibliothèques NCurses. C'est cette bibliothèque qui est en général utilisé dans les installeurs en mode texte (avec menus notamment)et par l’éditeur Nano. En regardant vite fait sur le web, ça semble utilisable avec Bash. Par contre la documentation de Ncurses n'est pas très riche.

Mais moi j'utiliserais plutôt Python, qui pourrait être pour toi considérable comme un intermédiaire entre le Bash et le C.

Dans les deux cas, c'est un exercice intéressant pour toi, avoir des compétences Python pourra te servir en administration système, bien que Python soit un vrai langage de programmation.

**BufferBob** · 26/12/2018, 19h57

salut,

les séquences d'échappement ANSI peuvent être un bon moyen de jongler avec ces subtilités d'affichages

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

echo -e "\033[5;10Hcoucou"  # écrit coucou aux coordonnées (10,5)

**Ezzmazz** · 27/12/2018, 10h42

Merci beaucoup pour vos réponses !

Envoyé par Flodelarab

Bonjour

Allez, c'est noël. Voici la boucle principale d'un sudoku que j'avais fait en bash.

[…]

Et la fonction d'affichage du curseur :

[…]

Tu comprends donc que les commandes sont composées d'une seule lettre minuscule, et les 4 dernières alternatives A B C D traitent l'appui des flèches.

Je n'en demandais pas tant, merci de partager ton code avec moi !

Envoyé par chrtophe

Pour le déplacement avec les flèches du clavier, je pensais à la bibliothèques NCurses. C'est cette bibliothèque qui est en général utilisé dans les installeurs en mode texte (avec menus notamment)et par l’éditeur Nano. En regardant vite fait sur le web, ça semble utilisable avec Bash. Par contre la documentation de Ncurses n'est pas très riche.

Mais moi j'utiliserais plutôt Python, qui pourrait être pour toi considérable comme un intermédiaire entre le Bash et le C.

Dans les deux cas, c'est un exercice intéressant pour toi, avoir des compétences Python pourra te servir en administration système, bien que Python soit un vrai langage de programmation.

Merci, je vais jeter un oeil à cette bibliothèque !

Mon tuteur m'a proposé, après le bash, de travailler soit sur le python, soir le java. Je pense choisir le python. De mon point de vue de novice, ça semble être plus " flexible " et plus " large " en terme d'outils que le java. Et puis pour un admin-sys linux, ça risque d'être plus utile, non ?

Envoyé par BufferBob

salut,

les séquences d'échappement ANSI peuvent être un bon moyen de jongler avec ces subtilités d'affichages

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

echo -e "\033[5;10Hcoucou"  # écrit coucou aux coordonnées (10,5)

Merci ! Je vais y jeter un oeil également !

**Christophe** · 27/12/2018, 12h28

Le python sera plus adapté pour un sysadmin que le Java.

Le Java pourrais te servir plus tard si tu te mets à faire du développement. Et dans cet éventuel cas, ton expérience Python te sera très utile. Mais dans un premier temps, je te recommandes Python.

**Flodelarab** · 27/12/2018, 12h34

Si on part comme ça, Perl est mieux que python qui est mieux que java pour un administrateur système. Non ?

**Christophe** · 27/12/2018, 13h26

Si on part comme ça, Perl est mieux que python qui est mieux que java pour un administrateur système. Non ?

A la base, l'utilisateur fait de l'administration système et apprend Bash.

Python ou Perl, qui me parait plus complexe à prendre en main que Python. Il est possible de développer des applications en Perl ou Python, mais là non plus ce ne sera pas forcément les outils les plus efficaces par rapport à Java ou C, mais resterons plus facile à prendre en main.

Python me parait un bon intermédiaire pour quelqu"un qui passe de la réalisation de script Bash à de la programmation. Par contre pas d’intérêt pour moi de passer de Python à Perl, les deux apportant plus ou moins la même chose (en restant général), ni de faire Bash->Python->Perl->java, autant faire bash->Python->Java ou bash->Perl->Java.

**Ezzmazz** · 27/12/2018, 16h45

Ah, il semblerait que j'ai déclenché un débat !

De toute façon mon choix se porte sur le Python, ça fait un moment que j'ai envie d'apprendre ce langage !

Pour en revenir à mon Jeu de la vie, je change mes plans histoire de faire quelques choses de plus simples pour le moment :

Je ne vais plus faire en sorte que l'utilisateur puisse bouger le curseur avec les flèches, mais lui demander d'entrer les coordonnées de la cellule qu'il veut placer, comme dans mon Morpion.

L'idée serait de pouvoir avoir toutes les coordonnées du tableau dans une seule et même variable. Par exemple, si je commence avec un tableau de 20 lignes et de 20 colonnes, il faut drait un truc du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
echo " + Place your cell using the array coordinates ( like "1,1" etc... ) or press "s" to start : "
echo -n " > " 
read coor
 
if [[ $coor -ge 1,1 ]] && [[ $coor -le 20,20 ]]
then
        ${tab[$x,$y]}="o"
else
        echo " Error ! Retry ! "
        cell_function
fi

Je sais très bien que ce bout de code ne fonctionne pas, mais c'est juste pour illustrer mon propos. J'aimerai faire en sorte que la saisie de l'utilisateur soit bloqué par le "xmin" et le "xmax" et par le "ymin" et "ymax". Ainsi, si j'entre 20 lignes et 20 colonnes, les coordonnées iraient de 1,1 à 20,20. L'idée est de soit faire un case, soit faire un truc qui y ressemble, pour que quand l'utilisateur entre une coordonnée, la fonction vérifie qu'elle fait bien partie de la " fourchette " de coordonnées enregistrées dans la fonction.

Ensuite, comme dans le Morpion, il suffirait que les coordonnées saisies par l'utilisateur soit remplacées visuellement par des " o " pour pouvoir ensuite les comparer avec les 0 et les 1.

Du coup, question : Comment regrouper l'ensemble des coordonnées ? Un truc du genre ${x,y .. x,y}, donc si 20 lignes et 20 colonnes, ${1,1 .. 20,20} ?

**Flodelarab** · 27/12/2018, 17h48

Un mathématicien ne t'a-t-il jamais dit qu'il n'y avait pas de relation d'ordre dans les espaces à plus d'une dimension ?
Faire des comparaisons et des classements sur les données à 2 dimensions, tu peux oublier.
Où alors, il faut les définir.

Concrètement, cela veut dire que tu vas prendre tes coordonnées, une par une, et que tu vas vérifier qu'elle est bien "supérieure à ..." et "inférieure à ..." avec des "if" classiques.

En ce qui concerne le regroupement, le plus simple ne serait-il pas de considérer un fichier avec un couple de coordonnées par ligne ? Auquel cas tu pourrais automatiser le traitement ?

Pour être franc, être contraint de rentrer des données à la volée, par un read, casse les pieds de tout utilisateur.

**BufferBob** · 27/12/2018, 18h26

allez c'est les fêtes, une boucle de saisie avec affichage top-moumoute ANSI sequences powered :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#!/bin/bash
 
# affichage sexy des messages d'erreur
#
errormsg() {
   echo -ne "$1"        # affiche le message (1er argument)
   sleep 2              # attend 2 secondes
   echo -ne "\033[2K"   # efface la ligne
   echo -ne "\033[1A"   # déplace le curseur vers le haut
   echo -ne "\033[2K"   # efface la ligne
   echo -ne "\r"        # place le curseur au début de la ligne
}
 
start=0
 
# boucle de saisie utilisateur
#
while read -p " + Place your cell using the array coordinates ( like '1,1' etc... ) or press 's' to start : " coords; do
   if [[ "$coords" =~ ^[0-9]+,[0-9]+$ ]]; then  # ca ressemble à des coordonnées ?
      X=${coords%,*}       # si oui on vérifie
      Y=${coords#*,}       # qu'elles sont valides
      if [[ $X -ge 1 ]] && # X >= 1
         [[ $X -le 9 ]] && # X <= 9
         [[ $Y -ge 1 ]] && # Y >= 1
         [[ $Y -le 9 ]]    # Y <= 9
      then                 # coordonnées OK, on sort du while
         break
      else                 # sinon on recommance la saisie
         errormsg " - coordinates are out of the grid."
      fi
   else
      if [[ "$coords" = "s" ]]; then            # on vérifie s'il s'agit de la commande "s"
         start=1
         break             # si c'est le cas on sort du while
      else                 # sinon on recommence la saisie
         errormsg " - your input is invalid, try again."
      fi
   fi
done
 
# affichage des coordonnées ou démarrage direct
#
if [[ $start -eq 1 ]]; then
   echo " + Starting... (coords=\"$coords\")"
else
   echo " + Coordinates confirmed. (coords=\"$coords\", X=$X, Y=$Y)"
fi

**Ezzmazz** · 28/12/2018, 10h42

Envoyé par Flodelarab

Un mathématicien ne t'a-t-il jamais dit qu'il n'y avait pas de relation d'ordre dans les espaces à plus d'une dimension ?
Faire des comparaisons et des classements sur les données à 2 dimensions, tu peux oublier.
Où alors, il faut les définir.

Concrètement, cela veut dire que tu vas prendre tes coordonnées, une par une, et que tu vas vérifier qu'elle est bien "supérieure à ..." et "inférieure à ..." avec des "if" classiques.

En ce qui concerne le regroupement, le plus simple ne serait-il pas de considérer un fichier avec un couple de coordonnées par ligne ? Auquel cas tu pourrais automatiser le traitement ?

Pour être franc, être contraint de rentrer des données à la volée, par un read, casse les pieds de tout utilisateur.

J'avais prévu ça comme ça au début, en ajoutant même un autre fichier comprenant les différentes formes de cellules que proposent le Jeu de la vie, mais mon tuteur m'a dit de ne pas le faire comme ça !

Envoyé par BufferBob

allez c'est les fêtes, une boucle de saisie avec affichage top-moumoute ANSI sequences powered :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#!/bin/bash
 
# affichage sexy des messages d'erreur
#
errormsg() {
   echo -ne "$1"        # affiche le message (1er argument)
   sleep 2              # attend 2 secondes
   echo -ne "\033[2K"   # efface la ligne
   echo -ne "\033[1A"   # déplace le curseur vers le haut
   echo -ne "\033[2K"   # efface la ligne
   echo -ne "\r"        # place le curseur au début de la ligne
}
 
start=0
 
# boucle de saisie utilisateur
#
while read -p " + Place your cell using the array coordinates ( like '1,1' etc... ) or press 's' to start : " coords; do
   if [[ "$coords" =~ ^[0-9]+,[0-9]+$ ]]; then  # ca ressemble à des coordonnées ?
      X=${coords%,*}       # si oui on vérifie
      Y=${coords#*,}       # qu'elles sont valides
      if [[ $X -ge 1 ]] && # X >= 1
         [[ $X -le 9 ]] && # X <= 9
         [[ $Y -ge 1 ]] && # Y >= 1
         [[ $Y -le 9 ]]    # Y <= 9
      then                 # coordonnées OK, on sort du while
         break
      else                 # sinon on recommance la saisie
         errormsg " - coordinates are out of the grid."
      fi
   else
      if [[ "$coords" = "s" ]]; then            # on vérifie s'il s'agit de la commande "s"
         start=1
         break             # si c'est le cas on sort du while
      else                 # sinon on recommence la saisie
         errormsg " - your input is invalid, try again."
      fi
   fi
done
 
# affichage des coordonnées ou démarrage direct
#
if [[ $start -eq 1 ]]; then
   echo " + Starting... (coords=\"$coords\")"
else
   echo " + Coordinates confirmed. (coords=\"$coords\", X=$X, Y=$Y)"
fi

Alors là... C'est très sympa de ta part ! Je vais essayer de ne pas copier bêtement ton code mais plutôt m'en inspirer afin de pouvoir sortir mon propre code !

D'ailleurs plusieurs questions concernant ton code :

Peux-tu m'expliquer ce que signifie ces deux lignes ? Je veux dire, je comprends ce qu'elles font grâce à tes commentaires, mais pourquoi on l'écrit comme ca ? Pourquoi l'étoile après la virgule et le % concernant le x et pourquoi l'étoile avant après le # mais juste avant la virgule pour le y ?
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
1
2
X=${coords%,*}       # si oui on vérifie
Y=${coords#*,}       # qu'elles sont valides
```

En m'inspirant de ton code, j'ai bidouillé ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
cell_function()
{
init_array               # J'appelle la fonction qui initialise le tableau
display_function     # Là, la fonction qui le fait apparaître
coord_function       #  Et ici, la fonction qui demande à l'utilisateur de placer les cellules vivantes
 
coord_function()
{
while true
do
        echo -n " + Place your cell using the array coordinates ( like '1,1' ) or press 's' to start : "
        read coord
 
        if [ $coord = "s" ]
        then
                echo " Goodbye ! "    # J'ai mis goodbye car la fonction start n'est pas encore faite 
                exit
        else
 
                if [[ "$coord" =~ ^[0-9]+,[0-9]+$ ]]
                then
                        x=${coord%, *}
                        y=${coord#*, }
                        if [[ $x -ge 1 ]] && [[ $x -le 9 ]] && [[ $y -ge 1 ]] && [[ $y -le 9 ]]
                                then
                                        echo " >  Coordinates confirmed for "$coord". "
                                        tab[$x,$y]="o"    # Le but ici, c'est de pouvoir remplacer le 0 ou le 1 généré aléatoirement par un o, je me suis inspiré d'une partie de mon code pour le Morpion. A voir juste en dessous.
                                        echo ""
                                else
                                        echo ""
                                        echo " > Error ! Coordinates are out of the grid ! Retry ! < "
 
                                        echo ""
                                        coord_function    # Là je relance la fonction coord_function en cas de mauvaise saisie ( la coordonnée 10,10 n'est pas prise en compte, d'ailleurs ).
 
                        fi
                fi
        fi
 
done
}
 
cell_function

Je me suis inspiré de ces lignes pour le faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
 
1,1) if [ "${tab[1,1]}" = "x" ] || [ "${tab[1,1]}" = "o" ] ; then echo " The cell is already used ! Retry ! " ; P1_function ; else  tab[1,1]="x" ; fi ;;     # Ici, dans le case, si l'utilisateur entre les coordonnées de la case 1,1, alors on vérifie si la case est déjà utilisée, si elle ne l'est pas, le la case 1,1 prend la valeur x.

Et évidemment... Ça ne fonctionne pas !

**zipe31** · 28/12/2018, 11h00

Salut,

Envoyé par Ezzmazz

D'ailleurs plusieurs questions concernant ton code :

[LIST=1][*] Peux-tu m'expliquer ce que signifie ces deux lignes ? Je veux dire, je comprends ce qu'elles font grâce à tes commentaires, mais pourquoi on l'écrit comme ca ? Pourquoi l'étoile après la virgule et le % concernant le x et pourquoi l'étoile avant après le # mais juste avant la virgule pour le y ?

man bash parameter expansion

Substring removal

**Ezzmazz** · 28/12/2018, 11h39

Envoyé par zipe31

Salut,

man bash parameter expansion

Substring removal

Je n'ai pas encore le reflexe de regarder le man, mais j'y ai pensé en même temps que tu me renvoyais vers le manuel ! Merci à toi !

Bon, j'ai un début de solution :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
#!/bin/bash
 
 
#################### HEADER ####################
header_function()
{
echo ""
echo " +~ ---------------- Conway's Game of Life ---------------- ~+ "
echo ""
}
 
header_function
echo " How many lines ? "
echo -n " > "
read Lines
 
echo " How many columns ? "
echo -n " > "
read Columns
echo ""
 
declare -A tab
 
num_lines=$Lines
num_columns=$Columns
 
 
#################### ARRAY FUNCTION ####################
init_array_function()
{
for ((x=1;x<=num_lines;x++))
do
        for ((y=1;y<=num_columns;y++))
        do
                tab[$x,$y]=$(( RANDOM % 2 ));
        done
done
}
 
#################### DISPLAY FUNCTION ####################
display_function()
{
header_function
f1="%$((${#num_lines}+1))s"
f2="%3s"
 
printf "$f1"
for ((x=1;x<=num_lines;x++))
do
        printf "$f2" $x
done
echo
 
for ((y=1;y<=num_columns;y++))
do
        printf "$f1" $y
        for ((x=1;x<=num_lines;x++))
        do
                printf "$f2" ${tab[$x,$y]}
        done
        echo
done
}
 
 
#################### CELL FUNCTION ####################
#cell_function()
#{
#init_array_function
#display_function
#coord_function
#}
 
 
#################### ASK COORDINATES ####################
coord_function()
{
init_array_function
echo ""
while true
do
        echo -n " + Place your cell using the array coordinates ( like '1,1' ) or press 's' to start : "
        read coord
 
        if [ $coord = "s" ]
        then
                echo " Goodbye ! "
                exit
        else
 
                if [[ "$coord" =~ ^[0-9]+,[0-9]+$ ]] ; then x=${coord%, *} ;  y=${coord#*, } ;
                if [[ $x -ge 1 ]] && [[ $x -le 9 ]] && [[ $y -ge 1 ]] && [[ $y -le 9 ]]
                then
                        echo " >  Coordinates confirmed for "$coord". "
                        tab[$coord]="o"
                        echo ""
                        display_function
                        echo ""
                else
                        echo ""
                        echo -e " \033[91m> Error ! Coordinates are out of the grid ! Retry ! <\033[0m "
                        echo ""
                        coord_function
                fi
                fi
        fi
done
display_function
}
init_array_function
display_function
coord_function
#cell_function

Pour le moment :

J'arrive à demander une saisie de coordonnées à l'utilisateur.
Le tableau s'affiche bien en remplaçant le 0 ou le 1 par le o si les coordonnées sont exactes, sinon ça met un message d'erreur et ça recommence !

Je suis sur la bonne voie, je continue ! Je posterai ici mon avancée et/ou mes questions si j'en ai encore !

Merci à vous !

**Ezzmazz** · 31/12/2018, 11h26

Bonjour !

Voilà où j'en suis :

J'ai déclarer un nouveau tableau " tabfutur " et fait une fonction " init_tabfutur_fu tableau ". Ce tableau est temporaire et permet de mettre le futur etat de chaque cellule du tableau actuel.
J'ai déclaré une variable " Counter " qui est égale à 0 et qui va avec une fonction " living_cell_function " qui retournera le nombre de cellules vivantes autour de la cellule.

De ce fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
init_tabfutur_function()
{
 
for ((x=1;x>=num_lines;x++))
do
        for ((y=1;y>num_columns;y++))
        do
                tabfutur[$x,$y]="";
        done
done
 
}
 
living_cell_function()
{
if ((x>0;x<$num_lines-1;y>0;y<$num_columns-1))
then
        if tab[$x-1,$y+1]="o"; then let Counter++ ; fi # La variable Counter est déclarée plus haut dans mon code général.
        if tab[$x,$y+1]="o" ; then let Counter++ ; fi
        if tab[$x+1,$y+1]="o" ; then let Counter++ ; fi
        if tab[x-1,y]="o" ; then let Counter++ ; fi
        if tab[$x+1,y]="o" ; then let Counter++ ; fi
        if tab[$x-1,$y-1]="o" ; then let Counter++ ; fi
        if tab[$x,$y-1]="o" ; then let Counter++ ; fi
        if tab[$x+1,$y-1]="o" ; then let Counter++ ; fi
fi
}

J'ai un énorme doute sur la synthaxe de mon de code :

N'est-il pas necessaire de mettre des crochets ou des parenthèses aux conditions de mon if ? Par exemple : if [ $tab[$x-1,$y+1] -eq "o" ] ou un quelque chose dans ce genre ? Car j'ai l'impression que les -1 ou +1 que je donne au x ou au y ne sont pas pris en compte.

Qu'en pensez-vous ?

**BufferBob** · 31/12/2018, 12h15

une syntaxe comme celle-ci fonctionne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if [[ "${tab[$((x+1)),$((y-1))]}" = "o" ]]; then ((Counter++)); fi

(et après on dit de Perl que c'est un langage moche et cryptique...

)

**Ezzmazz** · 01/01/2019, 09h19

Bonjour !

Tout d'abord, une excellente année à vous et aux personnes qui m'ont aidé sur ce poste ! C'est très sympa !

Merci pour cette proposition de correction synthaxique.

Voici ce qu'on m'a conseillé de faire, pour que vous puissiez comprendre ce que j'essaie de faire :

Il te faut un tableau futur, que tu rempliras en fonction de ton tableau actuel. Si on considère que ton tableau contient L cellules en largeur et H cellules en hauteurs, si ton tableau commence à indice 0, on initialise un compteur cpt à 0.

Si tu n’es pas sur un bord (x>0,x<L-1,y>0,y<H-1)
alors
on teste les cellules au dessus :

si tab[x-1,y+1] pas vide
alors cpt++
si tab[x,y+1] pas vide
alors cpt++
si tab[x+1,y+1] pas vide
alors cpt++

on teste les cellule de chaque cote:
si tab[x-1,y] pas vide
alors cpt++
si tab[x+1,y] pas vide
alors cpt++

on teste les cellule en dessous:
si tab[x-1,y-1] pas vide
alors cpt++
si tab[x,y-1] pas vide
alors cpt++
si tab[x+1,y-1] pas vide
alors cpt++

si cpt = nbcellule pour vie
alors tabFutur[x,y]=vie

si cpt = nbcellule pour pour
alors tabFutur[x,y]=mort

Puis traiter les cas pour les bords. Le faire pour chaque cellule et remplacer tab par tabFutur

Certaines choses restent encore un peu flou pour moi. De ce fait, je propose cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
init_tabfutur_function()
{
 
for ((x=1;x>=num_lines;x++))
do
        for ((y=1;y>num_columns;y++))
        do
                tabfutur[$x,$y]="";
        done
done
display_function
}

Pas trop de probème ici, c'est exactement la même boucle que la prmière, j'ai juste renommé mon tableau en " tabfutur " et je ne l'ai laissé vide.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
living_cell_function()
{
init_tabfutur_function
for ((x=1;x<=num_lines+1)) && ((y=1;y<=num_columns-1))
do
        if [[ "${tab[$((x-1)),$((y+1))]}"="o" ]] ; then ((Counter++)) ; fi
        if [[ "${tab[$((x)),$((y+1))]}"="o" ]] ; then ((Counter++)) ; fi
        if [[ "${tab[$((x+1)),$((y+1))]}"="o" ]] ; then ((Counter++)) ; fi
        if [[ "${tab[$((x-1)),$((y))]}"="o" ]] ; then  ((Counter++)) ; fi
        if [[ "${tab[$((x+1)),$((y))]}"="o" ]] ; then  ((Counter++)) ; fi
        if [[ "${tab[$((x-1)),$((y-1))]}"="o" ]] ; then  ((Counter++)) ; fi
        if [["${tab[$((x)),$((y-1))]}"="o" ]] ; then  ((Counter++)) ; fi
        if [[ "${tab[$((x+1)),$((y-1))]}"="o" ]] ; then ((Counter++)) ; fi
done
display_function
}

Plus compliqué pour moi ici. La ligne " Si tu n'es pas sur un bord (x>0, x<L-1, y>0,y<H-1) " est totalement flou pour moi car ne je n'ai jamais vu un if écrit comme celà en bash. Du coup j'ai fait une boucle for, mais même cette boucle me semble... Bizarre !

Auriez-vous une quelques indications, conseils à me donner afin que je puisse finaliser ce jeu de la vie ?

**Ezzmazz** · 03/01/2019, 16h05

Bonjour !

Il y a de l'évolution ! Ça commence à être bon pour mon script ! Voici où j'en suis :

- Je demande le nombre de colonnes et de lignes au début
- Je demande aussi la forme de la cellule ( ça c'est pour moi, au lieu de mettre des o partout, j'ai fait une variable CELL à laquelle j'attribue la forme que je veux ! Ça m'évite de devoir changer tous les caractères a chaque que je veux en essayer un nouveau !

)

Voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
#!/bin/bash
 
echo ""
echo "+~ ----------------------- Conway's Game of Life --------------------- ~+"
echo "|                                                                       |"
echo "|    This is the Bash script version of John Conway's "Game of Life".     |"
echo "|       "Life" is a simple implementation of cellular automata.           |"
echo "|                                                                       |"                      
echo "| --------------------------------------------------------------------- |"
echo "|                                                                       |"
echo "|                                  Rules :                              |"
echo "|                                                                       |"
echo "|  1) A living cell with either 2 or 3 living neighbors remains alive.  |"
echo "|                                                                       |"
echo "|          2) A dead cell with 3 living neighbors comes alive.          |"
echo "|                                                                       |"
echo "|   3) All other cases result in a dead cell for the next generation.   |"
echo "|                                                                       |"
echo "+ --------------------------------------------------------------------- +"
echo ""
echo ""
 
read -p "> Press any key to continue ... "
clear
 
#################### HEADER ####################
header_function()
{
echo ""
echo " +~ ---------------- Conway's Game of Life ---------------- ~+ "
echo ""
}
 
header_function
echo " How many lines ? "
echo -n " > "
read -r Lines
 
echo ""
 
echo " How many columns ? "
echo -n " > "
read -r Columns
 
echo ""
 
echo " Cell's form ? "
echo -n " > "
read -r CELL
 
declare -A tab
declare -A tabfutur #Test => Tableau temporaire qui va recevoir le futur etat de chaque cellule.
 
num_lines=$Lines
num_columns=$Columns
CELL=$CELL
 
#################### ARRAY FUNCTION ####################
init_array_function()
{
for ((x=1;x<=num_lines;x++))
do
    for ((y=1;y<=num_columns;y++))
    do
            tab[$x,$y]=".";
    done
done
}
 
init_tabfutur_function()
{
for ((x=1;x<=num_lines;x++))
do
    for ((y=1;y<=num_columns;y++))
    do
            tabfutur[$x,$y]="";
    done
done
}
 
#################### DISPLAY FUNCTION ####################
display_function()
{
#header_function
clear
echo ""
f1="%$((${#num_lines}+1))s"
f2="%3s"
 
printf "$f1"
for ((x=1;x<=num_lines;x++))
do
    printf "$f2" $x
done
echo
 
for ((y=1;y<=num_columns;y++)) 
do
    printf "$f1" $y
    for ((x=1;x<=num_lines;x++))
    do
            printf "$f2" ${tab[$x,$y]}
    done
    echo
done  
}
 
#################### ASK COORDINATES ####################
coord_function()
{
init_array_function
echo ""
echo ""
while : 
do
    echo ""
    echo -n " + Place your cell using the array coordinates ( like '1,1' ) or press 's' to start : "
    read -r coord
 
    if [ "$coord" == "s" ]
    then
            array_analyze_function
    else
 
            if [[ "$coord" =~ ^[0-9]+,[0-9]+$ ]] ; then x=${coord%, *} ;  y=${coord#*, } ;
            #if [[ $x -ge 0 ]] && [[ $x -le 9 ]] && [[ $y -ge 0 ]] && [[ $y -le 9 ]]
            #then
                    #echo " >  Coordinates confirmed for $coord".
                    tab[$coord]="${CELL}"
                    display_function
                    echo ""
            #else
             #       echo 
             #      echo -e " \033[91m> Error ! Coordinates are out of the grid ! Retry ! <\033[0m "
            #       echo                    
            #fi
            fi
    fi
done
display_function
}
 
################################ STARTING LIFE  ################################
start_function()
{
array_analyze_function
}
 
################################ ARRAY ANALIZE  ################################
array_analyze_function()
{
tput civis
while true
do
    for ((x=1;x<=num_lines;x++))
    do
            for ((y=1;y<=num_columns;y++))
            do
 
            Counter=0
            #tabfutur[$x,$y]="";
 
            # Voisine (x-1,y-1)
            [[ "${tab[$(($x-1)),$(($y-1))]}" == $CELL ]] && ((Counter++))
 
            # Voisine (x,y-1)
            [[ "${tab[$(($x)),$(($y-1))]}" == $CELL ]] && ((Counter++))
 
            # Voisine (x+1,y-1)
            [[ "${tab[$(($x+1)),$(($y-1))]}" == $CELL ]] && ((Counter++))
 
            # Voisine (x-1,y)
            [[ "${tab[$(($x-1)),$(($y))]}" == $CELL ]] && ((Counter++))
 
            # Voisine (x+1,y)
            [[ "${tab[$(($x+1)),$(($y))]}" == $CELL ]] && ((Counter++))
 
            # Voisine (x-1,y+1)
            [[ "${tab[$(($x-1)),$(($y+1))]}" == $CELL ]] && ((Counter++))
 
            # Voisine (x, y+1)
            [[ "${tab[$(($x));$(($y+1))]}" == $CELL ]] && ((Counter++))
 
            # Voisine (x+1,y+1)
            [[ "${tab[$(($x+1)),$(($y+1))]}" == $CELL ]] && ((Counter++))
 
            # Si vivante et deux voisines, elle survit
            [[ ${tab[$(($x)),$(($y))]} == $CELL ]] && [[ ${Counter} -eq 2 ]] && tab[{x},${y}]=$CELL
 
            # Si 3 voisines, soit survie, soit naissance 
            [[ ${Counter} -eq 3 ]] && tab[${x},${y}]=$CELL
 
            # Si entre 4 et 8, mort par surpopulation
            [[ ${Counter} -ge 4 ]] && [[ ${Counter} -le 8 ]] && tab[${x},${y}]="."
 
            done
    done
 
 
  for ((x=1;x<=num_lines;x++))
            do
                    for ((y=1;y<=num_columns;y++))
                    do
                            tab[$x,$y]=${tabfutur[$x,$y]};
                            display_function
                    done
            done
done
}
 
init_array_function
display_function
coord_function

Il n'est pas encore parfait, mais ça ressemble à quelque chose au moins !

Maintenant, les derniers problèmes sont :

- Pouvoir gérer les bordures
- Voir pourquoi l'évolution des cellules s'arrête en plein milieu

Merci pour l'aide que vous m'avez apporté !

**Flodelarab** · 03/01/2019, 16h31

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
echo " Cell's form ? "
echo -n " > "
read -r CELL

3 instructions qui peuvent être résumées en 1, avec l'option -p :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
read -r -p " Cell's form ? 
 > " CELL

**Ezzmazz** · 04/01/2019, 10h55

Merci bien pour cette correction !

Jeu de la vie en bash

Shell et commandes GNU

Discussions similaires

Partager

Partager