Lorsque l'on veut commencer à programmer un programme assez complet, il faut commencer par s'organiser. Ici, je sépare le projet en deux grandes parties :
Le programme principal qui affiche l'interface et qui interagit avec l'utilisateur. Le moteur de l'application qui va permettre de lancer les simulations.
Je vais donc créer un fichier/module pour chacune de ces parties. Je sépare ainsi l'interface du moteur de l'application. En général, cela permet de refaire une interface sans avoir à modifier son application lorsque celle-ci ne nous plaît pas ou si l'on souhaite développer une interface graphique plus tard par exemple. Le moteur pourra être réutilisé indépendant de l'interface par la suite. Ainsi, je pourrais améliorer mon programme sans jamais avoir à refaire un moteur de simulation !
J'ai donc créé les fichiers qu'il me faudra pour mon programme et je commence à organiser les fonctions qui me seront sûrement utiles. Cela me permet de prédécouper mon code et donc de mieux réfléchir à ce que je veux faire à petite échelle.
Moteur.py
Secret (cliquez pour afficher)
Code : Python #################################### # Jeu de la vie # # --- # # Auteur : Suzy # # Créé le : 09/07/2010 # # --- # # Ce petit programme de simulation # # permet de modéliser une forme de # # vie simplicime ! Vous pourrez y # # voir apparaître des formes qui # # se perpétuent dans le temps ou # # qui restent constantes. #
# --- # # Moteur du jeu de la vie : #
# Contient toutes les fonctions # # qui permettent d'effectuer des # # opérations sur la grille et # # d'émuler la vie ! #
####################################
from random import random #Constantes :
FORMES_POSSIBLES = ("plan","cylindre","tore")
def creerGrille(lignes = 20, colonnes = 20, proba = 0.5) : """
Permet de créer une grille du nombre de lignes et de colonnes spécifiées. Les cellules seront vivantes selon la probabilité données en paramètre.
lignes = 20 : Le nombre de lignes pour la grille. colonnes = 20 : La nombre de colonnes pour la grille.
proba = 0.5 : La probabilité qu'une cellule créée soit vivante. Retourne : Retourne une grille de lignes x colonnes cellules aléatoirement vivantes.
""" pass
def chargerGrille(nomFichier) : """
Permet de charger une grille à partir d'un fichier. Le fichier doit être composé de lignes de 0 (mort) et de 1 (vivant). Si elles ne sont pas toutes de la même taille, une exception sera levée.
nomFichier : Le chemin vers le fichier à charger. Retourne : La grille chargée à partir du fichier. Exception : - IOError : Si le fichier n'existe pas.
- ValueError : quelque chose n'est pas un nombre dans la grille. - AssertionError : un nombre différent de 0 ou 1.
- AssertionError : lignes de différentes longueurs. - AssertionError : une seule ligne dans le fichier. - AssertionError : pas de cellule vivante.
""" pass
def sauvegarderGrille(grille, nomFichier) : """
Permet d'enregistrer une grille dans un fichier qui pourra être chargé par la suite. Le fichier sera préalablement effacé s'il existe déjà.
grille : La grille à sauvegarder.
nomFichier : Le nom du fichier à utiliser pour la sauvegarde. Retourne : 0 si l'opération s'est bien passée, 1 sinon.
""" pass
def voisines(grille, i, j, forme) : """
Permet d'obtenir une liste des voisines d'une cellule aux coordonnées
demandées dans une grille demandée. La forme du modèle est prise en compte.
grille : La grille contenant la cellule à étudier. i : L'indice de la ligne de la cellule.
j : L'indice de la colonne de la cellule.
forme : La forme du modèle (plan, cylindre, tore).
Retourne : La liste des voisines de la cellule demandée. Exception : - IndexError si i et/ou j sort de la grille. - AssertionError si la forme demandée n'est pas reconnue. """
pass
def tourSuivant(grille, regle1 = 3, regle2 = 2, forme = "tore") : """
Permet de créer le tour suivant de la grille en fonction des
règles en vigueur dans la source de vie que vous avez créée. grille : La grille de cellules à faire évoluer.
regle1 = 3 : Le nombre de cellules à avoir pour qu'une cellule soit vivante au prochain tour.
regle2 = 2 : Le nombre de cellules à avoir pour qu'une cellule reste dans le même état au tour suivant.
forme = "plan" : Le modèle peut prendre différentes formes, soit un plan fermé ("plan"), soit un cylindre ("cylindre"),
soit un tore ("tore").
Change les voisines aux bords du modèle.
Retourne : Retourne la nouvelle grille après évolution.
Exception : AssertionError : la forme donnée n'est pas reconnue. """
pass
def encoreDeLaVie(grille) : """
Permet de savoir si la grille contient encore de la vie ou non. grille : La grille a tester.
Retourne : Retourne True si la grille contient de la vie, False sinon.
""" pass
JeuDeLaVie.py
Secret (cliquez pour afficher)
Code : Python #################################### # Jeu de la vie # # --- # # Auteur : Suzy # # Créé le : 09/07/2010 # # --- # # Ce petit programme de simulation # # permet de modéliser une forme de # # vie simplicime ! Vous pourrez y # # voir apparaître des formes qui # # se perpétuent dans le temps ou # # qui restent constantes. #
# --- # # Programme principal : # # - Grille # # - Interface # # - Options # #################################### #Importation de mes modules perso :
import Moteur
#Importation des modules intégrés :
import os, time, platform
def nettoyerConsole() : """
Permet de nettoyer la console ! """
pass
def menuPrincipal() :
"""
Affiche le titre du programme avec un petit texte introductif. Affiche ensuite le menu principal et récupère le choix de l'utilisateur.
Lance ensuite la ou les simulations en fonction du choix... """
pass
def simuRapide() : """
Lance une simu rapide de 20x20 en forme de tore ou propose de revenir en arrière. """ pass def simuAvancee() : """
Propose de définir tout un tas de paramètres pour lancer une simulation ou de revenir en arrière. """ pass def aPropos() : """
Affiche quelques infos à propos du jeu de la vie. """
pass
def mesCredits() : """
Affiche les crédits. """
pass
def lancerSimulation(grille, regle1 = 3, regle2 = 2, forme = "tore") :
"""
Lance une simulation avec les règles et les options demandées. grille : La grille initiale.
regle1 = 3 : La règle de vie (combien de cellules vivantes pour naître)
regle2 = 2 : La règle de neutralité (combien de cellules vivantes pour rester
inchangé.
forme = "tore" : La forme à considérer pour la grille. """
pass
def lancerSimulationInfinie(grille, regle1, regle2, forme, pasAvantSauvegarde, nomFichier) :
"""
Lance une simulation infinie qui ne sera stoppée que si le modèle meurt ou si
l'utilisateur la tue !
grille : La grille initiale.
regle1 : La règle de vie (combien de cellules vivantes pour naître)
regle2 : La règle de neutralité (combien de cellules vivantes pour rester
inchangé.
forme : La forme à considérer pour la grille.
pasAvantSauvegarde : Le nombre de pas entre deux sauvegarde (0
pour ne pas sauvegarder).
nomFichier : Le nom du fichier de sauvegarde. """
pass
def afficherGrille(grille, tour) : """
Convertit une grille en chaîne de caractères pour l'afficher dans la console.
grille : La grille a afficher. tour : Le numéro de tour. """
pass
Vous avez ici, une première ébauche du code qui composera le coeur de notre application. Pour m'organiser, j'ai commencé à créer les fonctions que j'aurais à utiliser pour pouvoir créer des simulations et faire évoluer tout ce petit monde dans le module Moteur.py et tout ce qui va permettre d'interagir avec l'utilisateur et de lancer des simulations dans le module JeuDeLaVie.py La documentation est bien entendu aussi complète que possible afin d'exprimer en langage naturel ce que l'on souhaite faire en code lors de la phase d'implémentation. Elle doit vous permettre de savoir à quoi celle-ci servira par la suite !
Pour ceux qui n'auraient pas d'idées sur comment faire l'interface, aidez-vous de ce que j'ai donné en exemple plus haut. Et surtout, ne cherchez pas à faire compliquer, vous pouvez vous contenter d'une petite interface basique !