Discussion :

[ismaa]

Bonjour je souhaiterais créé un automate cellulaire avec tkinter :
Voici les règles : le temps est discret. On execute les cellules dans un ordre que vous fixerez.
Executer une cellule signifie faire ´evoluer le passager qui est dans la cellule
si il n’est pas encore arriv´e `a sa destination et qu’il peut bouger.
un passager avance dans le couloir de 1 cellule par unit´e de temps si il
n’y a personne sur la cellule suivante. Sinon il est bloqu´e pendant cet
intervalle de temps.
il y a une seule entrée dans l’avion et un seul passager peut entrer par
unit´e de temps. D`es que l’entr´ee est vide, un nouveau passager arrive si
l’avion n’est pas plein (il y a 180 si`eges et donc 180 passagers qui doivent
arriver à leur siège).
Je ne sais pas par ou commencer, quelqu'un pourrait m'aider ? Merci d'avance.

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
import tkinter as tk
import random as rd
 
################################ INITIALISATION
screen = tk.Tk()
screen.title("Simulation avion")
 
################################# CONSTANTES
SIEGES_VIDES = "steel blue"
COULOIR = "light steel blue"
ZERO_BAGAGE = "yellow"
UN_BAGAGE = "orange"
DEUX_BAGAGES = "red"
SIEGES_OCCUPEES = "green"
LARGEUR = 140
HAUTEUR = 600
 
# Longeur des carrés qui constituent le quadrillage
COTE = 20
NB_COl = LARGEUR // COTE
NB_LINE = HAUTEUR // COTE
 
################################# VARIABLES
# Initialisations des listes et des variables
tableau = None
coordonnées = None  # Numéros des places dans l'avion
liste_passagers = None  # Liste des 180 passagers
voisins_milieu = 0
voisins_gauche = 0
voisisns_droite = 0
 
 
################################# FONCTIONS
def sieges_couloir():
    global COTE, SIEGES, COULOIR
    """Création des sièges de l'avion et du couloir de l'avion"""
    for i in range(7):  # Création des colonnes
        for j in range(30):  # Création des lignes
            celule = canvas.create_rectangle(i * COTE, j * COTE, (1 + i) * COTE, (1 + j) * COTE, fill="blue")
            if i == 3:
                canvas.itemconfig(celule, fill=COULOIR)
 
 
def coordonnees_sieges():
    """Attribue une coordonnée à chaques sièges de l'avion sous forme
    de tableau à deux dimensions"""
    coordonnées = []
    for col in range(1, 4):
        for line in range(1, 31):
            coordonnées.append([col, line])  # Sièges à gauche du couloir
    for col in range(4, 8):
        for line in range(1, 31):
            coordonnées.append([col, line])  # Sièges à droite du couloir
    return coordonnées
 
 
def tableau_2D():
    """Création d'un tableau à deux dimension permettant de connaître
    le rôle de chaque celule, le couloir est initilisé à 0, tandis
    que les sièges sont initialisés à 1"""
    global tableau
    tableau = []
    for i in range(NB_COl):
        if i == 3:
            tableau.append([0] * NB_LINE)  # Couloir
        else:
            tableau.append([1] * NB_LINE)  # Sièges
    return tableau
 
 
def création_passagers_bagages():
    """Création des 180 passagers numéroté de 0 à 179 à qui on affecte un chiffre
    entre 0 et 2 qui correspond au nombre de bagage(s) et une place au sein de l'avion"""
    global coordonnées
    liste_passagers = []
    place = []
    max_nb_hasard = 179
    nb = 0
    for passagers in range(180):
        liste_passagers.append([passagers])  # Donne un numéro à chaque passager entre 0 et 179
        for bagages in range(1):
            liste_passagers[passagers].append(rd.randint(0, 2))  # Donne entre 0 et 2 bagages aléatoirement
    for i in range(1, 8):  # Création des coordonnées des places de l'avion
        if i == 4:  # Exclus la colonne du couloir pour avoir les coordonnées des 180 sièges
            continue
        for j in range(1, 31):
            place.append([i, j])  # Ajoute les coordonnées dans la liste place
    for i in range(180):
        nb_hasard = rd.randint(0, max_nb_hasard)  # Choisi un nombre au hasard
        liste_passagers[nb].append(place[
                                       nb_hasard])  # Ajoute la coordonnée dans la liste liste_passagers à partir de l'indice donné aléatoirement par nb_hasard
        del place[nb_hasard]  # Supprime la coordonnée de la liste place
        max_nb_hasard -= 1
        nb += 1
    return liste_passagers
 
 
def voisins_couloir():
    """Examine le couloir de l'avion pour savoir si les passagers ont
    des voisins devant eux"""
    global tableau
    voisins_milieu = 0
    for v in range(3, 4):
        for w in range(NB_LINE):
            if tableau[v][w] != 0 and [v, w] != [i, j]:
                voisins_milieu += 1
    return voisins_milieu
 
 
def voisins_sièges_gauche():
    """Examine les sièges à gauche du couloir pour voir si un passager
    est déjà placé"""
    global tableau
    voisins_gauche = 0
    for v in range(0, 3):
        for w in range(NB_LINE):
            if tableau[v][w] != 0 and [v, w] != [i, j]:
                voisins_gauche += 1
    return voisins_gauche
 
 
def voisins_sièges_droite():
    global tableau
    """Examine les sièges à droite du couloir pour voir si un passager
    est déjà placé"""
    voisins_droite = 0
    for v in range(4, 7):
        for w in range(NB_LINE):
            if tableau[v][w] != 0 and [v, w] != [i, j]:
                voisins_droite += 1
    return voisins_droite
 
 
def legende():
    """Création d'une légende pour définir chaques carrés de couleur"""
    canvas.create_rectangle((180, 40), (200, 60), fill=SIEGES_VIDES)
    leg_siege = tk.Label(screen, text="Siège", font="Arial")
    leg_siege.grid(column=1, row=0)
 
    canvas.create_rectangle((180, 140), (200, 160), fill=COULOIR)
    leg_couloir = tk.Label(screen, text="Couloir", font="Arial")
    leg_couloir.grid(column=1, row=1)
 
    canvas.create_rectangle((180, 240), (200, 260), fill=ZERO_BAGAGE)
    leg_zero_bagage = tk.Label(screen, text="Passager avec aucun bagage", font="Arial")
    leg_zero_bagage.grid(column=1, row=2)
 
    canvas.create_rectangle((180, 340), (200, 360), fill=UN_BAGAGE)
    leg_un_bagage = tk.Label(screen, text="Passager avec un bagage", font="Arial")
    leg_un_bagage.grid(column=1, row=3)
 
    canvas.create_rectangle((180, 440), (200, 460), fill=DEUX_BAGAGES)
    leg_deux_bagage = tk.Label(screen, text="Passager avec deux bagages", font="Arial")
    leg_deux_bagage.grid(column=1, row=4)
 
    canvas.create_rectangle((180, 540), (200, 560), fill=SIEGES_OCCUPEES)
    leg_place = tk.Label(screen, text="Passager assis à sa place", font="Arial")
    leg_place.grid(column=1, row=5)
 
 
################################# PROGRAMME PRINCIPALE
canvas = tk.Canvas(screen, width=280, height=600, borderwidth=0, highlightthickness=0, bg="black")
sieges_couloir()
legende()
 
################################# PLACEMENT DES WIDGETS
canvas.grid(column=0, row=0, rowspan=6)
 
################################# FIN DE LA BOUCLE
screen.mainloop()

[wiztricks]

Salut,

Toute la question est de (savoir) traduire l'état du tas cellules à l'instant t et calculer leur état en t+1.

Déjà vous avez un soucis de conception: soit un siège est une cellule qui sera occupée ou pas par un passager (et donc une cellule pouvant avoir plusieurs états), soit on a sièges , passagers et cellules comme entités indépendantes (et pas sûr que le problème mérite un tel bazar).

Dans tous les cas, la conception n'est pas un problème tkinter ou Python: c'est le truc à penser avant de coder...

Et on peut coder trivialement un tableau de cellules (certaines étant sièges, couloir) occupées ou pas par des passagers.

A l'instant t, on dessine l'état des cases correspondantes sur le Canvas.
Puis on calcule l'état en t+1.
Et côté tkinter, on efface le contenu du Canvas pour dessiner l'état du tableau.
Et on recommence jusqu'à une condition d'arrêt (genre tous les passagers sont assis).

- W

[ismaa]

Bonsoir, merci de votre réponse.
Ma question ne concerne pas vraiment la conception mais plutôt concrètement ce que je dois coder.
Vous avez une idée de comment coder cette automate cellulaire? Merci d'avance.

[wiztricks]

Salut,

Vous avez une idée de comment coder cette automate cellulaire?

Je vous l'ai déjà dit: à l'instant T vous avez un tableau de cellules dans un certain état.
Vous devez écrire une fonction qui calcule l'état de chaque cellule à l'instant T + 1.

Et avant de pouvoir écrire cette fonction, il va falloir réfléchir à ce qu'on va y mettre dedans.

A priori, les passagers entrent par une porte et se répartissent dans les 2 directions du couloir pour aller s'assoir. Probable qu'il soit inutile de regarder toutes les cellules mais propager les passagers qui progressent.

Ma question ne concerne pas vraiment la conception mais plutôt concrètement ce que je dois coder.

Ce que vous devez coder dépend de la conception: s'il n'y en a pas, on ne sait pas... Et si on ne sait pas ce qu'on veut coder, on ne peut rien écrire... et si on n'écrit rien, ce n'est pas encore un sujet Python/tkinter.

Pas grand monde va se prendre le chou à prendre un feuille de papier et un crayon pour concevoir ce qu'on peut faire dans ce cas à votre place.


- W

[ismaa]

Je vois ce que vous voulez dire, il serait possible si vous savez le faire d' écrire la fonction qui calcule l'état de chaque cellule à l'instant T + 1 avec l'algorithme que j'ai écris dans le premier message? Je vous en serais vraiment reconnaissant.

[wiztricks]

il serait possible si vous savez le faire d' écrire la fonction qui calcule l'état de chaque cellule à l'instant T + 1 avec l'algorithme que j'ai écris dans le premier message?

C'est à vous de le faire.

Vous pouvez (essayer de) commencer "petit" en imaginant comment déplacer un seul passager de l'entrée à son siège. Cela devrait vous donner une idée de la fonction qui partant d'un passager à la position (i, j) à l'instant t calcule sa position en t+1.

- W