l =  [[1, 2, 5, 4, 8, 6, 9, 3, 7] ,
      [8, 5, 6, 9, 7, 3, 1, 5, 2] ,
      [3, 7, 9, 2, 1, 5, 4, 8, 6], 
      [2, 1, 8, 5, 9, 4, 7, 6, 3], 
      [6, 5, 4, 7, 3, 2, 8, 1, 9], 
      [7, 9, 3, 1, 6, 8, 2, 4, 5], 
      [5, 3, 2, 8, 4, 9, 6, 7, 1], 
      [9, 8, 7, 6, 5, 1, 3, 2, 4], 
      [4, 6, 1, 3, 2, 7, 5, 9, 8]]
>>> l[0][0]
1
>>> l[1][0]
8

#-*-*- Fin de <Jeu> || Début de <Plateau> -*-*-#  

class Plateau(object):
    """Permet de tenir à jour le plateau du jeu 'démineur'."""
    def __init__(self):
        """
        Définie les variables nécessaires

        """
        self.mapp = []
        self.longueur = 5 #Pour le nombres de case 5²
        self.nombreMines = 0
        

    def genererGrille(self):
        """Génère une grille de démineur. Appelle placerBombe()
           Retourne la grille ainsi qu'une copie remplie de '*'
        """
        for i in range(self.longueur):          #Pour un tableau de 5x5
            self.mapp.append([0] * self.longueur)#Remplie de '0' (type = int)

        #Appel à la fonction: placerBombe (deux fois pour l'essai)
        self.mapp = self.placerBombe() #On met à
        self.mapp = self.placerBombe() #jour la map
        
        #Appel à la fonction: placerChiffre
        

    def placerBombe(self):
        """Génère des nombres aléatoire
           pour placer une bombe et appelle chiffrerMap()
        """
        #On pose une bombe 'B' aléatoirement dans la map suivant la longueur de celle-ci ->(self.longueur)
        self.col, self.ligne, self.bombe = random.randrange(0, self.longueur), random.randrange(0, self.longueur), 'B'
        #On place la bombe aux coordonnées trouvées aléatoirement
        self.mapp[self.col][self.ligne] = self.bombe

        #Appel de la fonction chiffrerMap
        self.mapp = self.chiffrerMap(self.col, self.ligne, self.mapp)

        print(self.mapp)
        return self.mapp


    def chiffrerMap(self, col, ligne, mapp):
        """Permet de chiffrer ma map pour
           savoir où se trouvent les bombes
        """

        #Implémentation de l'algorithme pour chiffrer ma map
        #[[0, 0, 0, 0, 0],
        # [0, 0, 0, 0, 0],
        # [0, 0, B, 0, 0],
        # [0, 0, 0, 0, 0],
        # [0, 0, 0, 0, 0]]

        #Implémentation de l'algo
        #Si il y a un 'B' dans la grille alors on met un '1' dans les huit cases
        #qui l'entoure donc dans les cases suivantes (<C>olonne;<L>igne) = '<B>ombe'

        #Sens d'une aiguille d'une montre. On commence en haut à gauche:
        #(C-1;L-1) -> (C-1;L) -> (C-1;L+1)
        #(C;L-1)   -> B:(C;L) -> (C;L+1)
        #(C+1;L-1) -> (C+1;L) -> (C+1,L+1)

        #Si une des cases est en contacte avec plusieurs bombes, alors:
        #compteur += 1, donc on placera un 2/3 au lieu du 1
        #La case aux coordonnées C;L = compteur

        #Ligne n°1:
        self.mapp[self.col-1][self.ligne-1] = 1
        self.mapp[self.col-1][self.ligne]   = 1
        self.mapp[self.col-1][self.ligne+1] = 1

        #Ligne n°2:
        self.mapp[self.col][self.ligne-1] = 1
        self.mapp[self.col][self.ligne]   = self.bombe
        self.mapp[self.col][self.ligne+1] = 1

        #Ligne n°3:
        self.mapp[self.col+1][self.ligne-1] = 1
        self.mapp[self.col+1][self.ligne]   = 1
        self.mapp[self.col+1][self.ligne+1] = 1

        return self.mapp

