Automate cellulaire : simulation de feu de forêt

rem ============================================================================
rem     Automate cellulaire : simulation de feu de forêt
rem            Par papydall : Mars 2017
rem ============================================================================
rem &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
rem ============================================================================
rem Un automate cellulaire est une grille à maillage carrée. Nous représenterons
rem cette grille par un tableau en deux dimensions.
rem Chaque case du tableau est appelée cellule.
rem Chaque cellule peut être dans un certain état.
rem Dans la simulation de feu de forêts, il y en a 4 (vide, arbre, feu ou cendre).
rem ============================================================================
rem Un automate cellulaire est un objet dynamique, qui change au cours du temps
rem selon certaines règles. Ces changements concernent chacune des cellules.
rem A la date t+1, l’état de toutes les cellules doit être recalculé et dépend
rem uniquement des règles de transition et de l’état de ces cellules aux dates
rem antérieures.
rem En ce qui nous concerne, l’état d’une cellule particulière dépendra uniquement
rem de l’état de ses cellules voisines (et d’elle même) à la date précédente.
rem Nous pourrons considérer en revanche plusieurs types de voisinage, comme le
rem voisinage de Moore (8 voisins) ou le voisinage de Von Neumann (4 voisins).
rem ============================================================================
rem Pour la simulation de feu de forêt, les règles de changement d’état sont :
rem Vide   => Vide
rem Feu    => Cendre
rem Cendre => Cendre
rem Arbre  => Feu si un voisin est en feu et Arbre => Arbre sinon
rem ============================================================================
rem On choisit de représenter chaque état par un carré de couleur différente.
rem Vide   : Noir
rem Arbre  : Vert
rem Feu    : Rouge
rem Cendre : Gris
rem ============================================================================
rem Améliorations possibles du programme :
rem * Faire intervenir la vitesse du vent
rem * Soigner la disposition aléatoire des arbres, ajout des clairières.
rem ============================================================================
rem &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
rem ============================================================================

Init()
repeat
    Feu()
    Afficher()
until scancode = 27 or incendie = 0
if incendie = 0 then caption 6, "Le feu a cessé de se propager"

end
rem ============================================================================
SUB Init()
    dim n : n = 30 : ' Constante à modifier
    dim tablo1(n+1,n+1), tablo2(n,n)
    dim vide   : vide   = 0
    dim arbre  : arbre  = 1
    dim feu    : feu    = 2
    dim cendre : cendre = 3
    dim cote, demi_cote
    dim i,j,etat
    dim incendie : ' flag indiquant la propagation du feu (= 1) ou sa cessation (= 0)
    width 0,600 : height 0,600 : color 0,200,150,100
    top 0,(screen_y-width(0))/2 : left 0,(screen_x-width(0))/2
    alpha 5 : font_bold 5 : font_name 5,"arial" : font_size 5,18 : left 5,15 : top 5,10
    alpha 6 : font_bold 6 : font_name 6,"arial" : font_size 6,18 : left 6,15 : top 6,50
    picture 10 : width 10,200 : height 10,200
    top 10,200 : left 10,200 : 2d_target_is 10
    caption 5,"Automate cellulaire : simulation de feu de forêt"
    caption 0,"<ESC> pour arrêter"
    cote = width(10)/n : demi_cote = cote / 2
' Initialiser les cases
    for i = 1 to n
        for j = 1 to n
            tablo1(i,j) =  int(rnd(2))  : ' Vide ou Arbre
        next j
    next i
    i = int(rnd(n)+1) : j = int(rnd(n)+1)
    tablo1(i,j) = feu  : ' Cellule de feu
    
END_SUB
rem ============================================================================
SUB Afficher()
    dim_local x,y
    2d_fill_on
    for i = 1 to n
        for j = 1 to n
            select tablo1(i,j)
                case 0 : 2d_pen_color 000,000,000 : 2d_fill_color 000,000,000 : ' vide
                case 1 : 2d_pen_color 000,255,000 : 2d_fill_color 000,255,000 : ' arbre
                case 2 : 2d_pen_color 255,000,000 : 2d_fill_color 255,000,000 : ' feu
                case 3 : 2d_pen_color 128,128,128 : 2d_fill_color 128,128,128 : ' cendre
            end_select
' Transformer les coordonnées i,j du tableau en coordonnées x,y de l'écran
            x = (i-1) * cote : y = (j-1) * cote
            2d_rectangle x,y,x+cote,y+cote
        next j
    next i

END_SUB
rem ============================================================================
SUB Feu()
    incendie = 0
    for i = 1 to n
        for j = 1 to n
            evolution(i,j)
            tablo2(i,j) = etat
        next j
    next i
    for i = 1 to n
        for j = 1 to n
            tablo1(i,j) = tablo2(i,j)
            if tablo1(i,j) = 2 then incendie = 1
        next j
    next i
    
END_SUB
rem ============================================================================
' Déterminer l'état suivant de la case(i,j) qui dépent de tablo1(i,j), des cases
' voisines et des règles de transition
SUB Evolution(i,j)

    if tablo1(i,j) = vide   then etat = vide   : exit_sub
    if tablo1(i,j) = feu    then etat = cendre : exit_sub
    if tablo1(i,j) = cendre then etat = cendre : exit_sub
    if tablo1(i,j) = arbre
       if (tablo1(i-1,j) = feu) or (tablo1(i+1,j) = feu)  or (tablo1(i,j-1) = feu) or (tablo1(i,j+1) = feu) or(tablo1(i-1,j+1) = feu) or (tablo1(i+1,j+1) = feu) or (tablo1(i-1,j-1) = feu) or (tablo1(i+1,j-1) = feu)
          etat = feu
       else
          etat = arbre
       end_if
    end_if
END_SUB
rem ============================================================================