1) Le cahier des charges:

- Ce que le joueur peut ou doit faire:

- Ce que les bombes peuvent/doivent faire:

- Ce que le joueur ne peut pas faire:

- Ce que les bombes ne peuvent pas faire:

- Environnement:

2) Les diférentes fonctions & classes:

3) Pseudo-Code

Citation : realmagma

Tout dabord merci pour ta réponse, ça fait plaisir .

Je n'ai pas encore vu les classes mais j'ai regardé ce que c'était en c++ tout à l'heure. (parce que j'avais déjà fait du C avant d'attaquer Python )
En tout cas je prends note pour la class 'grid'.

Je pense aussi faire une class 'personnage' voir même une class 'bombe' mais je m'avance beaucoup en disant cela. J'attends avec impatience la suite du/des tutoriel(s) Python, plus précisement sur les 'class'.

J'espère ne pas trop m'embêter avec les colisions *Siflote* ... sachant que ça va être très dure.

Citation : W3YZOH0RTH

Bonsoir,

Héhé, mais c'est cool, je suis aussi en train de coder un bomberman mais j'ai pas le cahier des charges
Je vais pouvoir m'inspirer du tien, si tu n'y vois pas d'inconvénient

Citation : NoHaR

Salut.

Tu sembles faire une sorte de complexe sur les classes à créer parce que tu débutes dans la POO.

Pour t'aider (sans te rediriger vers des tutos que tu devras lire de toute façon), voici quelques conseils :

une classe, c'est un type d'objets qui a des responsabilités et un état.

L'état est en général donné par ses attributs (ses "variables"), et ses responsabilités remplies par des actions qui sont effectués au moyenvde méthodes (ses "fonctions").

Un moyen très efficace de savoir comment découper tes classes est de procéder à une analyse textuelle.

Par exemple :
"je dois implémenter une chattière automatique qui fonctionne de la manière suivante :
mon chat miaule, la chattière s'ouvre, mon chat sort pour aller faire ses besoins

