BOMBERMAN
Fait par : Alexandre Rodriguez et Loïc Minato
Disponible sur : https://www.bombermanisnal.webnode.fr/
SOMMAIRE
Présentation du projet……………………………………….………………………………..p.3
Analyse du besoin et recherches d’idées…………………………………………………..…p.4
Répartition des tâches et démarches collaborative……………………………..…………….p.5
Partie personnelle Alexandre………………………………………………………………...p.6
Partie personnelle Loïc……………………………………………………………………...p.12
Diffusion du projet……………………………………………………………………….....p.20
Annexes……………………………………………………………………………………..p.21
Présentation du projet
Le projet étant le jeu Bomberman, nous avons de nombreux problèmes à résoudre et beaucoup de choses à apprendre à travers cette tâche. Nous devons réussir à générer une carte sous forme de damier avec des cases fixes et des cases aléatoires. Le tout étant intéractif avec les joueurs. Nous répondrons donc à la problèmatique : Comment rendre intéractif avec les joueurs un environnement aléatoire ?
Ce projet est intéressant au niveau algorithmique car il est complexe de gérer :
- L’environnement fixe et aléatoire ;
- Les personnages ;
- Les bombes ;
- Les collisions entre chaque fonction ;
- Les bonus.
De même, nous avons pris plaisir à faire ce projet car c’est un jeu que beaucoup d’entre nous connait car c’était un jeu très populaire dans les années 70, notamment sur les bornes d’arcade. Aujourd’hui, de nombreux remakes sortent sur les consoles telles que les consoles portables Nintendo (le jeu est japonais à l’origine).
Différents problèmes surviendront à travers ce projet :
Comment allons-nous générer la carte?
L'emplacement des blocs cassables avec une méthode random() est-elle une bonne idée?
Comment gérer les collisions de la bombe? Celles du personnage? Comment gérer les bonus et leur probabilité? Comment gérer le nombre de bombes et leur décompte avant explosion indépendamment à chaque bombe?
Comment gérer l'animation du personnage suivant son mouvement?
Comment définir les touches de déplacement pour deux joueurs différents sur le même clavier et qu'il n'y ait aucune interférences entre les entrées?
Comment rendre l'expérience ludique pour les joueurs? Comment gérer un système de bonus ayant des impacts sur le joueur, sur la bombe et sur la carte?
Analyse du besoin et recherches d’idées
Bomberman : Jeu 2 joueurs
La fenêtre est un damier de 30x20 (le tour étant des blocs durs), chaque joueur apparaissant dans les coins opposés sur une zone libre d'au moins 5 blocs adjacents. Le damier est aléatoirement constitué de blocs cassables ou vides, un bloc fixe sur deux, une ligne sur deux.
Exemple : ligne 1 : blocs durs (tour de carte) ; ligne 2 : aucun blocs durs; ligne 3 : un bloc dur sur deux etc.
Le joueur avance case par case. Les cases remplies par des bombes ou des blocs ne peuvent pas être traversées par le joueur. Le joueur peut poser une bombe, de portée 1x1x1x1 qui ne traverse pas les blocs adjacents.
Si :
-le bloc touché est dur : l'explosion n'a pas d'effet;
-le bloc touché est mou : le bloc se désintègre;
-un joueur est touché : il meurt;
La bombe met 2 secondes avant d'exploser, cela constituera 3 images différentes.
Lorsqu’un bloc mou disparait, un item peut apparaître :
-bonus déflagration : portée de feu +1;
-bonus coupe-bloc : la déflagration des bombes traverse les blocs mous;
-bonus bombe de la mort : le joueur possède des bombes ayant une portée supérieure à celle originellement maximale.
Nous n’avons pas trouvé d’exemples complets sur internet. De ce fait, nous nous sommes inspirés d’exemples Processing. Nous les avons donc agencé afin d’obtenir un programme cohérent.
Java Examples > Books > Processing Handbook > Synthesis > Synthesis_03_grids_01
Java Examples > Basics > Input > KeyboardFunctions
Java Examples > Basics > Input > MousePress
Java Examples > Basics > Objects > CompositeObjects
Répartition des tâches et démarches collaborative
|
Tâches |
Planning |
Noms |
|
Créer un damier |
19 et 20/12/2014 |
Groupe |
|
Contour et blocs durs |
20/12/2014 |
Groupe |
|
random() |
09 et 10/01/2015 |
Groupe |
|
Collisions |
16/01/2015 |
Alexandre |
|
Début bombe |
23/01/2015 |
Groupe |
|
Menu 1 |
23/01/2015 |
Loïc |
|
Collisions bombe |
24/01/2015 |
Groupe |
|
Création class bombe{} |
30/01/2015 |
Alexandre |
|
Répartition bonus |
30/01/2015 |
Loïc |
|
Codage bonus |
30/01/2015 |
Loïc |
|
Développement bombe{} |
06/02/2015 |
Groupe |
|
Menu 2 |
07/02/2015 |
Groupe |
|
Affichage bonus |
13/02/2015 |
Loïc |
|
Correctifs + commentaires |
28/02/2015 |
Alexandre |
Nous détaillerons la répartition du travail de groupe dans les parties personnelles.
Nous avons adopté une démarche très collaborative et un esprit d’équipe s’est directement intégré dans l’élaboration de notre programme afin que chacun de nous comprenne bien les diverses fonctions dans celui-ci. Le travail personnel s’est résumé à développer une idée commune. L’adaptation des parties individuelles a été simple, car nous avions vu les principes ensemble pour que le programme reste cohérent et compréhensible.
Partie personnelle Alexandre
Réalisation
|
L |
oïc et moi, ayant les mêmes options, avons choisis de nous mettre ensemble pour le projet. Je possédais déjà quelques connaissances en matière d’informatique car c’est un sujet qui m’intéresse depuis longtemps. J’ai donc décidé de me mettre avec ce précieux camarade afin de faire partager ma connaissance. Le projet étant assez complexe, nous avons dû redoubler d’efforts pour pouvoir le finir à temps. De plus, nous avons eu la chance de bénéficier de conseils extérieurs.
Nous avons donc adopté une philosophie d’équipe. C’est-à-dire que les idées ont été pensées ensemble. Nous avons ensuite réparti les tâches suivant le questionnement mutuel qui a été fait au préalable. Du fait de posséder les mêmes options, nos concertations étaient plus fréquentes.
La première partie individuelle que j’ai écrite est la matrice. Cela nous sert à donner des coordonnées à chaque « carré », pour pouvoir ensuite y attribuer des valeurs. D’ailleurs, la partie concernant les premières attributions de valeurs dans celle-ci est détaillée dans la partie individuelle de Loïc.
La matrice était donc notre premier problème. Nous ne savions pas comment faire pour faire en sorte qu’un tableau puisse prendre des valeurs suivant sa coordonnée « visuelle », c’est-à-dire avec l’interface graphique que les joueurs auront pour jouer.
Après de longs moments de recherches, j’ai trouvé la solution !
int crect = 30; //crect étant le coté d’un carré pour définir les coordonnées
int map[][] = new int[900][600];
for (int i = 0; i<width; i+=crect) {
for (int j = 0; j<height; j+=crect) {
int u = i/crect;
int v = j/crect;
map[u][v] = 0;
rect(i,j,crect,crect);}}
Cela permet de couper la fenêtre en blocs et ainsi donner des valeurs à ces cases. Voici un aperçu :
À cela vient s’ajouter le contour de la carte que mon camarade aura détaillé. Avec une matrice comme celle-ci, il fallait bien attribuer des valeurs. Les premières que nous souhaitions affecter étaient celles des blocs cassables par la bombe et infranchissables par le joueur, défini aléatoirement. Nous devions donc savoir comment attribuer des valeurs aléatoires.
Nous avons vu en classe et également dans les exemples Processing quelle était la fonction le permettant : random() ;
Nous avions donc mis dedans :
int r ;
r = random(2) ;
Cela résulte en une erreur car r est un entier et le random tel quel nous renvoie une valeur quelconque comprise en 0 et 2. Donc également des nombres décimaux. Cependant, nous avons cherché longtemps car nous avons eu un problème majeur : la carte était rempli de blocs cassables. Cela était dû à un problème de condition.
Il a donc fallu ajouter un cast :
r = int(random(2)) ;
De cette façon nous avons un entier compris en 0 et 2 inclus.
Afin de remplir la carte de blocs cassables comme décrit précédemment, j’ai donc ajouté une condition, avec les variables préalablement définies :
if(r==1){ //une chance sur deux
map[u][v]=1; //la valeur est attribuée
}
if(map[u][v]==1){
image(blocmou,i,j); //l’image apparait
}
Afin de pouvoir interagir avec l’interface graphique, le joueur doit avoir un personnage mobile. Nous y avons donc réfléchi ensemble et avons décrété que je m’attèlerai à cette tâche.
J’ai d’abord cherché les images officielles et en libre accès sur Internet des personnages de Bomberman. Je les ai rognées et adaptées pour le programme. À l’aide de booléen, j’ai ensuite fait apparaitre les images suivant la direction et la collision qui est expliquée ci-dessous.
Nous avons donc vu, grâce à des exemples de Processing, comment interagir avec le clavier de l’ordinateur : la fonction void KeyPressed() et la variable key.
Nous avons donc agi de la sorte. Grâce à diverses conditions pour les quatre directions (haut, bas, gauche et droite), j’ai donc réalisé les premières collisions :
if (key == 'z' || key == 'Z') {
if (map[x][y-1] == 1 || map[x][y-1] == 2){ //la valeur de la case en haut du personnage est vérifiée pour permettre le déplacement
haut = false;
}
else { //le déplacement du joueur est possible
droite = false;
gauche = false;
haut = true;
bas = false;
y--;
}
}
Le tout étant copiés et adaptés pour les trois autres directions. La condition s’enrichira ensuite avec les divers objets qui seront interactifs avec le personnage.
Nous avons pu ensuite réaliser l’engrenage le plus important du jeu, c’est-à-dire la bombe. Nous avons tout d’abord coder dans un simple void qui était appelé dans le void draw(). Mais cela ne nous permettait pas de mettre plusieurs bombes par joueur simultanément et de pouvoir gérer le compteur avant explosion pour chacune de celles-ci. C’était donc plutôt embêtant. Nous avons ensuite revu les premiers cours afin de nous inspirer et résoudre ce problème majeur. C’est là que nous trouvions la solution : les objets.
Cela sera donc ma tâche car Loïc s’occupait des bonus en attendant, il détaillera dans sa partie.
J’ai donc commencé par réécrire ce qui était dans la fonction bombe() originellement créée et a l’adapté pour la syntaxe de la class. Cela nous permettait d’appeler plusieurs objets pour un seul personnage, c’est-à-dire avoir plusieurs bombes pour un seul joueur mais cela s’est avéré bien difficile à notre grande surprise. Nous avons laissé donc une seule bombe par joueur, le gameplay en est très largement touché.
class Bombe {
Bombe(int xBomb, int yBomb, int compteur, int deflagration, boolean OverWalls) {
g = xBomb;
h = yBomb;
b = compteur;
def = deflagration;
OW = OverWalls;
}
Nous pouvons donc apercevoir un constructeur. L’affichage de la bombe est géré dès que le joueur presse la touche « b » ou « 0 ». Le compteur se met à s’incrémenter et dès qu’une valeur est atteinte la bombe explose et les collisions de celle-ci se mettent en marche. La partie suivante se trouve dans un void display() de la class. Elle sera adaptée pour les quatre directions et pour chacun des personnages.
for (int l = g; l < g+def; l++) { //cette partie est pour vérifier les valeurs à droite de la bombe
if (boom == true && blocg == true) { //si la touche “b” a été pressée et si la case vérifiée est vide
if (map[l][h] == 2) { //le bloc est dur, pas d’effet
boom = false;
}
if (map[l][h] == 0) { //la case est vide, ça explose mais pas d’effet
bomb = false;
blocg = true;
}
if (map[l][h] == 1) { //le bloc est cassable, ça explose, change la valeur de la case arrête l’explosion ici
map[l][h] = 0;
bomb = false;
blocg = false;
}
if (OW == true) { //si le bonus OverWalls est activé, la déflagration passe à travers tous les blocs vérifiés
blocg = true;
}
}
}
boom = true;
Intégration et Validation
|
L |
e programme ayant été fait en équipe, le nom des variables était donc pas un problème pour intégrer les parties personnelles. Nous avons vérifié le programme à chaque bloc fonctionnel écrit pour vérifier les erreurs de syntaxe commises par inattention ou simplement pour déceler une erreur d’algorithmique. Vous avez des imprimes-écrans disponibles ci-dessus pour les vérifications. Le reste étant dynamique, il est difficile de le prendre sur une photo qui est figée quant à elle. Nous avons également testé le programme avec des lignes en commentaire après améliorations pour voir l’importance de cette partie du code ou bien si elles fonctionnaient bien comme prévu. Cela nous a permis d’écrire un programme complet et aujourd’hui fonctionnel. Bomberman est un jeu amusant et évolutif en fonction des actions des joueurs.
Bilan et Perspectives
|
C |
e projet n’a fait qu’enrichir mes petites bases acquises en autodidacte. C’est un projet très intéressant car il faut beaucoup de fonctions pour pouvoir interagir avec les joueurs et également très ludique. Lors de nos tests, on ne testait pas simplement, Loïc et moi rigolions car on s’amusait sur ce jeu en même temps. Lors des tests de bombe, on avait pratiquement la boule au ventre car le compteur de la bombe avant explosion nous laisse un suspens assez serré. Cependant cela n’a pas toujours était facile car nous avons rencontré beaucoup de bugs et il fallait bien les corriger. Il y a eu donc beaucoup de réflexion. Maintenant, c’est un jeu abouti qui permet de s’amuser et se divertir entre amis, le gameplay reste intéressant.
Comme Bomberman est un jeu complexe et chargé en animations, en toutes sortes de bonus, nous pouvons bien sûr encore l’améliorer. Nous pouvons corriger notre bug premier : plusieurs bombes pour un seul joueur. Et également mettre des animations lors des phases de marches des personnages ; mettre une animation pour la déflagration de la bombe ; ajouter des bonus comme désactiver le compteur de la bombe et avoir une touche prédéfinie pour faire exploser la bombe au moment voulu, être invincible pendant une durée limitée et bien d’autres encore ; créer une IA pour jouer seul contre l’ordinateur et bien plus !
Nous nous sommes recentrés sur les fonctions réalisables et essentielles, nous avons réussi.
À travers ce projet j’ai pu apprendre une certaine rigueur notamment grâce à la syntaxe informatique. J’ai appris à collaborer en équipe et avoir de réelles responsabilités sur une création commune.
Partie personnelle Loïc
|
A |
lexandre avait déjà des bases de programmations avant de commencer l'année d'ISN, alors que je n'avais jamais réalisé de programmes avant Septembre. Durant la réalisation du projet, Alexandre a donc apporté ses connaissances générales, afin de nous donner une orientation dans la manière de monter nos fonctions, et j'ai ainsi pu progresser assez vite en écoutant ses conseils. Entre son expérience et mon regard nouveau, nous avons pu créer ce programme fonctionnel, à partir d'exemples Processing et de conseils extérieurs (car nous ne trouvions pas d'exemple satisfaisant sur internet).
La majorité de notre projet a ainsi été réalisée en duo, afin d'obtenir un résultat cohérent, et aussi pour pouvoir avoir deux avis sur les problèmes, que nous pouvions ainsi résoudre plus rapidement. Ainsi, comme nous faisons les mêmes options, nous avons pu nous rejoindre régulièrement et seules quelques parties du programme sont le résultat d'un travail individuel.
Pour cette raison, nous vous présenterons chacun notre travail personnel, et nous nous répartirons les parties communes.
Vous trouverez l'explication de la réalisation de la matrice dans la partie d'Alexandre.
Pour ma part je vais vous présenter la génération des blocs durs, c'est-à-dire infranchissables par les joueurs et indestructibles par les bombes. Les joueurs ne doivent pas sortir de la carte, pour cela, nous devons poser des blocs durs sur tout le tour de la carte. Nous avons donc décidé d'attribuer la valeur 2 aux cases contenant un bloc dur (dans le tableau qui sert à gérer la carte). Pour le contour il suffit de prendre les valeurs des premières et dernières lignes et colonnes et d'attribuer la valeur 2 à toute la rangée :
if (u == 0 || v == 0 || u == 28 || v == 18) {
map[u][v] = 2;
}
Pour rendre la carte plus intéressante, il fallait aussi placer sur une ligne sur deux des blocs durs une case sur deux. Pour cela nous avons réinvesti des connaissances vues en classe (pour créer un calendrier) afin de déterminer si la valeur de la colonne et de la ligne était paire. Si les deux conditions sont remplies, le programme place un bloc dur sur cette case, ce qui permet d'obtenir une répartition automatique des blocs fixes
pariteLigne = u % 2;
pariteColonne = v % 2;
if (pariteLigne == 0 && pariteColonne == 0) {
map[u][v] = 2;
}
Le symbole % permet de prendre le reste de la division euclidienne, ici par 2, afin de déterminer la parité de la ligne et de la colonne. On obtenait ainsi ceci :
 |