#!/usr/bin/env python
# -*- coding: UTF-8 -*-

from random import randint

if __name__ == '__main__':
    plateau = []
    longueur = 4
    r = 0
    for i in range(longueur):          #Pour un tableau de 5x5
        plateau.append([0] * longueur)#Remplie de '0' (type = int)

    #on place des bombes - peu fiable
    for i in range(longueur):
        for j in range(longueur):
            r = randint(1, longueur)

            if r == longueur:
                plateau[i][j] = "B"

    #et là on va vérifier les cases - implémentation naive
    for i in range(longueur):
        for j in range(longueur):
            nbBombes = 0
            if plateau[i][j] != "B":
                if j > 0: #gauche
                    if plateau[i][j-1] == "B":
                        nbBombes += 1
                if j < longueur-1:#droite
                    if plateau[i][j+1] == "B":
                        nbBombes += 1
                if i > 0: #faut voir si on est pas première ligne
                    #on va regarder toutes les cases de la ligne précédente
                    if j > 0: #haut gauche
                        if plateau[i-1][j-1] == "B":
                            nbBombes += 1
                    #haut
                    if plateau[i-1][j] == "B":
                        nbBombes += 1
                    if j < longueur-1: #haut droite
                        if plateau[i-1][j+1] == "B":
                            nbBombes += 1
                if i < longueur-1: #si on est pas dernière ligne
                    if j > 0: #bas gauche
                        if plateau[i+1][j-1] == "B":
                            nbBombes += 1
                    #bas
                    if plateau[i+1][j] == "B":
                        nbBombes += 1
                    if j < longueur-1: #bas droite
                        if plateau[i+1][j+1] == "B":
                            nbBombes += 1
                #maj de la case
                plateau[i][j] = nbBombes
#debug
            print "case " + str(i) + "/" + str(j) + " = " + str(nbBombes)
    print plateau
#fin debug

class Plateau(object):
    """Permet de tenir à jour le plateau du jeu 'démineur'."""
    def __init__(self):
        """
        Définie les variables nécessaires

        """
        self.mapp = []
        self.longueur = 5 #Pour le nombres de case 5²
        self.nombreMines = 0
        

    def genererGrille(self):
        """Génère une grille de démineur. Appelle placerBombe()
           Retourne la grille ainsi qu'une copie remplie de '*'
        """
        for i in range(self.longueur):          #Pour un tableau de 5x5
            self.mapp.append([0] * self.longueur)#Remplie de '0' (type = int)

        #Appel à la fonction: placerBombe (deux fois pour l'essai)
        self.mapp = self.placerBombe() #On met à
        self.mapp = self.placerBombe() #jour la map
        print(self.mapp)

    def placerBombe(self):
        """Génère des nombres aléatoire
           pour placer une bombe et appelle chiffrerMap()
        """
        #On pose une bombe 'B' aléatoirement dans la ma suivant la longueur de celle-ci ->(self.longueur)
        self.col, self.ligne, self.bombe = random.randrange(0, self.longueur), random.randrange(0, self.longueur), 'B'
        #On place la bombe aux coordonnées trouvées aléatoirement
        self.mapp[self.col][self.ligne] = self.bombe

        #Appel de la fonction chiffrerMap
        self.mapp = self.chiffrerMap(self.col, self.ligne, self.mapp)

        return self.mapp


    def chiffrerMap(self, col, ligne, mapp):
        """Permet de chiffrer ma map pour
           savoir où se trouvent les bombes
        """
        
        #Implémentation de l'algorithme pour chiffrer ma map
        #[[0, 0, 0, 0, 0],
        # [0, 0, 0, 0, 0],
        # [0, 0, B, 0, 0],
        # [0, 0, 0, 0, 0],
        # [0, 0, 0, 0, 0]]
        
        #Implémentation de l'algorithme
        #On parcours notre mapp à l'aide d'une double boucle
        #On ajoute dans une liste à part les 8 case entourant la case actuelle
        #On regarde combien il y a de 'B'ombes.
        #Ma case prendra la valeur du nombre d'occurences de 'B' dans ma listeDesC...

        self.listeDesCasesAutourDeJ = []

        for i in self.mapp: #On parcours mon tableau 2D
            for j in i: 
                #On ajoute les 8 valeurs entourant ma case 'J'
                self.listeDesCasesAutourDeJ.append([self.col-1, self.col+1, self.ligne-1, self.ligne+1])
                
                #On compte le nombre d'occurences de la lettre "B"
                self.compteur = self.listeDesCasesAutourDeJ.count("B")
                self.mapp[self.col][self.ligne] = self.compteur
                
                self.listeDesCasesAutourDeJ = [] #On remet à '0'
            
        return self.mapp #On retourne la grille chiffrée

