Code automate cellulaire : object "_" has no attribute ' _ '

import tkinter as tk
import random
import math
from enum import IntEnum
from random import randint as EntAléa

class Etats(IntEnum):
    VIDE = 0
    OBSTACLE = 1
    OCCUPEV = 2
    OCCUPEM = 3

class Espace(IntEnum):
    NORMAL = 0
    FEU = 1

class ModeleEvacuation:
    SHOW_GRILLE = True

    PAS = 1000
    TMAX = 1200
    HAUTEUR = 100
    LARGEUR = 100
    COTE = 8

    NB_PERSONNES = 50
    NB_OBSTACLES = 0

# Initialisation

    npersonnes = 0
    nobstacles = 0


    def __init__(self):
        self.gen = 0
        self.nb_personnes_initial = self.NB_PERSONNES
        self.nb_obstacles_initial = self.NB_OBSTACLES

        self.tab = [[[] for _ in range(self.LARGEUR)] for _ in range(self.HAUTEUR)]

        self.environnement = [[[Etats.VIDE,0,0,0,0,0,0,0, Terrain.NORMAL] for _ in range(self.LARGEUR)]
                                for _ in range(self.HAUTEUR)]

        self._initialisation()

    def remplir():
        x = EntAléa(0,self.HAUTEUR - 1)
        y = EntAléa(0,self.LARGEUR - 1)
        if self.environnement[x][y][Indices.ETAT] is Etats.VIDE:
            remplir()
        else:
            self.environnement[x][y][Indices.ETAT] = Etats.OCCUPEV

    def _initialisation(self):

        if self.nb_personnes_initial + self.nb_obstacles_initial > self.HAUTEUR * self.LARGEUR:
            raise ValueError("Paramètres incompatibles")

        for _ in range (self.nb_personnes_initial):
            remplir()


    def cases_voisines(self, x:int, y:int, etat:Etats):
        """ Retourne la liste des cases adjacentes à la case donnée en paramètre (Voisinage de Moore de rayon 1)
        et contenant le type d'état recherché
        : param x : abscisse de la case à considérer
        : param y : ordonnée de la case à considérer
        : param etat : le type d'etat à considérer
        """
        entourage = [(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1),(0,-1),(1,-1)]
        v = []
        for case_x , case_y in entourage:
            if (0 <= (x+case_x) < self.HAUTEUR and 0 <= (y+case_y) < self.LARGEUR
                    and self.environnement[x+case_x][y+case_y][Indices.ETAT] is etat):
                v.append((x+case_x, y+case_y))
        return v

    def obstacle(self, x:int, y:int, p: float):
        """
        une personne tombe aléatoirement et ralentit l'évacuation
        peut faire tomber aléatoirement les personnes à proximité avec une probabilité décroissante

        """
        if self.nobstacles <= self.nb_obstacles_initial and self.environnement [x][y] == Etats.OCCUPEV :
            self.nobstacles += 1
            self.environnement[x][y][Indices.ETAT] = OCCUPEM

            for v_x,v_y in self.cases_voisines(x,y,Etats.OCCUPEV):
                r = random.random()
                if r < p:
                    self.obstacle(v_x,v_y, self, 0.5*p)

    def comportement_personnes(self,x:int,y:int):
        v = self.cases_voisines(x,y,Etats.VIDE)
        if not v:
            return
        a,b = random.choice(v)
        self.environnement[a][b][Indices.ETAT] = Etats.OCCUPEV
        self.environnement[x][y][Indices.ETAT] = Etats.VIDE

    def transformations(self):

        for x in range(self.LARGEUR):
            for y in range(self.HAUTEUR):
                case = self.environnement[x][y]
                if case[Indices.ETAT] is Etats.OCCUPEV:
                    self.comportement_personnes(x,y)
        self.gen += 1

class RepresentationTourParTour:
    def __init__(self, modele: ModeleEvacuation, app: tk.Tk):
        self.modele = modele
        self.canvas = tk.Canvas(app, width = self.modele.COTE * self.modele.LARGEUR,
                                    height = self.modele.COTE  * self.modele.HAUTEUR,
                                    highlightthickness = 0)
        self.canvas.pack()

        for y in range(self.modele.LARGEUR):
            for x in range(self.modele.HAUTEUR):
                self.modele.tab[x][y] = self.canvas.create_rectangle((x*self.modele.COTE,
                                            y*self.modele.COTE, (x+1)*self.modele.COTE,
                                            (y+1)*self.modele.COTE), outline = "white", fill = "white")

    def update_representation(self):

        for x in range(self.modele.LARGEUR):
            for y in range(self.modele.HAUTEUR):
                case = self.modele.environnement[x][y]
                if case[Indices.ETAT] is Etats.VIDE:
                    couleur = "white"
                elif case[Indices.ETAT] is Etats.OCCUPEV:
                    couleur = "spring green"
                elif case[Indices.ETAT] is Etats.OCCUPEM:
                    couleur = "red"
                elif case[Indices.ETAT] is Etats.OBSTACLE:
                    couleur = "dim grey"
                else:
                    raise ValueError("valeur inattendue pour case ({x},{y}): {case}")
                self.canvas.itemconfig(self.modele.tab[x][y], fill = "couleur")

def main():
    app = tk.Tk()
    app.wm_title("test")
    modele = ModeleEvacuation
    rtpt = RepresentationTourParTour(modele,app)

    def loop():
        if ModeleEvacuation.SHOW_GRILLE:
            rtpt.update_representation()
        modele.transformations()
        if modele.gen >= modele.TMAX:
            print("fin")
            return
        app.after(ModeleEvacuation, PAS, loop)

    loop()
    app.mainloop()