Dans la partie d'Alexandre vous pourrez découvrir notre assimilation de la fonction random() afin de remplir le tableau d'un labyrinthe aléatoire de blocs destructibles. Afin que le joueur puisse démarrer sans se faire exploser, j'ai mis en place une zone de sûreté de cinq blocs de long qui se crée à la fin, une fois toutes les autres cases attribuées.
Nous traitons aussi de la manière dont nous avons gérer la bombe dans sa partie personnelle.
Pour agrémenter un peu l'expérience de jeu, nous avons voulu placer sur la carte des bonus qui changeront les caractéristiques des bombes des joueurs, rendant l'expérience plus périlleuse. Pour cela, j'ai utilisé des fonctions random() (dont nous avions enfin compris le fonctionnement).
Ces bonus se situent d'abord dans des blocs cassables avant de tomber au sol lorsqu'un joueur casse le bloc les contenant. Il faut donc que le random() des bonus ne s'effectue que si la case possède déjà un bloc cassable afin d'éviter de surcharger la carte. Nous avons donc placé les random() à la suite du random() décidant du remplissage avec des blocs cassables simples.
Ensuite, nous avons placer les random() les uns après les autres, ce qui fait que les bonus les plus rares n'apparaissent que si les plus communs ne sont pas apparus. Afin de vérifier qu'aucun bonus n'est encore présent sur la case de la matrice, nous utilisons un boolean (rItem) qui empêche le calcul des autres random() si un précédant s'est déjà vérifié. Nous avons donc répété la condition suivante en faisant varier les valeurs du random et les variables déterminant le nom du bonus :
if (rItem = true) {
rBombUp = int(random(4));
if (rBombUp == 1) {
map[u][v] = 3;
}
Au fur et à mesure de l'avancée du programme, nous avons rajouté des items, donc des randoms, même si certains bonus n'ont au final pas été utilisés.
Pour vérifier que la répartition des bonus était cohérente, j'ai remplacé la valeur du bloc s'affichant sur la carte afin d'avoir une vue d'ensemble :
Pour pouvoir les utiliser, il faut que nous lorsque la bombe fait exploser les blocs contenant les bonus, ces derniers tombent au sol afin d'être récupérer dans le joueur. Ceci rajoute des conditions au niveau de la classe bombe, mais pas de difficultés particulières.
Lorsque le bonus tombe au sol, la valeur de la case change, et si un joueur passe sur cette case, une condition s'active dans perso() et modifie une caractéristique (la portée de la bombe, …).
Ainsi, dans le constructeur de la classe Bombe :
Bombe(int xBomb, int yBomb, int compteur, int deflagration, boolean OverWalls)
deflagration et OverWalls sont des variables modifiées par le gain de bonus par le joueur, si le OverWalls est vrai, la déflagration de la bombe traverse tous les blocs mous sur son passage, car la condition : if (boom == true && blocg == true) n'est jamais fausse (boom s'annule seulement à la fin de la classe), les collisions ne font donc que détruire les blocs et pas arrêter la déflagration.
deflagration s'incrémente de 1 quand le joueur passe sur le bonus FlamUp, cela augmente donc la portée de la bombe, car la boucle for permettant l'effet de la bombe s'exécute tant que la valeur du compteur reste inférieur à la case de départ plus la déflagration :
for (int l = g; l < g+def; l++)
Ainsi, avec une très grande portée et OverWalls actif nous obtenons :
Afin de rendre le programme plus interactif, nous avons décidé de mettre en place un menu de départ. Pour cela nous nous sommes inspirés de l'exemple Processing :
Java Examples > Basics > Input > MousePress
Nous avons ainsi créer l'image d'accueil présentant les touches de chaque joueur sur paint et nous l'avons mis en fond d'écran de la fonction void afficherMenu() puis nous avons dû définir un moyen de passer à l'affichage du jeu en lui-même.
C'est là que nous nous sommes servis de l'exemple, en créant des zones à textes qui réagissent au passage de la souris :
if (mouseX >=650 && mouseX<=860 && mouseY >=400 && mouseY <=450)
Si la souris passe sur le rectangle défini par ces coordonnées, la couleur du rectangle change, mais pas le texte à l'intérieur.
Lorsque le joueur se décide à lancer la partie, il clique sur le bouton commencer, ce qui met fin au menu() et lance la partie.
if (mouseX >=650 && mouseX<=860 && mouseY >=400 && mouseY <=450) {
menu = false ;}
Si le joueur décide de quitter, la fonction exit() ferme simplement la fenêtre.
Dès qu'un joueur meurt, on lance le void respawn(), qui réappelle le menu, et permet de recommencer une nouvelle partie sans relancer le programme.
Validation et Intégration
|
N |
ous avons, comme dis précédemment réaliser le programme majoritairement en équipe, et l'intégration des parties individuelles n'a pas été compliquée car les bases ayant été discutée à deux, nous utilisions les mêmes variables.
Pour la vérification du bon fonctionnement de notre programme, je vous ai déjà montré quelques imprimes-écrans qui montrent de quelle manière nous testions progressivement notre programme. Nous avons ainsi fais varier certaines valeurs des random(), ou mis en commentaire quelques lignes pour observer leur influences sur le programme.
Le résultat final nous donne une carte évolutive, qui prend en compte la position et l'évolution des joueurs et des valeurs des blocs afin de gérer les bonus et les bombes.
Bilan et perspectives
|
F |
inalement, ce projet m'a permis d'aborder de nombreuses notions d'informatiques, et d'acquérir des connaissances de bases et spécifiques sur la manière de coder le déroulement d'un jeu.
Nous sommes tous les deux satisfaits, car malgré de nombreux bugs durant le développement du programme, nous avons réussi à en régler une grande majorité, et le jeu propose actuellement un gameplay divertissant et équilibré qui permet de passer de bons moments entre amis.
Bien entendu, nous pouvons encore le développer, par exemple en créant des niveaux de difficultés (déplacements limités, attente avant de poser une autre bombe, …) ou en finissant de réaliser toutes nos ambitions premières. Car au fur et à mesure de l'avancer de notre code, nous nous sommes rendus compte que certains bonus ne seraient pas applicables. Notamment celui permettant de poser plusieurs bombes à la fois. Nous avons essayé de placer plusieurs objets de la classe (c'était le but premier de créer une classe), mais gérer l'ordre des bombes s'est révélé trop compliqué. Nous pourrions aussi créer un IA afin de permettre de jouer en 1 joueurs, mais sur un jeu comme celui-ci, cela demande des heures de travails afin de faire poser la bombe au bon endroit, d'essayer de viser le joueur ennemi, de se cacher des déflagrations. Peut-être que cela viendra…
Finalement, nous avons pu réaliser l'ensemble de nos objectifs réalisables, c'est-à-dire ceux qui s'appuient sur le code de base, sans rajouter de nouvelles fonctions trop complexes, ce qui est une réussite.
Le développement de ce jeu a permis d'aborder des principes d'algorithmiques qui pourront s'avérer utiles dans d'autres programmes, plus “sérieux”. Il m'a aussi appris à être extrêmement précis dans la manière de déclarer les variables, de mettre en place mes conditions, de créer un programme compréhensible par un observateur extérieur.
Diffusion du projet
La progression de notre programme peut être observée sur le site : https://bombermanisnal.webnode.fr/.
Sur ce site, nous avons décrit chaque étape de notre avancée ainsi que nos échecs, nos questions, nos découvertes et apprentissages comme un carnet de bord.
Nous créerons ensuite pour le BAC un site présentant notre projet dans ses grandes lignes et permettant d’exécuter le programme Processing directement depuis votre ordinateur grâce à un fichier .bat.
Nous choisissons une diffusion libre de notre programme afin de favoriser l’avancée de l‘informatique et pour permettre au monde libre un nouveau pas dans le domaine de la programmation et de du libre-accès aux informations contrairement à de nombreux concurrents.
ANNEXES
CODE AU 09/05/2015
//ONGLET GENERAL//
int crect = 30;
int map[][] = new int[870][570];
int g, h;
int g1, h1;
int b = 0, b1 = 0;
//MENU
boolean menu = true;
PFont texteMenu;
PImage logo;
//OBJET BOMBE PERSO
Bombe Bombe1;
//OBJET BOMBE PERSO1
Bombe_1 Bombe1_1;
//IMAGES BLOCS
PImage blocdur;
PImage blocmou;
//IMAGES BOMBES
PImage bombe;
PImage bombe1;
PImage warning;
PImage Burnl;
PImage Burnu;
PImage Burnm;
PImage Burnb;
PImage Burnh;
PImage Burng;
PImage Burnd;
//IMAGES BONUS
PImage BombUp;
PImage FlameUp;
PImage OverWalls;
PImage FootBomb;
PImage Invincibility;
PImage PowerFull;
void setup() {
//IMAGES MENU
logo = loadImage("logo.jpg");
texteMenu = createFont("Arial", 35, true);
//IMAGES BLOC
blocdur = loadImage("blocdur.jpg");
blocmou = loadImage("blocmou.jpg");
//IMAGES BOMBES
bombe = loadImage("Bomb.jpg");
bombe1 = loadImage("Bomb1.jpg");
warning = loadImage("Bomb2.jpg");
Burnl = loadImage("Burnl.jpg");
Burnu = loadImage("Burnu.jpg");
Burnm = loadImage("Burnm.jpg");
Burnb = loadImage("Burnb.jpg");
Burnh = loadImage("Burnh.jpg");
Burng = loadImage("Burng.jpg");
Burnd = loadImage("Burnd.jpg");
//IMAGES BONUS
BombUp = loadImage("BombUp.jpg");
FlameUp = loadImage("FlameUp.jpg");
OverWalls = loadImage("OverWalls.jpg");
FootBomb = loadImage("FootBomb.jpg");
Invincibility = loadImage("Invincibility.jpg");
PowerFull = loadImage("PowerFULL.jpg");
//PARAMETRES DE BASE + OBJETS
size(870, 570);
frameRate(50);
carte();
Bombe1 = new Bombe( g, h, b, def, OW) ;
Bombe1_1 = new Bombe_1( g1, h1, b1, def1, OW1) ;
}
void draw() {
if (menu == true) {
afficherMenu();
carte();
}
if (menu == false) {
afficherc();
noStroke();
}
println(map[mouseX/crect][mouseY/crect]);
println(b);
println(b1);
}
void respawn() {
boom = true;
boom1 = true;
menu = true;
x = 1;
y = 1;
x1 = 27;
y1 = 17;
def = 2;
def1 = 2;
OW = false;
OW1 = false;
PowerFULL = false;
PowerFULL1 = false;
}
//ONGLET BOMBE//
class Bombe {
Bombe(int xBomb, int yBomb, int compteur, int deflagration, boolean OverWalls) { //constructeur
g = xBomb;
h = yBomb;
b = compteur;
def = deflagration;
OW = OverWalls;
}
void display() { //affichage
boolean blocg = true;
boolean blocb = true;
boolean blocd = true;
boolean bloch = true;
boolean boom = true;
if (key == 'b' || key == 'B') { //poser la bombe
bomb = true;
}
if (bomb == true) {
b++; //incrément pour le compteur
}
if (b == 70) //changement des images suivant le compteur
map[g][h] = 11;
if (b == 80)
map[g][h] = 12;
if (b == 85)
map[g][h] = 13;
if (b >= 90) {
boom = true;
for (int l = g; l < g+def; l++) { //collisions de la bombe à droite
map[x][y] = 30;
map[x1][y1] = 31;
if (boom == true && blocg == true) { //bloc dur
if (map[l][h] == 2) {
boom = false;
}
if (map[l][h] == 0) { //case vide
bomb = false;
blocd = true;
image(Burnl, l*crect, h*crect); //image pour les flammes
if ( l == g+def-1) {
image(Burnd, l*crect, h*crect);
}
}
if (map[l][h] == 4) { //bonus FlameUp
map[l][h] = 20;
}
if (map[l][h] == 6) { //bonus OverWalls
map[l][h] = 22;
}
if (map[l][h] == 1 || map[l][h] == 3 || map[l][h] == 5 || map[l][h] == 7) { //blocs cassables
map[l][h] = 0;
bomb = false;
blocd = false;
}
if (OW == true) { //activation de OverWalls
blocd = true;
}
if (map[l][h] == 8) { //bonus PowerFULL
map[l][h] = 28;
}
if (map[l][h] == 30 || map[l][h] == 31) { //Mort d'un des joueurs
respawn();
}
}
map[x][y] = 0;
map[x1][y1] = 0;
}
boom = true;
for (int l = h; l < h+def; l++) { //collision de la bombe en bas
map[x][y] = 30;
map[x1][y1] = 31;
if (boom == true && blocb == true) {
if (map[g][l] == 2) {
boom = false;
}
if (map[g][l] == 0) {
bomb = false;
blocb = true;
image(Burnu, g*crect, l*crect);
if ( l == h+def+1) {
image(Burnb, g*crect, l*crect);
}
}
if (map[g][l] == 4) {
map[g][l] = 20;
}
if (map[g][l] == 6) {
map[g][l] = 22;
}
if (map[g][l] == 1 || map[g][l] == 3 || map[g][l] == 5 || map[g][l] == 7) {
map[g][l] = 0;
bomb = false;
blocb = false;
}
if (OW == true) {
blocb = true;
}
if (map[g][l] == 8) {
map[g][l] = 28;
}
if (map[g][l] == 30 || map[g][l] == 31) {
respawn();
}
}
map[x][y] = 0;
map[x1][y1] = 0;
}
boom = true;
for (int l = g; l > g-def; l--) { //collision de la bombe à gauche
map[x][y] = 30;
map[x1][y1] = 31;
if (boom == true && blocd == true) {
if (map[l][h] == 2) {
boom = false;
}
if (map[l][h] == 0) {
bomb = false;
blocg = true;
image(Burnl, l*crect, h*crect);
if ( l == g+def+1) {
image(Burng, l*crect, h*crect);
}
}
if (map[l][h] == 4) {
map[l][h] = 20;
}
if (map[l][h] == 6) {
map[l][h] = 22;
}
if (map[l][h] == 1 || map[l][h] == 3 || map[l][h] == 5 || map[l][h] == 7) {
map[l][h] = 0;
bomb = false;
blocg = false;
}
if (map[l][h] == 8) {
map[l][h] = 28;
}
if (OW == true) {
blocg = true;
}
if (map[l][h] == 30 || map[g][l] == 31) {
respawn();
}
}
map[x][y] = 0;
map[x1][y1] = 0;
}
boom = true;
for (int l = h; l > h-def; l--) { //collision de la bombe en haut
map[x][y] = 30;
map[x1][y1] = 31;
if (boom == true && bloch == true) {
if (map[g][l] == 2) {
boom = false;
}
if (map[g][l] == 0) {
bomb = false;
bloch = true;
image(Burnu, g*crect, l*crect);
if ( l == h+def-1) {
image(Burnh, g*crect, l*crect);
}
}
if (map[g][l]==4) {
map[g][l] = 20;
}
if (map[g][l] == 6) {
map[g][l] = 22;
}
if (map[g][l] == 1 || map[g][l] == 3 || map[g][l] == 5 || map[g][l] == 7) {
map[g][l] = 0;
bomb = false;
bloch = false;
}
if (OW == true) {
bloch = true;
}
if (map[g][l] == 8) {
map[g][l] = 28;
}
if (map[g][l] == 30 || map[g][l] == 31) {
respawn();
}
}
map[x][y] = 0;
map[x1][y1] = 0;
}
boom = true;
if (bomb == false) { //réinitialisation des cases touchées
b = 0;
map[g][h] = 0;
limiteur --;
}
}
}
}
//ONGLET BOMBE_1//
class Bombe_1 {
Bombe_1(int xBomb1, int yBomb1, int compteur1, int deflagration1, boolean OverWalls1) {
g1 = xBomb1;
h1 = yBomb1;
b1 = compteur1;
def1 = deflagration1;
OW1 = OverWalls1;
}
void display() {
boolean blocg = true;
boolean blocb = true;
boolean blocd = true;
boolean bloch = true;
boolean boom1 = true;
if (key == '0') {
bomb1 = true;
}
if (bomb1 == true) {
b1++;
}
if (b1 == 70)
map[g1][h1] = 11;
if (b1 == 80)
map[g1][h1] = 12;
if (b1 == 85)
map[g1][h1] = 13;
if (b1 >= 90) {
boom1 = true;
for (int l1 = g1; l1 < g1+def1; l1++) {
map[x][y] = 15;
map[x1][y1] = 16;
if (boom1 == true && blocg == true) {
if (map[l1][h1] == 2) {
boom1 = false;
}
if (map[l1][h1] == 0) {
bomb1 = false;
blocd = true;
image(Burnl, l1*crect, h1*crect);
if ( l1 == g1+def1-1) {
image(Burnd, l1*crect, h1*crect);
}
}
if (map[l1][h1] == 4) {
map[l1][h1] = 20;
}
if (map[l1][h1] == 6) {
map[l1][h1] = 22;
}
if (map[l1][h1] == 1 || map[l1][h1] == 3 || map[l1][h1] == 5 || map[l1][h1] == 7) {
map[l1][h1] = 0;
bomb1 = false;
blocd = false;
}
if (OW1 == true) {
blocd = true;
}
if (map[l1][h1] == 15 || map[l1][h1] == 16) {
respawn();
}
}
map[x][y] = 0;
map[x1][y1] = 0;
}
boom1 = true;
for (int l1 = h1; l1 < h1+def1; l1++) {
map[x][y] = 15;
map[x1][y1] = 16;
if (boom1 == true && blocb == true) {
if (map[g1][l1] == 2) {
boom1 = false;
}
if (map[g1][l1] == 0) {
bomb1 = false;
blocb = true;
image(Burnu, g1*crect, l1*crect);
if ( l1 == h1+def1+1) {
image(Burnb, g1*crect, l1*crect);
}
}
if (map[g1][l1] == 4) {
map[g1][l1] = 20;
}
if (map[g1][l1] == 6) {
map[g1][l1] = 22;
}
if (map[g1][l1] == 1 || map[g1][l1] == 3 || map[g1][l1] == 5 || map[g1][l1] == 7) {
map[g1][l1] = 0;
bomb1 = false;
blocb = false;
}
if (OW1 == true) {
blocb = true;
}
if (map[g1][l1] == 15 || map[g1][l1] == 16) {
respawn();
}
}
map[x][y] = 0;
map[x1][y1] = 0;
}
boom1 = true;
for (int l1 = g1; l1 > g1-def1; l1--) {
map[x][y] = 15;
map[x1][y1] = 16;
if (boom1 == true && blocd == true) {
if (map[l1][h1] == 2) {
boom1 = false;
}
if (map[l1][h1] == 0) {
bomb1 = false;
blocg = true;
image(Burnl, l1*crect, h1*crect);
if ( l1 == g1+def1+1) {
image(Burng, l1*crect, h1*crect);
}
}
if (map[l1][h1] == 4) {
map[l1][h1] = 20;
}
if (map[l1][h1] == 6) {
map[l1][h1] = 22;
}
if (map[l1][h1] == 1 || map[l1][h1] == 3 || map[l1][h1] == 5 || map[l1][h1] == 7) {
map[l1][h1] = 0;
bomb1 = false;
blocg = false;
}
if (OW1 == true) {
blocg = true;
}
if (map[l1][h1] == 15 || map[l1][h1] == 16) {
respawn();
}
}
map[x][y] = 0;
map[x1][y1] = 0;
}
boom1 = true;
for (int l1 = h1; l1 > h1-def1; l1--) {
map[x][y] = 15;
map[x1][y1] = 16;
if (boom1 == true && bloch == true) {
if (map[g1][l1] == 2) {
boom1 = false;
}
if (map[g1][l1] == 0) {
bomb1 = false;
bloch = true;
image(Burnu, g1*crect, l1*crect);
if ( l1 == h1+def1-1) {
image(Burnh, g1*crect, l1*crect);
}
}
if (map[g1][l1] == 4) {
map[g1][l1] = 20;
}
if (map[g1][l1] == 6) {
map[g1][l1] = 22;
}
if (map[g1][l1] == 1 || map[g1][l1] == 3 || map[g1][l1] == 5 || map[g1][l1] == 7) {
map[g1][l1] = 0;
bomb1 = false;
bloch = false;
}
if (OW1 == true) {
bloch = true;
}
if (map[g1][l1] == 15 || map[g1][l1] == 16) {
respawn();
}
}
map[x][y] = 0;
map[x1][y1] = 0;
}
boom1 = true;
if (bomb1 == false) {
b1 = 0;
map[g1][h1] = 0;
limiteur1 --;
}
}
}
}
//ONGLET BONUS//
int def = 2, def1 = 2;
boolean OW = false, OW1 = false;
int nombreBombe = 1, nombreBombe1 = 1;
int limiteur = 0, limiteur1 = 0;
boolean PowerFULL = false, PowerFULL1 = false;
//ONGLET MAP//
void carte() {
for (int i = 0; i for (int j = 0; j int u = i/crect;
int v = j/crect;
map[u][v] = 0;
int pariteLigne;
int pariteColonne;
int r;
int rFlameUp;
int rFoot;
int rInvic;
int rOverWalls;
int rPower;
int rBombUp;
boolean rItem = true;
//blocs cassables
r = int(random(2));
if (r==1) {
map[u][v] = 1;
}
r = int(random(3));
if (r==1) {
map[u][v] = 1;
}
//safe zone
if (u == 1 && v >= 1 && v<=3 || v == 1 && u >= 1 && u<= 3) {
map[u][v] = 0;
}
if (u == 27 && v >= 15 && v<=18 || v == 17 && u >= 25 && u<= 28) {
map[u][v] = 0;
}
//blocs durs
if (u == 0 || v == 0 || u == 28 || v == 18) {
map[u][v] = 2;
}
pariteLigne = u % 2;
pariteColonne = v % 2;
if (pariteLigne == 0 && pariteColonne == 0) {
map[u][v] = 2;
}
if (map[u][v]==1) {
r =int(random(2));
if (r==1) { //répartition des items avec random()
if (rItem = true) {
rBombUp = int(random(4));
if (rBombUp == 1) {
map[u][v] = 3; //blocmou + BombUp = 3
}
}
if (rItem = true) {
rBombUp = int(random(3));
if (rBombUp == 1) {
map[u][v] = 3; //blocmou + BombUp = 3
rItem = false;
}
}
if (rItem = true) {
rFlameUp = int(random(4));
if (rFlameUp == 1) {
map[u][v] = 4; //blocmou + FlameUp = 4
}
}
if (rItem = true) {
rFlameUp = int(random(3));
if (rFlameUp == 1) {
map[u][v] = 4; //blocmou + FlameUp = 4
rItem = false;
}
}
if (rItem = true) {
rOverWalls = int(random(50)); //blocmou + OverWalls = 6
if (rOverWalls == 1) {
map[u][v] = 6;
rItem = false;
}
}
map[14][9] = 8; //blocmou + PowerFULL = 8
}
}
}
}
}
void afficherc() {
for (int i = 0; i for (int j = 0; j int u = i/crect;
int v = j/crect;
//affichage
if (map[u][v] == 0 ) { //case vide
fill(#167C0E);
rect(i, j, crect, crect);
}
if (map[u][v]==1) { //bloc mou sans bonus
image(blocmou, i, j);
}
if (map[u][v] == 2) { //bloc dur
image(blocdur, i, j);
}
if (map[u][v] == 4) { //bloc mou avec FlameUp
image(blocmou, i, j);
}
if (map[u][v] == 6) { //bloc mou avec OverWalls
image(blocmou, i, j);
}
if (map[u][v] == 8) { //bloc mou avec PowerFULL
image(blocmou, i, j);
}
if (map[u][v] == 10) { //image de la bombe
image(bombe, i, j);
}
if (map[u][v] == 11) { //image de la bombe1
image(bombe1, i, j);
}
if (map[u][v] == 12) { //image de la bombe2
image(warning, i, j);
}
if (map[u][v] == 13) { //image de la déflagration au milieu
image(Burnm, i, j);
}
if (map[u][v] == 14) { //image de la déflagration à droite
image(Burnd, i, j);
}
if (map[u][v] == 15) { //image de la déflagration en bas
image(Burnb, i, j);
}
if (map[u][v] == 16) { //image de la déflagration en haut
image(Burnh, i, j);
}
if (map[u][v] == 17) { //image de la déflagration à gauche
image(Burng, i, j);
}
if (map[u][v] == 20) { //image du bonus FlameUp fonctionnel
image(FlameUp, i, j);
}
if (map[u][v] == 22) { //image du bonus OverWalls fonctionnel
image(OverWalls, i, j);
}
if (map[u][v] == 28) { //image du bonus PowerFULL fonctionnel
image(PowerFull, i, j);
}
}
}
perso();
perso1();
if (bomb == true) {
Bombe1.display();
}
if (bomb1 == true) {
Bombe1_1.display();
}
}
//ONGLET MENU//
void afficherMenu() {
image(logo, 0, 0);
fill(#7994CB);
noStroke();
rect(650, 400, 210, 50);
fill(255);
textFont(texteMenu);
text("Commencer", 660, 436);
fill(#7994CB);
noStroke();
rect(650, 460, 210, 50);
fill(255);
textFont(texteMenu);
text("Quitter", 700, 496);
//CHANGEMENT AU PASSAGE DE LA SOURIS
if (mouseX >=650 && mouseX<=860 && mouseY >=400 && mouseY <=450) {
fill(#2E8BC6);
rect(650, 400, 210, 50);
stroke(0);
fill(255);
textFont(texteMenu);
text("Commencer", 660, 436);
}
if (mouseX >=650 && mouseX<=860 && mouseY >=460 && mouseY <=460+50) {
fill(#2E8BC6);
rect(650, 460, 210, 50);
fill(255);
textFont(texteMenu);
text("Quitter", 700, 496);
}
//CLIC DES BOUTONS
if (mousePressed == true) {
if (mouseX >=650 && mouseX<=860 && mouseY >=400 && mouseY <=450) {
menu = false;
}
if (mouseX >=650 && mouseX<=860 && mouseY >=460 && mouseY <=460+50) {
exit();
}
}
}
//ONGLET PERSOS_ET_COLLISIONS//
//position initiale perso + direction + bombe
boolean immobile = true;
boolean droite = false;
boolean gauche = false;
boolean haut = false;
boolean bas = false;
int x = 1;
int y = 1;
boolean bomb = false;
//position initiale perso1 + direction1 + bombe1
boolean immobile1 = true;
boolean droite1 = false;
boolean gauche1 = false;
boolean haut1 = false;
boolean bas1 = false;
int x1 = 27;
int y1 = 17;
boolean bomb1 = false;
void perso() {
PImage persoh = loadImage("Persoh.jpg");
PImage persob = loadImage("Persob.jpg");
PImage persog = loadImage("Persog.jpg");
PImage persod = loadImage("Persod.jpg");
if (immobile == true) {
image(persob, x*crect+5, y*crect);
}
if (droite == true) {
image(persod, x*crect+5, y*crect);
}
if (gauche == true) {
image(persog, x*crect+5, y*crect);
}
if (bas == true) {
image(persob, x*crect+5, y*crect);
}
if (haut == true) {
image(persoh, x*crect+5, y*crect);
}
if (map[x][y] == 20) { //changement de la variable suite à FlameUp
def ++;
map[x][y] = 1;
map[x][y] = 0;
}
if (PowerFULL == false) { //condition de la portée et des effets de la bombe à cause de PowerFULL
if (def == 11) {
def --;
}
} else {
def = 30;
OW = true;
}
if (map[x][y] == 28) { //activation de PowerFULL
PowerFULL = true;
map[x][y] = 1;
map[x][y] = 0;
}
if (map[x][y] == 22) { //activation de OverWalls
OW = true;
map[x][y] = 1;
map[x][y] = 0;
}
}
void perso1() {
PImage perso1h = loadImage("Perso1h.jpg");
PImage perso1b = loadImage("Perso1b.jpg");
PImage perso1g = loadImage("Perso1g.jpg");
PImage perso1d = loadImage("Perso1d.jpg");
if (immobile1 == true) {
image(perso1b, x1*crect+5, y1*crect);
}
if (droite1 == true) {
image(perso1d, x1*crect+5, y1*crect);
}
if (gauche1 == true) {
image(perso1g, x1*crect+5, y1*crect);
}
if (bas1 == true) {
image(perso1b, x1*crect+5, y1*crect);
}
if (haut1 == true) {
image(perso1h, x1*crect+5, y1*crect);
}
if (map[x1][y1] == 20) {
def1 ++;
map[x1][y1] = 1;
map[x1][y1] = 0;
}
if (PowerFULL1 == false) {
if (def1 == 11) {
def1 --;
}
} else {
def1 = 30;
OW1 = true;
}
if (map[x1][y1] == 28) {
PowerFULL1 = true;
map[x1][y1] = 1;
map[x1][y1] = 0;
}
if (map[x1][y1]==22) {
OW1 = true;
map[x1][y1] = 1;
map[x1][y1] = 0;
}
}
void keyPressed() { //PERSO
if (key == 'z' || key == 'Z') {
if (map[x][y-1] == 1 || map[x][y-1] == 2 || map[x][y-1] == 3 || map[x][y-1] == 4 || map[x][y-1] == 5 || map[x][y-1] == 6 || map[x][y-1] == 7 || map[x][y-1] == 8 || map[x][y-1] == 10 || map[x][y-1] == 11 || map[x][y-1] == 12) {
haut = false;
} else {
droite = false;
gauche = false;
haut = true;
bas = false;
y--;
}
}
if (key == 's' || key == 'S') {
if (map[x][y+1] == 1 || map[x][y+1] == 2 || map[x][y+1] == 3 || map[x][y+1] == 4 || map[x][y+1] == 5 || map[x][y+1] == 6 || map[x][y+1] == 7 || map[x][y+1] == 8 || map[x][y+1] == 10 || map[x][y+1] == 11 || map[x][y+1] == 12) {
bas = false;
} else {
droite = false;
gauche = false;
haut = false;
bas = true;
y++;
}
}
if (key == 'd' || key == 'D') {
if (map[x+1][y] == 1 || map[x+1][y] == 2 || map[x+1][y] == 3 || map[x+1][y] == 4 || map[x+1][y] == 5 || map[x+1][y] == 6 || map[x+1][y] == 7 || map[x+1][y] == 8 || map[x+1][y] == 10 || map[x+1][y] == 11 || map[x+1][y] == 12) {
droite = false;
} else {
droite = true;
gauche = false;
haut = false;
bas = false;
x++;
}
}
if (key == 'q' || key == 'Q') {
if (map[x-1][y] == 1 || map[x-1][y] == 2 || map[x-1][y] == 3 || map[x-1][y] == 4 || map[x-1][y] == 5 || map[x-1][y] == 6 || map[x-1][y] == 7 || map[x-1][y] == 8 || map[x-1][y] == 10 || map[x-1][y] == 11 || map[x-1][y] == 12) {
gauche = false;
} else {
droite = false;
gauche = true;
haut = false;
bas = false;
x--;
}
}
if (key == 'b' || key == 'B') {
if (nombreBombe == 1) { //LIMITEUR
if (limiteur == 0) {
g = x;
h = y;
map[g][h] = 10;
bomb = true;
limiteur = limiteur +1;
}
}
if (nombreBombe == 2) {
if (limiteur == 1 || limiteur == 0) {
g = x;
h = y;
map[g][h] = 10;
bomb = true;
limiteur = limiteur +1;
}
}
if (nombreBombe == 3) {
if (limiteur <= 2) {
g = x;
h = y;
map[g][h] = 10;
bomb = true;
limiteur = limiteur +1;
}
}
if (nombreBombe == 4) {
if (limiteur <= 3) {
g = x;
h = y;
map[g][h] = 10;
bomb = true;
limiteur = limiteur +1;
}
}
if (nombreBombe == 5) {
if (limiteur <= 4) {
g = x;
h = y;
map[g][h] = 10;
bomb = true;
limiteur = limiteur +1;
}
}
}
//PERSO1
if (key == '8') {
if (map[x1][y1-1] == 1 || map[x1][y1-1] == 2 || map[x1][y1-1] == 3 || map[x1][y1-1] == 4 || map[x1][y1-1] == 5 || map[x1][y1-1] == 6 || map[x1][y1-1] == 7 || map[x1][y1-1] == 8 || map[x1][y1-1] == 10 || map[x1][y1-1] == 11 || map[x1][y1-1] == 12) {
haut1 = false;
} else {
droite1 = false;
gauche1 = false;
haut1 = true;
bas1 = false;
y1--;
}
}
if (key == '2') {
if (map[x1][y1+1] == 1 || map[x1][y1+1] == 2 || map[x1][y1+1] == 3 || map[x1][y1+1] == 4 || map[x1][y1+1] == 5 || map[x1][y1+1] == 6 || map[x1][y1+1] == 7 || map[x1][y1+1] == 8 || map[x1][y1+1] == 10 || map[x1][y1+1] == 11 || map[x1][y1+1] == 12) {
bas1 = false;
} else {
droite1 = false;
gauche1 = false;
haut1 = false;
bas1 = true;
y1++;
}
}
if (key == '6') {
if (map[x1+1][y1] == 1 || map[x1+1][y1] == 2 || map[x1+1][y1] == 3 || map[x1+1][y1] == 4 || map[x1+1][y1] == 5 || map[x1+1][y1] == 6 || map[x1+1][y1] == 7 || map[x1+1][y1] == 8 || map[x1+1][y1] == 10 || map[x1+1][y1] == 11 || map[x1+1][y1] == 12) {
droite1 = false;
} else {
droite1 = true;
gauche1 = false;
haut1 = false;
bas1 = false;
x1++;
}
}
if (key == '4') {
if (map[x1-1][y1] == 1 || map[x1-1][y1] == 2 || map[x1-1][y1] == 3 || map[x1-1][y1] == 4 || map[x1-1][y1] == 5 || map[x1-1][y1] == 6 || map[x1-1][y1] == 7 || map[x1-1][y1] == 8 || map[x1-1][y1] == 10 || map[x1-1][y1] == 11 || map[x1-1][y1] == 12) {
gauche1 = false;
} else {
droite1 = false;
gauche1 = true;
haut1 = false;
bas1 = false;
x1--;
}
}
if (key == '0') {
if (nombreBombe1 == 1) { //LIMITEUR1
if (limiteur1 == 0) {
g1 = x1;
h1 = y1;
map[g1][h1] = 10;
bomb1 = true;
limiteur1 = limiteur1 +1;
}
}
if (nombreBombe1 == 2) {
if (limiteur1 == 1 || limiteur1 == 0) {
g1 = x1;
h1 = y1;
map[g1][h1] = 10;
bomb1 = true;
limiteur1 = limiteur1 +1;
}
}
if (nombreBombe1 == 3) {
if (limiteur1 <= 2) {
g1 = x1;
h1 = y1;
map[g1][h1] = 10;
bomb1 = true;
limiteur1 = limiteur1 +1;
}
}
if (nombreBombe1 == 4) {
if (limiteur1 <= 3) {
g1 = x1;
h1 = y1;
map[g1][h1] = 10;
bomb1 = true;
limiteur1 = limiteur1 +1;
}
}
if (nombreBombe1 == 5) {
if (limiteur1 <= 4) {
g1 = x1;
h1 = y1;
map[g1][h1] = 10;
bomb1 = true;
limiteur1 = limiteur1 +1;
}
}
}
}