for i in range(self.ligne):
            for j in range(self.col):
                self.newL = []
                for ii in range(max(0, i-1), min(i+2, self.ligne-1)):
                    for jj in range(max(0, j-1), min(j+2, self.col-1)):
                        self.newL.append(self.mapp[ii][jj])
                self.compteur = self.newL.count("B")
                self.mapp[ii][jj] = self.compteur

        return self.mapp

for i in range(self.ligne):
            for j in range(self.col):
                self.newL = []
                for ii in range(max(0, i-1), min(i+2, self.longueur-1)):
                    for jj in range(max(0, j-1), min(j+2, self.longueur-1)):
                        self.newL.append(self.mapp[ii][jj]) #On capture les 8 cases
                self.compteur = self.newL.count("B") #Combien il y a t'il de bombe
                self.mapp[ii][jj] = self.compteur #Ma case porte son nouveau numéro

        return self.mapp #On retourne le tout

#!/usr/bin/env python
#-*- coding: utf-8 -*-

from __future__ import print_function
from random import randint

###############################################################################
# Constantes globales

MINE = '*'    # Dessin d'une mine
FLAG = '!'    # Drapeau
NOFLAG = '.'  # Case cachée normale
NOTHING = ' ' # Case vide

class Cell(object):
    """
    Classe modélisant une case du champ de mines.

    """
    def __init__(self):
        """
        Initialisation des attributs.

        """
        self.mine = False  # La case contient-elle une mine ?
        self.flag = False  # Y-a t'il un drapeau posé sur cette case ?
        self.show = False  # La case est-elle visible ?
        self.value = 0     # Combien de cases adjacentes contiennent une mine ?

    def __str__(self):
        """
        Retourne un caractère symbolisant l'état de la case.

        """
        if self.show:
            return str(self.value) if self.value else NOTHING
        else:
            return FLAG if self.flag else NOFLAG

class Field(object):
    """
    Classe modélisant un champ de mines.

    """
    def __init__(self, rows, cols, n_mines):
        """
        Initialisation du champ de mines.

        rows: nombre de lignes
        cols: nombre de colonnes
        n_mines: nombre de mines

        """
        self.rows = rows
        self.cols = cols
        self.n_mines = n_mines
        self.hidden = rows * cols  # nombre de cases cachées
        self.flagged = 0           # nombre de cases portant un drapeau
        self.gameover = False
        self.cells = []
        self._init_cells()         # initialisation des cases
        # remplissage aléatoire du champ de mines
        for _ in xrange(n_mines):
            idx = randint(0, rows * cols -1)
            while self.cells[idx].mine:
                idx = randint(0, rows * cols -1)
            row = idx // cols
            col = idx - row * cols
            self.cells[idx].mine = True
            self._count_mines(row, col)
        
    def _init_cells(self):
        """
        Initialisation des cases.
        Cette fonction pourra être surchargée si une classe fille désire 
        utiliser une autre classe pour les cases. (voir interface)

        """
        self.cells = [Cell() for _ in xrange(self.rows * self.cols)]

    def _count_mines(self, row, col):
        """
        Incrémente les compteurs de mines autour de la case (row, col)
        row: numéro de ligne de la case.
        col: numéro de colonne de la case.

        """
        for r in xrange(max(row-1, 0), min(row+2, self.rows)):
            for c in xrange(max(col-1, 0), min(col+2, self.cols)):
                self.cells[r * self.cols + c].value += 1