Les noms redondants (que j'ai mis en gras) correspondent en général à des classes différentes, et les verbes (en vert) sont leurs méthodes.

En procédant ainsi, tu es à peu près sûr d'avoir une conception qui tient la route, quitte à l'améliorer avec l'expérience.

Citation : realmagma

Le tutoriel sur python (non-officiel) parle des classes, je n'ai pas compris à quoi servent les accesseurs et les mutateurs. (Les exemples ne sont pas faciles à comprendre non plus )Je vais donc lire et re-lire ce chapitre jusqu'a ce qu'il soit acquis.

Encore merci à vous de prendre un peu de votre temps pour m'aider.

class test(object):
    def __init__(self,var):
        self.var = var

a = test(3)
print(a.var)

# a mettre à l'intèrieur de la classe précédente (comme une méthode)
def get_var(self):
    return self.var # en général les accésseurs sont des méthodes qui n'ont qu'un return

# je pourrais faire ceci :
a = test(3)
a.var = 6 # je change la valeur d'un attribut de a, cela ne respecte pas le principe d'encapsulation

def set_var(self,nouvelle_valeur):
    # ici des tests pour vérifier que 'nouvelle_valeur' n'est pas une valeur stupide
    self.var = nouvelle_valeur

Citation : realmagma

donc si j'ai bien compris, pour chaque méthode, il y aura un accesseur et un mutateur.

class Joueur:
    """Classe représentant le joueur et permettant de le déplacer"""

    def setNom(self, nom):
        """Renomme le joueur en <nom> (type : str)"""
        self.nom = nom

    def getNom(self):
        """Retourne le nom du joueur"""
        return self.nom

    def deplacerJoueur(self, positionJoueur, directionJoueur):
        """Déplace le joueur d'une case de <positionJoueur> vers <directionJoueur>"""

Citation : realmagma

Est-ce utile de mettre "mon explosion" (dans les 4 directions) comme étant une classe ?

Citation

Est-ce utile de mettre "mon explosion" (dans les 4 directions) comme étant une classe ?

class Rectangle(object):
    def __init__(self, hauteur, largeur):
        self.hauteur = hauteur
        self.largeur = largeur

    def get_hauteur(self):
        return self.hauteur

    def get_largeur(self):
        return self.largeur

    def get_aire(self):
        return self.hauteur * self.largeur

    def set_hauteur(self, hauteur):
        if hauteur > 0:
            self.hauteur = hauteur
        else:
            raise ValueError, 'hauteur <= 0'

    def set_largeur(self, largeur):
        if largeur > 0:
            self.largeur = largeur
        else:
            raise ValueError, 'largeur <= 0'

>>> mon_rect = Rectangle(3, 4)
>>> mon_rect.get_aire()
12
>>> mon_rect.set_hauteur(5)
>>> mon_rect.get_aire()
20
>>> mon_rect.set_largeur(-1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "rectangle.py", line 28, in set_largeur
    raise ValueError, 'largeur <= 0'
>>> mon_rect.get_aire()
20

>>> mon_rect.largeur = -1
>>> mon_rect.get_aire()
-5

class Rectangle(object):
    def __init__(self, hauteur, largeur):
        self.__hauteur = hauteur
        self.__largeur = largeur

    def get_hauteur(self):
        return self.__hauteur

    def get_largeur(self):
        return self.__largeur

    def get_aire(self):
        return self.__hauteur * self.__largeur

    def set_hauteur(self, hauteur):
        if hauteur > 0:
            self.__hauteur = hauteur
        else:
            raise ValueError, 'hauteur <= 0'

    def set_largeur(self, largeur):
        if largeur > 0:
            self.__largeur = largeur
        else:
            raise ValueError, 'largeur <= 0'

>>> from rectangle import Rectangle
>>> mon_rect = Rectangle(3, 4)
>>> mon_rect.get_aire()
12
>>> mon_rect.set_largeur(-1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "rectangle.py", line 28, in set_largeur
    raise ValueError, 'largeur <= 0'
ValueError: largeur <= 0
>>> mon_rect.__largeur = -1
>>> mon_rect.get_aire()
12

class Rectangle(object):
    def __init__(self, hauteur, largeur):
        self.__hauteur = hauteur
        self.__largeur = largeur

    def _get_hauteur(self):
        return self.__hauteur

    def _get_largeur(self):
        return self.__largeur

    def _get_aire(self):
        return self.__hauteur * self.__largeur

    def _set_hauteur(self, val):
        if val > 0:
            self.__hauteur = val
        else:
            raise ValueError, 'hauteur <= 0'

    def _set_largeur(self, val):
        if val > 0:
            self.__largeur = val
        else:
            raise ValueError, 'largeur <= 0'

    hauteur = property(fget=_get_hauteur, fset=_set_hauteur)
    largeur = property(fget=_get_largeur, fset=_set_largeur)
    aire = property(fget=_get_aire)

>>> from rectangle import Rectangle
>>> mon_rect = Rectangle(3,4)
>>> mon_rect.aire
12
>>> mon_rect.hauteur = 5
>>> mon_rect.aire
20
>>> mon_rect.hauteur = -1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "rectangle.py", line 19, in _set_hauteur
    raise ValueError, 'hauteur <= 0'
ValueError: hauteur <= 0
>>> mon_rect.aire = 12
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: can't set attribute
>>>

Citation : realmagma

Est-ce utile de mettre "mon explosion" (dans les 4 directions) comme étant une classe ?

Citation : W3YZOH0RTH

Les explosions ou du moins les flammes, sont une classe à part entière (l'explosion est une méthode de la bombe).
Une bombe explose en créant des flammes. Les flammes grandissent, brulent les joueurs, cassent les murs cassables et les bonus et font exploser les bombes.

Voilou

hauteur = property(fget=_get_hauteur, fset=_set_hauteur)
largeur = property(fget=_get_largeur, fset=_set_largeur)
aire = property(fget=_get_aire)

Citation : NoHaR

Ce sont les paramètres arguments de la fonction "property".
Tu devrais jeter un oeil au lien sur la doc que j'ai donné.
Edit : vocabulaire

"""
Petit programme gerant les deplacements
d'un personnage a partir d'une classe
'Perso'sous Pygame.
"""

################################
## Les Modules Importés:  (2) ##
#
import pygame, os


################################
## Les classes & fonctions:   ##
#
class Perso(object):
    """
    Tout ce qui concerne le perso:
    - Retiens la posistion (x;y), \
      la distance et le fait avancer.
    - Retiens le nom du personnage
    """
    def __init__(self, distanceX = 3, distanceY = 3):
        """
        Les attributs du constructeur
        """
        self.posX = 0
        self.posY = 0

        self.distanceX = distanceX
        self.distanceY = distanceY

        self.nom = "Pseudo_1"
        
    #
    ##Les Getters (accesseurs)
    #
    def g_distanceX(self):
        """
        Combien de pixels avance/recule
        le personnage en abcisse?
        """
        return self.distanceX
    
    def g_distanceY(self):
        """
        Combien de pixels avance/recule
        le personnage en ordonnee?
        """
        return self.distanceY


    def g_posX(self):
        """
        Ou est le perso
        en abcisse ?
        """
        return self.posX
    
    def g_posY(self):
        """
        Ou est le perso
        en ordonnee ?
        """
        return self.posY


    def g_nom(self):
        """
        Quel est le nom
        du personnage ?
        """
        return self.nom
    #
    ##Les Setters (Mutateurs)
    #
    def s_distanceX(self, newDistanceX):
        """
        Pour faire avancer/reculer
        le personnage en abcisse
        """
        self.posX += newDistanceX
    
    def s_distanceY(self, newDistanceY):
        """
        Pour faire avancer/reculer
        le personnage en ordonnee?
        """
        self.posY += newDistanceY


    def s_nom(self, newNom):
        """
        Quel sera le nouveau
        nom du personnage ?
        """
        self.nom = newNom

    
################################
## Les diférrentes variables: ##
#
hauteur = 200                 #Pour la-
largeur = 200                 #-fenetre
continuer = True              

distance = 3
p = Perso(3, 3)


################################
## Programme Principale:      ##
#
pygame.init()

#On cree la surface de l'ecran
screen = pygame.display.set_mode((hauteur, largeur))
pygame.display.set_caption("Acka Boum-Boum")
screen.fill((255, 255, 255))  #En blanc pour faire jolie

#Preciser ou est l'image et les associer dans mes variables
chemin = os.path.join("C:", "Documents\\Logiciels\\Python\\fichier\\gui\\")
monImageB = pygame.image.load(chemin + "teteB.PNG") #Tete bas
monImageH = pygame.image.load(chemin + "teteH.PNG") #Tete Haut
monImageG = pygame.image.load(chemin + "teteG.PNG") #Tete Gauche
monImageD = pygame.image.load(chemin + "teteD.PNG") #Tete Droit

#Enlever les contours inutiles. Ici blanc
monImageB.set_colorkey((255, 255, 255))
monImageH.set_colorkey((255, 255, 255))
monImageG.set_colorkey((255, 255, 255))
monImageD.set_colorkey((255, 255, 255))

#Transparence: monImageB.set_alpha(255)
#Premier blit sur l'ecran dans la memoire
screen.blit(monImageB, (35, 35))
pygame.display.flip()


while(continuer):
    
    for event in pygame.event.get():
        if(event.type == pygame.QUIT): #So on clique sur la croix, on ferme
           continuer = False
           
        elif(event.type is pygame.KEYDOWN):
            
            if(pygame.key.name(pygame.K_UP)):   #Pour le Haut
                p.s_distanceY(-distance)
                
                screen.fill((255, 255, 255))
                screen.blit(monImageH, (p.g_posX(), p.g_posY())) #On blit a la pos
                pygame.display.flip()
                print(p.g_posX(), p.g_posY()) #Essai
                
            elif(pygame.key.name(pygame.K_DOWN)): #Pour le Bas
                p.s_distanceY(distance)
                
                screen.fill((255, 255, 255))
                screen.blit(monImageB, (p.g_posX(), p.g_posY())) 
                pygame.display.flip()

            elif(pygame.key.name(pygame.K_RIGHT)): #Pour la droite
                p.s_distanceX(distance)
                
                screen.fill((255, 255, 255))
                screen.blit(monImageD, (p.g_posX(), p.g_posY())) 
                pygame.display.flip()

            elif(pygame.key.name(pygame.K_LEFT)):  #Pour la gauche
                p.s_distanceX(-distance)
                
                screen.fill((255, 255, 255))
                screen.blit(monImageG, (p.g_posX(), p.g_posY())) 
                pygame.display.flip()

Citation : Maxibolt

Je n'ai pas testé ton code, mais je me demande si ton problème ne pourrait pas être résolu en nettoyant la pile d'évènements à chaque appui de touche. Je crois avoir eu un problème de ce genre quand j'avais essayé Pygame.

Sinon, tes accesseurs et mutateurs sont superflus : en Python, tous les attributs sont publics. On peut éventuellement rendre leur accès de l'extérieur moins évident (en les précédant de __), mais ils seront toujours modifiables et consultables. L'idée derrière, c'est que celui qui modifie ça est responsable de ce qu'il fait : "nous sommes tous entre adultes consentants". Si tu veux quand même faire ça de façon "propre" (le mot est discutable), tu peux utiliser les méthodes setattr et getattr, qui font ce que tu veux, sans que tu aies besoin de surcharger ton code.
Note que les fonctions comme le déplacement peuvent toujours avoir leur place, parce que ça deviendra vite plus compliqué que "modifier un attribut avec la valeur passée en second argument".