#!/usr/bin/env python
# -*- coding: UTF-8 -*-


from plateau import Plateau


class Main:
    """Classe principale du jeu. Gere les I/O
    c pour mode creuser, d pour mode drapeau, q pour quitter"""

    def __init__(self):
        """Initialisation de la partie"""
        self.__flagMode = False
        self.__taille = 5
        self.__arreter = False
        self.__plateau = Plateau(self.__taille)
        self.jouer()

    def jouer(self):
        """Fonction pour jouer, affiche l'invite
        puis appelle la fonction pour trairer l'entrée"""

        invite = "c: creuser - d : drapeau - q quitter\n{0} > "

        while not self.__arreter:
            print
            print self.__plateau

            saisieJoueur = raw_input(
                    invite.format('drapeau' if self.__flagMode else 'creuser'))
            self.traiterInput(saisieJoueur.strip().lower())

        self.__plateau.revelerMines()
        print self.__plateau

    def traiterInput(self, chaine):
        """Permet de traiter l'entrée utilisateur, et appelle les fonctions au besoin
        inspiré de la fonction écrite par NoHaR :)"""

        if chaine == "q":
            raise SystemExit

        if chaine == "c":
            self.__flagMode = False
            return 0

        if chaine == "d":
            self.__flagMode = True
            return 0

        try:
            lig, col = [int(num) for num in chaine.split()] #splitter et affecter à la fois
            #si on est en mode drapeau
            if self.__flagMode:
                self.__plateau.traiterDrapeaux(lig, col)
            #non? alors on creuse
            else:
                if not self.creuser(int(lig), int(col)):
                    self.__arreter = True
                    print "PERDU"
                if self.__plateau.getNbCasesSansMines() == 0:
                    self.__arreter = True
                    print "VICTOIRE"
        except (ValueError, TypeError):
            print 'Entrée invalide : 2 nombres attendus'
        except IndexError:
            print 'Entrée invalide : Ligne est colonne compris entre 0 et ' + str(self.__taille)

    def creuser(self, ligne=0, colonne=0):
        """Fonction qui demande à creuser une certaine case"""
        if ligne < 0 or colonne < 0:
            print "Erreur d'une coordonnée. 0 est le minimum"
            return True
        elif ligne > self.__taille or colonne > self.__taille:
            print "Erreur d'une coordonnée. " + str(self.__taille) + " est le maximum"
            return True
        else:
            return self.__plateau.creuserCase(ligne, colonne)

if __name__ == '__main__':
    partie = Main()

#!/usr/bin/env python
# -*- coding: UTF-8 -*-


from case import Case
from random import randint


class Plateau:
    """Classe contenant le plateau de jeu"""

    def __init__(self, taille=5):
        """Initialisation du plateau de jeu"""

        self.__taille = taille
        self.__plateau = self.creerPlateau()

        self.__nbBombes = 0
        while self.__nbBombes == 0:
            self.__nbBombes = self.placerBombes()

        self.__nbCasesSansMines = (self.__taille*self.__taille)-self.__nbBombes

    def creerPlateau(self):
        """Creer le plateau en tant que tab a deux dimensions et place les bombes
        puis retourne le tableau"""

        plateau = []

        for i in xrange(self.__taille):
            plateau.append([None] * self.__taille) #remplir de 0
        return plateau

    def placerBombes(self):
        """Place les bombes de manière aléatoire en fonction de la taille
        et renvoie le nombre au plateau.
        Il ne peut pas y avoir plus de <taille plateau> bombes"""

        nb=0

        for i in xrange(self.__taille):
            for j in xrange(self.__taille):
                r = randint(1, self.__taille)
                self.__plateau[i][j] = Case()

                if r == self.__taille and nb < self.__taille: #pas plus de <taille> bombes
                    self.__plateau[i][j].devenirBombe()
                    nb += 1
        return nb

    def compterBombes(self, ligne=0, colonne=0):
        """Compter les bombes pour une case donnée"""

        l_min = max(0, ligne-1)
        l_max = min(ligne+2, self.__taille)
        c_min = max(0, colonne-1)
        c_max = min(colonne+2, self.__taille)
        bombes = 0
        for lig in xrange(l_min, l_max):
            for col in xrange(c_min, c_max):
                if self.__plateau[lig][col].getEstUneBombe():
                    bombes += 1

        self.__plateau[ligne][colonne].setNbBombesAutour(bombes)

    def traiterDrapeaux(self, ligne=0, colonne=0):
        """Place ou retire un drapeau sur la case donnée"""
        self.__plateau[ligne][colonne].setEstDreapeau()

    def creuserCase(self, ligne=0, colonne=0):
        """Creuser une case : si pas encore révélée ou pas un drapeau
        compter les mines autour de cette case,
        la rendre visible. Si c'est une mine, on retourne false
        ------
        v2 : la fonction permet de creuser intelligemment (et est plus lisible)
        merci NoHaR :)"""

        case = self.__plateau[ligne][colonne]

        if case.getEstDrapeau():
            return True

        #si la case n'(est pas déjà creusée
        if not case.getEstVisible():
            self.compterBombes(ligne, colonne)
            case.rendreVisible()
            #si c'est une bombe : perdu
            if case.getEstUneBombe():
                return False
            #ça n'en est pas une
            else:
                self.__nbCasesSansMines -= 1
                #si la case vaut 0, on creuse les voisines
                if case.getNbBombesAutour() == 0:
                    #voir fonction compterBombes pour ces 2 boucles en détail
                    for lig in xrange( max(0, ligne-1), min(ligne+2, self.__taille) ):
                        for col in xrange( max(0, colonne-1), min(colonne+2, self.__taille) ):
                            self.creuserCase(lig, col)
                return True
        else:
            return True

    def getNbCasesSansMines(self):
        return self.__nbCasesSansMines

    def revelerMines(self):
        """Revèler les bombes du plateau"""
        for i in xrange(self.__taille):
            for j in xrange(self.__taille):
                if self.__plateau[i][j].getEstUneBombe():
                    self.__plateau[i][j].rendreVisible()

    def __str__(self):
        """Pour pouvoir afficher le tableau avec un simple print"""

        affichage = "+" + ("-" * 2 * self.__taille) + "-+"
        ligne = ""

        for i in xrange(self.__taille):
            ligne = "| "
            for j in xrange(self.__taille):
                ligne = ligne + str(self.__plateau[i][j]) + " "
            affichage = affichage + "\n" + ligne + "|"
            ligne = ""

        affichage += "\n+" + ("-" * 2 * self.__taille) + "-+"

        return affichage


if __name__ == '__main__':
    print "Veuillez lancer le script 'main.py'"

#!/usr/bin/env python
# -*- coding: UTF-8 -*-


class Case:
    """Classe gérant les cases du plateau de jeu"""

    def __init__(self):
        """Initialisation d'une case"""
        self.__estUneBombe = False
        self.__estDrapeau = False
        self.__estVisible = False
        self.__nbBombesAutour = 0

    def devenirBombe(self):
        """La case est une bombe"""
        self.__estUneBombe = True

    def rendreVisible(self):
        """Rend une case visible"""
        self.__estVisible = True

    def getEstUneBombe(self):
        return self.__estUneBombe

    def getEstVisible(self):
        return self.__estVisible

    def setEstDreapeau(self):
        if self.__estDrapeau:
            self.__estDrapeau = False
        else:
            self.__estDrapeau = True

    def getEstDrapeau(self):
        return self.__estDrapeau

    def setNbBombesAutour(self, nb=0):
        self.__nbBombesAutour = nb

    def getNbBombesAutour(self):
        return self.__nbBombesAutour

    def __str__(self):
        """Pour faire un print d'une case"""
        if self.__estVisible:
            if self.__estUneBombe:
                return "x"
            else:
                if self.__nbBombesAutour > 0:
                    return str(self.__nbBombesAutour)
                else:
                    return " "
        elif self.__estDrapeau:
            return "D"
        else:
            return "."

if __name__ == '__main__':
    print "Veuillez lancer le script 'main.py'"