Devenez Un Petit Gu00e9nie Des Jeux Vidu00e9o

Devenez un des

petit génie

jeux vidéo Développez facilement des jeux vidéos multiplates-formes http://www.free-livres.com/

à 7 D e ! s n a 7 9 Ian Cinnamon

L E

P R O G R A M M E U R

Devenez un petit génie des jeux vidéo Ian Cinnamon

Pearson Education France a apporté le plus grand soin à la réalisation de ce livre afin de vous fournir une information complète et fiable. Cependant, Pearson Education France n’assume de responsabilités, ni pour son utilisation, ni pour les contrefaçons de brevets ou atteintes aux droits de tierces personnes qui pourraient résulter de cette utilisation. Les exemples ou les programmes présents dans cet ouvrage sont fournis pour illustrer les descriptions théoriques. Ils ne sont en aucun cas destinés à une utilisation commerciale ou professionnelle. Pearson Education France ne pourra en aucun cas être tenu pour responsable des préjudices ou dommages de quelque nature que ce soit pouvant résulter de l’utilisation de ces exemples ou programmes. Tous les noms de produits ou marques cités dans ce livre sont des marques déposées par leurs propriétaires respectifs.

Publié par Pearson Education France 47 bis, rue r ue des Vinaigriers Vinaigriers 75010 PARIS Tél. : 01 72 74 90 00

Titre original : Programming Video Games for the Evil Genius Traduit et adapté de l’américain par Isabelle Hurbain-Palatin

Mise en e n pages page s : TyPAO TyPAO ISBN : 978-2-7440-4090-0 Copyright© 2009 Pearson Education France

Tous droits réservés

ISBN : 978-0-07-149 978-0-07-149752-7 752-7 Copyright © 2008 by The McGraw-Hill Companies, Inc. All rights reserved

Aucune représentation ou reproduction, même partielle, autre que celles prévues à l’article L. 122-5 2˚ et 3˚ a) du code de la propriété intellectuelle ne peut être faite sans l’autorisation expresse de Pearson Education France ou, le cas échéant, sans le respect des modalités prévues à l’article L. 122-10 dudit code. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from Pearson Education, Inc.

Sommaire

.............. ............... ............... .............. ............... ............... .............. ....... VII Préface ....... .............. ............... ............... .............. ....... VIII À propos de l’auteur ....... Introduction .... ........... .......... .......... .............. .......... .......... .............. .......... ....... 1 Le compilateur ... .............. .......... .......... .............. .......... .......... .............. ..... 5

.......... .............. .......... .......... .............. .......... ..... 3. Jeux de plateau .......

.................. 1. Java dans les starting-blocks ...

9

....... ........ ....... ....... ........ ....... ....... ........ ....... ....... ........ 2. Jeux de course ...

39

.......... ........ ....... ....... ........ ....... ....... ........ ........ 229 7. Jeux de réflexion ...... ............... .............. .............. ............... ............... .............. ............... ............ 275 Index ........

91

........ ....... ....... ........ ....... ....... ........ ....... ....... ....... ....... ........ ...... 125 4. Jeux de tir ....

5. Jeux de stratégie ...... .......... ........ ....... ....... ........ ....... ....... ........ ........ 143 .......... .............. .......... .......... ....... 18 1877 6. Anciens jeux... revisités ...

Table des matières

Préface ............................................................ VII À propos de l’auteur ...................................... VIII Introduction .................................................... Remerciements ...........................................

1 4

Le compilateur ...............................................

5

CHAPITRE 1. Java dans les starting-blocks ... Projet 1 : Le perroquet ................................ Projet 2 : Devinez le mot de passe ! ........... Projet 3 : Calcul mental .............................. Projet 4 : Une bibliothèque virtuelle de jeux Projet 5 : Devinez le nombre ! ................... Java dans les starting-blocks : le résumé ....

9 10 14 23 30 35 37

CHAPITRE 2. Jeux de course ........................... La course du courage Projet 6 : La piste ....................................... Projet 7 : Les voitures ................................ Projet 8 : Collisions ! ................................. Projet 9 : Personnalisation ......................... Le skieur Projet 10 : La piste ...................................... Projet 11 : Piste verte ................................. Projet 12 : La compétition .........................

39 40 47 53 61 72 77 83

CHAPITRE 3. Jeux de plateau ......................... La chasse aux mauvais génies Projet 13 : Le laboratoire ............................ Projet 14 : Attrapez-les vite ! ..................... Projet 15 : Plus intelligent... ...................... Le morpion boxeur Projet 16 : Le ring ...................................... Projet 17 : Combat ! ................................... Projet 18 : K.-O. ! ...................................... CHAPITRE 4. Jeux de tir .................................. Destructeurs de l’espace Projet 19 : Le paysage .............................. Projet 20 : Lasers ....................................... Projet 21 : La vengeance ............................ CHAPITRE 5. Jeux de stratégie ....................... Démineurs Projet 22 : Le petit nouveau de l’équipe ..... Projet 23 : Démineur expert ....................... Projet 24 : BOUM ! ................................... Projet 25 : Promotions ............................... Pièges Projet 26 : Déplacements .......................... Projet 27 : Mise en place des pièges ..........

91 92 97 101 105 110 116 125 126 129 135 143 144 148 153 159 166 170

VI

Devenez un petit génie des jeux vidéo

Projet 28 : Piégé ! ....................................... 175 Projet 29 : Le spectacle .............................. 180

CHAPITRE 6. Anciens jeux... revisités ............ Oiram Projet 30 : La plate-forme ......................... Projet 31 : Allez Oiram ! ............................ Projet 32 : Les méchants ............................ Projet 33 : Un monde compliqué ............... Javaman Projet 34 : L’univers de Javaman ............... Projet 35 : Javaman vit ! ............................ Projet 36 : L’attaque du C++ ......................

187 188 192 198 205 214 217 222

CHAPITRE 7. Jeux de réflexion ....................... 229 Jeu de mémoire Projet 37 : Dessin de la grille .................... Projet 38 : Correspondances ...................... Projet 39 : Battez le chronomètre .............. Ian a dit Projet 40 : Jeu de couleurs ......................... Projet 41 : Surchauffe de cerveau .............. Projet 42 : Plus de niveaux ! ...................... Projet 43 : Accessoires de jeu ....................

230 235 240 248 252 259 265

Index ............................................................... 275

Préface

Il y a plusieurs années, Ian Cinnamon a assisté aux iD Tech Camps de UCLA (University of California, Los Angeles). Ian y a appris à programmer en C++ et en Java. Année après année, Ian a continué à assister aux camps et sa maîtrise de la programmation s’est visiblement améliorée. Mais il est apparu qu’il dépassait ses pairs et qu’il avait besoin de nouveaux défis. Ses instructeurs disaient de lui qu’il absorbait et assimilait rapidement les notions de programmation, comme s’il rentrait chez lui, lisait et résolvait des problèmes sur son temps libre. Il se trouve que c’est exactement ce qu’il faisait. J’ai eu l’occasion de rencontrer Ian il y a deux ans à l’Université de Stanford. C’est un jeune homme formidable avec de bonnes manières, d’excellentes capacités sociales et, bien sûr, un grand talent de programmeur. Il est un des meilleurs programmeurs que j’ai vus aux iD Tech Camps, ce qui est impressionnant au vu des milliers de programmeurs qui ont reçu leur diplôme des iD Tech Camps pendant toutes ces années. Ian, qui a aujourd’hui tout juste quinze ans, est devenu un modèle pour sa génération. Son livre, Devenez un petit génie des jeux vidéo , offre une approche étape par étape à la programmation de jeux vidéo, ce qui est un rêve pour de nombreux jeunes. J’entends souvent des phrases comme "J’aimerais savoir programmer mon propre jeu" et "Je ne sais pas par où commencer". Ma suggestion est de participer aux id Tech Camps et de se procurer un exemplaire du livre de Ian. Savoir où aller et y plonger sont des étapes cruciales. Ian élève sa génération et démystifie le code des jeux vidéo. Je suis très impatient de voir où Ian en sera dans cinq ou dix ans. Préparez-vous. Pete Ingram-Cauchi Président et CEO, iD Tech Camps, internalDrive, Inc.

À propos de l’auteur Ian Cinnamon est un phénomène de 15 ans qui programme depuis plus de sept ans et qui est certifié en Java et en C++. Il est actuellement lycéen à la Harvard-Westlake School de Los Angeles, Californie.

Introduction

Maîtriser l’univers des jeux Quoi de mieux que jouer aux jeux vidéo ? Créer vos propres jeux vidéo ! Des jeux que vous concevez, des jeux que vous contrôlez... des jeux selon vos règles. Lorsque vous achetez un jeu en magasin, ce jeu est souvent le résultat de mois, voire d’années d’efforts d’une petite équipe de professionnels créant des programmes extrêmement complexes aidés des ordinateurs les plus récents et les plus puissants. Mais il leur manque quelque chose pour créer le jeu parfait : vous-même, le créateur de jeux. Vous êtes le maître de votre univers de jeu. Vous pouvez créer le monde que vous voulez. Vous pouvez choisir les couleurs de fond, les niveaux de difficulté, la forme du plateau de jeu et les codes de triche. Vous pouvez inventer des personnages, concevoir des défis, choisir comment les points sont distribués et comment un joueur gagne... ou perd. Vous pouvez programmer tout ce à quoi vous pensez.

Votre borne d’arcade personnelle Vous est-il déjà arrivé de vous ennuyer à force de jouer au même jeu, encore et encore ? Ce ne sera bientôt plus le cas. Vous pouvez créer un assortiment de jeux avec des variantes illimitées. Vous trouverez dans ces pages le secret de la construction de jeux de course, de jeux de plateau, de jeux de tir, de jeux de stratégie, d’anciens jeux revisités et de jeux de réflexion.

2

●

●

●

●

●

●


Jeux de course. Attention à l’adrénaline ! Construisez des jeux dans lesquels vous ferez une course contre la montre, contre un adversaire ou même contre vousmême. La vitesse et la précision seront vos atouts clés lorsque vous vous déplacerez, que votre moyen de transport soit une voiture, une fusée, un balai, une paire de skis ou tout autre moyen de transport qui puisse être imaginé par un petit génie de la programmation. Jeux de plateau. Des terrains mentaux minés pour vous rendre fou ! Des jeux et des labyrinthes qui vous demanderont des prouesses de réflexion, d’astuce et de manœuvres pour battre vos adversaires ! Frustrez vos ennemis et mettez-les à genoux. Le concept : un jeu du morpion dopé aux stéroïdes ! Jeux de tir. Des jeux mettant à rude épreuve vos réflexes et vos nerfs ! Transformez-vous en soldat, en charmeur de serpent, en guerrier alien ou en homme de Neandertal jetant des pierres tandis que vous visez dans le monde que vous créez. Jeux de stratégie. Piégez vos adversaires dans une boîte dont il sera impossible de sortir ou désamorcez une bombe avant qu’elle puisse détruire la Terre ! Dans tous les cas, relevez le défi. Une tête froide et une réflexion rapide seront nécessaires. Jeux anciens revisités. Revoyez les classiques à votre sauce ! Créez des variations de Mario et de Pac-Man en programmant de nouvelles fonctionnalités et astuces qui renouvelleront ces jeux. Jeux de réflexion. Avez-vous une bonne mémoire ? Gérez-vous bien la pression ? Nous l’espérons, car dans ces jeux, vous vivrez ou mourrez en fonction de ce que vous vous rappelerez. Réglez la difficulté en fonction de votre courage.

La programmation : le langage des jeux En musique, il existe des notes ; en mathématiques, des équations ; dans une langue, des mots. Dans le monde des jeux vidéo, il existe des commandes qui donnent vie à vos jeux. Cela s’appelle la programmation. C’est ainsi que vous indiquez à l’ordinateur ce qu’il doit faire. Tous les jeux que vous allez créer seront programmés en Java, le langage de programmation le plus universel. Et qu’en est-il si vous ne savez absolument pas programmer ? Si vous n’avez aucune idée de la manière dont l’ordinateur transforme vos idées en actions et en images ? Pas d’inquiétude ! Je vous guiderai étape par étape à travers les bases de ce langage très polyvalent. Lorsque vous en aurez terminé avec Devenez un petit génie des jeux vidéo, vous aurez non seulement une bibliothèque de jeux personnalisés fantastique, mais vous serez aussi un habile créateur de jeux.

Introduction 3

Les briques de la création de jeux La programmation se compose de plusieurs briques. Vous apprendrez facilement à vous en servir, nous les détaillerons étape par étape. Les captures d’écrans sont vos guides lorsque vous apprenez à maîtriser ces outils importants car elles sont infaillibles. Et, comme rouler à bicyclette, lorsque vous savez vous en servir, cela ne s’oublie pas. Si vous êtes débutant en programmation, la section 1 vous permettra de partir très rapidement sur de bonnes bases. Si vous avez déjà un peu d’expérience, vous pouvez passer directement à la section 2. Les briques utilisées dans la création de jeux incluent : ●

●

●

●

●

●

●

●

●

●

Les instructions. Centre névralgique et squelette de tous les jeux. Les commentaires. Ils permettent d’annoter votre code pour savoir ce que fait chaque ligne. Les contrôles de flux. Ils vous permettent de répéter du code. Ils sont très pratiques pour relancer un jeu. Les variables. Elles permettent de garder une trace des scores, des noms des joueurs, des niveaux, etc. Les instructions if. Elles permettent de tester vos variables grâce à des conditions. Par exemple, si vous tuez un ennemi, votre score augmente. JOptionPane.

Ils permettent de gérer les entrées et les sorties, par exemple pour afficher le score d’un joueur ou pour récupérer son nom pour la liste des scores les plus élevés.

Les nombres aléatoires. Ils sont à la base de l’intelligence artificielle. Pour déplacer un ennemi de manière aléatoire, les nombres aléatoires sont ce qu’il vous faut. Les pauses. Elles permettent d’influencer le rafraîchissement de l’écran pour que vos graphismes restent clairs et nets. Les tableaux et les ArrayList. Ils servent à grouper des objets similaires (ennemis, recharges, etc.) et ainsi à gagner du temps. Les accès aux fichiers (lecture et écriture). Ils permettent de sauvegarder le jeu, ce qui est pratique lorsque votre chef arrive de manière impromptue et que vous êtes en train de jouer au lieu de travailler.

4


Remerciements Vous ne seriez pas en train de lire ce livre sans le dévouement et le soutien des personnes suivantes : ●

●

●

●

Mes parents : leur amour inébranlable, leurs encouragements, leur aide et même leurs plaisanteries ont été vitaux à l’écriture de ce livre. Ils ont toujours été là pour moi et je sais qu’ils le seront toujours. Maman, papa, je vous aime. Ma petite sœur, Molly : elle est mon agent publicitaire officieux et dit à tous ceux qu’elle rencontre d’acheter ce livre. Judy Bass, mon éditrice à McGraw-Hill : son enthousiasme pour le projet et sa foi en moi dès le départ compteront toujours pour moi. Pete Ingram-Cauchi, le CEO de iD Tech Camps : ses cours à UCLA et à Stanford ont nourri ma passion pour tout ce qui touche à la programmation.

Le compilateur

Faire obéir votre ordinateur Vous n’avez besoin que de trois choses pour commencer à créer vos propres jeux : un ordinateur (PC, Mac), ce livre... et un compilateur. Ce logiciel traduit votre code en un langage que votre ordinateur pourra comprendre. Si vous n’avez pas encore de compilateur, il peut être téléchargé gratuitement sur Internet. Sous Windows et sous Linux, allez à l’adresse http://java.sun.com et cliquez sur Java SE sous Popular Downloads. Cliquez sur le bouton Download situé à côté du titre JDK 6 Update 6 with NetBeans 6.1 . Dans la page qui s’affiche, cliquez sur le bouton Download. Choisissez votre plateforme et acceptez l’accord de licence avant de cliquer sur Continue. Cliquez sur le lien pour télécharger l’installeur. Mac OS X dispose déjà d’un compilateur Java et il suffit donc d’installer NetBeans. Allez à l’adresse http://download.netbeans.org/netbeans/6.1/final/ , choisissez votre plate-forme dans le menu en haut à droite et cliquez sur le bouton Download de la première colonne (Web & Java EE). JDK signifie Java Development Kit (kit de développement Java). Ce logiciel permettra à l’ordinateur de comprendre le code. NetBeans est un environnement de développement intégré qui facilite l’écriture du code. Installez NetBeans en cliquant sur l’icône d’installation (sous Linux, NetBeans peut également faire partie de votre base de paquetages par défaut, auquel cas il n’est pas nécessaire de le télécharger et il s’installera comme tout autre logiciel).

6


Examinons maintenant l’interface. Cliquez sur File > New Project. Figure 0.1 Le menu File de NetBeans

Cliquez sur Java Application. Figure 0.2 La fenêtre de création de projets

Le compilateur 7

Cliquez sur Next et saisissez le nom du projet dans Project Name. Ce nom devrait commencer par une majuscule et ne pas contenir d’espace.

Figure 0.3 Nommer le projet

Cliquez sur Finish. Pour créer un environnement dans lequel vous pourrez écrire votre code, commencez par supprimer Main.java, puis cliquez sur le répertoire parent et cliquez sur New > Java Class...

8


Figure 0.4 Suppression du fichier Main.java

Figure 0.5 Création d’une nouvelle classe Java

Et voilà... Vous n’avez plus qu’à conquérir le monde des jeux vidéo !

1 Java dans les starting-blocks Au sommaire de ce chapitre : ●

Projet 1 : Le perroquet

●

Projet 2 : Devinez le mot de passe !

●

Projet 3 : Calcul mental

●

Projet 4 : Une bibliothèque virtuelle de jeux

●

Projet 5 : Devinez le nombre !

10


Projet 1 : Le perroquet Projet Nouvelles briques

• Tapez un message, appuyez sur deux boutons, et l’ordinateur le répétera. • Classes, instructions et variables

Lorsque l’on apprend à programmer en Java, il faut connaître quatre types de code essentiels : les commentaires, les instructions, les déclarations et le contrôle de flux.

Les commentaires Les commentaires commencent toujours par //. Les compilateurs ne prennent pas en compte ces commentaires. Ils ne sont utiles qu’aux programmeurs qui peuvent ainsi documenter le code. Une bonne documentation (de bons commentaires) permet de modifier le code plus facilement ultérieurement. Lorsqu’un programme atteint quelques centaines de lignes, il est difficile de se souvenir à quoi sert chaque ligne. Les commentaires sont très utiles dans ce cas.

Les instructions Les instructions permettent de "faire des choses", par exemple afficher quelque chose à l’écran. Elles se terminent toujours par un point-virgule.

Les déclarations Les déclarations sont des instructions qui créent ou modifient des variables. Les variables s’utilisent comme en mathématiques (x = 4), à ceci près qu’elles peuvent contenir d’autres éléments que des nombres. Nous en parlerons plus longuement dans le prochain projet.

Le contrôle de flux Le contrôle de flux sert à manipuler les instructions utilisées. Nous en parlerons plus tard (Projet 3). Tous les programmes Java sont contenus dans ce que l’on appelle une classe (class). On crée une classe avec le code suivant : public class

Chapitre 1

Java dans les starting-blocks 11

Le nom de la classe doit correspondre au nom du fichier, il doit toujours commencer par une lettre majuscule et ne doit pas contenir d’espace. Par exemple, la classe Pingouin sera contenue dans le fichier Pingouin.java. Pour délimiter le code appartenant à une classe, on utilise les caractères { et } au début et à la fin du code, respectivement. Au sein d’une classe, Java cherche la méthode principale, appelée main. Une méthode est un morceau de code qui peut être appelé plusieurs fois. La méthode main est une méthode spéciale : Java l’appelle toujours en premier (c’est-à-dire exécute le code qui s’y trouve). Voici ce à quoi elle ressemble : public static void main (String[] args)

Vous pouvez pour l’instant considérer que cette ligne de code doit introduire la méthode main. Nous discuterons des différents éléments de cette ligne plus tard. En dehors des méthodes, il ne peut y avoir dans une classe que des déclarations et des commentaires. Les déclarations sont appelées les variables de la classe. Dans la méthode d’une classe, on peut trouver des déclarations, des commentaires, du contrôle de flux et des instructions. On peut accéder aux variables d’une classe à partir de toutes les méthodes, mais les variables à l’intérieur d’une méthode ne sont accessibles que depuis cette méthode. Voici une instruction simple, également illustrée à la Figure 1.1, permettant d’afficher un message à l’écran : System.out.println("Ce message entre guillemets est affiché.");

Figure 1.1 Ce code affiche du texte à l’écran

Ce code est une méthode fournie par Java. Il suffit de lui indiquer le texte à afficher, entre guillemets. À l’intérieur des guillemets, il existe des séquences d’échappement qui sont des suites de caractères permettant de manipuler le texte. Ajoutez-les simplement dans le texte entre guillemets.

12


Tableau 1.1 : Séquences d’échappement Séquence d’échappement

Résultat

\n

Crée un retour à la ligne

\t

Indente la ligne (ajoute une tabulation)

\"

Permet d’ajouter un guillemet à l’intérieur des guillemets

Créer le jeu Pour que le programme répète le texte que vous avez saisi, vous devez donc créer une classe, écrire la méthode main et ajouter le code System.out.println(). Tout ce que vous placerez entre guillemets sera répété par l’ordinateur. Essayez de faire cela tout seul. Si cela fonctionne, vous avez gagné et vous pouvez passer au projet suivant ! Si vous avez besoin d’aide, le code complet est indiqué ci-après : // crée une classe nommée S1P1 public class S1P1 { // ceci est la méthode main public static void main (String[] args) { // ceci affiche ce qui est écrit entre guillemets System.out.println("Ce que vous tapez ici... sera répété !"); } }

Cliquez sur Build > Build Main Project > OK. Ceci compile votre jeu, comme le montre la Figure 1.2. Cliquez sur Run > Run Main Project. Ceci lance le projet, comme le montre la Figure 1.3. La Figure 1.4 illustre l’affichage de votre premier jeu ! Figure 1.2 Compiler le projet

Chapitre 1


Figure 1.3 Lancer le projet

Figure 1.4 Affichage du projet

Dans le projet suivant, vous apprendrez comment enregistrer des informations importantes (telles que le score actuel) et comment obtenir une saisie de l’utilisateur.

14


Projet 2 : Devinez le mot de passe ! Projet

Nouvelles briques

• Programmez l’ordinateur pour vérifier que le mot de passe a bien été tapé. Dans cet exercice à deux joueurs, un joueur donne des indices pendant que l’autre tape des essais de mots de passe. L’ordinateur prévient le joueur lorsqu’il a gagné. Le mot de passe peut être changé par le biais de fenêtres pop-up et il est sauvé dans un fichier. • Variables (création et utilisation), blocs if, transtypage, saisie utilisateur, accès à des fichiers

À l’heure actuelle, vous savez créer un programme simple qui affiche un message à l’écran. Vous allez maintenant apprendre à créer des variables, à les manipuler et à les tester.

Création de variables Ces lignes se terminent toujours par des points-virgules ! Voici les types de variables de base que vous utiliserez le plus souvent : Integer (entier) int. Un entier positif ou négatif. ● Double (nombre à virgule flottante) double. Un nombre décimal positif ou négatif. ● Character (caractère) char. Une lettre. ● String (chaîne) String. Un ensemble de caractères. ● Boolean (booléen) boolean. Une valeur vraie (true) ou fausse ( false). ● Comment créer (déclarer et initialiser) une variable ? Les variables de type int, double ou char se déclarent comme ceci : int int peut

= ;

être remplacée par double ou par char. est à remplacer par n’importe quel nom commençant par une lettre minuscule (pas de nombre ni de symbole). Pour les variables de type int, peut contenir n’importe quel nombre (par exemple –10, –9 999 ou 298). Pour les variables de type char, est une lettre entre apostrophes (par exemple, char lettre = ’k’;). Pour les variables de type String, est une chaîne de caractères entre guillemets (par exemple, String texte = "Je suis une chaîne de caractères.";).


Chapitre 1

Vous pouvez aussi créer une variable sans indiquer sa valeur (cela s’appelle une déclaration). Il suffit pour cela de terminer la ligne prématurément avant l’initialisation de la variable grâce à un point-virgule : int number;

Si la variable est déjà déclarée et si vous voulez modifier (ou initialiser) sa valeur, utilisez le code suivant (cela s’appelle une initialisation) : nombre = 1;

On peut aussi modifier la valeur d’un entier int ou d’un flottant double en utilisant les syntaxes qui suivent. Pour ajouter 1 à nombre : nombre++;

Pour enlever 1 à nombre : nombre--;

Pour ajouter 5 (ou toute autre valeur/variable) à nombre : nombre +=5;

Pour donner à nombre la valeur de la somme de deux variables : nombre =

+

variable1 et variable2 peuvent être remplacées par un nombre ou par une autre ble de type int ou double.

varia-

+ peut

être remplacé par -, *, / ou %. L’opérateur % renvoie le reste de la division du premier nombre par le second. On peut concaténer des variables de type String. La concaténation est la combinaison de deux chaînes. Par exemple, la chaîne txt résultant de String txt = "Ceci est ajouté à" + " cela." contiendra "Ceci est ajouté à cela.".

Tester des variables Utilisez des instructions if pour tester des variables, comme le montre le code suivant : if( == ){} et peuvent

valeur.

être remplacées par n’importe quelle variable ou

16


On peut aussi utiliser d’autres comparateurs à la place de == : ●

!= teste

l’inégalité.

●

> teste

si la première variable est strictement supérieure à la seconde.

●

< teste

si la première variable est strictement inférieure à la seconde.

●

>= teste

si la première variable est supérieure ou égale à la seconde.

●

<= teste

si la première variable est inférieure ou égale à la seconde.

Lorsque les variables sont de type syntaxe suivante :

String,

il ne faut pas utiliser

==.

Il faut utiliser la

if(.equals())

Pour tester si elles sont différentes : if(!.equals())

L’instruction if exécute le code contenu entre accolades lorsque la condition est vraie. Comment faire si vous désirez que du code soit exécuté lorsque la condition est fausse ? Java permet de faire cela de la manière suivante : if( ) { // code lorsque condition1 est vérifiée } else if( ) { //code lorsque condition1 n’est pas vérifiée mais que condition2 l’est } else { //code lorsque ni condition1 ni condition2 ne sont vérifiées }

Vous pouvez utiliser tout ou partie du code ci-dessus pour autant que l’instruction if soit la première et que le bloc else (si vous en avez un) soit le dernier. On ne peut utiliser un booléen b que de deux manières avec une instruction if : if(b) signifie "si b a la valeur true" (vrai) et if(!b) signifie "si b a la valeur false" (faux). On peut initialiser une variable de type boolean comme toute autre variable : boolean b = true; boolean b = false;

Chapitre 1


Saisie de l’utilisateur Vous savez maintenant comment comparer des valeurs. Vous devez maintenant accéder à la saisie de l’utilisateur. Ajoutez d’abord une ligne (qu’il vous suffit de mémoriser, nous l’expliquerons plus tard) au tout début de votre programme, avant la déclaration de la classe : import javax.swing.*;

Ajoutez ensuite le code suivant à l’endroit où vous désirez que l’utilisateur saisisse quelque chose : String saisie = JOptionPane.showInputDialog("Quel est votre nom ?");

Ceci crée une fenêtre de dialogue, demandant "Quel est votre nom ?" et permettant de répondre dans zone de saisie (voir Figure 2.1). Figure 2.1 Boîte de dialogue de saisie

saisie contient la valeur saisie par l’utilisateur. Cette valeur est toujours une valeur de type String, mais peut être transformée en d’autres valeurs.

Cette méthode peut diminuer le nombre de valeurs à coder en dur. Coder en dur signifie insérer la valeur d’une variable directement dans le programme. Lorsque vous obtenez une saisie d’un utilisateur, vous pouvez initialiser des variables après la compilation du programme.

Transtypage Le transtypage permet de modifier un type de variable (par exemple String) en un autre type de variable (par exemple int). Pour faire cela, utilisez le code suivant (en supposant que vous ayez déjà une variable de type String nommée saisie) : int saisieSousFormeInt = Integer.parseInt(input); double saisieSousFormeDouble = Double.parseDouble(input);

Vous pouvez maintenant manipuler des entrées utilisateur !

18


Créer des fichiers Tous les types de fichiers sont sauvés de la même manière. La seule différence est l’extension (.doc, .txt, .avi, .jpg, etc.). Les extensions servent à indiquer à l’ordinateur et à l’utilisateur quel programme doit être utilisé pour ouvrir le fichier. Dans notre exemple, le mot de passe sera enregistré dans un fichier.mdp. Mais nous aurions aussi bien pu l’enregistrer dans un fichier.petitGenie ou .nimportequoi. Créez d’abord un fichier grâce au code suivant : File fichier = new File("motdepasse.mdp");

Cette ligne ne fait pour l’instant pas grand-chose. Elle se contente d’allouer un espace pour un fichier nommé motdepasse.mdp. Nous allons maintenant voir comment sauver ce fichier sur votre ordinateur. Vous devez pour cela écrire le code suivant : FileOutputStream fluxSortie = new FileOutputStream(); est le nom de l’objet File créé précédemment (dans notre cas, Fichier). fluxSortie est

le nom de la variable ; c’est un nom arbitraire.

PrintWriter sortie = new PrintWriter(fluxSortie); fluxSortie est sortie est

le nom de l’objet FileOutputStream défini précédemment.

également un nom de variable.

Jusqu’ici, nous avons alloué de l’espace pour un fichier et préparé l’ordinateur à l’enregistrer. La ligne suivante enregistre effectivement le fichier : sortie.println("Ce texte est écrit dans le fichier"); "Ce texte est écrit dans le fichier" est String.

habituellement une variable de type

Une fois le fichier créé, il faut indiquer à l’ordinateur que tout est fini. Utilisez pour cela les lignes suivantes : sortie.flush(); sortie.close(); fluxSortie.close();

Voilà, vous savez à présent comment écrire et enregistrer un fichier.


Chapitre 1

Accéder à des fichiers Créez à nouveau un objet File : File fichier = new File("motdepasse.mdp");

Cette fois, la variable de type String (ici, "motdepasse.mdp") est le nom du fichier que vous allez ouvrir. Ensuite, créez un objet de type FileReader. La classe FileReader sert à ouvrir le fichier et à en préparer la lecture. FileReader fr = new FileReader(fichier); fichier est fr est

l’objet File créé précédemment auquel nous accédons.

le nom de la variable.

Créez alors un objet de type BufferedReader. La classe BufferedReader sert à lire le texte d’un fichier ouvert. BufferedReader tampon = new BufferReader(fr); fr est

le nom de l’objet FileReader.

tampon est

le nom de la variable.

Pour lire la première ligne de votre fichier, utilisez la ligne : String ligne = tampon.readLine();

Lorsque vous avez terminé d’accéder à un fichier, vous devez indiquer à l’ordinateur que vous avez fini : tampon.close(); fr.close();

Vous devez aussi ajouter un throw Exception (dont nous parlerons dans le Projet 3) dans la déclaration de la méthode main et une ligne import java.io.*; pour pouvoir accéder aux fichiers.

Créer le jeu Lorsque le joueur lance le jeu, deux options s’offrent à lui : jouer ou réinitialiser le jeu. S’il décide de réinitialiser le jeu, il doit saisir un nouveau mot de passe (qui sera sauvegardé dans un fichier).

20


S’il décide de jouer, il pourra essayer de deviner le mot de passe. Pour écrire le jeu, nous utiliserons la classe JOptionPane pour proposer les différents choix au joueur. Lorsque le joueur décide de saisir un nouveau mot de passe, il faut utiliser le code d’écriture de fichier pour sauvegarder le nouveau mot de passe dans un fichier. Si le joueur préfère essayer de trouver le mot de passe, accèdez au fichier et testez l’égalité des essais du joueur avec le texte du fichier. Affichez un message positif (par exemple "Bravo, vous avez deviné : vous êtes un petit génie !") grâce à System.out.println() si l’utilisateur a deviné le mot de passe. Sinon, affichez un message d’échec (par exemple : "Raté !"). //permettre la saisie utilisateur import javax.swing.*; // permettre l’accès aux fichiers import java.io.*; //crée une classe nommée S1P2 public class S1P2 { //méthode main. throws Exception est nécessaire pour les accès aux fichiers public static void main(String[] args) throws Exception { //cette chaine contiendra la saisie utilisateur String saisie; //saisie utilisateur saisie = JOptionPane.showInputDialog("1 pour initialiser le mot de ➥ passe,\n"+"2 pour chercher le message"); //fichier modifié et lu File fichier = new File("motdepasse.mdp"); //faut-il saisir ou lire le mot de passe ? if(saisie.equals("1")) { //on veut modifier le mot de passe //récupère le nouveau mot de passe String p = JOptionPane.showInputDialog("Saisissez le nouveau mot ➥ de passe"); //ces deux lignes initialisent l’écriture dans le fichier FileOutputStream fluxSortie = new FileOutputStream(fichier); PrintWriter sortie = new PrintWriter(fluxSortie); //écrit le mot de passe dans le fichier sortie.println(p); //on ferme tout sortie.flush(); sortie.close(); fluxSortie.close(); }


Chapitre 1

}

}

//si l’utilisateur veut trouver le mot de passe else { //il faut d’abord le récupérer FileReader fr = new FileReader(fichier); BufferedReader tampon = new BufferedReader(fr); //le mot de passe du fichier String passe = tampon.readLine(); //récupère l’essai de l’utilisateur String passeUtilisateur; passeUtilisateur = JOptionPane.showInputDialog("Saisissez votre essai..."); //tester le mot de passe if(passe.equals(passeUtilisateur)) { //si c’est correct JOptionPane.showMessageDialog(null,"CORRECT !!!!"); } else { //si c’est faux JOptionPane.showMessageDialog(null,"RATÉ :("); } }

Les Figures 2.2 à 2.6 illustrent le jeu. Figure 2.2 Réinitialiser ou deviner le mot de passe

Figure 2.3 Saisir le nouveau mot de passe

Figure 2.4 Deviner le mot de passe enregistré

22


Figure 2.5 Bonne réponse

Figure 2.6 Mauvaise réponse


Chapitre 1

Projet 3 : Calcul mental Projet

Nouvelles briques

• Le programme affiche des équations mathématiques. L’utilisateur doit résoudre le problème avant que l’ordinateur n’ait fini son décompte depuis 3 et n’affiche la réponse correcte. Pouvez-vous battre l’ordinateur ? • Nombres aléatoires, pauses, boucles.

Nombres aléatoires Les nombres aléatoires sont de type double car ils sont compris entre 0 (inclus) et 1 (exclus). Pour créer un nombre aléatoire entre 0 et 1, utilisez cette instruction : Math.random()

Elle renvoie une valeur, de la même manière que JOptionPane, à ceci près que la valeur renvoyée est de type double et non String. Pour créer un nombre aléatoire d’un chiffre, essayez ce code : int rand = (int) (Math.round(Math.random()*10)); (int) permet

de s’assurer que la variable résultante est bien de type int.

Math.round() arrondit

à l’entier le plus proche.

Faire une pause Vous pouvez imposer à l’ordinateur de faire une pause d’une durée donnée avec une commande très simple : Thread.sleep(100);

100 est le nombre de millisecondes de la pause (cette valeur peut être remplacée par une variable de type int). Vous devez aussi ajouter un élément à la fin de la déclaration de la méthode Après (String[] args), ajoutez throws Exception. La ligne complète ressemblera alors à ceci : public static void main (String[] args) throws Exception

main.

24


Boucles Il est temps d’apprendre quelques techniques de contrôle de flux. Le contrôle de flux permet de répéter et d’exécuter différentes parties du code à différents moments en fonction d’une condition (par exemple, x==4). Il existe trois types de boucles.

Boucles for Les boucles for permettent d’exécuter le code à l’intérieur des accolades jusqu’à ce qu’une condition donnée soit satisfaite. En voici le format : for (; ; ) { // le code répété se trouve ici } est

une déclaration de variable classique (par exemple int

i = 0;).

peut

être i<0, i>0, i>=0 ou i<=0 ou encore une instruction quelconque pouvant se trouver à l’intérieur des parenthèses d’une instruction if. peut

être par exemple i++ (c’est souvent le cas).

Fonctionnement d’une boucle for Lorsque le JRE ( Java Runtime Environment , Environnement d’exécution Java) atteint la déclaration de la variable, il crée la variable (qui n’existe qu’au sein du bloc for). Si la condition est vérifiée, le code est exécuté. Puis, le code de l’itérateur est exécuté. La condition est à nouveau vérifiée et le processus est répété. Par exemple, dans le cas suivant, si la variable i n’est pas modifiée dans le bloc de la boucle for, le code entre accolades sera exécuté dix fois : for (int i=0; i<10; i++) {}

Boucles while Les boucles while sont similaires aux boucles for, à ceci près qu’elles n’incluent pas la déclaration de la variable ni l’itération. Elles n’incluent que la condition. L’équivalence de la boucle for précédente sous la forme d’une boucle while serait : int i = 0; while (i < 10) { i++; }

Chapitre 1


Fonctionnement d’une boucle while Lorsque le compilateur rencontre une boucle while, la condition est testée. Si elle est vérifiée, le compilateur entre dans la boucle et reteste la condition à chaque itération. Si la condition n’est pas vérifiée, la boucle est arrêtée. Boucles do ... while Les boucles do ... while sont presque identiques aux boucles exemple :

while.

En voici un

int i = 0; do { i++; } while (i<10);

Fonctionnement d’une boucle do ... while Les boucles do ... while fonctionnent de la même manière que les boucles while, mais le code entre accolades est toujours exécuté une fois avant même que la condition ne soit testée.

Mots clés Le mot clé le plus important lorsqu’on travaille avec des boucles est immédiatement de la boucle. En voici un exemple :

break qui

sort

for (int i=0; i<10; i++) { if(i==1) { break; } }

Dans ce cas, le compilateur passe une première fois (pour i=0) dans la boucle, puis une seconde fois (pour i=1) et sort de la boucle (en raison de la condition i==1).

Créer le jeu Vous pouvez à présent créer un jeu utilisable dans des compétitions mathématiques dans le monde entier ! Créez une équation mathématique avec deux nombres en utilisant n’importe laquelle de ces opérations : addition, soustraction, multiplication, division ou modulo.

26


Déclarez et initialisez deux variables de type int avec un nombre aléatoire entre 0 et 9. Puis, créez une nouvelle variable de type int avec un nombre aléatoire entre 0 et 4 : ●

Si le nombre est 0, l’opération sera * (multiplication).

●

Si le nombre est 1, l’opération sera / (division).

●

Si le nombre est 2, l’opération sera + (addition).

●

Si le nombre est 3, l’opération sera – (soustraction).

●

Si le nombre est 4, l’opération sera % (modulo).

Créez une nouvelle variable contenant la solution du problème mathématique. Puis, mettez le programme en pause pour laisser à l’utilisateur le temps de répondre à la question. Affichez la variable qui contient la solution. Si le joueur peut calculer la réponse correcte avant que l’ordinateur ne l’affiche, il gagne la partie. Pour rendre les choses un peu plus amusantes, nous pouvons laisser l’utilisateur choisir son niveau de difficulté en modifiant le décompte de temps (de 1, petit génie, à 10, nul en mathématiques) : plus le niveau est bas, moins le joueur a de temps pour répondre. Nous pouvons aussi demander à l’utilisateur s’il désire continuer grâce à une boucle do... while. Les plus malins d’entre vous se demanderont ce qu’il se passe si le générateur de nombres aléatoires propose une division pour le signe et un 0 comme second opérande de l’opération. Dans ce cas, le programme lance une exception, ce qui le fait terminer avec une erreur. Pour éviter cela, il suffit de placer le code de génération du second opérande dans une boucle do... while ; si le résultat est 0, il suffit de le modifier. Voici le code : //permettre la récupération de saisies utilisateur import javax.swing.*; //crée une classe nommée S1P3 public class S1P3 { //méthode main. (throw Exception) est nécessaire pour Thread.sleep() public static void main(String[] args) throws Exception { //nombre de demi-secondes accordées à l’utilisateur int difficulte;

Chapitre 1


difficulte = Integer.parseInt(JOptionPane.showInputDialog("À quel point ➥ êtes-vous doué ?\n" + "1 = je suis un petit génie !\n"+ "10 = je ne suis pas vraiment doué.")); //indique à la boucle s’il faut continuer ou pas boolean cont = false; //le contenu de la méthode main est encadré dans une boucle while do { //réinitialise la variable cont à false cont = false; //nombres aléatoires pour l’équation int num1 = (int)(Math.round(Math.random()*10)); //la boucle do... while sert à éviter l’exception. num2 doit être //déclaré à l’extérieur de la boucle do... while pour être visible //à l’extérieur de cette boucle. int num2; do { //initialisation de num2 num2 = (int)(Math.round(Math.random()*10)); } while(num2 == 0); //si num2 vaut zéro, on recommence //nombre aléatoire pour le signe int signe = (int)(Math.round(Math.random()*3)); //contiendra la réponse int reponse; //rend l’affichage plus lisible System.out.println("\n\n*****"); if(signe==0) { //affiche la question et calcule la réponse System.out.println(num1+" fois "+num2); reponse = num1*num2; } else if(signe == 1) { //affiche la question et calcule la réponse System.out.println(num1+" divisé par "+num2); reponse = num1/num2; } else if(signe == 2) { //affiche la question et calcule la réponse System.out.println(num1+" plus "+num2); reponse = num1+num2; } else if(signe == 3) { //affiche la question et calcule la réponse System.out.println(num1+" moins "+num2); reponse = num1-num2; } else { //affiche la question et calcule la réponse System.out.println(num1+" % "+num2); reponse = num1%num2; } //rend l’affichage plus lisible System.out.println("*****\n");

28


//décompte pour la difficulté - on utilise une boucle for for(int i = difficulte; i >= 0; i--) { //affichage du temps restant System.out.println(i+"..."); //on attend une demi-seconde par //niveau de difficulté Thread.sleep(500); } //affiche la réponse System.out.println("RÉPONSE : "+reponse); //demande à l’utilisateur s’il veut rejouer String encore; encore = JOptionPane.showInputDialog("Rejouer ? (oui/non)"); //si l’utilisateur répond oui, on passe la valeur de cont à true if(encore.equals("oui")) cont = true;

}

}

} while(cont); //on continue tant que cont a la valeur true

Les Figures 3.1 à 3.3 illustrent le jeu. Figure 3.1 Saisie du niveau de difficulté

Figure 3.2 Équation, décompte et résultat

Chapitre 1


Figure 3.3 Rejouer ?

Pour aller plus loin... Vous devez avoir remarqué que les réponses ne sont pas toujours exactes. Par exemple, 3/4 renvoie 1 et non 0,75. Pour corriger ce comportement, il suffit de modifier toutes les variables de type int (sauf celle contenant le signe) en variables de type double.

30


Projet 4 : Une bibliothèque virtuelle de jeux Projet Nouvelles briques

• Une archive des jeux que vous avez créés. • Tableaux, ArrayList .

Nous avons vu comment créer des jeux basiques ; nous allons maintenant apprendre à les enregistrer pour y accéder facilement. Pour cela, nous avons besoin de structures de données. La structure de données dont nous allons parler dans ce projet s’appelle un tableau (array). Un tableau permet d’enregistrer de nombreuses variables du même type (par exemple int, double ou String). Vous pourrez alors récupérer la valeur d’une variable d’un tableau en fonction de sa position. L’inconvénient des tableaux est qu’il est difficile d’y ajouter de nouvelles variables (appelées, dans un tableau, des éléments). C’est pour cette raison que nous allons également introduire les objets ArrayList.

Tableaux Pour créer et initialiser un tableau en une seule instruction, utilisez ce type de ligne : int pleinDEntiers[] = {-981, 45, -6, 7};

Cette instruction crée un tableau nommé pleinDEntiers contenant les valeurs –981, 45, –6 et 7. Pour créer un tableau sans en initialiser les éléments, on utilise cette syntaxe : int sixEntiers = new int[6];

Ceci crée un tableau pouvant contenir six éléments de type int ; pour l’instant, les valeurs du tableau sont vides. Il faut toujours définir la taille d’un tableau, qui dans notre cas est six. Pour accéder à une valeur/un élément d’un tableau ou pour la modifier, il faut se souvenir d’une notion importante : les numéros d’éléments commencent à zéro. Par exemple, dans le tableau pleinDEntiers, le premier élément (à la position 0) est –981. Le second élément (à la position 1) est 45. Et, bien sûr, l’élément à la position 2 est –6.

Modifier une valeur dans un tableau Pour modifier une valeur dans un tableau, on utilise une syntaxe de ce type : [] = ;

Chapitre 1


Par exemple, pour modifier le premier élément (à la position 0) du tableau DEntiers et lui donner la valeur 50, on utilisera :

plein-

pleinDEntiers[0] = 50;

Récupérer une valeur dans un tableau Pour récupérer une valeur dans un tableau, on utilise une syntaxe du type : = [];

Pour récupérer la valeur du premier élément de pleinDEntiers, on utilisera donc : int num = pleinDEntiers[0];

Objets ArrayList Un ArrayList contient des classes (aussi appelées objets). Il s’agit bien de la même chose que les classes que vous déclarez lorsque vous créez un programme (dans le code public class). Pour l’instant, nous n’utiliserons cependant que des classes déjà programmées. Nous avons déjà utilisé les syntaxes Integer.parseInt() et Double.parseDouble(). Double et Integer sont deux classes pouvant être contenues dans un ArrayList. Pour simplifier, nous ne parlerons pour l’instant que de ces deux classes. Toutes les classes appartiennent à une hiérarchie. Le membre le plus élevé de toutes les classes est appelé Object. Un ArrayList ne contient que des Object que l’on peut ensuite transtyper dans la classe de l’objet d’origine (dans notre cas, Integer ou Double). Voici le code utilisé pour créer un ArrayList. Notez qu’il n’est fait aucune mention du type des objets qui seront contenus dedans. ArrayList structure = new ArrayList();

Il n’est pas possible d’initialiser des valeurs sur la même ligne. Pour ajouter une valeur, on utilise : structure.add(new Integer(5));

Vous pouvez ajouter autant d’éléments que vous le désirez. Pour récupérer une valeur (dont vous connaissez la position, qui commence toujours par 0), utilisez le code suivant :

32


Object objTemp = structure.get(0); Integer intTemp = (Integer)tempObj; int numFinal = intTemp.intValue();

La première ligne récupère l’Object à la position 0 de l’ ArrayList. La deuxième ligne transforme l’objet en entier (pour le transformer en Double, remplacez Integer par Double). La dernière ligne transforme l’objet Integer en variable de type int (si vous travaillez avec des Double, changez intValue en doubleValue et int en double).

Créer le jeu Nous allons créer une bibliothèque virtuelle pour enregistrer le nom des jeux que vous avez créés. La bibliothèque permet d’accéder aux jeux en saisissant le numéro d’élément du jeu. Elle permet également de créer des éléments. Pour cela nous allons utiliser un ArrayList. Demandez à l’utilisateur, grâce à un JOptionPane, s’il désire ajouter un nouveau jeu ou accéder à un jeu. S’il saisit 1, ajoutez la nouvelle chaîne de caractères à l’ ArrayList. S’il saisit 2, utilisez un nouveau JOptionPane pour obtenir le numéro d’élément, puis un troisième JOptionPane pour afficher le nom du jeu. Le tout est encapsulé dans une boucle do... le programme s’il le désire.

while pour que

l’utilisateur puisse relancer

//on importe les éléments nécessaires import javax.swing.*; import java.util.*; public class S1P4 { public static void main (String[] args) { //définition de l’ArrayList ArrayList jeux = new ArrayList(); //utilisé comme condition d’arrêt de la boucle boolean cont = false; do { cont = false; //réinitialiser cont //que veut faire l’utilisateur ? int choix = Integer.parseInt(JOptionPane. showInputDialog("Saisissez\n"+"1 pour ajouter un nouveau jeu\n"+ "2 pour accéder à un jeu")); if(choix == 1) { //récupère le nom String nom; nom = JOptionPane.showInputDialog("Nom du jeu ?");


Chapitre 1

//on l’ajoute jeux.add(nom);

} if(choix ==2) { //on demande à l’utilisateur quel nom renvoyer int element = Integer.parseInt(JOptionPane. showInputDialog("Quel ➥ élément ?")); //ceci est affiché dans un nouveau JOptionPane String sortie = "Le nom du jeu est :\n"; //concaténation et récupération de l’élément sortie+=((String)jeux.get(element)); //on affiche dans le JOptionPane JOptionPane.showMessageDialog(null,sortie); } //saisie utilisateur pour la répétition String repeter = JOptionPane.showInputDialog("Recommencer ? (oui/non)"); if(repeter.equals("oui")) cont = true;

} while(cont); //continuer tant que cont a la valeur true } }

Les Figures 4.1 à 4.5 illustrent les différentes phases du programme. Dans le projet suivant, nous résumerons tout ce que nous avons appris dans un jeu de devinettes de nombres ! Figure 4.1 Choix du mode : ajout d’un jeu ou affichage d’un jeu

Figure 4.2 Saisie d’un nouveau nom de jeu

34


Figure 4.3 Continuer le programme

Figure 4.4 Accéder à un jeu en indiquant son numéro

Figure 4.5 Affichage du jeu demandé


Chapitre 1

Projet 5 : Devinez le nombre ! Projet

• L’ordinateur génère un nombre aléatoire entre 0 et 100 et vous devez le trouver. Après chaque essai, l’ordinateur offre un indice : trop grand ou trop petit. • Pour ce projet, vous devrez assembler plusieurs briques des projets précédents : les classes, les instructions, les variables, la saisie utilisateur, les boucles, les commentaires, l’affichage, le transtypage et les instructions if.

Créer le jeu Commencez par générer un nombre aléatoire. Puis, utilisez une boucle do... while. Récupérez une saisie utilisateur (son essai) et comparez-la au nombre correct avec des instructions if. Cela fournira les indices pour le joueur. La boucle do... while se termine lorsque la tentative est couronnée de succès. import javax.swing.*; public class S1Resume { public static void main (String[] args) { //contient les essais de l’utilisateur int essai = -1; //nombre d’essais int nombre = 0; //création du nombre int num = (int) (Math.random()*100); //boucle pour interroger l’utilisateur do { essai = Integer.parseInt(JOptionPane. showInputDialog("Devinez un nombre ➥ entre 0 et 100")); if(essai>num) JOptionPane.showMessageDialog(null,"Trop grand"); if(essai
36


Les Figures 5.1 à 5.4 montrent le jeu Devinez le nombre ! Si vous avez des problèmes avec ce code, ne désespérez pas ! Revoir les projets précédents pourra vous aider à rafraîchir vos connaissances. Si vous avez pu écrire ce code tout seul, bravo, vous êtes sur le bon chemin pour devenir un petit génie de la programmation de jeux vidéo ! Figure 5.1 Tentative pour deviner le nombre

Figure 5.2 L’essai tape trop haut

Figure 5.3 L’essai tape trop bas

Figure 5.4 Vous avez trouvé la bonne réponse !

Chapitre 1


Java dans les starting-blocks : le résumé ●

Commentaires. Les commentaires permettent de documenter le code pour savoir ce que fait chaque partie de votre jeu.

Instructions. Les instructions sont des commandes. Elles sont à la base de tout jeu. Contrôle de flux. Les boucles permettent de répéter du code. Elles sont utiles ● lorsqu’un utilisateur veut réessayer un jeu lorsqu’il a perdu. Variables. Les variables permettent de garder trace du score du joueur, des points, ● etc. Instructions if. Les instructions if permettent de tester des variables. Vous ● pouvez par exemple tester si un joueur a encore des vies ou s’il est définitivement mort. ● JOptionPane. Un JOptionPane permet d’obtenir des saisies et d’afficher des messages. Un exemple de message peut être le score d’un utilisateur. Un exemple de saisie peut être le nom de l’utilisateur pour la liste des scores records. Nombres aléatoires. Les nombres aléatoires servent à l’intelligence artificielle ● (faire bouger un ennemi de manière aléatoire, etc.). Pauses. Les pauses permettent d’attendre que l’écran se rafraîchisse pour que les ● graphismes du jeu aient une qualité optimale. ●

Tableaux. Les tableaux peuvent garder trace de l’environnement du jeu (par exemple la liste des voitures dans un jeu de course, une liste de munitions dans un jeu de tir). ● ArrayList. Les ArrayList peuvent être utilisés pour enregistrer les noms et scores des joueurs. Accès aux fichiers. Les accès aux fichiers servent à garder une liste de records ● permanents pour les jeux. ●

2 Jeux de course Au sommaire de ce chapitre :

La course du courage ●

Projet 6 : La piste

●

Projet 7 : Les voitures

●

Projet 8 : Collisions !

●

Projet 9 : Personnalisation

Le skieur ●

Projet 10 : La piste

●

Projet 11 : Piste verte

●

Projet 12 : La compétition

40


Projet 6 : La course du courage – La piste La course du courage

Des voitures de course que vous avez conçues roulant sur une piste que vous avez dessinée, avec des graphismes et des effets sonores sensationnels ! Projet Nouvelles briques

• Créez l’environnement : une piste de course virtuelle avec une interface graphique. • JFrame, méthodes.

JFrame Un JFrame est une des méthodes les plus simples pour créer une interface graphique (GUI, Graphical User Interface). Il crée une fenêtre (similaire à un JOptionPane) d’une taille donnée. Vous pouvez y ajouter des graphismes, des boutons, des champs de texte, des libellés, etc. La Figure 6.1 représente un JFrame avant tout ajout de graphismes ou d’images. Pour créer un JFrame, ajoutez extends JFrame à la fin de la ligne public exemple, si votre classe s’appelle Jeu, la ligne ressemblerait à ceci :

class... Par

public class Jeu extends JFrame

Modifiez également la méthode main afin qu’elle ne contienne qu’une ligne de code : = new ();

Dans notre classe Jeu, la méthode main ne contiendrait donc que la ligne : Jeu j = new Jeu();

Cette ligne de code exécute le constructeur de la classe. Un constructeur est similaire à la méthode main, à ceci près qu’il est appelé automatiquement lorsqu’on crée une instance de la classe (en utilisant le code ci-dessus). Par conséquent, tout le code nécessaire pour faire fonctionner le jeu doit se trouver dans le constructeur et non dans la méthode main. On programme un constructeur avec cette syntaxe : public () {

Chapitre 2

}

Jeux de course 41

// le code est ajouté ici

Le code du constructeur de la classe Jeu commencerait donc ainsi : public Jeu() { }

Dans le constructeur, il faut ajouter ces quatre lignes de code pour créer le JFrame et en indiquer le titre et la taille : super("voici le titre"); setSize(400,400); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Et voilà : vous avez créé votre toute première interface graphique ! Une interface graphique est un canevas blanc auquel vous pouvez facilement ajouter des formes, des images, des boutons, des champs de texte ou tout ce que vous pouvez imaginer. Dans ce qui suit, nous expliquerons comment inclure des ennemis menaçants, des héros audacieux ou des aliens dégoûtants. Figure 6.1 Un JFrame vide

Tapez le code suivant à l’extérieur du constructeur, mais à l’intérieur de la classe : public void paint(Graphics g) { super.paint(g); }

42


Cette méthode permet de dessiner des formes quelconques : des rectangles, des carrés, des cercles, des arcs ou même des lettres géantes. Pour l’instant, nous allons nous intéresser à deux commandes pour choisir une couleur et dessiner un rectangle. Pour choisir une couleur, on utilise le code suivant (il faut aussi ajouter une ligne import java.awt.*) : g.setColor(Color.); est

le nom d’une couleur en anglais ; NetBeans affiche la liste des couleurs disponibles lorsque vous tapez "Color.". Cette liste est illustrée à la Figure 6.2. Figure 6.2 Quelques-unes des nombreuses couleurs disponibles

Pour dessiner un rectangle, il faut utiliser cette syntaxe : g.fillRect(, , , ); , , et sont

des variables de type int.

Dessinez un rectangle vert comme celui de la Figure 6.3, à la position 100, 100, large de 100 et haut de 200. Vous savez maintenant comment tracer une piste de course simple ! Attention, il arrivera un moment où vous devrez vérifier si la voiture sort des limites du rectangle. Pour anticiper cela, sauvez les points dans un objet Rectangle. Cela rendra les collisions plus faciles à détecter. Vous pourrez ensuite tracer le rectangle en récupérant ses valeurs, comme ceci : Rectangle r1 = new Rectangle(100,100,100,200); g.fillRect(r1.x, r1.y, r1.width, r1.height);

Jeux de course 43

Chapitre 2

Figure 6.3 Un rectangle vert dans un JFrame

Et, pour redessiner le JFrame, il suffit d’utiliser le code suivant dans votre programme : repaint();

Le code public

void paint... est

toujours exécuté au démarrage du programme.

Méthodes Les méthodes contiennent du code qui peut être exécuté plusieurs fois. On utilise des méthodes pour pouvoir répéter du code plus facilement. Vous pouvez appeler (c’est-à-dire exécuter) une méthode à partir du constructeur ou depuis une autre méthode, mais pas depuis la méthode main. Une méthode peut prendre en entrée une variable (aussi appelée argument) ou renvoyer une variable, non exclusivement et non obligatoirement. Pour créer une méthode, on utilise cette syntaxe : public (arguments) { //code } doit

être remplacé par void si la méthode ne renvoie pas de résultat. Si elle retourne un élément de type int, il doit être remplacé par int. Si elle retourne un objet de type Integer, il doit être remplacé par Integer. peut être un type primitif (int, double, char, etc.) ou un objet.

44


est

le nom de la méthode. Ce nom est à votre convenance, pour autant qu’il commence par une lettre. arguments représente les variables en entrée de la méthode lorsqu’elle

est appelée. Ces arguments sont séparés par des virgules. Si votre méthode prend deux arguments, un de type int et un de type double, vous devez écrire ceci : public void exemple (int i, double d){}

À l’intérieur de la méthode, i et d sont les noms de variables via lesquels les arguments sont accessibles. Pour renvoyer une valeur, utilisez ceci : return ; doit

être du type que vous avez indiqué lorsque vous avez déclaré la

méthode. Pour appeler une méthode, en l’occurrence la méthode syntaxe pour passer les arguments 1 et 4.563. :

exemple,

il faut utiliser cette

exemple(1, 4.563)

Si exemple renvoie une valeur de type int, vous pouvez récupérer la valeur renvoyée comme ceci : int i = exemple(1, 4.563);

Créer le jeu Tracez à présent une piste de course virtuelle. Le code complet se trouve ci-après : import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; //crée la classe en utilisant JFrame public class Course extends JFrame { //constantes contenant la taille de l’écran final int LARGEUR = 900, HAUTEUR = 650; /* *Le code suivant (créant les rectangles) peut sembler compliqué *à première vue, mais cela n’est dû qu’à l’utilisation de LARGEUR *et HAUTEUR pour créer les morceaux. Vous pouvez aussi utiliser *des valeurs codées en dur. */

Chapitre 2

Jeux de course 45

/*Définition de tous les rectangles à dessiner*/ /* *Le code suivant (créant les rectangles) peut sembler compliqué à première vue, *mais cela n’est dû qu’à l’utilisation de LARGEUR et HAUTEUR pour créer les *morceaux. Vous pouvez aussi utiliser des valeurs codées en dur. */ //crée les rectangles à gauche, à droite, en haut, en bas et au centre Rectangle gauche = new Rectangle(0,0,LARGEUR/9,HAUTEUR); Rectangle droite = new Rectangle((LARGEUR/9)*8,0,LARGEUR/9,HAUTEUR); Rectangle haut = new Rectangle(0,0,LARGEUR, HAUTEUR/9); Rectangle bas = new Rectangle(0,(HAUTEUR/9)*8,LARGEUR,HAUTEUR/9); Rectangle centre = new Rectangle((int)((LARGEUR/9)*2.5),(int) „ ((HAUTEUR/9)*2.5), (int)((LARGEUR/9)*5),(HAUTEUR/9)*4); //obstacles sur la route rendant la navigation plus difficile Rectangle obstacle = new Rectangle(LARGEUR/2,(int)((HAUTEUR/9)*7),LARGEUR/10,HAUTEUR/9); Rectangle obstacle2 = new Rectangle(LARGEUR/3,(int)((HAUTEUR/9)*5),LARGEUR/10,HAUTEUR/4); Rectangle obstacle3 = new Rectangle(2*(LARGEUR/3),(int)((HAUTEUR/9)*5),LARGEUR/10,HAUTEUR/4); Rectangle obstacle4 = new Rectangle(LARGEUR/3,HAUTEUR/9,LARGEUR/30,HAUTEUR/9); Rectangle obstacle5 = new Rectangle(LARGEUR/2,(int)((HAUTEUR/9)*1.5),LARGEUR/30,HAUTEUR/4); //ligne d’arrivée pour les deux joueurs Rectangle arrivee = new Rectangle(LARGEUR/9,(HAUTEUR/2)-HAUTEUR/9, „ (int)((LARGEUR/9)*1.5), HAUTEUR/70); //ligne de départ pour le joueur extérieur Rectangle ligneO = new Rectangle(LARGEUR/9,HAUTEUR/2,(int)((LARGEUR/9)*1.5)/2,HAUTEUR/140); //ligne de départ pour le joueur intérieur Rectangle ligneI = new Rectangle(((LARGEUR/9)+((int)((LARGEUR/9)*1.5)/2)), „ (HAUTEUR/2)+(HAUTEUR/10), (int)((LARGEUR/9)*1.5)/2, HAUTEUR/140); //constructeur public Course() { //crée le JFrame super("La Course du courage"); setSize(LARGEUR,HAUTEUR); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setVisible(true); } //dessine les voitures et la piste public void paint(Graphics g) { super.paint(g); //dessine le fond pour la piste g.setColor(Color.DARK_GRAY); g.fillRect(0,0,LARGEUR,HAUTEUR); //la bordure des dessins est verte g.setColor(Color.GREEN); //on dessine grâce aux rectangles g.fillRect(gauche.x,gauche.y,gauche.width,gauche.height);

46


}

g.fillRect(droite.x,droite.y,droite.width,droite.height); g.fillRect(haut.x,haut.y,haut.width,haut.height); g.fillRect(bas.x,bas.y,bas.width,bas.height); g.fillRect(centre.x,centre.y,centre.width,centre.height); g.fillRect(obstacle.x,obstacle.y,obstacle.width,obstacle.height); g.fillRect(obstacle2.x,obstacle2.y,obstacle2.width,obstacle2.height); g.fillRect(obstacle3.x,obstacle3.y,obstacle3.width,obstacle3.height); g.fillRect(obstacle4.x,obstacle4.y,obstacle3.width,obstacle4.height); g.fillRect(obstacle5.x,obstacle5.y,obstacle5.width,obstacle5.height); //pour les lignes de départ on dessine en blanc g.setColor(Color.WHITE); //on dessine les lignes de départ g.fillRect(ligneO.x,ligneO.y,ligneO.width,ligneO.height); g.fillRect(ligneI.x,ligneI.y,ligneI.width,ligneI.height); //la ligne d’arrivée est en jaune g.setColor(Color.YELLOW); //on dessine la ligne d’arrivée g.fillRect(arrivee.x,arrivee.y,arrivee.width,arrivee.height);

} //ceci démarre le programme en appelant le constructeur public static void main (String[] args) { new Course(); }

La Figure 6.4 présente une copie d’écran de la piste complète. Figure 6.4 La piste complète

Dans le prochain projet, nous donnerons vie à la course du courage. Nous allons créer deux voitures qui accélèrent vers l’avant. Vroum, vroum !

Jeux de course 47

Chapitre 2

Projet 7 : La course du courage – Les voitures Projet

Nouvelles briques

• Maintenant que vous savez comment créer une interface graphique, vous allez l’éveiller à la vie. Grâce à des Thread (fils d’exécution, grâce auxquels plusieurs choses peuvent arriver en même temps), vous allez faire accélérer deux voitures vers l’avant. • Thread, classes internes.

Thread et classes internes Pour créer un Thread, vous devez d’abord programmer une classe interne. Pour faire cela, saisissez le code suivant à l’intérieur d’une classe, mais en dehors de toute méthode ou de tout constructeur : public class extends Thread { } peut

être remplacé par un nom quelconque différent du nom de la classe prin-

cipale. Dans cette nouvelle classe, il faut créer une méthode programme puisse compiler :

run,

obligatoire pour que le

public void run(){}

Dans cette méthode, nous allons faire avancer une des voitures. Il faut y créer une boucle while infinie : while (true) { }

Dans la boucle while, ajoutez le code suivant : try { //code } catch (Exception e) { break; }

48


Ces quelques lignes permettent de vérifier s’il y a des erreurs dans le bloc encadré par try. Si une erreur survient, l’ordinateur exécute le code se trouvant dans le bloc encadré par catch. Dans ce cas, on appelle break, ce qui permet de sortir de la boucle infinie. Les contrôles faisant avancer la voiture doivent être placés à la place de //code. Une fois ce Thread terminé, appelez-le depuis le constructeur avec la syntaxe suivante, dans laquelle Mouvement est le nom de votre classe interne : Mouvement m = new Mouvement(); m.start();

Créer le jeu Commencez par dessiner un Rectangle pour représenter la voiture (nous les personnaliserons dans le Projet 10). Puis, programmez un Thread (grâce à une classe interne). Ajoutez la méthode run, la boucle while et le code try.... Créez ensuite une variable globale pour contenir la vitesse de la première voiture. Dans le code try..., augmentez lentement la vitesse jusqu’à la vitesse finale (ici, 4). Puis, faites bouger la voiture en modifiant la valeur y de son rectangle en y ajoutant la valeur de la vitesse de la voiture. Pour finir, rafraîchissez l’écran et ajoutez un délai (grâce à Thread.sleep(75);). Lorsque tout ceci fonctionne, essayez d’ajouter la deuxième voiture. Le code complet se trouve ci-après : //on importe tout ce qui est nécessaire import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; //crée le JFrame public class Course extends JFrame { //constantes pour la taille de l’écran final int LARGEUR = 900, HAUTEUR = 650; //vitesse des deux joueurs double vitesseJ1 =.5, vitesseJ2 =.5; //rectangles représentant la gauche, la droite, le haut, le bas et le centre Rectangle gauche = new Rectangle(0,0,LARGEUR/9,HAUTEUR); Rectangle droite = new Rectangle((LARGEUR/9)*8,0,LARGEUR/9,HAUTEUR); Rectangle haut = new Rectangle(0,0,LARGEUR,HAUTEUR/9); Rectangle bas = new Rectangle(0,(HAUTEUR/9)*8,LARGEUR,HAUTEUR/9); Rectangle centre = new Rectangle((int)((LARGEUR/9)*2.5),(int) „ ((HAUTEUR/9)*2.5),(int) ((LARGEUR/9)*5), (HAUTEUR/9)*4);

Chapitre 2

Jeux de course 49

//obstacles sur le chemin rendant la navitation plus difficile Rectangle obstacle = new Rectangle(LARGEUR/2,(int)((HAUTEUR/9)*7), LARGEUR/10,HAUTEUR/9); Rectangle obstacle2 = new Rectangle(LARGEUR/3,(int)((HAUTEUR/9)*5),LARGEUR/10,HAUTEUR/4); Rectangle obstacle3 = new Rectangle(2*(LARGEUR/3),(int)((HAUTEUR/9)*5),LARGEUR/10,HAUTEUR/4); Rectangle obstacle4 = new Rectangle(LARGEUR/3,HAUTEUR/9,LARGEUR/30,HAUTEUR/9); Rectangle obstacle5 = new Rectangle(LARGEUR/2,(int) ((HAUTEUR/9)*1.5),LARGEUR ➥ /30,HAUTEUR/4); //ligne d’arrivée pour les deux joueurs Rectangle arrivee = new Rectangle(LARGEUR/9,(HAUTEUR/2)-HAUTEUR/9, (int) ((LARGEUR/9)*1.5),HAUTEUR/70); //rectangle pour la voiture du joueur 1 Rectangle j1 = new Rectangle(LARGEUR/9,HAUTEUR/2, LARGEUR/30,LARGEUR/30); //rectangle pour la voiture du joueur 2 Rectangle j2 = new Rectangle(((LARGEUR/9)+((int)((LARGEUR/9)*1.5)/2)), ➥ (HAUTEUR/2)+ (HAUTEUR/10), LARGEUR/30,LARGEUR/30); //constructeur public Course() { //création du JFrame super("La Course du courage"); setSize(LARGEUR,HAUTEUR); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setVisible(true); //démarrage de la classe interne, qui a un fonctionnement indépendant //puisqu’il s’agit d’un Thread Mouvement1 m1 = new Mouvement1(); Mouvement2 m2 = new Mouvement2(); m1.start(); m2.start(); } //dessine les voitures et la piste public void paint(Graphics g) { super.paint(g); //dessine le fond de la piste g.setColor(Color.DARK_GRAY); g.fillRect(0,0,LARGEUR,HAUTEUR); //la bordure de ce qu’on dessine est verte g.setColor(Color.GREEN); //ligne de départ pour le joueur 1 Rectangle ligne1 = new Rectangle(LARGEUR/9,HAUTEUR/2,(int)((LARGEUR/9)*1.5)/2,HAUTEUR/140); //ligne de départ pour le joueur 2 Rectangle ligne2 = new Rectangle(((LARGEUR/9)+((int)((LARGEUR/9)*1.5)/2)), „ (HAUTEUR/2)+(HAUTEUR/10),(int)((LARGEUR/9)*1.5)/2,HAUTEUR/140); //on dessine la piste g.fillRect(gauche.x,gauche.y,gauche.width,gauche.height); g.fillRect(droite.x,droite.y,droite.width,droite.height); g.fillRect(haut.x,haut.y,haut.width,haut.height); g.fillRect(bas.x,bas.y,bas.width,bas.height);

50


g.fillRect(centre.x,centre.y,centre.width,centre.height); g.fillRect(obstacle.x,obstacle.y,obstacle.width,obstacle.height); g.fillRect(obstacle2.x,obstacle2.y,obstacle2.width,obstacle2.height); g.fillRect(obstacle3.x,obstacle3.y,obstacle3.width,obstacle3.height); g.fillRect(obstacle4.x,obstacle4.y,obstacle3.width,obstacle4.height); g.fillRect(obstacle5.x,obstacle5.y,obstacle5.width,obstacle5.height); //les lignes de départ sont en blanc g.setColor(Color.WHITE); //on dessine les lignes de départ g.fillRect(ligne1.x,ligne1.y,ligne1.width,ligne1.height); g.fillRect(ligne2.x,ligne2.y,ligne2.width,ligne2.height); //la ligne d’arrivée est en jaune g.setColor(Color.YELLOW); //on dessine la ligne d’arrivée g.fillRect(arrivee.x,arrivee.y,arrivee.width,arrivee.height); //le joueur 1 est dessiné en bleu g.setColor(Color.BLUE); //dessin du joueur g.fill3DRect(j1.x,j1.y,j1.width,j1.height,true); //le joueur 2 est dessiné en rouge g.setColor(Color.RED); //dessin du joueur g.fill3DRect(j2.x,j2.y,j2.width,j2.height,true); } private class Mouvement1 extends Thread { public void run() { //tout est dans une boucle infinie pour que le processus soit while(true) { //le code est dans un bloc try pour pouvoir sortir s’il y a try { //rafraîchit l’écran repaint(); //augmente un peu la vitesse if(vitesseJ1<=5) vitesseJ1+=.2; j1.y-=vitesseJ1; //diminue le taux de rafraîchissement Thread.sleep(75); } catch(Exception e) { //s’il y a une exception, sort de la boucle break; } } } } private class Mouvement2 extends Thread { public void run() { //tout est dans une boucle infinie pour que le processus soit while(true) { //le code est dans un bloc try pour pouvoir sortir s’il y a try {

répété une erreur

répété une erreur

Jeux de course 51

Chapitre 2

}

}

//rafraîchit l’écran repaint(); //augmente un peu la vitesse if(vitesseJ2<=5) vitesseJ2+=.2; j2.y-=vitesseJ2; //diminue le taux de rafraîchissement Thread.sleep(75); } catch(Exception e) { //s’il y a une exception, sort de la boucle break; }

} } //ceci démarre le programme en appelant le constructeur public static void main(String[] args) { new Course(); }

Les Figures 7.1 et 7.2 illustrent la course du courage. Dans le Projet 8, nous verrons comment ajouter la détection des collisions et comment transformer votre clavier en volant. Figure 7.1 La course du courage

52


Figure 7.2 Les voitures accélèrent vers l’avant

Jeux de course 53

Chapitre 2

Projet 8 : La course du courage – Collisions ! Projet

Briques

• Programmez les voitures pour qu’elles rebondissent et ralentissent lorsqu’elles se percutent l’une l’autre ou lorsqu’elles percutent les murs. Transformez aussi votre clavier en volant en attribuant des touches aux voitures. • Détection de collisions et KeyListener .

Détection de collisions La détection de collisions (détecter si des objets se touchent, comme l’illustre la Figure 8.1) est simple en Java. Comme vous avez créé tous vos graphiques avec des classes Rectangle, détecter des collisions est facile : la classe Rectangle fournit une méthode intersects. Figure 8.1 Exemple de détection de collisions

Pour vérifier une collision entre r1 et r2, on utilise cette méthode de la manière suivante : if(r1.intersects(r2))

Pour gérer plusieurs collisions, vous pouvez utiliser les opérateurs dans la condition du bloc if.

&& (et)

et

|| (ou)

Par exemple, pour voir si r1 est en contact avec r2 ou avec r3, on écrit : if(r1.intersects(r2) || r1.intersects(r3))

KeyListener La classe KeyListener permet de recevoir des saisies clavier venant de l’utilisateur. Celles-ci peuvent par exemple servir à contrôler les directions des voitures. Pour utiliser un KeyListener, il faut ajouter les éléments suivants à la déclaration de votre classe (ligne public class...) :

54


implements KeyListener

Cela s’applique aussi aux classes internes dérivées de Thread. Puis, dans le constructeur (ou dans la méthode run si vous utilisez des Thread), ajoutez cette ligne : addKeyListener(this);

Elle indique au clavier de se "réveiller" et de commencer à écouter les commandes. Vous devez aussi ajouter trois méthodes à votre code : public void keyPressed(KeyEvent e){} public void keyReleased(KeyEvent e){} public void keyTyped(KeyEvent e){}

Ces méthodes sont appelées automatiquement lorsqu’une touche est tapée. keyPressed est appelée lorsque l’utilisateur appuie sur une touche. keyReleased est appelée lorsqu’une touche est relâchée. keyTyped est appelée lorsqu’une touche est pressée puis relâchée. keyTyped est probablement la méthode que vous utiliserez le plus. Vous pourrez alors modifier le jeu en changeant certaines valeurs comme la direction de la voiture en fonction de la touche. Pour savoir quelle touche a été tapée, on utilise : e.getKeyChar()

Créer le jeu Créez des variables globales de type int pour la direction de la voiture. Si leur valeur est 0, la voiture va vers le haut, si sa valeur est 1, la voiture va vers la gauche, etc. Pour simplifier, créez des constantes avec l’attribut final ; par exemple une valeur de type int nommée HAUT dont la valeur est 0. Pour savoir si la voiture va vers le haut, il suffit alors de comparer sa direction avec HAUT plutôt qu’avec 0. Puis, utilisez un KeyListener pour que le joueur puisse modifier sa direction. Modifiez la direction en testant la direction actuelle de la voiture et modifiez x si la voiture va vers la gauche ou vers la droite, y si elle va vers le haut ou vers le bas. Vérifiez également si le joueur est entré en collision avec un mur ou avec une autre voiture. Si c’est le cas, la vitesse du joueur doit être négative pour que la voiture recule avant de pouvoir reprendre de la vitesse.

Chapitre 2

Jeux de course 55

Voici le code complet : //on importe tout ce qu’il faut import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; //crée la classe et le JFrame public class Course extends JFrame { //constantes pour les dimensions de l’écran final int LARGEUR = 900, HAUTEUR = 650; //vitesse des joueurs double vitesseJ1 =.5, vitesseJ2 =.5; //constantes représentant les directions final int HAUT = 0, DROITE = 1, BAS = 2, GAUCHE = 3; //garde trace de la direction du joueur (par défaut, vers le haut) int directionJ1 = HAUT; int directionJ2 = HAUT; //crée des rectangles pour les parties gauche, droite, haute, basse et centre Rectangle gauche = new Rectangle(0,0,LARGEUR/9, HAUTEUR); Rectangle droite = new Rectangle((LARGEUR/9)*8,0,LARGEUR/9,HAUTEUR); Rectangle haut = new Rectangle(0,0,LARGEUR,HAUTEUR/9); Rectangle bas = new Rectangle(0,(HAUTEUR/9)*8,LARGEUR,HAUTEUR/9); Rectangle centre = new Rectangle((int)((LARGEUR/9) *2.5),(int)((HAUTEUR/9)*2.5), (int)((LARGEUR/9)*5),(HAUTEUR/9)*4); //obstacles pour rendre la navigation plus difficile Rectangle obstacle = new Rectangle(LARGEUR/2,(int)((HAUTEUR/9)*7), „ LARGEUR/10,HAUTEUR/9); Rectangle obstacle2 = new Rectangle(LARGEUR/3,(int)((HAUTEUR/9)*5), „ LARGEUR/10,HAUTEUR/4); Rectangle obstacle3 = new Rectangle(2*(LARGEUR/3),(int)((HAUTEUR/9)*5), „ LARGEUR/10,HAUTEUR/4); Rectangle obstacle4 = new Rectangle(LARGEUR/3,HAUTEUR/9,LARGEUR/30,HAUTEUR/9); Rectangle obstacle5 = new Rectangle(LARGEUR/2,(int)((HAUTEUR/9)*1.5), LARGEUR/30,HAUTEUR/4); //rectangle pour la ligne d’arrivée pour les deux joueurs Rectangle arrivee = new Rectangle(LARGEUR/9,(HAUTEUR/2)-HAUTEUR/9, (int)((LARGEUR/9)*1.5),HAUTEUR/70); //rectangle pour la voiture du joueur 1 Rectangle j1 = new Rectangle(LARGEUR/9,HAUTEUR/2, LARGEUR/30,LARGEUR/30); //rectangle pour la voiture du joueur 2 Rectangle j2 = new Rectangle(((LARGEUR/9)+ ((int)((LARGEUR/9)*1.5)/2)), „ (HAUTEUR/2)+(HAUTEUR/10),LARGEUR/30,LARGEUR/30); //constructeur public Course() { //ce code crée le JFrame super("La Course du courage"); setSize(LARGEUR,HAUTEUR); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setVisible(true);

56


//démarre la classe interne (qui fonctionne indépendamment puisqu’il s’agit „ d’un Thread) Mouvement1 m1 = new Mouvement1(); Mouvement2 m2 = new Mouvement2(); m1.start(); m2.start();

} //dessine les voitures et la piste public void paint(Graphics g) { super.paint(g); //fond de la piste g.setColor(Color.DARK_GRAY); g.fillRect(0,0,LARGEUR,HAUTEUR); //les bordures du dessin sont vertes g.setColor(Color.GREEN); //ligne de départ pour le premier joueur Rectangle ligne1 = new Rectangle(LARGEUR/9,HAUTEUR/2,(int)((LARGEUR/9)*1.5) „ /2,HAUTEUR/140); //ligne de départ pour le deuxième joueur Rectangle ligne2 = new Rectangle(((LARGEUR/9)+((int)((LARGEUR/9)*1.5)/2)), „ (HAUTEUR/2)+(HAUTEUR/10), (int) ((LARGEUR/9)*1.5)/2,HAUTEUR/140); //on dessine la piste g.fillRect(gauche.x,gauche.y,gauche.width,gauche.height); g.fillRect(droite.x,droite.y,droite.width,droite.height); g.fillRect(haut.x,haut.y,haut.width,haut.height); g.fillRect(bas.x,bas.y,bas.width,bas.height); g.fillRect(centre.x,centre.y,centre.width,centre.height); g.fillRect(obstacle.x,obstacle.y,obstacle.width,obstacle.height); g.fillRect(obstacle2.x,obstacle2.y,obstacle2.width,obstacle2.height); g.fillRect(obstacle3.x,obstacle3.y,obstacle3.width,obstacle3.height); g.fillRect(obstacle4.x,obstacle4.y,obstacle3.width,obstacle4.height); g.fillRect(obstacle5.x,obstacle5.y,obstacle5.width,obstacle5.height); //la ligne de départ est en blanc g.setColor(Color.WHITE); //on dessine la ligne de départ g.fillRect(ligne1.x,ligne1.y,ligne1.width,ligne1.height); g.fillRect(ligne2.x,ligne2.y,ligne2.width,ligne2.height); //la ligne d’arrivée est en jaune g.setColor(Color.YELLOW); //on dessine la ligne d’arrivée g.fillRect(arrivee.x,arrivee.y,arrivee.width,arrivee.height); //le joueur 1 est en bleu g.setColor(Color.BLUE); //dessin du joueur g.fill3DRect(j1.x,j1.y,j1.width,j1.height,true); //le joueur 2 est en rouge g.setColor(Color.RED); //dessin du joueur g.fill3DRect(j2.x,j2.y,j2.width,j2.height,true); }

Chapitre 2

Jeux de course 57

private class Mouvement1 extends Thread implements KeyListener { public void run() { //active le KeyListener addKeyListener(this); //boucle infinie pour pouvoir répéter le processus while(true) { //le code est encapsulé dans un bloc try pour l’arrêter en cas d’erreur try { //rafraîchit l’écran repaint(); //si la voiture tape dans un mur extérieur, sa vitesse passe à -4 if(j1.intersects(gauche) || j1.intersects(droite) || j1.intersects(haut) || j1.intersects(bas) || j1.intersects(obstacle) || j1.intersects(obstacle2)|| j1.intersects(j2) || j1.intersects(obstacle3) || j1.intersects(obstacle4) || j1.intersects(obstacle5)) { vitesseJ1 = -4; } //si la voiture tape dans le centre, sa vitesse passe à -2.5 if(j1.intersects(centre)) { vitesseJ1 = -2.5; } //augmentation de la vitesse if(vitesseJ1<=5) vitesseJ1+=.2; //déplacement du joueur en fonction de sa direction if(directionJ1==HAUT) { j1.y-=(int)vitesseJ1; } if(directionJ1==BAS) { j1.y+=(int)vitesseJ1; } if(directionJ1==GAUCHE) { j1.x-=(int)vitesseJ1; } if(directionJ1==DROITE) { j1.x+=(int)vitesseJ1; } //diminue le taux de rafraîchissement Thread.sleep(75); } catch(Exception e) { //s’il y a une exception (une erreur) on sort de la boucle break; } } } //nécessaire pour le KeyListener public void keyPressed(KeyEvent event) { }

58


//nécessaire pour le KeyListener public void keyReleased(KeyEvent event) { } //nécessaire pour le KeyListener public void keyTyped(KeyEvent event) { if(event.getKeyChar()==’q’) { directionJ1 = GAUCHE; } if(event.getKeyChar()==’s’) { directionJ1 = BAS; } if(event.getKeyChar()==’d’) { directionJ1 = DROITE; } if(event.getKeyChar()==’z’) { directionJ1 = HAUT; } }

} private class Mouvement2 extends Thread implements KeyListener { public void run() { //active le KeyListener addKeyListener(this); //boucle infinie pour pouvoir répéter le processus while(true) { //le code est encapsulé dans un bloc try pour l’arrêter en cas d’erreur try { //rafraîchit l’écran repaint(); //si la voiture tape dans un mur extérieur, sa vitesse passe à -4 if(j2.intersects(gauche) || j2.intersects(droite) || j2.intersects(haut) || j2.intersects(bas) || j2.intersects(obstacle) || j2.intersects(obstacle2) || j1.intersects(j2)) { vitesseJ2 = -4; } //si la voiture tape dans le centre, sa vitesse passe à -2.5 if(j2.intersects(centre)) { vitesseJ2 = -2.5; } //augmentation de la vitesse if(vitesseJ2<=5) vitesseJ2+=.2; //déplace le joueur en fonction de sa direction if(directionJ2==HAUT) { j2.y-=(int)vitesseJ2; }

Jeux de course 59

Chapitre 2

if(directionJ2==BAS) { j2.y+=(int)vitesseJ2; } if(directionJ2==GAUCHE) { j2.x-=(int)vitesseJ2; } if(directionJ2==DROITE) { j2.x+=(int)vitesseJ2; } //diminue le taux de rafraîchissement Thread.sleep(75); } catch(Exception e) { //s’il y a une exception (une erreur) on sort de la boucle break; }

}

} //nécessaire pour le KeyListener public void keyPressed(KeyEvent event) { } //nécessaire pour le KeyListener public void keyReleased(KeyEvent event) { } //nécessaire pour le KeyListener public void keyTyped(KeyEvent event) { if(event.getKeyChar()== ’j’) { directionJ2 = GAUCHE; } if(event.getKeyChar()==’k’) { directionJ2 = BAS; } if(event.getKeyChar()==’l’) { directionJ2 = DROITE; } if(event.getKeyChar()==’i’) { directionJ2 = HAUT; } } } //démarre le programme en appelant le constructeur public static void main(String[] args) { new Course(); } }

La Figure 8.2 illustre les véhicules sur la piste.

60


Figure 8.2 Les voitures tournent et se promènent sur la piste

Jeux de course 61

Chapitre 2

Projet 9 : La course du courage – Personnalisation Projet

Briques

• Ajoutez des modifications au jeu : ajoutez-y des images et des sons. Ajoutez un écran de bienvenue. Ajoutez un compteur de tours indiquant le gagnant après trois tours de piste. • Images, sons.

Images Envie d’avoir des images dans votre jeu ? Ce n’est pas difficile. Vous pouvez transformer votre voiture de course en vaisseau spatial, en bateau, en avion, en guépard ou en tracteur... Laissez libre cours à votre imagination ! Vous devez d’abord dessiner une image ou en trouver une sur Internet. Une fois votre moyen de transport choisi, sauvegardez-le dans le répertoire dans lequel se trouve le fichier .class compilé (habituellement, /build/classes/ ). Les Figures 9.1 à 9.3 illustrent quelques possibilités de décor pour votre jeu. Figure 9.1 Voiture de course

Figure 9.2 Bateau

62


Figure 9.3 Avion

Ajoutez ces lignes avant de dessiner l’image : Image img = null; try { URL url = this.getClass().getResource("nom"); img = Toolkit.getDefaultToolkit().getImage(url); } catch(Exception e){} nom doit

être remplacé par le nom de l’image à utiliser (y compris son extension). Ensuite, remplacez le code qui dessine les rectangles par cette ligne : g.drawImage(img, x, y, this)

où

x et y sont les x et y du java.io.* et java.net.*.

rectangle. De plus, il faut importer, en début de fichier,

Toutes les images utilisées dans les jeux de cet ouvrage sont disponibles dans le répertoire Projets, sur le site web de Pearson, www.pearson.fr, à la page dédiée à cet ouvrage.

Sons Pour ajouter rapidement des effets sonores à vos jeux, utilisez ces lignes : URL moteur = this.getClass().getResource("moteur.wav"); AudioClip son = JApplet.newAudioClip(moteur); son.loop(); moteur.wav est

le nom du fichier son. snd.loop() joue le son en boucle. Si vous préférez ne le jouer qu’une fois, vous pouvez remplacer cette ligne par : snd.play();

N’oubliez pas d’importer java.applet.AudioClip. Tous les sons utilisés dans les jeux de cet ouvrage sont disponibles dans le répertoire de Projets, sur le site web de Pearson, www.pearson.fr, à la page dédiée à cet ouvrage.

Chapitre 2

Jeux de course 63

Créer le jeu Ajoutez un écran de bienvenue grâce à JOptionPane. Vous pouvez aussi programmer le décompte du nombre de tours en comptant les collisions avec la ligne d’arrivée. Remplacez les voitures rectangulaires par des images. N’oubliez pas d’orienter les images dans le sens dans lequel le véhicule se déplace (lorsqu’il va vers la droite, l’image devrait pointer vers la droite). Voici le code complet : //on importe ce qu’il faut : import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; import java.io.*; import java.net.*; import java.applet.AudioClip; //crée une nouvelle classe et le JFrame public class Course extends JFrame { //variables pour les images URL url1 = null, url2 = null, url3 = null, url4 = null, url5 = null, url6 = null, url7 = null, url8 = null, urlT = null; Image img1,img2,img3,img4, img5,img6,img7,img8, titre; //constante pour la taille de l’écran final int LARGEUR = 900, HAUTEUR = 650; //a la valeur true si quelqu’un a gagné boolean gagnantOK = false; //vitesse des joueurs double vitesseJ1 =.5, vitesseJ2 =.5; //nombre de tous des joueurs int toursJ1 = 0, toursJ2 = 0; //constantes pour les directions final int HAUT = 0, DROITE = 1, BAS = 2, GAUCHE = 3; //directions des joueurs (par défaut vers le haut) int directionJ1 = HAUT; int directionJ2 = HAUT; //crée des rectangles pour les parties haute, basse, gauche, droite et centre „ de l’écran Rectangle gauche = new Rectangle(0,0,LARGEUR/9,HAUTEUR); Rectangle droite = new Rectangle((LARGEUR/9)*8,0,LARGEUR/9,HAUTEUR); Rectangle haut = new Rectangle(0,0,LARGEUR,HAUTEUR/9); Rectangle bas = new Rectangle(0,(HAUTEUR/9)*8,LARGEUR,HAUTEUR/9); Rectangle centre = new Rectangle((int)((LARGEUR/9)*2.5), „ (int)((HAUTEUR/9)*2.5), (int)((LARGEUR/9)*5),(HAUTEUR/9)*4); //obstacles pour rendre la course plus difficile Rectangle obstacle = new Rectangle(LARGEUR/2,(int)((HAUTEUR/9)*7), „ LARGEUR/10,HAUTEUR/9);

64


Rectangle obstacle2 = new Rectangle(LARGEUR/3,(int)((HAUTEUR/9)*5), „ LARGEUR/10,HAUTEUR/4); Rectangle obstacle3 = new Rectangle(2*(LARGEUR/3),(int)((HAUTEUR/9)*5), „ LARGEUR/10,HAUTEUR/4); Rectangle obstacle4 = new Rectangle(LARGEUR/3,HAUTEUR/9,LARGEUR/30,HAUTEUR/9); Rectangle obstacle5 = new Rectangle(LARGEUR/2,(int)((HAUTEUR/9)*1.5), „ LARGEUR/30,HAUTEUR/4); //ligne d’arrivée pour les deux joueurs Rectangle arrivee = new Rectangle(LARGEUR/9,(HAUTEUR/2)-HAUTEUR/9, „ (int)((LARGEUR/9)*1.5), HAUTEUR/70); //rectangle pour la voiture du joueur 1 Rectangle j1 = new Rectangle(LARGEUR/9,HAUTEUR/2,LARGEUR/30,LARGEUR/30); //rectangle pour la voiture du joueur2 Rectangle j2 = new Rectangle(((LARGEUR/9)+((int)((LARGEUR/9)*1.5)/2)), „ (HAUTEUR/2)+(HAUTEUR/10),LARGEUR/30,LARGEUR/30); //constructeur public Course() { //on crée le JFrame super("La Course du courage"); setSize(LARGEUR,HAUTEUR); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setVisible(true); //on charge les adresses try { url1 = this.getClass().getResource("course1.jpg"); url2 = this.getClass().getResource("course2.jpg"); url3 = this.getClass().getResource("course3.jpg"); url4 = this.getClass().getResource("course4.jpg"); url5 = this.getClass().getResource("course5.jpg"); url6 = this.getClass().getResource("course6.jpg"); url7 = this.getClass().getResource("course7.jpg"); url8 = this.getClass().getResource("course8.jpg"); urlT = this.getClass().getResource("titre.png"); } catch(Exception e){} //on récupère les images pointées par les URL img1 = Toolkit.getDefaultToolkit().getImage(url1); img2 = Toolkit.getDefaultToolkit().getImage(url2); img3 = Toolkit.getDefaultToolkit().getImage(url3); img4 = Toolkit.getDefaultToolkit().getImage(url4); img5 = Toolkit.getDefaultToolkit().getImage(url5); img6 = Toolkit.getDefaultToolkit().getImage(url6); img7 = Toolkit.getDefaultToolkit().getImage(url7); img8 = Toolkit.getDefaultToolkit().getImage(url8); titre = Toolkit.getDefaultToolkit().getImage(urlT); //affichage d’un écran de bienvenue avec les règles JOptionPane.showMessageDialog(null, "Bienvenue à la Course du Courage !\n\n"+ "Le jeu : deux joueurs font la course.\n"+ "Le but : terminer trois tours avant votre adversaire !\n"+ "Contrôles :\n"+ "Joueur 1 (voiture bleue) :\n"+ "directions ZQSD, la vitesse est gérée automatiquement.\n"+

Chapitre 2

Jeux de course 65

"Joueur 2 (voiture rouge) :\n"+ "directions IJKL, la vitesse est gérée automatiquement.\n"+ "Attention à l’herbe verte, elle peut vous faire déraper !\n"+ "Cliquez sur OK pour démarrer");

//démarre les classes internes (indépendantes, puisqu’il s’agit de Thread) Mouvement1 m1 = new Mouvement1(); Mouvement2 m2 = new Mouvement2(); m1.start(); m2.start(); //joue le son try { URL moteur = this.getClass().getResource("moteur.wav"); AudioClip son = JApplet.newAudioClip(moteur); son.loop(); } catch(Exception e){}

} //dessine les voitures et la piste public void paint(Graphics g) { super.paint(g); //fond de la piste g.setColor(Color.DARK_GRAY); g.fillRect(0,0,LARGEUR,HAUTEUR); //la bordure est verte g.setColor(Color.GREEN); //ligne de départ pour le joueur 1 Rectangle ligne1 = new Rectangle(LARGEUR/9, HAUTEUR/2,(int) „ ((LARGEUR/9)*1.5)/2,HAUTEUR/140); //ligne de départ pour le joueur 2 Rectangle ligne2 = new Rectangle(((LARGEUR/9)+ ((int)((LARGEUR/9)*1.5)/2)),(HAUTEUR/2)+(HAUTEUR/10),(int) „ ((LARGEUR/9)*1.5)/2, HAUTEUR/140); //on dessine la piste g.fillRect(gauche.x,gauche.y,gauche.width,gauche.height); g.fillRect(droite.x,droite.y,droite.width,droite.height); g.fillRect(haut.x,haut.y,haut.width,haut.height); g.fillRect(bas.x,bas.y,bas.width, bas.height); g.fillRect(centre.x,centre.y,centre.width,centre.height); g.fillRect(obstacle.x,obstacle.y,obstacle.width,obstacle.height); g.fillRect(obstacle2.x,obstacle2.y,obstacle2.width,obstacle2.height); g.fillRect(obstacle3.x,obstacle3.y,obstacle3.width,obstacle3.height); g.fillRect(obstacle4.x,obstacle4.y,obstacle3.width,obstacle4.height); g.fillRect(obstacle5.x,obstacle5.y,obstacle5.width,obstacle5.height); //les lignes de départ sont blanches g.setColor(Color.WHITE); //on dessine les lignes de départ g.fillRect(ligne1.x,ligne1.y,ligne1.width,ligne1.height); g.fillRect(ligne2.x,ligne2.y,ligne2.width,ligne2.height); //la ligne d’arrivée est jaune g.setColor(Color.YELLOW);

66


//on dessine la ligne d’arrivée’ g.fillRect(arrivee.x,arrivee.y,arrivee.width,arrivee.height); //image de titre au milieur de l’écran g.drawImage(titre,centre.x+10,centre.y+80,this); //dessine le joueur 1 if(directionJ1==HAUT) g.drawImage(img5,j1.x,j1.y,this); if(directionJ1==GAUCHE) g.drawImage(img8,j1.x,j1.y,this); if(directionJ1==BAS) g.drawImage(img7,j1.x,j1.y,this); if(directionJ1==DROITE) g.drawImage(img6,j1.x,j1.y,this); //draw the images for p2 if(directionJ2==HAUT) g.drawImage(img1,j2.x,j2.y,this); if(directionJ2==GAUCHE) g.drawImage(img4,j2.x,j2.y,this); if(directionJ2==BAS) g.drawImage(img3,j2.x,j2.y,this); if(directionJ2==DROITE) g.drawImage(img2,j2.x,j2.y,this);

} private class Mouvement1 extends Thread implements KeyListener { public void run() { //"réveille" le KeyListener addKeyListener(this); //tout ceci est dans une boucle infinie pour pouvoir répéter le processus while(true) { //tout le code est dans un bloc try pour sortir en cas d’erreur try { //rafraîchit l’écran repaint(); //gestion des collisions avec les murs extérieurs et l’autre joueur //la vitesse est alors diminuée à -4 if(j1.intersects(gauche) || j1.intersects(droite) || „ j1.intersects(haut) || j1.intersects(bas) || j1.intersects(obstacle) || j1.intersects(obstacle2)|| j1.intersects(j2) || „ j1.intersects(obstacle3) || j1.intersects(obstacle4) || j1.intersects(obstacle5)) { vitesseJ1 = -4; } //si la voiture touche le centre, on diminue sa vitesse à -2.5 if(j1.intersects(centre)) { vitesseJ1 = -2.5; } //nombre de tours : if(j1.intersects(arrivee)&&directionJ1==HAUT) { toursJ1++; }

Jeux de course 67

Chapitre 2

//3 tours complets correspondent à un compte de tours d’environ 24. //on utiliser un bloc if pour compter et l’indiquer à l’utilisateur //si gagnantOK est false, le joueur a gagné, sinon il a perdu if(toursJ1>=24) { if(!gagnantOK) { gagnantOK = true; JOptionPane.showMessageDialog(null, "Le joueur 1 (bleu) a gagné !!!"); break; } else { JOptionPane.showMessageDialog(null, "Joueur 1 : (bleu) : PERDU ! „ \n Joueur 2 (rouge) : GAGNÉ !"); break; } } //augmente la vitesse if(vitesseJ1<=5) vitesseJ1+=.2; //déplace le joueur en fonction de la direction if(directionJ1==HAUT) { j1.y-=(int)vitesseJ1; } if(directionJ1==BAS) { j1.y+=(int)vitesseJ1; } if(directionJ1==GAUCHE) { j1.x-=(int)vitesseJ1; } if(directionJ1==DROITE) { j1.x+=(int)vitesseJ1; } //diminue le taux de rafraîchissement Thread.sleep(75); } catch(Exception e) { //s’il y a une exception on sort de la boucle break; }

}

} //nécessaire pour le KeyListener public void keyPressed(KeyEvent event) { } //nécessaire pour le KeyListener public void keyReleased(KeyEvent event) { } //nécessaire pour le KeyListener public void keyTyped(KeyEvent event) { if(event.getKeyChar()==’q’) { directionJ1 = GAUCHE; }

68


if(event.getKeyChar()==’s’) { directionJ1 = BAS; } if(event.getKeyChar()==’d’) { directionJ1 = DROITE; } if(event.getKeyChar()==’z’) { directionJ1 = HAUT; }

} } private class Mouvement2 extends Thread implements KeyListener { public void run() { //"réveille" le KeyListener addKeyListener(this); //tout ceci est dans une boucle infinie pour pouvoir répéter le processus while(true) { //tout le code est dans un bloc try pour sortir en cas d’erreur try { //rafraîchit l’écran repaint(); //gestion des collisions avec les murs extérieurs et l’autre joueur

if(j2.intersects(gauche) || j2.intersects(droite) || j2.intersects(haut) || j2.intersects(bas) || j2.intersects(obstacle) ||j2.intersects(obstacle2) || j1.intersects(j2) || j1.intersects(obstacle3) || j1.intersects(obstacle4) || j1.intersects(obstacle5)) { vitesseJ2 = -4; } //si la voiture touche le centre, on diminue sa vitesse à -2.5 if(j2.intersects(centre)) { vitesseJ2 = -2.5; } //nombre de tours if(j2.intersects(arrivee)&&directionJ2==HAUT) { toursJ2++; } //3 tours complets correspondent à un compte de tours d’environ 24. //on utiliser un bloc if pour compter et l’indiquer à l’utilisateur //si gagnantOK est false, le joueur a gagné, sinon il a perdu if(toursJ2>=24) { if(!gagnantOK) { gagnantOK = true; JOptionPane.showMessageDialog(null, "Le joueur 2 (rouge) „ a gagné !!!"); break; } else { JOptionPane.showMessageDialog(null, "Joueur 1 : (bleu) : GAGNÉ ! „ \n Joueur 2 (rouge) : PERDU !"); break; }

Jeux de course 69

Chapitre 2

}

} //augmente la vitesse if(vitesseJ2<=5) vitesseJ2+=.2; //déplace le joueur en fonction de la direction if(directionJ2==HAUT) { j2.y-=(int)vitesseJ2; } if(directionJ2==BAS) { j2.y+=(int)vitesseJ2; } if(directionJ2==GAUCHE) { j2.x-=(int)vitesseJ2; } if(directionJ2==DROITE) { j2.x+=(int)vitesseJ2; } //diminue le taux de rafraîchissement Thread.sleep(75); } catch(Exception e) { //s’il y a une exception on sort de la boucle break; }

} //nécessaire pour le KeyListener public void keyPressed(KeyEvent event) { } //nécessaire pour le KeyListener public void keyReleased(KeyEvent event) { } //nécessaire pour le KeyListener public void keyTyped(KeyEvent event) { if(event.getKeyChar()==’j’) { directionJ2 = GAUCHE; } if(event.getKeyChar()==’k’) { directionJ2 = BAS; } if(event.getKeyChar()==’l’) { directionJ2 = DROITE; } if(event.getKeyChar()==’i’) { directionJ2 = HAUT; } }

}

} //démarre le programme en appelant le constructeur public static void main(String[] args) { new Course(); }

70


Figure 9.4 Écran de bienvenue

Figure 9.5 Les voitures sont sur le départ !

Chapitre 2

Figure 9.6 La voiture bleue a gagné !

Jeux de course 71

72


Projet 10 : Le skieur – La piste Le skieur

La pente est glissante et vous avez quinze secondes pour descendre la montagne sur une piste que vous créez vous-même. Si vous échouez, vous mourrez, mais si vous réussissez, à vous la gloire ! Projet

Nouvelles briques

• Dans ce projet, vous allez créer un environnement de dessins de piste : la piste est-elle une pente douce, un à-pic ou un terrain plein de bosses, de rochers et d’arbres ? C’est vous qui décidez ! • MouseListener, classes préfabriquées.

MouseListener Nous avons déjà vu comment programmer l’ordinateur pour qu’il réponde à des saisies clavier de l’utilisateur. Nous allons maintenant étudier comment voir où l’utilisateur clique. Dans un KeyListener, il fallait ajouter trois méthodes, qu’elles soient utilisées ou non. Le MouseListener répond aux mêmes principes, mais il y a cinq méthodes : public public public public public

void void void void void

mouseClicked(MouseEvent e){} mouseEntered(MouseEvent e){} mouseExited(MouseEvent e){} mousePressed(MouseEvent e){} mouseReleased(MouseEvent e){}

Le skieur n’utilise que les deux dernières méthodes. mousePressed indique où l’utilisateur a appuyé sur le bouton de la souris (le premier point de la piste). mouseReleased est utilisé pour savoir où l’utilisateur a relâché le bouton, c’est-à-dire où la piste s’arrête. Ces méthodes ne servent certes pas à grand-chose si vous ne savez pas récupérer les coordonnées à partir des clics des utilisateurs. Pour récupérer la coordonnée en X, on utilise : e.getX();

On accède à la coordonnée Y avec : e.getY();

Chapitre 2

Jeux de course 73

Classes préfabriquées Java fournit de nombreuses classes préfabriquées que vous pouvez utiliser. L’API Java est la liste complète des classes et leur description. On la trouve à l’adresse http:// java.sun.com/j2se/1.5.0/docs/api/ (cette documentation est en anglais). Nous allons utiliser deux classes préfabriquées dans le skieur : Line2D.Double, contenant les informations relatives à une ligne, et Point2D.Double, contenant les informations relatives à un point (qui est la première partie de la ligne). L’API vous indique ce qu’il faut importer. La table "Constructor Summary" indique de plus comment créer la classe. Pour initialiser un Point2D.Double, il faut passer deux variables de type double au constructeur : les coordonnées x et y. La méthode mousePressed permet donc de créer le premier point de la ligne en créant un Point2D.Double. Il est alors possible de définir une ligne grâce à la méthode mouseReleased en utilisant le point précédent et le point où l’utilisateur relâche la souris. La ligne peut être ajoutée à un ArrayList. Pour savoir quelles méthodes peuvent être utilisées avec une classe, créez une nouvelle instance de cette classe dans NetBeans. Si on prend pour exemple la classe Point2D.Double, faites cela ainsi : Point2D.Double pnt = new Point2D.Double(23.5, 563.0).

Figure 10.1 Pop-up dans NetBeans

74


Puis, tapez ceci : pnt.

Lorsque vous tapez le point, NetBeans crée une liste de toutes les méthodes utilisables. La plupart sont claires, mais NetBeans offre une description pour les plus complexes. Cette description s’affiche sous la forme d’un pop-up, comme le montre la Figure 10.1.

Créer le jeu Il est temps de créer la première partie du skieur : l’environnement de dessin de piste. Utilisez MouseListener et les classes Point2D.Double et Line2D.Double pour dessiner la piste de ski. Enregistrez les lignes dans un ArrayList et utilisez une boucle for pour afficher toutes les lignes de l’ ArrayList avec la méthode paint. //importe ce qu’il faut import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; import java.awt.geom.*; import java.util.*; //la classe public class Skieur extends JFrame implements MouseListener { //enregistre les lignes ArrayList lignes = new ArrayList(); //enregistre le premier point de la ligne Point2D.Double point; //constructeur public Skieur() { //titre super("Le Skieur"); setSize(700,700); setVisible(true); setDefaultCloseOperation(JFrame. EXIT_ON_CLOSE); addMouseListener(this); } public void paint(Graphics g) { super.paint(g); //les lignes sont dessinées en noir g.setColor(Color.black); //parcourt l’ArrayList et dessine toutes les lignes for(int i = 0; i
Jeux de course 75

Chapitre 2

{ //récupère la ligne Line2D.Double temp = (Line2D.Double) lignes.get(i); //récupère les coordonnées int x1 = Integer.parseInt(""+Math.round (temp.getX1())); int y1 = Integer.parseInt(""+Math.round (temp.getY1())); int x2 = Integer.parseInt(""+Math.round (temp.getX2())); int y2 = Integer.parseInt(""+Math.round (temp.getY2())); g.drawLine(x1,y1,x2,y2);

}

} //méthode nécessaire à MouseListener public void mouseClicked(MouseEvent e){} //méthode nécessaire à MouseListener public void mouseEntered(MouseEvent e){} //méthode nécessaire à MouseListener public void mouseExited(MouseEvent e){} //méthode nécessaire à MouseListener public void mousePressed(MouseEvent e) { //exécuté lorsqu’on appuie sur le bouton de la souris //récupère le premier point de la ligne point = new Point2D.Double(e.getX(),e.getY()); } //méthode nécessaire à MouseListener public void mouseReleased(MouseEvent e) { //exécuté lorsqu’on relâche le bouton de la souris //termine la ligne et l’ajoute à l’ArrayList Point2D.Double fin = new Point2D.Double(e.getX(),e.getY()); lignes.add(new Line2D.Double(point,fin)); //rafraîchit l’écran pour dessiner la ligne repaint(); } public static void main (String[] args) { //lance le programme new Skieur(); } }

La Figure 10.2 illustre le dessin de plusieurs lignes dans l’interface du skieur. N’hésitez pas à faire preuve d’imagination. Dans le chapitre suivant, nous allons créer un skieur pour dévaler les pentes que vous dessinez.

76


Figure 10.2 Des lignes connectées pour créer la piste

Jeux de course 77

Chapitre 2

Projet 11 : Le skieur – Piste verte Projet

• Créez une silhouette pour skier le long de la piste dessinée par le joueur.

Créer le jeu Générez d’abord l’image et le Rectangle représentant le skieur. Pour que celui-ci descende le long de la piste, initialisez un Thread pour contrôler le mouvement du joueur. Dans le Thread, créez une méthode qui définit la position initiale du skieur (au-dessus et légèrement à la droite du premier point de la première ligne) comme le montre la Figure 11.1. Figure 11.1 Point de départ

Appelez cette méthode dans run avant la boucle while. Créez aussi une autre méthode dont l’argument est un booléen qui peut arrêter la boucle while. Dans la boucle while, vérifiez si le Rectangle du skieur touche une des lignes (grâce à la méthode intersects). Pour contrôler les mouvements x et y du skieur, créez deux variables globales de type double, vitesse et gravite. Si le skieur n’est pas sur la ligne, augmentez la variable gravite. S’il est sur la ligne, calculez la différence entre les deux points de la ligne et divisez par 50 sur l’axe y et par 100 sur l’axe x. Ajoutez ces valeurs, respectivement aux variables gravite et vitesse. N’oubliez pas de rafraîchir l’écran et d’ajouter un petit délai avant de repasser dans la boucle. À l’extérieur du Thread, utilisez KeyListener pour détecter des appuis sur ’l’ (lancer) ou sur ’q’ (quitter). Si l’utilisateur appuie sur l, lancez la boucle. Si l’utilisateur appuie sur q, terminez la boucle.

78


//on importe le nécessaire import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; import java.awt.geom.*; import java.util.*; import java.io.*; import java.net.*; //la classe public class Skieur extends JFrame implements MouseListener, KeyListener { //lignes de la piste ArrayList lignes = new ArrayList(); //premier point de la ligne Point2D.Double point; //fil d’execution Mouvement mouvement; //informations géométriques sur le skieur Rectangle skieur = null; //dessin ou non du skieur boolean dessineSkieur = false; //constructeur public Skieur() { //titre super("Le Skieur"); setSize(700,700); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); addMouseListener(this); addKeyListener(this); } public void paint(Graphics g) { super.paint(g); //les lignes sont dessinées en noir g.setColor(Color.black); //boucle dans toutes les lignes de l’ArrayList et les dessine for(int i = 0; i
Jeux de course 79

Chapitre 2

Image img = Toolkit.getDefaultToolkit().getImage(url); g.drawImage(img, skieur.x, skieur.y, this); } catch(Exception e){} } } //méthode nécessaire à MouseListener public void mouseClicked(MouseEvent e){} //méthode nécessaire à MouseListener public void mouseEntered(MouseEvent e){} //méthode nécessaire à MouseListener public void mouseExited(MouseEvent e){} //méthode nécessaire à MouseListener public void mousePressed(MouseEvent e) { //exécuté lorsqu’on appuie sur le bouton de la souris //indique le premier point de la ligne point = new Point2D.Double(e.getX(),e.getY()); } //méthode nécessaire à MouseListener public void mouseReleased(MouseEvent e) { //exécuté lorsqu’on relâche le bouton de la souris //termine la ligne et l’ajoute à l’ArrayList Point2D.Double fin = new Point2D.Double(e.getX(),e.getY()); lignes.add(new Line2D.Double(point, fin)); //rafraîchit l’écran pour dessiner la ligne repaint(); } //méthode nécessaire à KeyListener public void keyPressed(KeyEvent e){} //méthode nécessaire à KeyListener public void keyReleased(KeyEvent e){} //méthode nécessaire à KeyListener public void keyTyped(KeyEvent e) { //si l’utilisateur appuie sur "l" ou sur "L", démarre le Thread if(e.getKeyChar()==’l’ || e.getKeyChar()==’L’) { //initialisation du Thread mouvement = new Mouvement(); mouvement.start(); mouvement.action(true); } //si l’utilisateur appuie sur "q" ou sur "Q", arrête le Thread if(e.getKeyChar()==’q’ || e.getKeyChar()==’Q’) { mouvement.action(false); dessineSkieur = false; mouvement = null; } } //fil d’exécution du mouvement du joueur private class Mouvement extends Thread { //vitesse et gravité du joueur double vitesse; double gravite;

80


//démarre et arrête le fil d’exécution boolean go = false; public void run() { if(go) { initSkieur(); vitesse = 0; gravite = 1; } while(go) { try { //ligne sur laquelle se trouve le skieur (ou null si aucune ligne) Line2D.Double ligneSkieur = null; //skieur sur la ligne ou non boolean surLigne = false; //il faut réinitialiser la gravité lorsque le skieur atterit sur la ligne //contient cette information et le numéro de la ligne int numeroLigne = -1; //vérifie si le skieur est sur une ligne for(int i = lignes.size()-1; i>=0; i--) { //récupère la ligne Line2D.Double temp = (Line2D.Double) lignes.get(i); if(temp.intersects(skieur.x,skieur.y,30,30)) { ligneSkieur = temp; surLigne = true; if(numeroLigne!=i) { numeroLigne = i; gravite = 0; } break; } } //si le skieur est sur une ligne if(surLigne) { //récupère la nouvelle gravité en soustrayant les y et en divisant par 50 double mGrav = (ligneSkieur.y2-ligneSkieur.y1)/50; //récupère la nouvelle vitesse en soustrayant les x et en divisant par 100 double mVit = (ligneSkieur.x2-ligneSkieur.x1)/100; //gestion des valeurs maximales if(vitesse<5) vitesse+=mVit; if(gravite<2.5) gravite+=mGrav; } else { gravite+=.2;

} //modifie le mouvement du skieur skieur.x += vitesse; skieur.y += gravite; //ralentit le taux de rafraîchissement Thread.sleep(75); //rafraîchit repaint();

Jeux de course 81

Chapitre 2

} catch(Exception e){ break; } } } public void action(boolean a) { //arrête le fil d’exécution go = a; } public void initSkieur() { /* * définit la position de départ du skieur */ //récupère la première ligne Line2D.Double premiereLigne = (Line2D.Double) lignes.get(0); //récupère le x et le y du premier point de cette ligne int x = Integer.parseInt(""+Math.round(premiereLigne.x1)); int y = Integer.parseInt(""+Math.round(premiereLigne.y1)); skieur = new Rectangle(x+30,y-20,30,30); dessineSkieur = true; } } public static void main(String[] args) { //lance le programme new Skieur(); } }

Les Figures 11.2 à 11.4 représentent la progression du skieur sur la piste dessinée. Figure 11.2 Départ du skieur

82


Figure 11.3 Le skieur est sur la piste

Figure 11.4 Le skieur est tombé !

Jeux de course 83

Chapitre 2

Projet 12 : Le skieur – La compétition Projet

• Modifiez le but du jeu : faire en sorte que le skieur termine sa descente en exactement quinze secondes. Ajoutez aussi des effets sonores pour que le skieur hurle lorsqu’il chute.

Créer le jeu Créez d’abord un compteur pour chronométrer la course du skieur grâce à une variable chrono. Puis, initialisez un nouveau fil d’exécution (Thread) nommé Chrono. Dans la méthode run, ajoutez une boucle while. Dans cette boucle, passez une pause d’une seconde et incrémentez chrono de 1. La Figure 12.1 illustre une manière amusante d’afficher le chronomètre. Figure 12.1 Affichage du chronomètre

Le chronomètre ne doit être lancé que lorsque le skieur est en mouvement. Il faut donc ajouter, dans les KeyListener qui démarrent et qui arrêtent la course du skieur, du code pour démarrer ou arrêter la boucle while du compteur en modifiant un booléen du Thread. Pour dessiner du texte, on utilise la méthode g.drawString("texte",

x, y).

84


On peut aussi définir la police du texte au préalable avec la méthode g.setFont(new Font()). Pour indiquer la police, reportez-vous aux constructeurs de la classe Font de l’API. Pour vérifier si un joueur a passé la ligne d’arrivée, créez un booléen nommé vivant. Dans le fil d’exécution contrôlant le mouvement, vérifiez si la coordonnée y est supérieure à 600 (une centaine de pixels avant le bord de la fenêtre). Si c’est le cas, il s’est écrasé. Vous pouvez si vous le désirez modifier l’icône et ajouter des effets sonores (enregistrez vos propres hurlements !). Lorsque le joueur s’écrase, appelez une méthode pour comparer le temps à quinze secondes. Vivant ou mort, si la descente de la piste est terminée en exactement quinze secondes, le joueur gagne. N’oubliez pas d’arrêter le chronomètre et d’afficher le temps final à la fin de la course. Pour cela, créez une variable appelée tempsFinal. //on importe le nécessaire import java.applet.AudioClip; import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; import java.awt.geom.*; import java.util.*; import java.io.*; import java.net.*; //la classe public class Skieur extends JFrame implements MouseListener, KeyListener { //lignes de la piste ArrayList lignes = new ArrayList(); //premier point de la ligne Point2D.Double point; //fils d’exécution Mouvement mouvement; Compteur compt; //informations géométriques sur le skieur Rectangle skieur = null; //dessin ou non du skieur boolean dessineSkieur = false; //compteur int compteur; //le son a-t-il été joué ? boolean sonJoue = false; //temps final int tempsFinal = 0;

Chapitre 2

Jeux de course 85

//utiliser la valeur retenue boolean utiliseTemps = false; //si le skieur arrive en bas, on change son icône boolean vivant = true; //constructeur public Skieur() { //titre super("Le Skieur"); setSize(700,700); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); addMouseListener(this); addKeyListener(this); compt = new Compteur(); compt.parti = false; compt.run(); } public void paint(Graphics g) { super.paint(g); //les lignes sont dessinées en noir g.setColor(Color.black); //boucle dans toutes les lignes de l’ArrayList et les dessine for(int i = 0; i
86


g.drawImage(img, skieur.x, skieur.y, this); //si le son n’a pas encore été joué, on le joueif the snd hasn’t been „ played, play it! if(!sonJoue) { //temps final tempsFinal = compteur; utiliseTemps = true; //joue le son URL son = this.getClass().getResource("hurlement.wav"); AudioClip hurlement = JApplet.newAudioClip(son); hurlement.play(); sonJoue = true; //regarde si le joueur a gagné verifieVictoire(); }

} } catch(Exception e){}

} } //méthode nécessaire à MouseListener public void mouseClicked(MouseEvent e){} //méthode nécessaire à MouseListener public void mouseEntered(MouseEvent e){} //méthode nécessaire à MouseListener public void mouseExited(MouseEvent e){} //méthode nécessaire à MouseListener public void mousePressed(MouseEvent e) { //exécuté lorsqu’on appuie sur le bouton de la souris //indique le premier point de la ligne point = new Point2D.Double(e.getX(),e.getY()); } //méthode nécessaire à MouseListener public void mouseReleased(MouseEvent e) { //exécuté lorsqu’on relâche le bouton de la souris //termine la ligne et l’ajoute à l’ArrayList Point2D.Double fin = new Point2D.Double(e.getX(),e.getY()); lignes.add(new Line2D.Double(point, fin)); //rafraîchit l’écran pour dessiner la ligne repaint(); } //méthode nécessaire à KeyListener public void keyPressed(KeyEvent e){} //méthode nécessaire à KeyListener public void keyReleased(KeyEvent e){} //méthode nécessaire à KeyListener public void keyTyped(KeyEvent e) { //si l’utilisateur appuie sur "l" ou sur "L", démarre le Thread if(e.getKeyChar()==’l’ || e.getKeyChar()==’L’) { //initialisation du Thread mouvement = new Mouvement(); mouvement.start(); mouvement.action(true);

Jeux de course 87

Chapitre 2

compt.parti = true; vivant = true; compteur = 0; utiliseTemps = false; sonJoue = false;

} //si l’utilisateur appuie sur "q" ou sur "Q", arrête le Thread if(e.getKeyChar()==’q’ || e.getKeyChar()==’Q’) { mouvement.action(false); dessineSkieur = false; mouvement = null; compt.parti = false; }

} //fil d’exécution du mouvement du joueur private class Mouvement extends Thread { //vitesse et gravité du joueur double vitesse; double gravite; //démarre et arrête le fil d’exécution boolean go = false; public void run() { if(go) { initSkieur(); vitesse = 0; gravite = 1; } while(go) { try { //ligne sur laquelle se trouve le skieur (ou null si aucune ligne) Line2D.Double ligneSkieur = null; //skieur sur la ligne ou non boolean surLigne = false; //il faut réinitialiser la gravité lorsque le skieur atterrit sur la ligne //contient cette information et le numéro de la ligne int numeroLigne = -1; //vérifie si le skieur est sur une ligne for(int i = lignes.size()-1; i>=0; i--) { //récupère la ligne Line2D.Double temp = (Line2D.Double) lignes.get(i); if(temp.intersects(skieur.x,skieur.y,30,30)) { ligneSkieur = temp; surLigne = true; if(numeroLigne!=i) { numeroLigne = i; gravite = 0; } break; } }

88


//si le skieur est sur une ligne if(surLigne) { //récupère la nouvelle gravité en soustrayant les y et en divisant par 50 double mGrav = (ligneSkieur.y2-ligneSkieur.y1)/50; //récupère la nouvelle vitesse en soustrayant les x et en divisant par 100 double mVit = (ligneSkieur.x2-ligneSkieur.x1)/100; //gestion des valeurs maximales if(vitesse<5) vitesse+=mVit; if(gravite<2.5) gravite+=mGrav; } else { gravite+=.2; } //modifie le mouvement du skieur skieur.x += vitesse; skieur.y += gravite; //regarde si le skieur est encore vivant if(skieur.y > 650){ vivant = false; } //ralentit le taux de rafraîchissement Thread.sleep(75); //rafraîchit repaint(); } catch(Exception e){ break; } } } public void action(boolean a) { //arrête le fil d’exécution go = a; } public void initSkieur() { /* * définit la position de départ du skieur */ //récupère la première ligne Line2D.Double premiereLigne = (Line2D.Double) lignes.get(0); //récupère le x et le y du premier point de cette ligne int x = Integer.parseInt(""+Math.round(premiereLigne.x1)); int y = Integer.parseInt(""+Math.round(premiereLigne.y1)); skieur = new Rectangle(x+30,y-20,30,30); dessineSkieur = true; } } private class Compteur extends Thread { public boolean parti = true; public void run() { try { while(true) {

Jeux de course 89

Chapitre 2

if(parti) { Thread.sleep(1000); compteur++; }

} } catch(Exception e){} } } //regarde si le but est atteint public void verifieVictoire() { if(tempsFinal==15) { JOptionPane.showMessageDialog(null, "Félicitations !\n\n" + "MISSION ACCOMPLIE !"); } } public static void main(String[] args) { //lance le programme new Skieur(); } }

La Figure 12.2 illustre la fin du jeu. Figure 12.2 Fin du jeu

3 Jeux de plateau Au sommaire de ce chapitre :

La chasse aux mauvais génies ●

Projet 13 : Le laboratoire

●

Projet 14 : Attrapez-les vite !

●

Projet 15 : Plus intelligent...

Le morpion boxeur ●

Projet 16 : Le ring

●

Projet 17 : Combat !

●

Projet 18 : K.-O. !

92


Projet 13 : La chasse aux mauvais génies – Le laboratoire La chasse aux mauvais génies

Un mauvais génie se cache dans son laboratoire avant de semer la panique sur le monde. Comme il craint le soleil et l’air frais, il ne sort que brièvement. Lorsqu’il sort, vous devez le frapper avec un clic de souris pour qu’il rentre dans son laboratoire souterrain. Le problème ? Il n’arrête pas de se cloner. Projet Nouvelles briques

• Créez d’abord le laboratoire. • Composants, JButton, JLabel .

Composants Un composant est un élément qui peut être ajouté à tout programme Java pour augmenter ses fonctionnalités. Les composants classiques incluent des boutons, des champs de texte et des libellés. Cependant, avant d’ajouter des composants, vous aurez besoin d’un endroit pour les y mettre. Cet endroit s’appelle un Container (conteneur). Pour créer un conteneur, ajoutez la ligne suivante dans votre constructeur après avoir créé un JFrame : Container = getContentPane(); est

une variable et son nom est arbitraire.

Après cette ligne, vous devez indiquer comment ajouter les composants. Il y a de nombreuses manières de les disposer : en grille, sur les côtés, l’un après l’autre, etc. Dans ce livre, nous nous focaliserons sur une disposition de type FlowLayout (disposition en flux) qui place les composants les uns après les autres. Cette disposition est la plus simple à coder et la plus simple à comprendre. Pour que votre conteneur ait une disposition en flux, utilisez cette ligne : cont.setLayout(new FlowLayout());

Avant de commencer à créer des composants, il reste une dernière chose à faire : la dernière ligne du constructeur doit contenir ceci : setContentPane(cont);

Jeux de plateau 93

Chapitre 3

cont doit être JFrame affiche

remplacé par le nom de votre conteneur. Cette ligne s’assure que le tous les composants que vous avez ajoutés.

JButton Un bouton est une zone sur laquelle on peut cliquer. En Java, les boutons sont appelés JButton. Un bouton simple est illustré à la Figure 13.1. Figure 13.1 Un JButton

Lorsque vous créez des JButton, il vaut mieux les créer de manière globale (en dehors du constructeur, mais dans la classe). Ainsi, il est plus simple de modifier leur texte à n’importe où dans le programme. Pour créer un JButton, utilisez la ligne suivante : JButton = new JButton("Texte"); est arbitraire, il s’agit d’une variable. "Texte" est le texte affiché dans le JButton. Pour afficher une image à la place d’un texte, utilisez le code suivant :

ImageIcon = new ImageIcon("chemin avec extension"); JButton = new JButton(); et sont des noms de variables et sont donc arbitraires. "chemin avec extension" est le chemin du fichier. Celui-ci est relatif au répertoire dans lequel

se trouve le projet Java et non, comme précédemment, à la classe compilée. La Figure 13.2 illustre un bouton avec une image. Pour ajouter un JButton au conteneur (en supposant que le nom du conteneur soit cont et que celui du bouton soit bouton), ajoutez cette ligne : cont.add(bouton);

94


Figure 13.2 Un JButton avec un ImageIcon

Les objets de type JButton ont, entre autres, de nombreuses méthodes pour désactiver, activer et modifier leurs icônes. Une liste de ces méthodes est fournie dans l’API. Pour ce jeu, nous devons parler de la méthode setEnabled(). Celle-ci prend en argument un booléen. Si le bouton s’appelle bouton, le code suivant le désactive : bouton.setEnabled(false);

Et le code suivant l’active : bouton.setEnabled(true);

JLabel Un

JLabel est un composant d’un autre type. JFrame. La Figure 13.3 illustre un JLabel.

Il permet d’afficher du texte dans un

Figure 13.3 Un JLabel

On crée un JLabel avec cette ligne : JLabel = new JLabel("texte");

Jeux de plateau 95

Chapitre 3

Comme les JButton, les JLabel peuvent être ajoutés à un JFrame avec une ligne de ce type (si le conteneur s’appelle cont) : cont.add();

Les JLabel peuvent également, comme les utilisé est presque identique :

JButton,

contenir une image. Le code

ImageIcon image = new ImageIcon("chemin avec extension"); JLabel libelle = new JLabel(image);

Lorsqu’on utilise des JLabels, il est souvent pratique de pouvoir modifier leur texte. On peut modifier le texte grâce à la méthode setText(), prenant un String en argument. Par exemple, si votre JLabel s’appelle libelle : libelle.setText("Ceci est le nouveau texte.");

Créer le jeu Créez un JFrame. Ajoutez-y un conteneur. Puis, créez un tableau 5 × 5 de JButton, utilisez des boucles for pour initialiser les JButton du tableau et ajoutez-les au conteneur. Ajoutez des images d’un mauvais génie aux boutons et désactivez tous les boutons. Pour finir, créez et ajoutez un JLabel pour le score (pour l’instant, il affichera juste "SCORE :"). import import import import

javax.swing.event.*; javax.swing.*; java.awt.*; java.awt.event.*;

public class ChasseAuxGenies extends JFrame { //ce tableau contient les 25 JButton JButton[][] boutons = new JButton[5][5]; //icone affichée lorsque le mauvais génie sort de son laboratoire ImageIcon vivant = new ImageIcon("vivant.gif");

//JLabel du score JLabel score = new JLabel("SCORE : "); //constructeur public ChasseAuxGenies(){ //crée le JFrame super("Chasse aux mauvais génies"); setSize(350,325); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //contient les boutons et libellés

96


}

Container cont = getContentPane(); cont.setLayout(new FlowLayout()); //prépare l’affichage des boutons for(int i = 0; i < boutons.length; i++ ) { for(int j = 0; j < boutons[0].length; j++ ) { //crée le JButton System.out.println(vivant); boutons[i][j] = new JButton(vivant); //ajoute le bouton au JFrame cont.add(boutons[i][j]); //désactive le bouton boutons[i][j].setEnabled(false); } } //affichage du score score.setText("SCORE : "); cont.add(score); setContentPane(cont);

} public static void main (String[] args) { //démarre le jeu new ChasseAuxGenies(); }

Figure 13.4 Le jeu à cette étape du développement

La Figure 13.4 illustre la première partie du développement de la chasse aux mauvais génies. Dans le prochain projet, nous verrons comment rendre le jeu opérationnel en déterminant si le joueur a appuyé sur un JButton.

Jeux de plateau 97

Chapitre 3

Projet 14 : La chasse aux mauvais génies – Attrapez-les vite ! Projet

Nouvelles briques

• Le jeu prend forme. Le visage du mauvais génie apparaît. Mais ne craignez rien, vous allez pouvoir le renvoyer dans sa tanière en ajoutant des interactions avec l’utilisateur. • ActionListener .

ActionListener Un ActionListener réagit aux actions. Dans notre cas, une action est un clic d’un joueur sur un bouton. Il faut ajouter un ActionListener à tous les boutons que vous désirez surveiller. Dans la chasse aux mauvais génies, il faut que tous les boutons aient un ActionListener. Pour cela, si votre JButton s’appelle bouton, il faut utiliser la ligne suivante : button.addActionListener(this);

Lorsque vous utilisez des ActionListener, il faut ajouter implements ActionListener à la déclaration de la classe. Si vous implémentez déjà KeyListener ou MouseListener, vous pouvez implémenter les deux interfaces en les séparant par des virgules. Un KeyListener a de nombreuses méthodes obligatoires. Un ActionListener n’en n’a qu’une. Lorsqu’on appuie sur un bouton, Java va dans cette méthode. Voici comment elle doit être déclarée : public void actionPerformed (ActionEvent event) { }

Pour savoir quel bouton a été actionné, il suffit de placer la condition suivante dans une instruction if : event.getSource() ==

Je vous avais suggéré d’utiliser des variables globales pour vos boutons, en voilà la raison. Vous devez vous référer au nom du bouton pour savoir sur lequel l’utilisateur a cliqué.

Créer le jeu Ajoutez d’abord des ActionListener à tous les boutons du tableau. Puis, implémentez ActionListener et ajoutez la méthode obligatoire.

98


Créez alors un nouveau fil d’exécution (Thread). Dans sa boucle while infinie, faites attendre le programme pendant une durée aléatoire (entre 0 et 1 500 millisecondes). Faites apparaître un mauvais génie (en activant son bouton). Attendez 1 000 millisecondes et désactivez le bouton. Dans la méthode actionPerformed, lorsque le joueur clique sur un bouton, incrémentez le compteur qui garde en mémoire le score et mettez les deux fils d’exécution en pause pour un quart de seconde (pour laisser au joueur le temps de reprendre son souffle). Vous pouvez ensuite afficher le score dans le JLabel. import javax.swing.event.*; import javax.swing.*; import java.awt.*; import java.awt.event.*; public class ChasseAuxGenies extends JFrame implements ActionListener { //ce tableau contient les 25 mauvais génies JButton[][] boutons = new JButton[5][5]; //affiche le score JLabel lblScore = new JLabel(); //le score double score = 0; //icone du mauvais génie ImageIcon vivant = new ImageIcon("vivant.gif"); //fil d’exécution du jeu T jeu = null; //constructeur public ChasseAuxGenies() { //Crée le JFrame super("Chasse aux mauvais génies"); setSize(350,325); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //contient les boutons et libellés Container cont = getContentPane(); cont.setLayout(new FlowLayout()); //prépare les boutons à afficher for(int i = 0; i < boutons.length; i++ ) { for(int j = 0; j < boutons[0].length; j++ ) { //crée le JButton boutons[i][j] = new JButton(vivant); //ajoute le bouton au JFrame cont.add(boutons[i][j]); //désactive le bouton boutons[i][j].setEnabled(false); //le bouton répond aux clics boutons[i][j].addActionListener(this); } }

Jeux de plateau 99

Chapitre 3

cont.add(lblScore); setContentPane(cont); //démarre le fil d’exécution jeu = new T(); jeu.start(); setContentPane(cont);

} //fil d’exécution private class T extends Thread { public void run() { //boucle infinie while(true) { //crée une durée aléatoire entre 0 et 1.5 secondes int pause = (int)(Math.random()*1500); try { //pause de la durée aléatoire Thread.sleep(pause); } catch(Exception e) { } //un génie aléatoire apparaît int genie = (int)(Math.random()*5); int genie2 = (int)(Math.random()*5); //fait sortir le génie en activant le bouton boutons[genie][genie2].setEnabled(true); try { //pause pour laisser le temps au joueur d’attraper le génie Thread.sleep(1000); } catch(Exception e) { } //fait disparaître le génie boutons[genie][genie2].setEnabled(false); //affiche le score lblScore.setText("SCORE: "+score);

} }

} //surveille les clics sur les boutons public void actionPerformed(ActionEvent e) { //augmente le score score++ ; //met le jeu en pause pour une demi-seconde try { jeu.sleep(500); Thread.sleep(500); } catch(Exception ex) { } }

100


}

public static void main(String[ ] args) { //démarre le jeu new ChasseAuxGenies(); }

La Figure 14.1 illustre la chasse aux mauvais génies. Figure 14.1 Vite, attrapez-le !

Continuez votre lecture pour savoir comment augmenter le niveau de difficulté au fur et à mesure que le joueur touche des mauvais génies. Attention, les génies peuvent devenir difficiles à attraper, ils apprennent de leurs erreurs... Après tout, ce sont des mauvais génies !

Jeux de plateau 101

Chapitre 3

Projet 15 : La chasse aux mauvais génies – Plus intelligent... Projet

• Dans ce projet, la tension augmente, le mauvais génie apparaît de plus en plus vite... Tourmentez vos joueurs et apprenez à contrôler les niveaux de difficulté.

Créer le jeu Lorsque la difficulté des jeux n’augmente pas, ceux-ci deviennent vite ennuyeux. Pour l’instant, la chasse aux mauvais génies est configurée à un niveau moyen. Pour régler ce problème, demandez d’abord au joueur combien de chances il désire avoir pour attraper le mauvais génie. Puis, créez une variable pour compter les tentatives. Au début de la boucle while du fil d’exécution, incrémentez le compteur. Affichez un message contenant le nombre de coups réussis, multiplié par 10 000 et divisé par le nombre de chances. Ce message termine le jeu. La Figure 15.3 illustre un exemple de boîte de dialogue. Ensuite, ajoutez un entier nommé maxPause. Lorsqu’un mauvais génie est attrapé, soustrayez 100 à cette valeur. Puis, créez un entier aléatoire sur la base de ce nombre : int apparition = (int) (Math.random() * maxPause);

Utilisez ce nouveau nombre comme temps pendant lequel le mauvais génie apparaît. Ainsi, plus vous vous améliorez, plus le jeu devient difficile. import javax.swing.event.*; import javax.swing.*; import java.awt.*; import java.awt.event.*; public class ChasseAuxGenies extends JFrame implements ActionListener { //ce tableau contient les 25 mauvais génies JButton[][] boutons = new JButton[5][5]; //affiche l’état du jeu JLabel score = new JLabel(); //variables pour garder trace du score int maxPause = 1000; double coups = 0; double tours = 0; double toursMax = 0; //icone qui apparaît lorsque le génie sort de son laboratoire ImageIcon vivant = new ImageIcon("vivant.gif"); //fil d’exécution T jeu = null;

102


//constructeur public ChasseAuxGenies() { //crée le JFrame super("Chasse aux mauvais génies"); setSize(350,325); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //contient le nombre de tours que l’utilisateur joue toursMax = Double.parseDouble (JOptionPane.showInputDialog „ ("Combien de chances voulez-vous avoir d’attraper un mauvais génie ?")); //contient les boutons et libellés Container cont = getContentPane(); cont.setLayout(new FlowLayout()); //prépare les boutons à afficher for(int i = 0; i < boutons.length; i ++ ) { for(int j = 0; j < boutons[0].length; j++ ) { //crée le JButton boutons[i][j] = new JButton(vivant); //l’ajoute au JFrame cont.add(boutons[i][j]); //désactive le bouton boutons[i][j].setEnabled(false); //le bouton répond aux clics boutons[i][j].addActionListener(this); } } //le JLabel affiche le score score.setText("Tour "+tours+"/"+toursMax+". Score actuel :"+ „ ((int)((coups/toursMax)*100))); cont.add(score); setContentPane(cont); //démarre le fil d’exécution jeu = new T(); jeu.start(); } //fil d’exécution private class T extends Thread { public void run() { //boucle infinie while(true) { //regarde si le jeu est terminé if(tours>=toursMax) { //si le jeu est terminé, affiche le score JOptionPane.showMessageDialog(null, "Le jeu est terminé.\n\n"+"Vous avez attrapé "+ coups+" mauvais génies en "+tours+" tours.\n"+"Votre score est "+ ((int)(((coups*10000)/tours))), "Fin du jeu", JOptionPane.INFORMATION_MESSAGE); break; }

Jeux de plateau 103

Chapitre 3

//compte le nombre de tours tours++; //crée une durée aléatoire entre 0 et 1.5 secondes int pause = (int)(Math.random()*1500); try { //pause de la durée aléatoire Thread.sleep(pause); } catch(Exception e) { } //fait apparaître un génie aléatoire int genie = (int)(Math.random()*5); int genie2 = (int)(Math.random()*5); //fait sortir le génie en activant le bouton boutons[genie][genie2].setEnabled(true); int apparition = (int) (Math.random() * maxPause); try { //pause pour laisser au joueur le temps d’attraper le génie Thread.sleep(apparition); } catch(Exception e) { } //fait disparaître le génie boutons[genie][genie2].setEnabled(false); //affiche les statistiques score.setText("Tour "+tours+"/"+toursMax+ ". Score actuel : "+ ((int)(((coups*10000)/toursMax))));

} }

} //surveille les clics de boutons public void actionPerformed(ActionEvent e) { //si un génie a été attrapé //diminue le temps d’affichage des génies //pour rendre le jeu plus difficile maxPause-=100; //augmente le score coups++ ; //met le jeu en pause pour une demi-seconde try { jeu.sleep(500); Thread.sleep(500); } catch(Exception ex) { } } public static void main(String[ ] args) { //démarre le jeu new ChasseAuxGenies(); } }

104


Les Figures 15.1 à 15.3 illustrent le jeu la chasse aux mauvais génies. Figure 15.1 Choisissez le nombre de tours

Figure 15.2 Attrapez-les !

Figure 15.3 Le jeu est terminé, le score est affiché.

Pour aller plus loin... Ajoutez de la musique, des applaudissements, des cris de déception, du tonnerre, des explosions ou tout son pouvant augmenter l’intensité du jeu. Vous pouvez aussi ajouter des images supplémentaires, modifier la taille de la grille ou créer une liste de records de scores. Vous pouvez aussi faire apparaître de temps à autre un personnage innocent – si vous le frappez, vous avez perdu !

Jeux de plateau 105

Chapitre 3

Projet 16 : Le morpion boxeur – Le ring Le morpion boxeur

Le jeu classique du morpion est transformé en un match de boxe dans lequel chaque combattant est représenté par une image différente de gants de boxe. Ajoutez des sons de coups, des gémissements ou des railleries pour défier vos adversaires (ou l’ordinateur) et gagner, perdre ou faire match nul. Projet Nouvelles briques

• Dessinez d’abord le ring avant de pouvoir enfiler vos gants et commencer à vous battre ! • NullLayout .

NullLayout Plutôt que d’utiliser une disposition de type FlowLayout, qui place les composants l’un après l’autre, vous pouvez utiliser une disposition vide (null) qui vous permet d’indiquer l’emplacement des composants en coordonnées de pixels. Pour cela, modifiez la ligne setLayout : cont.setLayout(null);

Vous pouvez ajouter des composants de la même manière qu’avec la disposition de type FlowLayout. Pour indiquer l’emplacement d’un composant, utilisez cette ligne : .setBounds(, , , ); est

la variable représentant le composant. et sont les coordonnées du point supérieur gauche du composant. et sont les dimensions souhaitées du composant. Avant que vous ne commenciez à créer des jeux et à ajouter des composants en vous basant sur leur emplacement en pixels, je préfère vous avertir : la disposition vide n’est pas des plus fiables. Il se peut que votre écran ne se rafraîchisse pas et que vos modifications ne soient pas prises en compte. Cependant, ne vous inquiétez pas : il existe une manière simple de rafraîchir l’écran de manière à ce que vos modifications soient systématiquement prises en compte. Une fois que vous avez ajouté tous les composants désirés au conteneur, ajoutez simplement la ligne : cont.repaint();

106


Créer le jeu Déclarez d’abord un tableau de neuf éléments JButton pour contenir le plateau de jeu. Ajoutez les boutons du tableau au conteneur dans une boucle. Les boutons seront ajoutés en fonction d’un emplacement en pixels. Vous devez donc concevoir un algorithme simple pour espacer les morceaux du ring correctement. Voici une suggestion : toutes les images du jeu mesurent 100 × 100 pixels ; les boîtes doivent donc être espacées de 100 pixels. Créez de plus deux variables de valeur 0 en dehors de la loupe. À chaque itération, incrémentez une des variables de 1. Puis, multipliez cette valeur par 100 pour obtenir l’espacement correct en x. Ajoutez une instruction if dans la boucle for. Si le compteur est un multiple de 3 (le plateau est large de trois morceaux), incrémentez la seconde variable pour passer à la ligne suivante. Tout ceci peut sembler confus, mais lorsque vous verrez le code, tout semblera plus clair. int nouvelleLigne = 0; int compteurLigne = 0; for(int i = 0; i < boutons.length; i++) { //initialisation avec une image vide boutons[i] = new JButton(blank); //regarde s’il faut utiliser une nouvelle ligne if(i==3 || i ==6) { nouvelleLigne++; compteurLigne = 0; } //définit la position du bouton boutons[i].setBounds(compteurLigne*100,nouvelleLigne* 100,100,100); //l’ajoute au conteneur container.add(boutons[i]); //ajoute l’ActionListener boutons[i].addActionListener(this); compteurLigne++; }

Maintenant que le plateau est complet, créez une variable appelée tour. Chaque fois que la méthode actionPerformed est exécutée, tour doit être incrémenté de 1. Vous pourrez ainsi vérifier de quel joueur c’est le tour sur la base de la parité de tour. Dans actionPerformed, si tour est impair, c’est le tour du joueur O. S’il est impair, c’est le tour du joueur X. En fonction du joueur qui est en train de jouer, modifiez l’icône pour afficher la bonne image. Lorsque vous avez modifié l’icône, pensez à supprimer l’ ActionListener pour qu’un joueur ne puisse pas voler la position de son adversaire !

Chapitre 3

Jeux de plateau 107

import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; import java.io.*; import java.net.*; //classe avec un JFrame et un ActionListener public class MorpionBoxeur extends JFrame implements ActionListener { //tableau de boutons. Nous utilisons un tableau et non un ArrayList //car le nombre de boutons est constant. JButton boutons[] = new JButton[9]; //garde le décompte des tours. le joueur 1 est pair, le joueur 2 impair //on utilise le modulo (%) pour différencier les valeurs int tour = 1; //représentent les adversaires ImageIcon rouge = new ImageIcon("rouge.png"); ImageIcon bleu = new ImageIcon("bleu.png"); ImageIcon blanc = new ImageIcon("blanc.png"); //constructeur public MorpionBoxeur() { super("Morpion Boxeur"); setSize(330,350); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //contient les boutons Container cont = getContentPane(); //disposition des boutons cont.setLayout(null); int nouvelleLigne = 0; int compteurLigne = 0; for(int i = 0; i < boutons.length; i++) { //initialise le bouton avec une image vide boutons[i] = new JButton(blanc); //faut-il utiliser une nouvelle ligne ? if(i==3 || i ==6) { nouvelleLigne++; compteurLigne = 0; } //position du bouton boutons[i].setBounds(compteurLigne*100,nouvelleLigne*100,100,100); //ajoute le bouton au conteneur cont.add(boutons[i]); //ajoute l’ActionListener boutons[i].addActionListener(this); compteurLigne++; } } //méthode obligatoire public void actionPerformed(ActionEvent e) { //regarde quel bouton a été cliqué

108


}

}

for(int i = 0; i < boutons.length; i++) { if(e.getSource()==boutons[i]) { //vérifie le tour if(tour%2==0) { //si pair, tour du joueur 1 (X) boutons[i].setIcon(rouge); } else { //si impair, tour du joueur 2 (0) boutons[i].setIcon(bleu); } //désactive le bouton pour qu’il ne puisse pas être modifié une fois cliqué boutons[i].removeActionListener(this); } } tour++;

//méthode de démarrage (main) public static void main(String[ ] args) { MorpionBoxeur mp = new MorpionBoxeur(); }

Les Figures 16.1 à 16.4 illustrent le déroulement du jeu. Figure 16.1 Démarrage du jeu

Chapitre 3

Figure 16.2 Le joueur 1 attaque

Figure 16.3 Le joueur 2 contre-attaque

Figure 16.4 Le joueur 1 ("O") gagne... mais l’ordinateur ne peut pas encore détecter le résultat

Jeux de plateau 109

110


Projet 17 : Le morpion boxeur – Combat ! Projet

• Bienvenue au camp d’entraînement. C’est ici que vous allez permettre à deux joueurs de s’affronter sur le ring. Ajoutez une image de titre pour les chauffer et programmez votre ordinateur pour déterminer qui est le champion et qui doit s’incliner.

Créer le jeu Commencez par l’objectif le plus simple : ajouter l’image de titre. Pour cela, créez une image de titre dans un logiciel graphique quelconque. Puis, créez un JLabel pour afficher cette image. Ajoutez ce JLabel au-dessus des boutons (à l’emplacement 0,0), N’oubliez pas de modifier la boucle qui ajoute les boutons pour que ceux-ci ne soient pas couverts par l’image du titre. Il suffit pour cela d’ajouter la hauteur de l’image aux valeurs en y de la position de vos boutons. Vous pouvez aussi ajouter un nombre à la valeur en x de la position des boutons pour qu’ils soient centrés comme le montre la Figure 17.1. Figure 17.1 L’image de titre et les boutons sont centrés

Ensuite, apprenez à l’ordinateur comment détecter les K.-O. Créez une méthode appelée verifieVictoire. À la fin de chaque appel de la méthode actionPerformed, appelez

Chapitre 3

Jeux de plateau 111

verifieVictoire.

Il existe deux techniques pour vérifier une victoire. La première implique une série d’instructions if qui n’est pas vraiment amusante. La seconde technique demande moins de code. Comme le plateau de morpion boxeur est un carré, il est plus simple de placer ces instructions if dans des boucles. Ceci supprime presque les deux tiers du code à écrire. Comme la Figure 17.2 l’illustre, une boucle unique peut vérifier six cas différents. Figure 17.2 Une seule boucle permet de gérer 6 cas

Voici maintenant la partie délicate : écrire cette boucle for. Pour cela, créez une boucle for allant de 0 à 2 (3 itérations). Dans la boucle, ajoutez 4 instructions if : une pour une victoire X en vertical, une pour une victoire O en vertical, une pour une victoire X en horizontal et une pour une victoire O en horizontal. Chaque itération de la boucle détermine si les icônes des boutons dans une position donnée sont toutes de la même couleur. Le code des instructions if est indiqué ci-après : //cherche une victoire X en vertical if(boutons[i].getIcon().equals(rouge) && boutons[i+3].getIcon().equals(rouge) && boutons[i+6].getIcon().equals(rouge)) JOptionPane.showMessageDialog(null,“X gagne”); //cherche une victoire O en vertical if(boutons[i].getIcon().equals(bleu) && boutons[i+3].getIcon().equals(bleu) && boutons[i+6].getIcon().equals(bleu)) JOptionPane.showMessageDialog(null,“O gagne”); //cherche une victoire X en horizontal if(boutons[i*3].getIcon().equals(rouge) && boutons[(i*3)+1].getIcon().equals(rouge) && boutons[(i*3)+2].getIcon().equals(rouge)) JOptionPane.showMessageDialog(null,“X gagne”);

112


//cherche une victoire O en horizontal if(boutons[i*3].getIcon().equals(bleu) && boutons[(i*3)+1].getIcon().equals(bleu) && boutons[(i*3)+2].getIcon().equals(bleu)) JOptionPane.showMessageDialog(null,“O gagne”);

Vous y êtes presque ! Il suffit d’ajouter une seconde boucle pour les victoires diagonales. On procède de la même manière que pour les lignes horizontales et verticales, à ceci près qu’il n’y a que deux itérations à la boucle. La boucle est indiquée ci-après : //cherche une victoire en diagonal for(int i = 0; i <= 2; i+=2) { //cherche une victoire X en diagonal if(boutons[i].getIcon().equals(rouge) && boutons[4].getIcon().equals(rouge) && boutons[8_i].getIcon().equals(rouge)) JOptionPane.showMessageDialog(null, “X gagne”); //cherche une victoire O en diagonal if(boutons[i].getIcon().equals(bleu) && boutons[4].getIcon().equals(bleu) && boutons[8_i].getIcon().equals(bleu)) JOptionPane.showMessageDialog(null, “O gagne”); }

Vous disposez maintenant de tout le code nécessaire pour vérifier les victoires. Le code complet est reproduit ci-après : import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; import java.io.*; import java.net.*; //classe avec un JFrame et un ActionListener public class MorpionBoxeur extends JFrame implements ActionListener { //tableau de boutons. On utilise un tableau et non un arrayList //car le nombre de boutons est constant. JButton boutons[] = new JButton[9]; //garde le décompte des tours. le joueur 1 est pair, le joueur 2 impair //on utilise le modulo (%) pour différencier les valeurs int tour = 1; //représentent les adversaires ImageIcon rouge = new ImageIcon("rouge.png"); ImageIcon bleu = new ImageIcon("bleu.png"); ImageIcon blanc = new ImageIcon("blanc.png"); //image de titre JLabel titre = new JLabel(new ImageIcon("titre.png"));

Chapitre 3

//constructeur public MorpionBoxeur() { super("Morpion Boxeur"); setSize(350,625); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //contient les boutons Container cont = getContentPane(); //disposition des boutons cont.setLayout(null); cont.add(titre); titre.setBounds(0,0,350,288); int nouvelleLigne = 0; int compteurLigne = 0; for(int i = 0; i < boutons.length; i++) { //initialisation avec une image vide boutons[i] = new JButton(blanc); //faut-il utiliser une nouvelle ligne ? if(i==3 || i==6) { nouvelleLigne++; compteurLigne = 0; } //position du bouton boutons[i].setBounds(15+(compteurLigne*100),288+ „ (nouvelleLigne*100),100,100); //ajout du bouton au conteneur cont.add(boutons[i]); //ajoute l’ActionListener boutons[i].addActionListener(this); compteurLigne++; } //rafraîchit l’écran cont.repaint(); } //méthode obligatoire public void actionPerformed(ActionEvent e) { //surveille les clics sur les boutons for(int i = 0; i < boutons.length; i++) { if(e.getSource()==boutons[i]) { //calcule de quel joueur c’est le tour if(tour%2==0) { //si le tour est pair, c’est le tour du joueur 1 (X) boutons[i].setIcon(rouge); } else

Jeux de plateau 113

114


{

}

//si le tour est impair, c’est le tour du joueur 2 (0) boutons[i].setIcon(bleu);

} //désactive le bouton pour qu’on ne puisse plus re-cliquer dessus boutons[i].removeActionListener(this);

} tour++; //avant que l’autre joueur ne joue, on regarde si quelqu’un a gagné verifieVictoire(); } public void verifieVictoire() { //trois itérations de la boucle pour vérifier les victoires horizontales //et verticale avec peu de code for(int i = 0; i < 3; i++) { //cherche une victoire X en vertical if(boutons[i].getIcon().equals(rouge) && boutons[i+3].getIcon().equals(rouge) && boutons[i+6].getIcon().equals(rouge)) JOptionPane.showMessageDialog(null,"X gagne"); //cherche une victoire O en vertical if(boutons[i].getIcon().equals(bleu) && boutons[i+3].getIcon().equals(bleu) && boutons[i+6].getIcon().equals(bleu)) JOptionPane.showMessageDialog(null,"O gagne"); //cherche une victoire X en horizontal if(boutons[i*3].getIcon().equals(rouge) && boutons[(i*3)+1].getIcon().equals(rouge) && boutons[(i*3)+2].getIcon().equals(rouge)) JOptionPane.showMessageDialog(null,"X gagne"); //cherche une victoire O en horizontal if(boutons[i*3].getIcon().equals(bleu) && boutons[(i*3)+1].getIcon().equals(bleu) && boutons[(i*3)+2].getIcon().equals(bleu)) JOptionPane.showMessageDialog(null,"O gagne"); } //cette boucle cherche les victoires en diagonal for(int i = 0; i <= 2; i+=2) { //cherche une victoire X en diagonal if(boutons[i].getIcon().equals(rouge) && boutons[4].getIcon().equals(rouge) && boutons[8-i].getIcon().equals(rouge)) JOptionPane.showMessageDialog(null,"X gagne"); //cherche une victoire 0 en diagonal if(boutons[i].getIcon().equals(bleu) && boutons[4].getIcon().equals(bleu) && boutons[8-i].getIcon().equals(bleu)) JOptionPane.showMessageDialog(null,"O gagne");

Chapitre 3

}

Jeux de plateau 115

} } //méthode de démarrage (main) public static void main(String[] args) { MorpionBoxeur mp = new MorpionBoxeur(); }

Les Figures 17.3 et 17.4 illustrent la nouvelle image de titre du morpion boxeur et la vérification des victoires. Ali, Tyson, Foreman : dans le prochain projet, vous apprendrez comment programmer le boxeur ultime en ajoutant de l’intelligence artificielle. Figure 17.3 Le joueur 1 (O) va gagner !

Figure 17.4 L’ordinateur reconnaît la victoire du joueur 1 (O).

116


Projet 18 : Le morpion boxeur – K.-O. ! Projet

• Oubliez les beaux jeux de jambes, les directs rapides et les coups de poing foudroyants. L’intelligence artificielle est la force la plus puissante sur un ring de boxe. Ce projet va vous expliquer comment créer une intelligence artificielle pour créer un adversaire à votre hauteur et à celle de vos amis.

Créer le jeu Pour créer une intelligence artificielle (IA), vous n’aurez pas besoin d’apprendre de nouveau concept ni de nouvelle syntaxe. En revanche, une quantité non négligeable de mathématiques sont en jeu. Cela n’est pas un problème. Penser à la manière dont on joue avant de programmer l’IA rend le processus bien plus simple. Lorsque vous créez une IA, vous devez analyser la manière avec laquelle la plupart des gens jouent au morpion. Généralement, on choisit comme premier coup un coin ou le milieu du plateau pour prendre l’avantage. Puis, on analyse le plateau pour en déduire la victoire la plus rapide. Si la victoire n’est qu’à une case, il suffit de prendre cette case pour assurer la défaite de l’adversaire. Si la victoire est plus lointaine, il faut penser défensif pour bloquer l’opposant. Une fois pris en considération le processus de pensée d’un humain pour arriver à la victoire, vous pouvez commencer à programmer l’IA ! Tout d’abord, au lieu de changer les icônes dans la méthode actionPerformed, il suffit que celle-ci affiche l’icône X. Puis, à la fin de actionPerformed, appelez une méthode nommée ia. Dans la méthode ia, commencez par examiner le compteur de tours. S’il s’agit du premier tour de l’ordinateur, choisissez le centre ou la case en haut à gauche. Puis, tapez l’instruction return pour terminer la méthode et laissez le joueur gérer son tour. S’il ne s’agit pas du premier tour de l’ordinateur, regardez s’il existe deux O alignés. Si c’est le cas, agissez de manière offensive et prenez la case, comme l’illustre la Figure 18.1. L’ordinateur met alors le joueur K.-O. ! S’il n’existe pas de ligne contenant deux O, jouez de manière défensive et cherchez deux X alignés. Bloquez alors le troisième emplacement pour que l’adversaire ne puisse pas gagner, comme l’illustre la Figure 18.2. Pour cela, créez une méthode dont l’argument est un objet de type Icon. Elle cherchera les alignements de deux de ces icônes avec des boucles for. Si un alignement est trouvé, placez-vous sur la troisième case et exécutez return, ce qui termine la méthode et évite que l’ordinateur ne joue deux fois en un tour.

Chapitre 3

Jeux de plateau 117

Figure 18.1 Agissez de manière offensive et jouez pour gagner

Figure 18.2 Jouez de manière défensive et empêchez votre adversaire de gagner

Et voilà ! Démarrez le premier round. Le code complet se trouve ci-après : import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; import java.io.*; import java.net.*; //classe avec un JFrame et un ActionListener public class MorpionBoxeur extends JFrame implements ActionListener { //tableau de boutons. Nous utilisons un tableau et non un ArrayList car //le nombre de boutons est constant. JButton boutons[] = new JButton[9]; //garde trace des tours : les tours pairs sont ceux du joueur 1, les tours //impairs ceux du joueur 2. On les différencie avec l’opérateur modulo (%) int tour = 1; //images pour représenter les camps ImageIcon rouge = new ImageIcon("rouge.png"); ImageIcon bleu = new ImageIcon("bleu.png"); ImageIcon blanc = new ImageIcon("blanc.png"); //image de titre JLabel titre = new JLabel(new ImageIcon("titre.png"));

118


//constructeur public MorpionBoxeur() { super("Morpion Boxeur"); setSize(350,625); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //contiendra les boutons Container cont = getContentPane(); //indique la disposition des boutons cont.setLayout(null); cont.add(titre); titre.setBounds(0,0,350,288); int nouvelleLigne = 0; int compteurLigne = 0; for(int i = 0; i < boutons.length; i++) { //initialisation avec une image vide boutons[i] = new JButton(blanc); //regarde s’il faut créer une ligne if(i==3 || i ==6) { nouvelleLigne++; compteurLigne = 0; } //définit la position du bouton boutons[i].setBounds(15+(compteurLigne*100),288+ „ (nouvelleLigne*100),100,100); //ajoute le bouton au conteneur cont.add(boutons[i]); //ajoute l’ActionListener boutons[i].addActionListener(this); compteurLigne++; } //rafraîchit l’écran cont.repaint(); } //méthode obligatoire public void actionPerformed(ActionEvent e) { //regarde sur quel bouton on a appuyé for(int i = 0; i < boutons.length; i++) { if(e.getSource()==boutons[i]) { //le bouton passe à X boutons[i].setIcon(rouge); //désactive le bouton pour qu’il ne puisse pas être rejoué boutons[i].removeActionListener(this); } } tour++; //avant de laisser l’ordinateur jouer, regarde si quelqu’un a gagné verifieVictoire(); //l’ordinateur joue ia(); }

Chapitre 3

Jeux de plateau 119

public void verifieVictoire() { //on commence par trois itérations pour chercher des victoires //en vertical ou en horizontal sans écrire trop de code for(int i = 0; i < 3; i++) { //cherche une victoire X en vertical if(boutons[i].getIcon().equals(rouge) && boutons[i+3].getIcon().equals(rouge) && boutons[i+6].getIcon().equals(rouge)) { JOptionPane.showMessageDialog(null,"Vous avez gagné !"); return; } //cherche une vitoire O en vertical if(boutons[i].getIcon().equals(bleu) && boutons[i+3].getIcon().equals(bleu) && boutons[i+6].getIcon().equals(bleu)) { JOptionPane.showMessageDialog(null,"Vous avez perdu !"); return; } //cherche une victoire X en horizontal if(boutons[i*3].getIcon().equals(rouge) && boutons[(i*3)+1].getIcon().equals(rouge) && boutons[(i*3)+2].getIcon().equals(rouge)) { JOptionPane.showMessageDialog(null,"Vous avez gagné !"); return; } //cherche une victoire O en horizontal if(boutons[i*3].getIcon().equals(bleu) && boutons[(i*3)+1].getIcon().equals(bleu) && boutons[(i*3)+2].getIcon().equals(bleu)) { JOptionPane.showMessageDialog(null,"Vous avez perdu !"); return; } } //cette boucle cherche les victoires en diagonal for(int i = 0; i <= 2; i+=2) { //cherche une victoire X en diagonal if(boutons[i].getIcon().equals(rouge) && boutons[4].getIcon().equals(rouge) && boutons[8-i].getIcon().equals(rouge)) { JOptionPane.showMessageDialog(null,"Vous avez gagné !"); return; } //cherche un victoire O en diagonal if(boutons[i].getIcon().equals(bleu) && boutons[4].getIcon().equals(bleu) && boutons[8-i].getIcon().equals(bleu)) { JOptionPane.showMessageDialog(null,"Vous avez perdu !"); return; } } }

120


public void ia() { boolean mouvementFait; //si c’est le premier tour de l’ordinateur, essaie de prendre la case en //haut à gauche. Si elle est déjà prise, prend la case du milieu. if(tour == 2) { //si la case en haut à gauche est prise, prend celle du milieu if(boutons[0].getIcon().equals(rouge)) { boutons[4].setIcon(bleu); boutons[4].removeActionListener(this); mouvementFait = true; } //sinon, prend celle en haut à gauche else { boutons[0].setIcon(bleu); boutons[0].removeActionListener(this); mouvementFait = true; } } //si ce n’est pas le premier tour, cherche les lignes où deux cases sont prises //s’il n’en existe pas, prend la première case disponible else { //appel de la méthode pour vérifier deux cases de la couleur passée „ en argument //la méthode prend alors la case mouvementFait = deuxAlignes(bleu); //si l’ordinateur n’a pas trouvé de case offensive, trouve une case défensive if(!mouvementFait) { mouvementFait = deuxAlignes(rouge); //s’il n’y a pas de mouvement défensif à faire, prend la première case //qu’il trouve if(!mouvementFait) { //trouve la première case disponible for(int i = 0; i < boutons.length; i++) { //si elle est vide, prendre la case if(boutons[i].getIcon().equals(blanc)) { boutons[i].setIcon(bleu); boutons[i].removeActionListener(this); mouvementFait = true; break; } } } } } tour++; System.out.println(tour); verifieVictoire(); if(!mouvementFait) { //si aucune case n’a été prise, match nul JOptionPane.showMessageDialog(null,"Match nul !!!"); } }

Chapitre 3

Jeux de plateau 121

public boolean deuxAlignes(Icon a) { for(int i = 0; i < 3; i++) { //cherche les colonnes avec deux éléments identiques en haut if(boutons[i].getIcon().equals(a) && boutons[i+3].getIcon().equals(a) && boutons[i+6].getIcon().equals(blanc)) { boutons[i+6].setIcon(bleu); boutons[i+6].removeActionListener(this); return true; } //cherche les colonnes du type "un élément, un trou, un élément" if(boutons[i].getIcon().equals(a) && boutons[i+6].getIcon().equals(a) && boutons[i+3].getIcon().equals(blanc)) { boutons[i+3].setIcon(bleu); boutons[i+3].removeActionListener(this); return true; } //cherche les colonnes avec deux éléments identiques en bas if(boutons[i+6].getIcon().equals(a) && boutons[i+3].getIcon().equals(a) && boutons[i].getIcon().equals(blanc)) { boutons[i].setIcon(bleu); boutons[i].removeActionListener(this); return true; } //cherche les lignes avec deux éléments identiques à gauche if(boutons[i*3].getIcon().equals(a) && boutons[(i*3)+1].getIcon().equals(a) && boutons[(i*3)+2].getIcon().equals(blanc)) { boutons[(i*3)+2].setIcon(bleu); boutons[(i*3)+2].removeActionListener(this); return true; } //chercje les lignes du type "un élément, un trou, un élément" if(boutons[i*3].getIcon().equals(a) && boutons[(i*3)+2].getIcon().equals(a) && boutons[(i*3)+1].getIcon().equals(blanc)) { boutons[(i*3)+1].setIcon(bleu); boutons[(i*3)+1].removeActionListener(this); return true; } //cherche les lignes avec deux éléments identiques à droite if(boutons[(i*3)+2].getIcon().equals(a) && boutons[(i*3)+1].getIcon().equals(a) && boutons[i*3].getIcon().equals(blanc)) { boutons[i*3].setIcon(bleu); boutons[i*3].removeActionListener(this); return true; } //cherche les diagonales avec deux éléments identiques contigus for(int j = 0; j <= 2; j+=2) {

122


if(boutons[j].getIcon() ==a && if(boutons[j].getIcon()==a boutons[4].getIcon()==a && boutons[8-j].getIcon().equals(blanc)) boutons[8-j].getIcon(). equals(blanc)) { boutons[8-j].setIcon(bleu); boutons[8-j].removeActionListener(this); return true; } //cherche les diagonales du type "un élément, un trou, un élément" if(boutons[j].getIcon()==a if(boutons[j].getIcon() ==a && boutons[8-j].getIcon()==a boutons[8-j].getIcon()= =a && boutons[4].getIcon().equals(blanc)) boutons[4].getIcon().eq uals(blanc)) { boutons[4].setIcon(bleu); boutons[4].removeActionListener(this); return true; } if(boutons[8-j].getIcon()==a if(boutons[8-j].getIcon ()==a && boutons[4].getIcon()==a && boutons[j].getIcon().equals(blanc)) boutons[j].getIcon().eq uals(blanc)) { boutons[j].setIcon(bleu); boutons[j].removeActionListener(this); return true; }

}

} return false; } //méthode de démarrage public static void main(String[] args) { MorpionBoxeur mp = new MorpionBoxeur(); } }

Les Figures 18.3 et 18.4 illustrent la victoire de l’ordinateur et le match nul. Figure 18.3 L’ordinateur L’or dinateur a gagné

Figure 18.4 Match nul !

Chapitre 3

Jeux de plateau 123

Pour aller plus loin... Vous pouvez ajouter des sons pour qu’un public encourage les adversaires ou ajouter des images pour améliorer les messages de fin de jeu indiquant quel joueur a gagné. Vous pouvez aussi modifier le ring de boxe pour que celui-ci contienne 16 cases (4 × 4) et non 9. Pour encore plus de challenge, vous pouvez passer le ring en trois dimensions et faire jouer plusieurs joueurs. Vous pouvez aussi gérer plusieurs niveaux de difficulté et faire progresser l’ordinateur après chaque round.

4 Jeux de tir Au sommaire de ce chapitre :

Destructeurs de l’espace ●

Projet 19 : Le paysage

●

Projet 20 : Lasers

●

Projet 21 : La vengeance

126


Projet 19 : Destructeurs de l’espace – Le paysage Destructeurs de l’espace

La planète Terre est envahie. Vous allez concevoir et commander un vaisseau militaire pour détruire les aliens. Votre arsenal contient des mitraillettes à plasma, des bonus de vie et des rayons réflecteurs. Sauvez notre planète ! Projet Nouvelles briques

• Cré Créez ez le pay paysag sagee et le le vaisse vaisseau. au. • MouseMotionListener.

MouseMotionListener Un MouseMotionListener détecte les mouvements de la souris. Comme le KeyListener et l’ ActionListener, le MouseMotionListener a deux méthodes obligatoires : public void mouseMoved (MouseEvent event)

et public void mouseDragged(MouseEvent event)

Pour obtenir la position en X et en Y du curseur, utilisez les méthodes : event.getX(); event.getY();

Créer le jeu Commencez par créer un JFrame de 500 par 700 pixels. Son arrière-fond doit être noir. Pour les vaisseaux militaires, créez deux objets de type ImageIcon : un pour le vaisseau de base et un pour le vaisseau lorsqu’il est endommagé. Puis, créez un JLabel et attribuez-lui l’ImageIcon. Ajoutez un MouseMotionListener à la classe. Dans la méthode mouseMoved, utilisez la méthode setBounds du vaisseau pour le déplacer en suivant le curseur. import import import import import

javax.swing.*; javax.swing.event.*; java.awt.*; java.awt.event.*; java.util.*;

Chapitre 4

Jeux de tir 127

public class DestructeursEspace extends JFrame implements MouseMotionListener { //contient les composants Container cont; //images du vaisseau ImageIcon imageVaisseau = new ImageIcon("vaisseau.png"); ImageIcon vaisseauEndommage = new ImageIcon("vaisseauTouche.png"); //vaisseau du joueur JLabel vaisseau = new JLabel(imageVaisseau); public DestructeursEspace() { super("Destructeurs de l’Espace"); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setSize(500,700); cont = getContentPane(); cont.setLayout(null); //définit la couleur de l’arrière-fond cont.setBackground(Color.BLACK); cont.add(vaisseau); vaisseau.setBounds(225, 550,50,50); addMouseMotionListener(this); setContentPane(cont); } public void mouseMoved(MouseEvent event) { vaisseau.setBounds(event.getX()-25,event.getY()-40,50,50); } public void mouseDragged(MouseEvent event){ } public static void main (String[] args) { new DestructeursEspace(); } }

La Figure 19.1 illustre le vaisseau suivant le curseur. Dans la suite, nous verrons comment ajouter des armes à votre vaisseau. Mais à quoi servent des armes si vous n’avez pas de cible ? Nous créerons donc aussi des aliens menaçants.

128


Figure 19.1 Le vaisseau est prêt pour l’action !

Jeux de tir 129

Chapitre 4

Projet 20 : Destructeurs de l’espace – Lasers Projet

• Vous êtes maintenant prêt à créer des aliens diaboliques ! Mais avant tout, ajoutez des lasers à votre vaisseau pour donner une chance à l’humanité de pouvoir se battre.

Créer le jeu Créez un ImageIcon et un JLabel pour les lasers du vaisseau. Créez un ArrayList pour contenir tous les lasers tirés par le vaisseau. Cet ArrayList contiendra les JLabel euxmêmes. Lorsque l’ ArrayList est prêt, ajoutez un KeyListener pour déterminer quand faire feu avec les lasers. Lorsque le joueur appuie sur la barre espace, ajoutez le laser au tableau de jeu et à l’ ArrayList. Après avoir créé un fil d’exécution et une boucle infinie, utilisez une boucle for et la méthode setBounds pour que les lasers tirent vers le haut. Il est maintenant temps de créer les aliens. Créez deux ImageIcon : un d’un alien normal (voir la Figure 20.1) et un d’un alien touché (voir la Figure 20.2). Figure 20.1 Alien normal

Figure 20.2 Alien endommagé

Ajoutez l’image de l’alien normal à un JLabel. Puis, créez deux variables : niveau et nbEnnemis. Le nombre d’ennemis correspond au carré de chaque numéro de niveau : ainsi, le deuxième niveau a 22 = 4 ennemis, le troisième, 32 = 9 ennemis. Dans le constructeur, utilisez une boucle pour initialiser les ennemis. Dans la boucle infinie, déplacez les aliens vers le bas. Créez également un ArrayList pour contenir les aliens. Une instruction if vérifiera le nombre d’ennemis encore en vie. Si ce nombre est 0, incrémentez la variable niveau de 1 et ajoutez les aliens correspondants à l’écran et à l’ ArrayList. Pour vous faciliter la vie, vous pouvez créer une méthode pour peupler l’ ArrayList. Lorsque les aliens arrivent en bas de l’écran et disparaissent, faites-les réapparaître en haut de l’écran.

130


Il faut également détecter les collisions entre les lasers du vaisseau et les aliens dans la boucle infinie. Si un alien et un laser entrent en collision, il faut les retirer. Et n’oubliez pas de passer l’icône de l’alien à celle de l’alien touché avant de le supprimer. import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; import java.util.*; public class DestructeursEspace extends JFrame implements KeyListener,MouseMotionListener { //contient les composants Container cont; //niveau courant int niveau = 1; //nombre d’ennemis int nbEnnemis = 1; //image du laser ImageIcon laserVaisseau = new ImageIcon("laserVaisseau.png"); //lasers du joueur ArrayList lasersJoueur = new ArrayList(); //ennemis ArrayList ennemis = new ArrayList(); //images du vaisseau ImageIcon imgVaisseau = new ImageIcon("vaisseau.png"); ImageIcon vaisseauEndommage = new ImageIcon("vaisseauTouche.png"); //images des ennemis ImageIcon imgEnnemi = new ImageIcon("ennemi.png"); ImageIcon ennemiEndommage = new ImageIcon("ennemiTouche.png"); //vaisseau du joueur JLabel vaisseau = new JLabel(imgVaisseau); public DestructeursEspace() { super("Destructeurs de l’Espace"); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setSize(500,700); cont = getContentPane(); cont.setLayout(null); //couleur de l’arrière fond cont.setBackground(Color.BLACK); cont.add(vaisseau); vaisseau.setBounds(225, 550,50,50); addKeyListener(this); addMouseMotionListener(this); peupleEnnemis(); Jeu jeu= new Jeu(); jeu.start(); setContentPane(cont); }

Chapitre 4

Jeux de tir 131

public void peupleEnnemis() { for(int i = 0; i < nbEnnemis; i++) { JLabel tmpEnnemi = new JLabel(imgEnnemi); int emplAleatoire = (int)(Math.random()*500); ennemis.add(tmpEnnemi); cont.add((JLabel)(ennemis.get(i))); tmpEnnemi.setBounds(emplAleatoire,10,30,30); cont.setComponentZOrder(((JLabel)(ennemis.get(i))),0); } } public class Jeu extends Thread { public void run() { while(true) { try { for(int i = 0; i < ennemis.size(); i++) { JLabel tmpEnnemi = (JLabel)(ennemis.get(i)); int distance = (int)(Math.random()*2); tmpEnnemi.setBounds(tmpEnnemi.getX(),tmpEnnemi.getY()+ „ distance,30,30); if(tmpEnnemi.getBounds().intersects(vaisseau.getBounds())) { cont.remove(tmpEnnemi); } if(tmpEnnemi.getY()>550)tmpEnnemi.setBounds(tmpEnnemi.getX(), „ 10, 30, 30); } //regarde si les lasers du joueur touchent les aliens boolean recommence = false; for(int i = 0; i < lasersJoueur.size(); i++) { JLabel temp = ((JLabel)(lasersJoueur.get(i))); temp.setBounds(temp.getX(),temp.getY()-8,10,20); if(temp.getY()<0) { cont.remove(temp); lasersJoueur.remove(i); i--; } for(int j = 0; j < ennemis.size(); j++) { JLabel tmpEnnemi = (JLabel)(ennemis.get(j)); if(temp.getBounds().intersects(tmpEnnemi.getBounds())) { tmpEnnemi.setIcon(ennemiEndommage); Thread.sleep(100); ennemis.remove(j); cont.remove(tmpEnnemi); nbEnnemis--; if(nbEnnemis<=0) { niveau++; nbEnnemis = niveau * niveau; peupleEnnemis(); recommence = true; break; } } }

132


if(recommence) break;

} cont.repaint(); Thread.sleep(10); } catch(Exception e){ } } }

} public void mouseMoved(MouseEvent event) { vaisseau.setBounds(event.getX()-25,event.getY()-40,50,50); } public void mouseDragged(MouseEvent event){ } public void keyPressed(KeyEvent event) { if(event.getKeyChar()==’ ’) { JLabel tmpLaser = new JLabel(laserVaisseau); tmpLaser.setBounds(vaisseau.getX()+20,vaisseau.getY()-20,10,20); lasersJoueur.add(tmpLaser); cont.add((JLabel)(lasersJoueur.get(lasersJoueur.size()-1))); cont.setComponentZOrder((JLabel)(lasersJoueur.get(lasersJoueur.size() „ -1)),0); } } public void keyReleased(KeyEvent event) { } public void keyTyped(KeyEvent event) { } public static void main(String[] args) { new DestructeursEspace(); }

}

Les Figures 20.3 à 20.5 montrent le joueur défendant la planète face à l’invasion. Les aliens arrivent désormais par salves. Mais la bataille ne sera qu’un faible défi à moins que les aliens n’aient également de la puissance de feu. C’est ce que permet de faire le projet suivant.

Chapitre 4

Figure 20.3 Arrivée des aliens

Figure 20.4 Ouverture du feu

Jeux de tir 133

134


Figure 20.5 Oh oh, ils se reproduisent !

Jeux de tir 135

Chapitre 4

Projet 21 : Destructeurs de l’espace – La vengeance Projet

• Le combat s’intensifie ! Offrez de la puissance de feu aux aliens et créez des bonus apparaissant à certains niveaux.

Créer le jeu Pour armer les aliens, créez une variable aléatoire entre 0 et 2 500. Si la valeur de cette variable est inférieure ou égale à 1, l’alien tire un laser. Créez un ArrayList et utilisez le même code que celui servant aux tirs du vaisseau. Dans la boucle infinie, cherchez les collisions entre les lasers aliens et le vaisseau. S’ils entrent en collision, modifiez l’icône du vaisseau pour afficher celle du vaisseau endommagé. Puis, créez deux variables : l’une d’elles représente le score et la seconde représente le niveau de vie du vaisseau. Lorsque le vaisseau est attaqué, diminuez le niveau de vie ; lorsqu’un alien est détruit, augmentez le score. En ce qui concerne les bonus, il en existe de deux types : des rayons réflecteurs et des bonus de vie. Les rayons réflecteurs mélangent les particules des aliens et les font disparaître temporairement. Les bonus de vie ajoutent de l’énergie au vaisseau. Tous les trois niveaux, un déflecteur de rayons apparaît. Tous les cinq niveaux, un bonus de vie apparaît. Aux niveaux correspondants, ajoutez le bonus en haut de l’écran et faitesle tomber pour que le vaisseau puisse le capturer. Lorsque le vaisseau attrape un bonus de vie, supprimez-le et augmentez le niveau de vie du vaisseau. Lorsque le vaisseau attrape un rayon réflecteur, supprimez l’icône et ajoutez un JLabel couvrant la largeur de l’écran. Déplacez ce rayon vers le haut grâce à la méthode setBounds. Si le rayon entre en collision avec un alien, supprimez l’alien et ajoutez des points au score du joueur. Ajoutez en bas de l’écran un JLabel contenant les statistiques du joueur (niveau, points, vie). N’oubliez pas d’en modifier la valeur après chaque itération de la boucle infinie. import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; import java.util.*; public class DestructeursEspace extends JFrame implements KeyListener,MouseMotionListener { //contient les composants Container cont; //niveau courant int niveau = 1;

136


//nombre d’ennemis int nbEnnemis = 1; //images des lasers ImageIcon laserVaisseau = new ImageIcon("laserVaisseau.png"); ImageIcon laserEnnemi = new ImageIcon("laserEnnemi.png"); //contient les lasers du joueur ArrayList lasersJoueur = new ArrayList(); //contient les ennemis ArrayList ennemis = new ArrayList(); //contient les lasers des ennemis ArrayList lasersEnnemis = new ArrayList(); //images du vaisseau ImageIcon imgVaisseau = new ImageIcon("vaisseau.png"); ImageIcon vaisseauEndommage = new ImageIcon("vaisseauTouche.png"); //images des ennemisthese are the images of the enemies ImageIcon imgEnnemi = new ImageIcon("ennemi.png"); ImageIcon ennemiEndommage = new ImageIcon("ennemiTouche.png"); //bonus : réflecteur JLabel reflecteur = new JLabel(new ImageIcon("reflecteur.png")); //vaisseau du joueur JLabel vaisseau = new JLabel(imgVaisseau); //attaque du réflecteur JLabel attaqueReflecteur = new JLabel(new ImageIcon("attaqueReflecteur.png")); //indique si le réflecteur est utilisé boolean utiliseReflecteur = false; //bonus de vie JLabel bonusVie = new JLabel(new ImageIcon("vie.png")); //score int score = 0; //vie int vie = 500; //score final int scoreFinal = 0; JLabel scoreLbl = new JLabel("Niveau : "+niveau+" Score : "+score+ „ " Vie : "+vie);

public DestructeursEspace() { super("Destructeurs de l’Espace"); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setSize(500,700); cont = getContentPane(); cont.setLayout(null); //couleur de l’arrière fond cont.setBackground(Color.BLACK); scoreLbl.setFont(new Font("Times New Roman", Font.BOLD, 20)); scoreLbl.setForeground(Color.WHITE); cont.add(scoreLbl); scoreLbl.setBounds(20,600,400,50); cont.add(vaisseau); vaisseau.setBounds(225, 550,50,50);

Jeux de tir 137

Chapitre 4

addKeyListener(this); addMouseMotionListener(this); peupleEnnemis(); Jeu jeu= new Jeu(); jeu.start(); setContentPane(cont);

} public void peupleEnnemis() { for(int i = 0; i < nbEnnemis; i++) { JLabel tmpEnnemi = new JLabel(imgEnnemi); int emplAleatoire = (int)(Math.random()*500); ennemis.add(tmpEnnemi); cont.add((JLabel)(ennemis.get(i))); tmpEnnemi.setBounds(emplAleatoire,10,30,30); cont.setComponentZOrder(((JLabel)(ennemis.get(i))),0); } } public class Jeu extends Thread { public void run() { while(true) { try { for(int i = 0; i < ennemis.size(); i++) { JLabel tmpEnnemi = (JLabel)(ennemis.get(i)); int distance = (int)(Math.random()*2); tmpEnnemi.setBounds(tmpEnnemi.getX(), tmpEnnemi.getY()+distance,30,30); //le rayon réflecteur touche-t-il des aliens ? if(utiliseReflecteur) { if(attaqueReflecteur.getBounds().intersects(tmpEnnemi.getBounds())) { cont.remove(tmpEnnemi); i--; nbEnnemis--; score +=15; } } if(tmpEnnemi.getBounds().intersects(vaisseau.getBounds())) { vie--; cont.remove(tmpEnnemi); } if(tmpEnnemi.getY()>550)tmpEnnemi.setBounds(tmpEnnemi.getX(), „ 10, 30, 30); int feu = (int)(Math.random()*2500); if(feu<=1) { JLabel tmpLaser = new JLabel(laserEnnemi); tmpLaser.setBounds(tmpEnnemi.getX()+5,tmpEnnemi.getY()+30,10,20); lasersEnnemis.add(tmpLaser); cont.add((JLabel)(lasersEnnemis.get(lasersEnnemis.size()-1))); cont.setComponentZOrder((JLabel)(lasersEnnemis.get „ (lasersEnnemis.size()-1)),0); } } //regarde si les lasers du joueur touchent des aliens boolean recommence = false;

138


for(int i = 0; i
Jeux de tir 139

Chapitre 4

if(reflecteur.getBounds().intersects(vaisseau.getBounds())) { utiliseReflecteur = true; cont.add(attaqueReflecteur); attaqueReflecteur.setBounds(0,vaisseau.getY(),500,10); cont.remove(reflecteur); reflecteur.setBounds(-200,-200,30,30); }

}

} if(niveau%5==0) { bonusVie.setBounds(bonusVie.getX(),bonusVie.getY()+1,30,30); if(bonusVie.getBounds().intersects(vaisseau.getBounds())) { vie+=50; score+=100; cont.remove(bonusVie); bonusVie.setBounds(-100,-100,30,30); } } //regarde si les lasers des aliens touchent le joueur recommence = false; for(int i = 0; i 550) { cont.remove(temp); lasersEnnemis.remove(i); i--; } if(vaisseau.getBounds().intersects(temp.getBounds())) { vaisseau.setIcon(vaisseauEndommage); Thread.sleep(100); vaisseau.setIcon(imgVaisseau); score-=100; vie-=50; cont.remove(temp); lasersEnnemis.remove(i); nbEnnemis--; if(nbEnnemis<=0) { niveau++; nbEnnemis = niveau * niveau; peupleEnnemis(); recommence = true; break; } } if(recommence) break; } cont.repaint(); Thread.sleep(10); scoreLbl.setText("Niveau : "+niveau+" Score : "+score+" Vie : "+vie); } catch(Exception e){ }

140


}

} } public void mouseMoved(MouseEvent event) { vaisseau.setBounds(event.getX()-25,event.getY()-40,50,50); } public void mouseDragged(MouseEvent event){ } public void keyPressed(KeyEvent event) { if(event.getKeyChar()==’ ’) { JLabel tmpLaser = new JLabel(laserVaisseau); tmpLaser.setBounds(vaisseau.getX()+20,vaisseau.getY()-20,10,20); lasersJoueur.add(tmpLaser); cont.add((JLabel)(lasersJoueur.get(lasersJoueur.size()-1))); cont.setComponentZOrder((JLabel)(lasersJoueur.get( lasersJoueur.size()-1)),0); score-=2; } } public void keyReleased(KeyEvent event) { } public void keyTyped(KeyEvent event) { } public static void main(String[] args) { new DestructeursEspace(); }

Les Figures 21.1 à 21.3 montrent la terrible bataille pour la Terre. Figure 21.1 Apparition d’un bonus de rayons réflecteurs

Chapitre 4

Figure 21.2 Le rayon réflecteur

Figure 21.3 Apparition d’un bonus de vie

Jeux de tir 141

142


Pour aller plus loin... Modifiez le niveau de vie initial du vaisseau pour rendre le jeu plus ou moins difficile. Ajoutez de nouveaux bonus, comme des rayons laser plus larges pouvant détruire plusieurs aliens à la fois. Utilisez plusieurs vaisseaux : faites jouer plusieurs personnes en même temps ! Attribuez différents pouvoirs aux aliens : certains tirent des lasers, d’autres des anneaux d’éclairs. Modifiez le nombre de lasers tirés par le vaisseau. Ajoutez une bombe à fragmentation aux armes spéciales et limitées du vaisseau. Ajoutez des points de vie aux ennemis et permettez-leur de survivre à une première attaque.

5 Jeux de stratégie Au sommaire de ce chapitre :

Démineurs ●

Projet 22 : Le petit nouveau de l’équipe

●

Projet 23 : Démineur expert

●

Projet 24 : BOUM !

●

Projet 25 : Promotions

Pièges ●

Projet 26 : Déplacements

●

Projet 27 : Mise en place des pièges

●

Projet 28 : Piégé !

●

Projet 29 : Le spectacle

144


Projet 22 : Démineurs – Le petit nouveau de l’équipe Démineurs

En tant que nouveau membre de l’équipe de démineurs, votre mission est d’aller risquer votre vie sur le terrain en désamorçant des engins explosifs amorcés. Vos meilleures armes ? Une excellente coordination vue/action, une réflexion rapide... et un peu de chance. Projet

• Apprenons les bases des explosifs en créant une bombe inerte.

Créer le jeu Créez d’abord un JFrame, de taille 500 par 500 et d’arrière-fond gris. Puis, dessinez l’image de la bombe et du détonateur. Pour cela, ouvrez Microsoft Paint (ou tout autre éditeur d’images) et indiquez la taille de l’image avec Image, Attributs comme le montre la Figure 22.1. Figure 22.1 Taille de l’image

Jeux de stratégie 145

Chapitre 5

Choisissez un fond gris clair pour la bombe et le détonateur de manière à vous fondre dans l’arrière-fond du JFrame. Ainsi, si le jeu est redimensionné, la différence entre l’image et le fond sera moins visible. L’image est composée de deux parties : la bombe et le détonateur. Dessinez d’abord la bombe en haut de l’écran. Utilisez les outils Rectangle et Crayon pour vous faciliter la tâche. N’oubliez pas le câble du détonateur et le texte TNT ! L’étape suivante consiste à ajouter le détonateur en bas de l’écran. Créez d’abord un rectangle gris. Donnez-lui l’illusion d’un volume 3D en créant des lignes de perspective. Ajoutez des emplacements pour les indices, le temps restant et le code de désamorçage. Vous ajouterez ensuite des composants à ces endroits. Une fois que vous avez fini de dessiner l’image de la bombe, ajoutez-la au JFrame à la position 0,0. Les Figures 22.2 et 22.3 illustrent le dessin de la bombe. Figure 22.2 Dessin de la bombe

import import import import public {

java.awt.*; java.awt.event.*; javax.swing.*; javax.swing.event.*; class Demineurs extends JFrame

146


Figure 22.3 Bombe avant son insertion dans le JFrame

//le JLabel de la bombe JLabel bombe = new JLabel(new ImageIcon("bombe.png")); //le conteneur des composants Container cont; public Demineurs() { super("Démineurs"); setSize(500,550); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); cont = getContentPane(); cont.setLayout(null); cont.setBackground(Color.gray); //Ajoute le fond de l’image’ cont.add(bombe); bombe.setBounds(0,0,500,500); setContentPane(cont); } public static void main (String[ ] args) { new Demineurs(); }

}

La Figure 22.4 illustre la bombe achevée. Vous voilà diplômé... Passons aux choses sérieuses et désamorçons des bombes susceptibles d’exploser à tout moment !

Chapitre 5

Figure 22.4 Bombe affichée dans le JFrame


148


Projet 23 : Démineurs – Démineur expert Projet

• Vous allez maintenant mettre vos compétences à rude épreuve pour éviter la détonation.

Créer le jeu La première partie de ce projet consiste à ajouter quatre composants à l’image de fond de la bombe : le temps, les indices, le bouton de désarmement et une zone de saisie de texte. Commencez par initialiser ces quatre composants. Créez la zone de saisie avec un composant TextField, de la même manière que vous créez un JButton ou un JLabel. Le texte saisi peut être obtenu avec la commande : field.getText();

Puis, utilisez la méthode setBounds pour placer les composants. Pour connaître leur position, ouvrez l’image dans Microsoft Paint et passez la souris au-dessus de la zone ciblée. Les coordonnées sont affichées en bas à droite du programme, comme l’illustre la Figure 23.1. Figure 23.1 Affichage des coordonnées

Chapitre 5


Après avoir ajouté les composants, créez une variable pour représenter le temps restant. Utilisez un fil d’exécution (Thread) pour diminuer cette variable de 1 toutes les secondes – et n’oubliez pas de réinitialiser le JLabel avec la nouvelle valeur. Il faut maintenant créer le processus de désamorçage de la bombe. Créez d’abord une méthode initialisant le code à un nombre aléatoire. Puis, si le joueur clique sur le JButton, modifiez le JLabel représentant l’indice pour indiquer si la proposition du joueur est trop élevée ou trop basse. import java.awt.*; import java.awt.event.*; import javax.swing.*; import javax.swing.event.*; public class Demineurs extends JFrame implements ActionListener { //temps restant avant la détonation int tempsRestant = 12; //JLabel affichant le temps destant JLabel temps = new JLabel(tempsRestant+""); //JLabel de la bombe JLabel bombe = new JLabel(new ImageIcon("bombe.png")); //indice JLabel indice = new JLabel(); //code: int code = 0; //champ de code de désamorçage TextField essai = new TextField(20); //bouton de désamorçage JButton desamorcage = new JButton("DÉSAMORCER"); //conteneur pour les composants Container cont; //fil d’exécution Compteur compteur; public Demineurs() { super("Démineurs"); setSize(500,550); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); cont = getContentPane(); cont.setLayout(null); cont.setBackground(Color.gray); //ajoute l’image de fond cont.add(bombe); bombe.setBounds(0,0,500,500); //police du JLabel temps.setFont(new Font("Courier", Font.BOLD, 20)); //ajoute le JLabel de temps restant cont.add(temps); //définit la position temps.setBounds(250,371,150,18);

150


//place le JLabel au-dessus du fond cont.setComponentZOrder(temps,0); //ajoute le bouton de désamorçage cont.add(desamorcage); desamorcage.setBounds(200,456,150,30); desamorcage.addActionListener(this); cont.setComponentZOrder(desamorcage,0); indice.setText("Un nombre entre 0 et "+20); cont.add(indice); indice.setBounds(167,435,250,20); //place le JLabel au-dessus du fond cont.setComponentZOrder(indice,0); //ajoute le champs de texte cont.add(essai); essai.setBounds(271,404,150,25); //valide tous les composants cont.validate(); setContentPane(cont); setCode(); compteur = new Compteur(); compteur.start();

} public void setCode() { code = (int)(Math.random()*20); } //fil d’exécution du décompte public class Compteur extends Thread { public void run() { while(true) { try { tempsRestant--; temps.setText(tempsRestant+""); Thread.sleep(1000); } catch(Exception e){ } } } } public void actionPerformed(ActionEvent event) { if(Integer.parseInt(essai.getText())>code) { indice.setText("ATTENTION : le code saisi est TROP GRAND"); } if(Integer.parseInt(essai.getText())
Chapitre 5


Les Figures 23.2 à 23.5 illustrent le processus de désamorçage. Le projet suivant vous expliquera comment ajouter des images d’explosion. Figure 23.2 Décompte du détonateur

Figure 23.3 L’essai tape trop haut

152


Figure 23.4 L’essai tape trop bas

Figure 23.5 La bombe devrait exploser... mais ne le fait pas encore


Chapitre 5

Projet 24 : Démineurs – BOUM ! Projet

• Faites exploser la bombe. Attention ! Couvrez-vous ! Courez !

Créer le jeu Pour ajouter des explosions flamboyantes, vous devez créer deux images : une première représentant une explosion (voir Figure 24.1) et une seconde, identique à la première, mais dont les couleurs sont inversées et dont la position est modifiée (voir Figure 24.2). Créez des JLabel pour chaque image. Puis, dans le fil d’exécution du décompte, vérifiez si le temps écoulé est inférieur ou égal à 0. Si c’est le cas, appelez une méthode pour afficher les JLabel. Cette méthode supprime tous les composants du conteneur. Il reste seulement les deux images alternées. Pour les faire alterner, utilisez la méthode setBounds. Figure 24.1 Première explosion

import import import import

java.awt.*; java.awt.event.*; javax.swing.*; javax.swing.event.*;

154


Figure 24.2 Seconde explosion

public class Demineurs extends JFrame implements ActionListener { //temps restant avant la détonation int tempsRestant = 12; //JLabel affichant le temps destant JLabel temps = new JLabel(tempsRestant+""); //JLabel de la bombe JLabel bombe = new JLabel(new ImageIcon("bombe.png")); //indice JLabel indice = new JLabel(); //la bombe explose JLabel explosion = new JLabel(new ImageIcon("explosion1.png")); JLabel explosion2 = new JLabel(new ImageIcon("explosion2.png")); //code: int code = 0; //champ de code de désamorçage TextField essai = new TextField(20); //bouton de désamorçage JButton desamorcage = new JButton("DÉSAMORCER"); //conteneur pour les composants Container cont; //fil d’exécution Compteur compteur; public Demineurs() { super("Démineurs"); setSize(500,550); setVisible(true);


Chapitre 5

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); cont = getContentPane(); cont.setLayout(null); cont.setBackground(Color.gray); //ajoute l’image de fond cont.add(bombe); bombe.setBounds(0,0,500,500); //police du JLabel temps.setFont(new Font("Courier", Font.BOLD, 20)); //ajoute le JLabel de temps restant cont.add(temps); //définit la position temps.setBounds(250,371,150,18); //place le JLabel au-dessus du fond cont.setComponentZOrder(temps,0); //ajoute le bouton de désamorçage cont.add(desamorcage); desamorcage.setBounds(200,456,150,30); desamorcage.addActionListener(this); cont.setComponentZOrder(desamorcage,0); indice.setText("Un nombre entre 0 et "+20); cont.add(indice); indice.setBounds(167,435,250,20); //place le JLabel au-dessus du fond cont.setComponentZOrder(indice,0); //ajoute le champs de texte cont.add(essai); essai.setBounds(271,404,150,25); //ajoute l’explosion en dehors de l’écran cont.add(explosion); explosion.setBounds(-1000,-1000,500,550); cont.setComponentZOrder(explosion,0); cont.add(explosion2); explosion2.setBounds(-1000,-1000,500,550); cont.setComponentZOrder(explosion2,0); //valide tous les composants cont.validate(); setContentPane(cont); setCode(); compteur = new Compteur(); compteur.start();

} public void setCode() { code = (int)(Math.random()*20); } //fil d’exécution du décompte public class Compteur extends Thread { public void run() { while(true) { try { if(tempsRestant>0) { tempsRestant--;

156


temps.setText(tempsRestant+""); } else { break; } Thread.sleep(1000); } catch(Exception e){ }

} //appelle la méthode qui affiche l’explosion explode();

} public void explode() { //supprime tous les autres éléments cont.remove(temps); cont.remove(bombe); cont.remove(indice); cont.remove(essai); cont.remove(desamorcage); //déplace les images de l’explosion à leur emplacement correct explosion.setBounds(0,0,500,550); explosion.setBounds(0,0,500,550); while(true) { try { explosion.setBounds(0,0,500,550); explosion2.setBounds(-1000,-1000,500,550); Thread.sleep(100); explosion2.setBounds(0,0,500,550); explosion.setBounds(-1000,-1000,500,550); Thread.sleep(100); } catch(Exception e){ } }

}

} public void actionPerformed(ActionEvent event) { if(Integer.parseInt(essai.getText())>code) { indice.setText("ATTENTION : le code saisi est TROP GRAND"); } if(Integer.parseInt(essai.getText())
Chapitre 5

Les Figures 24.3 à 24.5 illustrent l’explosion de la bombe. Figure 24.3 Décompte du détonateur

Figure 24.4 Explosion flamboyante


158


Figure 24.5 Image alternée de la bombe qui explose

Prêt pour plus d’action ? Dans le projet suivant, nous ajouterons des niveaux au jeu. Au fur et à mesure que vous gagnerez de l’expérience, les codes deviendront de plus en plus difficiles.


Chapitre 5

Projet 25 : Démineurs – Promotions Projet

• Ajoutez des niveaux au jeu. Les premiers défis sont plutôt tranquilles... mais ne faites pas trop le malin, les codes vont devenir de plus en plus complexes !

Créer le jeu Créez d’abord un panneau indiquant à l’utilisateur qu’il a désarmé une bombe. Pour cela, créez une image qui félicite le joueur comme celle de la Figure 25.1. Affichez cette image dans l’instruction if comparant la saisie de l’utilisateur et le code aléatoire. Puis, réinitialisez le code avec un nombre plus grand. Vous pouvez faire cela en calculant le code sur la base d’un nombre maximal plus grand. Augmentez ce maximum à chaque tour. Comme les niveaux deviennent plus difficiles, il faut donner plus de temps au joueur pour deviner le code de désamorçage. Pour cela, créez un multiplicande qui augmente le temps alloué à chaque tour. Essayez de jouer. Lorsque vous terminez un niveau, le détonateur fait toujours exploser la bombe ! Pourquoi ? Vous n’avez pas encore mis le jeu en pause. Figure 25.1 Félicitations au joueur

Voici comment procéder : déclarez un booléen qui arrête le compteur lorsque sa valeur est true. Puis, vous devez créer un bouton pour que le joueur indique qu’il est prêt à démarrer un nouveau niveau. L’astuce est de ne pas ajouter de nouveau bouton mais d’utiliser le bouton de désamorçage. Il n’y a plus qu’un élément à ajouter : un score. Créez un JLabel qui affiche le score et incrémentez celui-ci du temps restant lorsque la bombe est désamorcée. N’oubliez pas de réinitialiser le texte dans le JLabel. import import import import

java.awt.*; java.awt.event.*; javax.swing.*; javax.swing.event.*;

160


public class Demineurs extends JFrame implements ActionListener { //score du joueur int score = 0; //temps restant avant la détonation int tempsRestant = 12; //affichage du temps restant JLabel temps = new JLabel(tempsRestant+""); //JLabel de la bombe JLabel bombe = new JLabel(new ImageIcon("bombe.png")); //indice JLabel indice = new JLabel(); //affichage du score JLabel affScore = new JLabel("Votre taux de succès : "+score); //explosion JLabel explosion = new JLabel(new ImageIcon("explosion.png")); JLabel explosion2 = new JLabel(new ImageIcon("explosion2.png")); //attend que le bouton soit à nouveau pressé boolean attente = false; //affiché après le désamorçage de la bombe JLabel promotion = new JLabel(new ImageIcon("promotion.png")); //variables pour le niveau de difficulté //multiplicande pour le nombre de chiffres int multiplicande = 1; int nombreMax = 10; //code int code = 0; //champ de texte pour le code de désamorçage TextField essai = new TextField(20); //bouton de désamorçage JButton desamorcage = new JButton("DÉSAMORÇAGE"); //conteneur des composants Container cont; //fil d’exécution Compteur compteur; public Demineurs() { super("Demineurs"); setSize(500,550); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); cont = getContentPane(); cont.setLayout(null); cont.setBackground(Color.gray); //ajoute l’image de fond cont.add(bombe); bombe.setBounds(0,0,500,500); //police du JLabel temps.setFont(new Font("Courier", Font.BOLD, 20)); //affiche letemps restant cont.add(temps);


Chapitre 5

//position temps.setBounds(250,371,150,18); //place le JLabel au-dessus du fond cont.setComponentZOrder(temps,0); //place le libellé de promotion en-dehors de l’écran cont.add(promotion); promotion.setBounds(-300,-300,276,122); cont.setComponentZOrder(promotion,0); //ajoute le score à l’écran cont.add(affScore); affScore.setBounds(5,480,500,30); affScore.setForeground(Color.white); affScore.setFont(new Font("Courier",Font.BOLD,19)); cont.setComponentZOrder(affScore,0); //ajoute le bouton de désamorçage cont.add(desamorcage); desamorcage.setBounds(200,456,150,30); desamorcage.addActionListener(this); cont.setComponentZOrder(desamorcage,0); indice.setText("A number between 0 and "+nombreMax); cont.add(indice); indice.setBounds(167,435,250,20); //place le JLabel au-dessus du fond cont.setComponentZOrder(indice,0); //ajoute le champ texte cont.add(essai); essai.setBounds(271,404,150,25); //ajoute l’explosion en-dehors de l’écran cont.add(explosion); explosion.setBounds(-1000,-1000,500,550); cont.setComponentZOrder(explosion,0); cont.add(explosion2); explosion2.setBounds(-1000,-1000,500,550); cont.setComponentZOrder(explosion2,0); //valide les composants cont.validate(); setContentPane(cont); setCode(); compteur = new Compteur(); compteur.start(); } public void setCode() { code = (int)(Math.random()*nombreMax); } //fil d’exécution du compteur public class Compteur extends Thread { public void run() { while(true) {

162


try { if(!attente) { if(tempsRestant>0) { tempsRestant--; temps.setText(tempsRestant+""); } else { break; } } Thread.sleep(1000); } catch(Exception e){ } } //appelle la méthode qui affiche l’explosion explosion(); } public void explosion() { //supprime tous les composants cont.remove(temps); cont.remove(bombe); cont.remove(indice); cont.remove(affScore); cont.remove(promotion); cont.remove(essai); cont.remove(desamorcage); //déplace les images au bon endroit explosion.setBounds(0,0,500,550); explosion2.setBounds(0,0,500,550); while(true) { try { explosion.setBounds(0,0,500,550); explosion2.setBounds(-1000,-1000,500,550); Thread.sleep(100); explosion2.setBounds(0,0,500,550); explosion.setBounds(-1000,-1000,500,550); Thread.sleep(100); } catch(Exception e){ } } }

} public void actionPerformed(ActionEvent event) { if(attente) { promotion.setBounds(-300,-300,276,122); setCode(); indice.setText("Un nombre entre 0 et "+nombreMax); tempsRestant = 15*multiplicande; attente = false; } else { if(Integer.parseInt(essai.getText())>code) { indice.setText("ATTENTION : le code saisi est TROP GRAND"); }


Chapitre 5

if(Integer.parseInt(essa i.getText())
}

} public static void main(String[ ] args) { new Demineurs(); } }

Figure 25.2 Décompte du détonateur

Les Figures 25.2 à 25.4 illustrent le stress lié au désamorçage.

164


Figure 25.3 Bombe désamorcée avec succès

Figure 25.4 BOUM ! Raté !

Chapitre 5


Pour aller plus loin... Placez deux bombes sur l’écran en même temps. Modifiez la difficulté du jeu en modifiant le temps alloué au désamorçage. Ajoutez des lettres ou des symboles au code. Faites travailler le joueur : donnez des équations mathématiques comme indice. Pour augmenter le niveau de stress, faites en sorte que le chronomètre affiche aussi les millisecondes. Ne donnez au joueur qu’un nombre limité de tentatives. S’il dépasse ce nombre, BOUM ! La bombe explose.

166


Projet 26 : Pièges – Déplacements Pièges

Dans ce jeu de stratégie multijoueurs, combattez les autres en les piégeant dans la trace que vous avez laissée derrière. Ne traversez ni le chemin de votre adversaire ni votre propre trace, vous seriez piégé ! Projet

• Construise Construisezz deux personnages personnages pouvant pouvant se déplacer déplacer, contrôlés contrôlés par les deux adversaires.

Créer le jeu Créez d’abord un JFrame de taille 500 × 500 pixels. Puis, créez des images de taille 10 × 10 pour les deux joueurs. Créez un JLabel pour chaque image. Utilisez la méthode setBounds pour positionner les JLabel de chaque côté du plateau. Créez deux nouveaux fils d’exécution pour contrôler chacune des directions des deux joueurs. Comme la direction des joueurs est contrôlée par le cla clavier, vier, chaque objet Thread doit implémenter KeyListener. Ajoutez les méthodes du KeyListener dans les deux classes. Dans les méthodes, vérifiez l’état des touches ’Q’, ’S’, ’D’ et ’Z’ pour le joueur 1 et ’J’, ’K’, ’L ’L’’ et ’I’ pour le joueur 2. Pour garder trace de la direction du joueur, utilisez la même technique que dans la course du courage : des variables entières représentent les différentes directions. Une fois ces variables créées, modifiezles pour modifier la direction dans la méthode keyPressed. Lorsque les directions des joueurs sont établies, il faut les faire bouger dans l’arène. Dans la boucle infinie de chaque fil d’exécution, faites bouger les joueurs grâce à la méthode setBounds. import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; public class Pieges extends JFrame { //les deux joueurs JLabel j1 = new JLabel(new ImageIcon("j1.png")); JLabel j2 = new JLabel(new ImageIcon("j2.png")); boolean continueJeu = true; //les directions int HAUT = 1, DROITE = 2, BAS = 3, GAUCHE = 4;

Chapitre 5

int j1Direction = DROITE; int j2Direction = GAUCHE; Container cont; public Pieges() { super("Pièges"); setSize(500,500); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setVisible(true); cont = getContentPane(); cont.setLayout(null); cont.add(j1); cont.setComponentZOrder(j1,0); j1.setBounds(20,245,10,10); cont.add(j2); cont.setComponentZOrder(j2,0); j2.setBounds(455,245,10,10); MouvementJ1 filJ1 = new MouvementJ1(); filJ1.start(); MouvementJ2 filJ2 = new MouvementJ2(); filJ2.start(); setContentPane(cont);


} public class MouvementJ1 extends Thread implements KeyListener { public void run() { addKeyListener(this); while(continueJeu) { try { if(j1Direction==HAUT) j1.setBounds(j1.getX(),j1.getY()-5,10,10); if(j1Direction==BAS) j1.setBounds(j1.getX(),j1.getY()+5,10,10); if(j1Direction==DROITE) j1.setBounds(j1.getX()+5,j1.getY(),10,10); if(j1Direction==GAUCHE) j1.setBounds(j1.getX()-5,j1.getY(),10,10); cont.validate(); Thread.sleep(75); } catch(Exception e){ } } } public void keyPressed(KeyEvent e) { if(e.getKeyChar()==’q’) j1Direction = GAUCHE; if(e.getKeyChar()==’s’) j1Direction = BAS;

168


if(e.getKeyChar()==’d’) j1Direction = DROITE; if(e.getKeyChar()==’z’) j1Direction = HAUT; } public void keyTyped(KeyEvent e){ } public void keyReleased(KeyEvent e){ }

} public class MouvementJ2 extends Thread implements KeyListener { public void run() { addKeyListener(this); while(continueJeu) { try { if(j2Direction==HAUT) j2.setBounds(j2.getX(),j2.getY()-5,10,10); if(j2Direction==BAS) j2.setBounds(j2.getX(),j2.getY()+5,10,10); if(j2Direction==DROITE) j2.setBounds(j2.getX()+5,j2.getY(),10,10); if(j2Direction==GAUCHE) j2.setBounds(j2.getX()-5,j2.getY(),10,10); cont.validate(); Thread.sleep(75); } catch(Exception e){ } } } public void keyPressed(KeyEvent e) { if(e.getKeyChar()==’j’) j2Direction = GAUCHE; if(e.getKeyChar()==’k’) j2Direction = BAS; if(e.getKeyChar()==’l’) j2Direction = DROITE; if(e.getKeyChar()==’i’) j2Direction = HAUT; } public void keyTyped(KeyEvent e){ } public void keyReleased(KeyEvent e){ } } public static void main (String[] args) { new Pieges(); } }

Chapitre 5


Les Figures 26.1 et 26.2 illustrent le mouvement des personnages. Le projet suivant vous expliquera comment ajouter les traces que laissent les personnages derrière eux lorsqu’ils bougent. Il est temps de commencer à les piéger ! Figure 26.1 L’arène

Figure 26.2 Les personnages se déplacent

170


Projet 27 : Pièges – Mise en place des pièges Projet

• Vous Vous pouvez pouvez ajouter ajouter des traces traces pour afficher afficher le mouveme mouvement nt des personnages. Ces traces sont au cœur du jeu. Ne vous laissez pas piéger... piéger ... et ne laissez pas votre adversaire s’échapper !

Créer le jeu La trace des joueurs est une ligne progressive d’images 10 × 10. Utilisez un segment noir pour représenter la trace du joueur 1 et un segment bleu pour le joueur 2. Pour enregistrer toutes les images, utilisez un ArrayList. Cette fonctionnalité sera ensuite utilisée pour détecter les collisions. Dans chaque boucle infinie, créez un JLabel temporaire pour garder l’image du ArrayList et au conteneur. segment de trace. Ajoutez ce JLabel temporaire à l’ ArrayList setBounds permettra de définir la position de l’image en fonction de la position du joueur. N’oubliez N’oubliez pas d’utiliser la méthode setComponentZOrder pour garder la piste en position "1" afin que l’image du joueur soit toujours affichée. import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; import java.util.*; public class Pieges extends JFrame { //les joueurs JLabel j1 = new JLabel(new ImageIcon("j1.png")); JLabel p2 = new JLabel(new ImageIcon("j2.png")); //définition des directions int HAUT = 1, DROITE = 2, BAS = 3, GAUCHE = 4; int j1Direction = DROITE; int j2Direction = GAUCHE; //trace des joueurs ArrayList traces = new ArrayList(); Container cont; public Pieges() { super("Pieges"); setSize(500,500); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setVisible(true); cont = getContentPane(); cont.setLayout(null); cont.add(j1); cont.setComponentZOrder(j1,0); j1.setBounds(20,245,20,20);


Chapitre 5

cont.add(p2); cont.setComponentZOrder(p2,0); p2.setBounds(455,245,20,20); MouvementJ1 filJ1 = new MouvementJ1(); filJ1.start(); MouvementJ2 filJ2 = new MouvementJ2(); filJ2.start(); setContentPane(cont); } public class MouvementJ1 extends Thread implements KeyListener { public void run() { addKeyListener(this); while(true) { try { //ajoute la trace JLabel temp = new JLabel(new ImageIcon("traceJ1.png") ImageIcon("traceJ1.png"));; );; traces.add(temp); cont.add(temp); cont.setComponentZOrder(temp,1); temp.setBounds(j1.getX(),j1.getY(),10,10); if(j1Direction==HAUT) j1.setBounds(j1.getX(),j1.getY()-5,20,20); if(j1Direction==BAS) j1.setBounds(j1.getX(),j1.getY()+5,20,20); if(j1Direction==DROITE) j1.setBounds(j1.getX()+5,j1.getY(),20,20); if(j1Direction==GAUCHE) j1.setBounds(j1.getX()-5,j1.getY(),20,20); cont.validate(); Thread.sleep(75); } catch(Exception e){ } } } public void keyPressed(KeyEvent e) { if(e.getKeyChar()==’q’) j1Direction = GAUCHE; if(e.getKeyChar()==’s’) j1Direction = BAS; if(e.getKeyChar()==’d’) j1Direction = DROITE; if(e.getKeyChar()==’z’) j1Direction = HAUT; } public void keyTyped(KeyEvent e){ } public void keyReleased(KeyEvent e){ } } public class MouvementJ2 extends Thread implements KeyListener { public void run() { addKeyListener(this); while(true) {

172


try { //ajoute la trace JLabel temp = new JLabel(new ImageIcon("traceJ2.png")) ImageIcon("traceJ2.png"));; ;; traces.add(temp); cont.add(temp); cont.setComponentZOrder(temp,1); temp.setBounds(p2.getX(),p2.getY(),10,10); if(j2Direction==HAUT) p2.setBounds(p2.getX(),p2.getY()-5,20,20); if(j2Direction==BAS) p2.setBounds(p2.getX(),p2.getY()+5,20,20); if(j2Direction==DROITE) p2.setBounds(p2.getX()+5,p2.getY(),20,20); if(j2Direction==GAUCHE) p2.setBounds(p2.getX()-5,p2.getY(),20,20); cont.validate(); Thread.sleep(75); } catch(Exception e){ }

}

} public void keyPressed(KeyEvent e) { if(e.getKeyChar()==’j’) j2Direction = GAUCHE; if(e.getKeyChar()==’k’) j2Direction = BAS; if(e.getKeyChar()==’l’) j2Direction = DROITE; if(e.getKeyChar()==’i’) j2Direction = HAUT; } public void keyTyped(KeyEvent e){ } public void keyReleased(KeyEvent e){ } } public static void main(String[] args) { new Pieges(); }

}

Les Figures 27.1 à 27.3 montrent les traces laissées par chaque joueur. Dans le projet suivant, nous verrons comment ajouter la détection des collisions.

Chapitre 5

Figure 27.1 Les joueurs commencent à bouger

Figure 27.2 Les joueurs laissent une trace


174


Figure 27.3 Le joueur 1 gagne... mais la victoire est peu probante puisque nous n’avons pas encore ajouté de détection de collisions.


Chapitre 5

Projet 28 : Pièges – Piégé ! Projet

• Ajoutez la détection des collisions. Attention !

Créer le jeu La détection de collisions cherche deux événements : un joueur quittant la zone de jeu et un joueur entrant en collision avec une trace. Pour savoir si un joueur quitte la zone de jeu, utilisez une instruction if dans chaque boucle infinie et vérifiez si les valeurs x et y du joueur sont comprises entre 0 et 500. Si ce n’est pas le cas, utilisez un JOptionPane pour indiquer le gagnant. Pour détecter une collision avec une des traces, utilisez une boucle for pour vérifier tous les JLabel (à l’exception des dix derniers) de l’ ArrayList. Il ne faut pas vérifier les dix derniers segments car ils ont toujours une intersection avec le joueur. S’il existe une collision, utilisez un JOptionPane pour indiquer le gagnant. Si vous exécutez le programme, vous remarquerez que le message s’affiche en continu car les fils d’exécution ne sont pas arrêtés. Pour arrêter l’affichage, utilisez un booléen pour contrôler la boucle infinie. Une valeur false pour ce booléen arrêtera les fils d’exécution. import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; import java.util.*; public class Pieges extends JFrame { //les deux joueurs JLabel j1 = new JLabel(new ImageIcon("j1.png")); JLabel j2 = new JLabel(new ImageIcon("j2.png")); boolean continueJeu = true; //les directions int HAUT = 1, DROITE = 2, BAS = 3, GAUCHE = 4; int p1Direction = DROITE; int p2Direction = GAUCHE; //traces des joueurs ArrayList traces = new ArrayList(); Container cont; public Pieges() { super("Pièges"); setSize(500,500); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

176


setVisible(true); cont = getContentPane(); cont.setLayout(null); cont.add(j1); cont.setComponentZOrder(j1,0); j1.setBounds(20,245,10,10); cont.add(j2); cont.setComponentZOrder(j2,0); j2.setBounds(455,245,10,10); MouvementJ1 filJ1 = new MouvementJ1(); filJ1.start(); MouvementJ2 filJ2 = new MouvementJ2(); filJ2.start(); setContentPane(cont); } public class MouvementJ1 extends Thread implements KeyListener { public void run() { addKeyListener(this); while(continueJeu) { try { //regarde si le joueur 1 tape dans les murs if(j1.getX()>500 || j1.getX()<0 || j1.getY()>500 || j1.getY()<0) { j1Perd(); } //regarde si le joueur 1 tape dans les traces for(int i = 0; i < traces.size()-10; i++) { JLabel tmpTrace = (JLabel) traces.get(i); if(j1.getBounds().intersects(tmpTrace.getBounds())) { j1Perd(); } } //ajoute la trace JLabel temp = new JLabel(new ImageIcon("traceJ1.png"));; traces.add(temp); cont.add(temp); cont.setComponentZOrder(temp,1); temp.setBounds(j1.getX(),j1.getY(),10,10); if(p1Direction==HAUT) j1.setBounds(j1.getX(),j1.getY()-5,10,10); if(p1Direction==BAS) j1.setBounds(j1.getX(),j1.getY()+5,10,10); if(p1Direction==DROITE) j1.setBounds(j1.getX()+5,j1.getY(),10,10);


Chapitre 5

if(p1Direction==GAUCHE) j1.setBounds(j1.getX()-5,j1.getY(),10,10); cont.validate(); Thread.sleep(75); } catch(Exception e){ } }

} public void j1Perd() { continueJeu = false; JOptionPane.showMessageDialog(null,"Le joueur 2 a gagné !"); } public void keyPressed(KeyEvent e) { if(e.getKeyChar()==’q’) p1Direction = GAUCHE; if(e.getKeyChar()==’s’) p1Direction = BAS; if(e.getKeyChar()==’d’) p1Direction = DROITE; if(e.getKeyChar()==’z’) p1Direction = HAUT; } public void keyTyped(KeyEvent e){ } public void keyReleased(KeyEvent e){ }

} public class MouvementJ2 extends Thread implements KeyListener { public void run() { addKeyListener(this); while(continueJeu) { try { //regarde si le joueur 1 tape dans les murs if(j2.getX()>500 || j2.getX()<0 || j2.getY()>500 || j2.getY()<0) { j2Perd(); } //regarde si le joueur 2 tape dans les traces for(int i = 0; i < traces.size()-10; i++) { JLabel tmpTrace = (JLabel) traces.get(i); if(j2.getBounds().intersects(tmpTrace.getBounds())) { j2Perd(); } }

178


//ajoute la trace JLabel temp = new JLabel(new ImageIcon("traceJ2.png"));; traces.add(temp); cont.add(temp); cont.setComponentZOrder(temp,1); temp.setBounds(j2.getX(),j2.getY(),10,10); if(p2Direction==HAUT) j2.setBounds(j2.getX(),j2.getY()-5,10,10); if(p2Direction==BAS) j2.setBounds(j2.getX(),j2.getY()+5,10,10); if(p2Direction==DROITE) j2.setBounds(j2.getX()+5,j2.getY(),10,10); if(p2Direction==GAUCHE) j2.setBounds(j2.getX()-5,j2.getY(),10,10); cont.validate(); Thread.sleep(75); } catch(Exception e){ }

} } public void j2Perd() { continueJeu = false; JOptionPane.showMessageDialog(null,"Le joueur 1 a gagné !!!"); } public void keyPressed(KeyEvent e) { if(e.getKeyChar()==’j’) p2Direction = GAUCHE; if(e.getKeyChar()==’k’) p2Direction = BAS; if(e.getKeyChar()==’l’) p2Direction = DROITE; if(e.getKeyChar()==’i’) p2Direction = HAUT; } public void keyTyped(KeyEvent e){ } public void keyReleased(KeyEvent e){ } } public static void main (String[] args) { new Pieges(); }

}

Les Figures 28.1 et 28.2 illustrent le jeu. Le projet suivant vous permettra d’ajouter un fond et d’afficher les gagnants et perdants en un peu plus gros.

Chapitre 5

Figure 28.1 Les joueurs combattent

Figure 28.2 Le joueur 1 a piégé le joueur 2


180


Projet 29 : Pièges – Le spectacle Projet

• Ajoutez une image de fond et des graphismes éblouissants pour indiquer le gagnant.

Créer le jeu Laissez libre cours à votre imagination. Dessinez une image de taille 500 × 500 pixels. Créez un JLabel pour l’insérer et utilisez la méthode setBounds pour la centrer. N’oubliez pas d’utiliser la méthode setComponentZOrder pour que l’image de fond se trouve effectivement derrière les autres icônes. Dessinez ensuite une image (celle que vous voulez) pour indiquer le gagnant. Affichez cette image à la place du JOptionPane lorsqu’un joueur gagne. Lorsqu’un joueur a gagné, ajoutez un "rembobinage" du jeu. Vous pouvez défaire les mouvements des joueurs avec une boucle for en supprimant les segments de trace. Pour cela, créez une boucle for qui part du nombre de composants dans le conteneur moins quatre, de manière à ne compter ni le fond ni les images des joueurs. Pour connaître le nombre de composants du conteneur, on utilise : cont.getComponentCount()

N’oubliez pas de rafraîchir le conteneur après avoir supprimé chaque morceau de trace. Créez aussi un JLabel contenant le même texte que le JOptionPane du projet précédent. import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; import java.util.*; public class Pieges extends JFrame { //les joueurs JLabel j1 = new JLabel(new ImageIcon("j1.png")); JLabel j2 = new JLabel(new ImageIcon("j2.png")); boolean continueJeu = true; //directions int HAUT = 1, DROITE = 2, BAS = 3, GAUCHE = 4; int directionJ1 = DROITE; int directionJ2 = GAUCHE; //traces des joueurs ArrayList traces = new ArrayList(); Container cont; public Pieges() {


Chapitre 5

super("Trapper"); setSize(500,500); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setVisible(true); cont = getContentPane(); cont.setLayout(null); //JLabel du fond JLabel fond = new JLabel(new ImageIcon("fond.png")); cont.add(fond); fond.setBounds(0,0,500,500); cont.add(j1); cont.setComponentZOrder(j1,0); j1.setBounds(20,245,10,10); cont.add(j2); cont.setComponentZOrder(j2,0); j2.setBounds(455,245,10,10); MouvementJ1 filJ1 = new MouvementJ1(); filJ1.start(); MouvementJ2 filJ2 = new MouvementJ2(); filJ2.start(); setContentPane(cont);

} public class MouvementJ1 extends Thread implements KeyListener { public void run() { addKeyListener(this); while(continueJeu) { try { //regarde si le joueur 1 tape dans les murs if(j1.getX()>500 || j1.getX()<0 || j1.getY()>500 || j1.getY()<0) { p1Perd(); } //regarde si le joueur 1 tape dans les traces for(int i = 0; i < traces.size()-10; i++) { JLabel tempTrail = (JLabel) traces.get(i); if(j1.getBounds().intersects(tempTrail.getBounds())) { p1Perd(); } } //ajoute la trace JLabel temp = new JLabel(new ImageIcon("traceJ1.png")); traces.add(temp); cont.add(temp); cont.setComponentZOrder(temp,1); temp.setBounds(j1.getX(),j1.getY(),10,10); if(directionJ1==HAUT) j1.setBounds(j1.getX(),j1.getY()-5,10,10); if(directionJ1==BAS) j1.setBounds(j1.getX(),j1.getY()+5,10,10); if(directionJ1==DROITE) j1.setBounds(j1.getX()+5,j1.getY(),10,10); if(directionJ1==GAUCHE) j1.setBounds(j1.getX()-5,j1.getY(),10,10);

182


cont.validate(); Thread.sleep(75); } catch(Exception e){ } } } public void p1Perd() { try { continueJeu = false; JLabel gagnant = new JLabel("Le joueur 2 (bleu) a gagné !"); cont.add(gagnant); cont.setComponentZOrder(gagnant,0); gagnant.setFont(new Font("arial",Font.BOLD,30)); gagnant.setBounds(75,50,400,100); for(int i = cont.getComponentCount()-4; i > 0; i--) { cont.remove(i); cont.repaint(); Thread.sleep(25); } } catch(Exception e){ } } public void keyPressed(KeyEvent e) { if(e.getKeyChar()==’q’) directionJ1 = GAUCHE; if(e.getKeyChar()==’s’) directionJ1 = BAS; if(e.getKeyChar()==’d’) directionJ1 = DROITE; if(e.getKeyChar()==’z’) directionJ1 = HAUT; } public void keyTyped(KeyEvent e){ } public void keyReleased(KeyEvent e){ }

} public class MouvementJ2 extends Thread implements KeyListener { public void run() { addKeyListener(this); while(continueJeu) { try { //regarde si le joueur 2 tape dans les murs if(j2.getX()>500 || j2.getX()<0 || j2.getY()>500 || j2.getY()<0) { j2Perd(); } //regarde si le joueur 1 tape dans les traces for(int i = 0; i < traces.size()-10; i++) { JLabel tempTrail = (JLabel) traces.get(i); if(j2.getBounds().intersects(tempTrail.getBounds())) { j2Perd(); } } //ajoute la trace JLabel temp = new JLabel(new ImageIcon("traceJ2.png"));


Chapitre 5

}

}

traces.add(temp); cont.add(temp); cont.setComponentZOrder(temp,1); temp.setBounds(j2.getX(),j2.getY(),10,10); if(directionJ2==HAUT) j2.setBounds(j2.getX(),j2.getY()-5,10,10); if(directionJ2==BAS) j2.setBounds(j2.getX(),j2.getY()+5,10,10); if(directionJ2==DROITE) j2.setBounds(j2.getX()+5,j2.getY(),10,10); if(directionJ2==GAUCHE) j2.setBounds(j2.getX()-5,j2.getY(),10,10); cont.validate(); Thread.sleep(75); } catch(Exception e){ }

} public void j2Perd() { try { continueJeu = false; JLabel winner = new JLabel("Le joueur 1 (noir) a gagné !"); cont.add(winner); cont.setComponentZOrder(winner,0); winner.setFont(new Font("arial",Font.BOLD,30)); winner.setBounds(75,50,400,100); for(int i = cont.getComponentCount()-4; i > 0; i--) { cont.remove(i); cont.repaint(); Thread.sleep(25); } } catch(Exception e){ } } public void keyPressed(KeyEvent e) { if(e.getKeyChar()==’j’) directionJ2 = GAUCHE; if(e.getKeyChar()==’k’) directionJ2 = BAS; if(e.getKeyChar()==’l’) directionJ2 = DROITE; if(e.getKeyChar()==’i’) directionJ2 = HAUT; } public void keyTyped(KeyEvent e){ } public void keyReleased(KeyEvent e){ }

} public static void main(String[] args) { new Pieges(); }

Les Figures 29.1 et 29.2 illustrent le jeu Pièges définitif.

184


Figure 29.1 L’image de fond est en place pendant que les joueurs combattent

Figure 29.2 Le joueur 2 gagne, la trace commence à disparaître

Chapitre 5


Pour aller plus loin... Augmentez la vitesse d’un des joueurs tout en diminuant la vitesse de l’autre. Chaque vitesse a ses avantages et ses inconvénients. Modifiez la taille des joueurs : très grands ou très petits ! Créez des niveaux : le meilleur joueur sur trois, cinq ou même onze tours gagne la partie. Ajoutez deux personnages pour faire jouer quatre joueurs simultanément. Si vous êtes seul à jouer, vous pouvez créer une intelligence artificielle pour vous battre contre l’ordinateur. Construisez le jeu de manière à ce que les joueurs ne puissent tourner que dans un sens. Modifiez les touches de manière aléatoire au milieu du jeu. Les joueurs n’auront aucune idée du sens dans lequel l’image tournera !

6 Anciens jeux... revisités Au sommaire de ce chapitre :

Oiram ●

Projet 30 : La plate-forme

●

Projet 31 : Allez Oiram !

●

Projet 32 : Les méchants

●

Projet 33 : Un monde compliqué

Javaman ●

Projet 34 : L’univers de Javaman

●

Projet 35 : Javaman vit !

●

Projet 36 : L’attaque du C++

188


Projet 30 : Oiram – La plate-forme Oiram

Aidez Oiram à capturer les étoiles et à sauter sur ses ennemis en sautant de plate-forme en plate-forme ! Attention cependant, ce jeu contient plusieurs niveaux. Au fur et à mesure qu’Oiram bat ses ennemis, de nouveaux ennemis attendent le niveau suivant pour apparaître ! Projet Nouvelles briques

• Commencez par créer la plate-forme dans laquelle Oiram se bat. • Tableaux à deux dimensions.

Tableaux à deux dimensions Les tableaux à deux dimensions fonctionnent comme les tableaux habituels, à ceci près qu’ils ont des informations supplémentaires dans une autre dimension. La Figure 30.1 explique les ressemblances et les différences. Figure 30.1 Deux types de tableaux

Pour créer un tableau à deux dimensions, créez un tableau standard avec une seconde paire de crochets : int tableau2D [][] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

Accéder à un élément se fait de la même manière que pour les tableaux à une dimension : int element = tableau2D[ligne][colonne];

Anciens jeux... revisités 189

Chapitre 6

Le code suivant permet de connaître le nombre de lignes et de colonnes d’un tableau à deux dimensions : int lignes = tableau2D.length; int colonnes = tableau2D[0].length;

Créer le jeu Le plateau de jeu est divisé en trois éléments : la terre, l’air et les échelles. Chacune de ces zones occupe un carré de 50 pixels de côté sur le plateau. Pour garder la trace de ces carrés, utilisez un tableau à deux dimensions contenant des caractères ’#’ pour la terre, ’|’ pour les échelles et une espace pour l’air. Vous devez dessiner les images avant d’ajouter les zones aux JFrame. Chaque image doit être de taille 50 × 50 pixels. Les Figures 30.2 à 30.4 représentent les trois zones différentes. Figure 30.2 Terre

Figure 30.3 Air

Figure 30.4 Échelle

Pour afficher le plateau dans un JFrame, itérez sur le tableau grâce à deux boucles for. À chaque itération, utilisez des instructions if pour vérifier si la zone courante contient de l’air, de la terre ou une échelle. Utilisez la méthode setBounds pour afficher la bonne image. import import import import import

javax.swing.*; javax.swing.event.*; java.awt.*; java.awt.event.*; java.util.*;

190


import java.awt.geom.*; public class Oiram extends JFrame { Container cont; //le tableau à deux dimensions String arene[][] = {{" "," "," "," "," "," "," "," "," "," "}, {" "," "," "," "," "," "," "," "," "," "}, {" "," "," "," "," "," ","|","#","#"," "}, {" ","#","#","#"," "," ","|","#"," "," "}, {" "," "," "," "," "," ","|","#"," "," "}, {" ","#","#","#","#","#","#","#","#"," "}, {" "," "," "," "," "," "," "," "," "," "}, {"#","#","#","#"," "," ","#","#","#","#"}, {" "," "," "," "," "," "," "," "," "," "}, {"#","#","#","#","#","#","#","#","#","#"}}; public Oiram() { super("Oiram"); setSize(500,500); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); cont = getContentPane(); cont.setLayout(null); cont.setBackground(Color.BLACK); //génère le tableau for(int i = 0; i < arene.length; i++) { for(int j = 0; j < arene[0].length; j++) { JLabel lbl = null; if(arene[j][i].equals("#")) { lbl = new JLabel(new ImageIcon("terre.png")); } else if(arene[j][i].equals(" ")) { lbl = new JLabel(new ImageIcon("air.png")); } else if(arene[j][i].equals("|")) { lbl = new JLabel(new ImageIcon("echelle.png")); } cont.add(lbl); lbl.setBounds(i*50,j*50,50,50); } } repaint(); cont.validate(); setContentPane(cont); } public static void main(String[ ] args) { new Oiram(); } }

Chapitre 6


La Figure 30.5 montre le monde de Oiram : la plate-forme. Figure 30.5 Plate-forme

Dans la projet suivant, libérez Oiram et donnez-lui des étoiles à récupérer !

192


Projet 31 : Oiram – Allez Oiram ! Projet

• Mettez Oiram dans sa maison et permettez-lui de se déplacer. Ajoutez des étoiles pour qu’il puisse les chasser et les capturer.

Créer le jeu Créez Oiram. Créez pour cela une image de taille 50 × 50 pixels. Utilisez un JLabel et la méthode setBounds pour placer Oiram dans le coin en bas à gauche. La Figure 31.1 montre Oiram à son emplacement de départ. Figure 31.1 Emplacement de départ d’Oiram

Dans le jeu, Oiram se déplace sur le sol, saute dans les airs et escalade des échelles. Créez des booléens pour représenter le saut et l’escalade. Puis, ajoutez un KeyListener. Dans la méthode keyTyped, regardez si le joueur appuie sur les touches Q, Z et D pour déterminer le mouvement d’Oiram. Lorsque le joueur appuie sur Q, Oiram bouge vers la gauche. Examinez le booléen indiquant si Oiram est en train d’escalader. Si oui, positionnez le booléen à false. Si non, déplacez-le de 50 pixels vers la gauche. Lorsque le joueur appuie sur Z, Oiram saute ou, s’il est sur une échelle, escalade. Si Oiram se trouve déjà dans les airs (c’est-à-dire s’il est déjà en train de sauter ou de tomber), il ne doit pas pouvoir sauter. Si Oiram n’est pas sur une échelle et si le carré au-dessus de lui est de l’air, déterminez si Oiram est déjà en train de sauter ou si le carré sous lui est de l’air (et s’il doit par conséquent tomber). Si Oiram est effectivement sur le sol et s’il n’est pas déjà en train de sauter, déplacez-le vers le haut de 50 pixels. S’il est sur une échelle, déplacez-le de 50 pixels vers le haut et regardez s’il se trouve sur un carré d’air. Si c’est le cas, déplacez-le de 50 pixels vers la droite et positionnez la variable d’escalade à false car il est arrivé en haut de l’échelle. Lorsque le joueur appuie sur D, Oiram se déplace vers la droite. Vérifiez d’abord qu’Oiram se trouve dans l’arène. Si oui, vérifiez si l’espace à la droite d’Oiram est de

Chapitre 6


l’air. Si oui, déplacez Oiram de 50 pixels vers la droite. Si l’emplacement à sa droite est une échelle, déplacez Oiram de 50 pixels vers la droite et positionnez la variable d’escalade à true. Démarrez maintenant le jeu. Lorsqu’Oiram monte sur une échelle, l’aspect de l’ensemble est bizarre, comme le montre la Figure 31.2. Figure 31.2 Oiram escalade, mais il a l’air bizarre

Pour corriger cela, créez une nouvelle image de taille 50 × 50 pixels représentant Oiram escaladant l’échelle. Ne l’affichez que lorsque la variable d’escalade est à true. La Figure 31.3 illustre la nouvelle image améliorée. Figure 31.3 Oiram escalade ; il n’a plus l’air bizarre

Oiram peut maintenant se déplacer. Il faut donc ajouter des étoiles pour qu’il puisse les attraper. Pour cela, créez une méthode qui génère aléatoirement la position des étoiles. Utilisez deux boucles for pour itérer dans le tableau du jeu. Si l’emplacement du plateau contient de l’air, utilisez un nombre aléatoire entre 0 et 9 pour donner une chance sur 10 à une étoile d’apparaître. Si le nombre généré est 0, créez une étoile à l’emplacement en question. N’oubliez pas de l’ajouter à un ArrayList. Cette méthode doit être appelée à partir du constructeur. Il ne reste que deux choses à faire : faire tomber Oiram et lui permettre de récupérer les étoiles. Pour cela, créez un fil d’exécution appelé Course. Dans la boucle infinie, itérez dans l’ ArrayList d’étoiles. Si Oiram entre en collision avec une étoile, retirez l’étoile du conteneur et de l’ ArrayList. Puis, ajoutez une instruction if pour savoir si Oiram est en train de sauter. Si c’est le cas, déplacez Oiram de 50 pixels vers le haut et terminez son saut en donnant la valeur false au booléen. Si Oiram n’est pas en train de sauter, vérifiez si le carré sous lui est composé d’air. Si oui, descendez Oiram de 50 pixels. N’oubliez pas d’ajouter la méthode Thread.sleep à votre boucle infinie.

194


import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; import java.util.*; import java.awt.geom.*; public class Oiram extends JFrame implements KeyListener { Container cont; //tableau à deux dimensions String arene[ ][ ] = {{" "," "," "," "," "," "," "," "," "," "}, {" "," "," "," "," "," "," "," "," "," "}, {" "," "," "," "," "," ","|","#","#"," "}, {" ","#","#","#"," "," ","|","#"," "," "}, {" "," "," "," "," "," ","|","#"," "," "}, {" ","#","#","#","#","#","#","#","#"," "}, {" "," "," "," "," "," "," "," "," "," "}, {"#","#","#","#"," "," ","#","#","#","#"}, {" "," "," "," "," "," "," "," "," "," "}, {"#","#","#","#","#","#","#","#","#","#"}}; ArrayList etoiles = new ArrayList(); JLabel personnage = new JLabel(new ImageIcon("oiram.png")); boolean saut = false; boolean escalade = false; Jeu jeu; public Oiram() { super("Oiram"); setSize(500,500); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); cont = getContentPane(); cont.setLayout(null); addKeyListener(this); cont.setBackground(Color.BLACK); cont.add(personnage); personnage.setBounds(0,400,50,50); genereEtoiles(); //genere le tableau for(int i = 0; i < arene.length; i++) { for(int j = 0; j < arene[0].length; j++) { JLabel lbl = null; if(arene[j][i].equals("#")) { lbl = new JLabel(new ImageIcon("terre.png")); } else if(arene[j][i].equals(" ")) { lbl = new JLabel(new ImageIcon("air.png")); } else if(arene[j][i].equals("|")) { lbl = new JLabel(new ImageIcon("echelle.png")); } cont.add(lbl); lbl.setBounds(i*50,j*50,50,50); } }


Chapitre 6

repaint(); cont.validate(); jeu = new Jeu(); jeu.start(); setContentPane(cont);

} //ajoute les étoiles public void genereEtoiles() { for(int i = 1; i < arene.length; i++) { for(int j = 0; j < arene[0].length; j++) { //regarde si l’emplacement est de l’air if(arene[i][j].equals("" ")) { if(arene[i][j].equals( //une chance sur 10 qu’une étoile apparaisse int placeEtoile = (int)(Math.random()*10) (int)(Math.random()*10);; if(placeEtoile==0) { JLabel etoile = new JLabel(new ImageIcon("etoile.png")) ImageIcon("etoile.png"));; cont.add(etoile); etoile.setBounds(j*50,i*50,50,50); cont.setComponentZOrder(etoile,0); cont.setComponentZOrder(personnage,0); etoiles.add(etoile); } } } } } public class Jeu extends Thread { public void run() { while(true) { try { //si Oiram touche une étoile, on l’enlève for(int i = 0; i < etoiles.size(); i++) { JLabel star = (JLabel) etoiles.get(i); if(star.getBounds().intersects(personnage.getBo if(star.getBounds().in tersects(personnage.getBounds())) unds())) { cont.remove(star); etoiles.remove(star); } } //fait tomber Oiram if(!saut) { if(arene[(personnage.getY()/50)+1][personnage.getX()/50] if(arene[(personnage.getY( )/50)+1][personnage.getX()/50].equals(" .equals(" ")) { personnage.setBounds(personnage.getX(),personnage.getY()+50,50,50); } } else { //termine le saut d’Oiram à l’itération suivante saut = false; //fait bouger Oiram vers le haut if(arene[(personnage.getY()/50)-1][personnage.getX()/50] if(arene[(personnage.getY( )/50)-1][personnage.getX()/50].equals(" .equals(" ")) { personnage.setBounds(personnage.getX(),personnage.getY()-50,50,50); } } Thread.sleep(250); } catch(Exception e){ }

196


}

}

}

} public void keyPressed(KeyEvent e){ } public void keyReleased(KeyEvent e){ } public void keyTyped(KeyEvent e) { //déplacement à gauche if(e.getKeyChar()==’q’)) { if(e.getKeyChar()==’q’ if(escalade) { escalade = false; personnage.setIcon(new ImageIcon("oiram.png")); } if(personnage.getX()>=50 && arene[personnage.getY()/50][(personnage.getX()/50)-1].equa arene[personnage.getY()/50][( personnage.getX()/50)-1].equals(" ls(" ")) { personnage.setBounds(personnage.getX()-50,personnage.getY(),50,50); } } //déplacement à droite if(e.getKeyChar()==’d’)) { if(e.getKeyChar()==’d’ if(personnage.getX()<=400 && arene [personnage.getY()/50][(personnage.getX()/50)+1].e [personnage.getY()/50][(p ersonnage.getX()/50)+1].equals(" quals(" ")) { personnage.setBounds(personnage.getX()+50,personnage.getY(),50,50); } if(arene[personnage.getY()/50][(personnage.getX() if(arene[personnage.getY( )/50][(personnage.getX()/50)+1].equals("|")) /50)+1].equals("|")) { personnage.setBounds(personnage.getX()+50,personnage.getY(),50,50); escalade = true; personnage.setIcon(new ImageIcon("surechelle.pn ImageIcon("surechelle.png")); g")); } } //déplacement vers le haut if(e.getKeyChar()==’z’)) { if(e.getKeyChar()==’z’ if(!escalade) { if(arene[(personnage.getY()/50)-1][personnage.g if(arene[(personnage.ge tY()/50)-1][personnage.getX()/50].equals(" etX()/50].equals(" ")) { if(!saut && !arene[(personnage.getY() !arene[(personnage.getY()/50)+1][personnage.getX() /50)+1][personnage.getX() „ /50].equals(" /50].equals(" ")) { saut = true; personnage.setBounds(personnage.getX(),personnage.getY()-50,50,50); } } } else { personnage.setBounds(personnage.getX(), personnage.setBounds(pe rsonnage.getX(), personnage.getY()-50,50, personnage.getY()-50,50,50); 50); if(arene[personnage.getY()/50][personnage.getX( if(arene[personnage.get Y()/50][personnage.getX()/50].equals(" )/50].equals(" ")) { personnage.setBounds(personnage.getX()+50,personnage.getY(),50,50); escalade = false; personnage.setIcon(new ImageIcon("oiram.png") ImageIcon("oiram.png")); ); } } } } public static void main(String[ ] args) { new Oiram(); }

Chapitre 6


Les Figures 31.4 et 31.5 montrent Oiram en action. Tout petit génie des jeux vidéo sait qu’un jeu n’est pas complet sans adversaire à affronter.. Le projet suivant explique comment rendre la affronter l a vie d’Oiram bien plus difficile. dif ficile. Figure 31.4 La plate-forme

Figure 31.5 Collecte d’étoiles

198


Projet 32 : Oiram – Les méchants Projet

• La chasse chasse est ouverte ouverte ! Dessinez Dessinez les ennemi ennemiss d’Oiram. d’Oiram. Ils sont sont rapides, acharnés... et redoutables.

Créer le jeu Dessinez d’abord une image de 50 × 50 pixels d’un ennemi d’Oiram, comme celui de la Figure 32.1. Figure 32.1 Ennemi d’Oiram

Puis, créez une méthode pour ajouter les ennemis à la plate-forme. Utilisez une boucle pour créer deux ennemis. Placez-les tout en haut de l’écran et donnez-leur une coordonnée X aléatoire. Ajoutez aussi les enemis à un ArrayList pour pouvoir y accéder facilement ultérieurement. Les ennemis d’Oiram sont contrôlés très simplement : s’il y a de l’air sous eux, ils tombent. Sinon, ils se déplacent vers la droite ou vers la gauche. Dans la boucle du fil d’exécution, utilisez une boucle for pour examiner la position de tous les ennemis de l’ ArrayList. Une instruction if permet de déterminer si l’ennemi se trouve au-dessus d’une zone d’air. Si c’est le cas, descendez l’ennemi de 50 pixels. Puis, générez un nombre aléatoire (0 ou 1) en multipliant le résultat de la méthode Math.random par deux. Si le nombre est 0, vérifiez si le carré à droite de l’ennemi est de l’air. Si oui, déplacez l’ennemi de 50 pixels vers la droite. Si le nombre aléatoire vaut 1, vérifiez si le carré à gauche de l’ennemi est de l’air. Si oui, déplacez l’ennemi de 50 pixels pix els vers la gauche. Maintenant que les ennemis se déplacent, il faut donner à Oiram une chance de se battre. S’il saute sur un ennemi, l’ennemi meurt. Utilisez une instruction if pour comparer l’emplacement d’Oiram et de son adversaire. Si Oiram est 50 pixels audessus de l’ennemi, supprimez l’ennemi du conteneur. Si Oiram occupe le même carré que son adversaire, supprimez Oiram : l’ennemi a gagné.

Chapitre 6


import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; import java.util.*; import java.awt.geom.*; public class Oiram extends JFrame implements KeyListener { //conteneur Container cont; //tableau à deux dimensions String arene[][] = {{" "," "," "," "," "," "," "," "," "," "}, {" "," "," "," "," "," "," "," "," "," "}, {" "," "," "," "," "," ","|","#","#"," "}, {" ","#","#","#"," "," ","|","#"," "," "}, {" "," "," "," "," "," ","|","#"," "," "}, {" ","#","#","#","#","#","# ","#","#","#","#","#","#","#","#"," ","#","#"," "}, {" "," "," "," "," "," "," "," "," "," "}, {"#","#","#","#"," "," ","#","#","#","#"}, {" "," "," "," "," "," "," "," "," "," "}, {"#","#","#","#","#","#","#","#","#","#"}}; //contient les étoiles ArrayList etoiles = new ArrayList(); //Oiram JLabel personnage = new JLabel(new ImageIcon("oiram.png") ImageIcon("oiram.png")); ); //Oiram est-il en train de sauter ou d’escalader ? boolean saut = false; boolean escalade = false; //fil d’exécution Jeu jeu; //contient les ennemis ArrayList ennemis = new ArrayList(); public Oiram() { super("Oiram"); setSize(500,500); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); cont = getContentPane(); cont.setLayout(null); addKeyListener(this); cont.setBackground(Color.BLACK); //ajoute Oiram cont.add(personnage); personnage.setBounds(0,400,50,50); //crée les étoiles et les ennemis genereEtoiles(); genereEnnemis(); //génère le tableau for(int i = 0; i < arene.length; i++) {

200


for(int j = 0; j < arene[0].length; j++) { JLabel lbl = null; if(arene[j][i].equals("#")) { lbl = new JLabel(new ImageIcon("terre.png")); } else if(arene[j][i].equals(" ")) { lbl = new JLabel(new ImageIcon("air.png")); } else if(arene[j][i].equals("|")) { lbl = new JLabel(new ImageIcon("echelle.png")); } cont.add(lbl); lbl.setBounds(i*50,j*50,50,50); } } repaint(); cont.validate(); //démarre le fil d’exécution jeu = new Jeu(); jeu.start(); setContentPane(cont); } public void genereEtoiles() { //boucle dans le tableau à deux dimensions for(int i = 1; i < arene.length; i++) { for(int j = 0; j < arene[0].length; j++) { if(arene[i][j].equals(" ")) { //probabilité de placer une étoile : 1/10 int placeEtoile = (int)(Math.random()*10); if(placeEtoile==0) { //ajoute l’étoile JLabel etoile = new JLabel(new ImageIcon("etoile.png")); cont.add(etoile); etoile.setBounds(j*50,i*50,50,50); cont.setComponentZOrder(etoile,0); cont.setComponentZOrder(personnage,0); etoiles.add(etoile); } } } } } public void genereEnnemis() { //ajoute les ennemis for(int i = 0; i < 2; i++) { JLabel ennemi = new JLabel(new ImageIcon("ennemi.png")); cont.add(ennemi); int emplX = (int)(Math.random()*8); ennemi.setBounds(emplX*50,0,50,50); cont.setComponentZOrder(ennemi,0); ennemis.add(ennemi); } }

Chapitre 6


public class Jeu extends Thread { public void run() { while(true) { try { //vérifie ce qui suit sur tous les ennemis for(int i = 0; i < ennemis.size(); i++) { JLabel ennemi = (JLabel) ennemis.get(i); //n’applique ce qui suit qu’aux ennemis sur l’écran if(ennemi.getY()<=450 && ennemi.getX()<=450) { //descent l’ennemi, si possible if(arene[(ennemi.getY()/50)+1][ennemi.getX()/50].equals(" ")) { ennemi.setBounds(ennemi.getX(),ennemi.getY()+50,50,50); } //déplace l’ennemi vers la droite ou la gauche int direction = (int)(Math.random()*2); if(direction==0) { if(arene[ennemi.getY()/50][(ennemi.getX()/50)+1].equals(" ")) { ennemi.setBounds(ennemi.getX()+50,ennemi.getY(),50,50); } } else { if(arene[ennemi.getY()/50][(ennemi.getX()/50)-1].equals(" ")) { ennemi.setBounds(ennemi.getX()-50,ennemi.getY(),50,50); } } //si Oiram saute sur un ennemi, supprime l’ennemi if(ennemi.getY()-50==personnage.getY() && ennemi.getX() „ ==personnage.getX()) { ennemi.setBounds(1000,1000,50,50); cont.remove(ennemi); } //si un ennemi mange Oiram, affiche l’image de défaite if(ennemi.getY()==personnage.getY() && ennemi.getX() „ ==personnage.getX()) { cont.remove(personnage); } } } //vérifie ce qui suit sur toutes les étoiles for(int i = 0; i < etoiles.size(); i++) { JLabel star = (JLabel) etoiles.get(i); //si Oiram capture une étoile, on la supprime if(star.getBounds().intersects(personnage.getBounds())) { cont.remove(star); etoiles.remove(star); } } //Oiram tombe if(!saut) { if(arene[(personnage.getY()/50)+1][personnage.getX()/50].equals(" ")) { personnage.setBounds(personnage.getX(),personnage.getY()+50,50,50); } }

202


//Oiram saute else { saut = false; if(arene[(personnage.getY()/50)-1][personnage.getX()/50] .equals(" ")) { personnage.setBounds(personnage.getX(),personnage.getY()-50,50,50); } } //temporisation Thread.sleep(250); } catch(Exception e){ }

}

} } public void keyPressed(KeyEvent e){ } public void keyReleased(KeyEvent e){ } public void keyTyped(KeyEvent e) { //déplacement vers la gaucuhe if(e.getKeyChar()==’q’) { //si Oiram escalade, on arrête l’escalade if(escalade) { escalade = false; personnage.setIcon(new ImageIcon("oiram.png")); } //déplacement vers la gauche s’il est possible if(personnage.getX()>=50 && arene[personnage.getY()/ 50][(personnage.getX()/50)1].equals(" ")) { personnage.setBounds(personnage.getX()-50,personnage.getY(),50,50); } } //déplacement vers la droite if(e.getKeyChar()==’d’) { //ne pas permettre à Oiram de sortir de l’écran if(personnage.getX()<=400 && arene[personnage.getY()/50][(personnage.getX()/50)+1].equals(" ")) { personnage.setBounds(personnage.getX()+50,personnage.getY(),50,50); } //si Oiram touche une échelle, commencer à escalader if(arene[personnage.getY()/50][(personnage.getX()/50)+1].equals("|")) { personnage.setBounds(personnage.getX()+50,personnage.getY(),50,50); escalade = true; personnage.setIcon(new ImageIcon("surechelle.png")); } } //saute/escalade if(e.getKeyChar()==’z’) { //si Oiram n’est pas surune échelle, saute if(!escalade) { if(arene[(personnage.getY()/50)-1][personnage.getX()/50].equals(" ")) {


Chapitre 6

if(!saut && !arene[(personnage.getY()/50)+1][personnage.getX() „ /50].equals(" ")) { saut = true; personnage.setBounds(personnage.getX(),personnage.getY()-50,50,50); }

}

} //déplace Oiram sur l’échelle else { personnage.setBounds(personnage.getX(), personnage.getY()-50,50,50); //Oiram arrive en haut de l’échelle. Modifie son icône et le déplace if(arene[personnage.getY()/50][personnage.getX()/50].equals(" ")) { personnage.setBounds(personnage.getX()+50,personnage.getY(),50,50); escalade = false; personnage.setIcon(new ImageIcon("oiram.png")); } }

} } public static void main(String[ ] args) { new Oiram(); } }

Les Figures 32.2 à 32.4 illustrent l’action de l’ennemi. Mais ce n’est pas terminé pour Oiram ! Continuez pour apprendre comment ajouter des niveaux supplémentaires de difficulté. Figure 32.2 Les ennemis sont vivants !

204


Figure 32.3 Un ennemi mort

Figure 32.4 Le dernier ennemi tue Oiram


Chapitre 6

Projet 33 : Oiram – Un monde compliqué Projet

• Ajoutez des niveaux de difficulté et des images de victoire ou de défaite.

Créer le jeu Oiram va se battre dans cinq niveaux : chaque niveau ajoute des ennemis supplémentaires. Pour augmenter le nombre d’ennemis, modifiez légèrement la méthode qui les dessine. Créez une variable globale pour garder trace du niveau de jeu. Déclarez une autre variable dans la méthode pour contenir un nombre aléatoire (1 ou 2). Ajoutez ce nombre aléatoire au numéro du niveau : cela déterminera le nombre d’ennemis. Un nouveau niveau commence lorsqu’Oiram supprime tous ses adversaires et lorsqu’il récupère toutes les étoiles. Pour commencer un nouveau niveau, initialisez deux variables : une qui garde trace des ennemis et une qui garde trace du nombre d’étoiles. Chaque fois qu’Oiram récupère une étoile ou bat un ennemi, décrémentez de 1 la variable appropriée. Dans la boucle infinie, vérifiez les valeurs des deux variables. Lorsqu’elles sont toutes les deux à 0, incrémentez le numéro du niveau de 1. Appelez les méthodes générant les étoiles et les ennemis. Ajoutez aussi un JLabel pour afficher le niveau courant. N’oubliez pas de rafraîchir le JLabel quand le niveau change. Pour donner un score à Oiram, créez une variable. Incrémentez-la de 100 chaque fois qu’Oiram capture une étoile. Incrémentez-la de 200 lorsqu’Oiram bat un adversaire. Affichez le score dans un JLabel. Vous pouvez aussi ajouter une image de titre amusante. Dessinez Oiram dans une image de 500 × 50 et affichez un JLabel contenant cette image en haut de la plateforme. Pour ajouter des images de victoire ou de défaite, créez deux images de 500 × 500. Affichez-les d’abord en dehors de l’écran. Si Oiram meurt ou gagne en passant le niveau 5, déplacez la bonne image au centre de l’arène. N’oubliez pas de supprimer toutes les autres images. import import import import import import public

javax.swing.*; javax.swing.event.*; java.awt.*; java.awt.event.*; java.util.*; java.awt.geom.*; class Oiram extends JFrame implements KeyListener {

206


//le conteneur Container cont; //tableau à deux dimensions String arene[][] = {{" "," "," "," "," "," "," "," "," "," "}, {" "," "," "," "," "," "," "," "," "," "}, {" "," "," "," "," "," ","|","#","#"," "}, {" ","#","#","#"," "," ","|","#"," "," "}, {" "," "," "," "," "," ","|","#"," "," "}, {" ","#","#","#","#","#","#","#","#"," "}, {" "," "," "," "," "," "," "," "," "," "}, {"#","#","#","#"," "," ","#","#","#","#"}, {" "," "," "," "," "," "," "," "," "," "}, {"#","#","#","#","#","#","#","#","#","#"}}; //contient les étoiles ArrayList stars = new ArrayList(); //Oiram JLabel character = new JLabel(new ImageIcon("oiram.png")); //Oiram est-il en train d’escalader ou de sauter ? boolean saut = false; boolean escalade = false; //fil d’exécution Jeu jeu; //score int score = 0; //nombre d’étoiles restantes int etoilesRestantes; //contient les ennemis ArrayList ennemis = new ArrayList(); //images pour la victoire ou la défaite JLabel victoire = new JLabel(new ImageIcon("victoire.png")); JLabel defaite = new JLabel(new ImageIcon("defaite.png")); //image de titre JLabel titre = new JLabel(new ImageIcon("titre.png")); //niveau courant int niveau = 1; //nombre d’ennemis int nbEnnemis = 1; //affiche le niveau et le score JLabel lblNiveau = new JLabel("Niveau "+niveau+"/5"); JLabel lblScore = new JLabel("Score "+score); public Oiram() { super("Oiram"); setSize(500,500); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); cont = getContentPane(); cont.setLayout(null); addKeyListener(this); cont.setBackground(Color.BLACK);


Chapitre 6

//ajoute les images de défaite et de victoire en dehors de l’écran cont.add(victoire); victoire.setBounds(500,500,500,500); cont.add(defaite); defaite.setBounds(500,500,500,500); //affiche le niveau cont.add(lblNiveau); lblNiveau.setFont(new Font("arial",Font.BOLD,20)); lblNiveau.setBounds(375,5,150,50); //affiche le score cont.add(lblScore); lblScore.setFont(new Font("arial",Font.BOLD,20)); lblScore.setBounds(20,5,150,50); //ajoute l’image de titre cont.add(titre); titre.setBounds(0,0,500,50); //ajoute Oiram cont.add(character); character.setBounds(0,400,50,50); //crée les étoiles et les ennemis genereEtoiles(); genereEnnemis(); //génère le tableau for(int i = 0; i < arene.length; i++) { for(int j = 0; j < arene[0].length; j++) { JLabel lbl = null; if(arene[j][i].equals("#")) { lbl = new JLabel(new ImageIcon("terre.png")); } else if(arene[j][i].equals(" ")) { lbl = new JLabel(new ImageIcon("air.png")); } else if(arene[j][i].equals("|")) { lbl = new JLabel(new ImageIcon("echelle.png")); } cont.add(lbl); lbl.setBounds(i*50,j*50,50,50); } } repaint(); cont.validate(); //démarre le fil d’exécution jeu = new Jeu(); jeu.start(); setContentPane(cont); } public void genereEtoiles() { //boucle dans le tableau à deux dimensions for(int i = 1; i < arene.length; i++) { for(int j = 0; j < arene[0].length; j++) { if(arene[i][j].equals(" ")) {

208


//une chance sur 10 de placer une étoile int placeEtoile = (int)(Math.random()*10); if(placeEtoile==0) { //ajoute l’étoile JLabel star = new JLabel(new ImageIcon("etoile.png")); cont.add(star); star.setBounds(j*50,i*50,50,50); cont.setComponentZOrder(star,0); cont.setComponentZOrder(character,0); stars.add(star); etoilesRestantes++; }

} }

} } public void genereEnnemis() { //ajoute un nombre aléatoire d’ennemis int augmenterDe = (int)(Math.random()*2)+1; nbEnnemis = niveau+augmenterDe; //ajoute les nouveaux ennemis for(int i = 0; i < nbEnnemis; i++) { JLabel ennemi = new JLabel(new ImageIcon("ennemi.png")); cont.add(ennemi); int emplX = (int)(Math.random()*8); ennemi.setBounds(emplX*50,0,50,50); cont.setComponentZOrder(ennemi,0); ennemis.add(ennemi); } } public class Jeu extends Thread { public void run() { while(true) { try { //score courant lblScore.setText("Score "+score); //vérifie ce qui suit pour tous les ennemis for(int i = 0; i < ennemis.size(); i++) { JLabel enemy = (JLabel) ennemis.get(i); //n’applique ce qui suit qu’aux ennemis sur l’écran if(enemy.getY()<=450 && enemy.getX()<=450) { //descend l’ennemi si c’est possible if(arene[(enemy.getY()/50)+1] [enemy.getX()/50].equals(" ")) { enemy.setBounds(enemy.getX(), enemy.getY()+50,50,50); } //déplace l’ennemi vers la gauche ou la droite int direction = (int)(Math.random()*2); if(direction==0) { if(arene[enemy.getY()/50][(enemy.getX()/50)+1].equals(" ")) { enemy.setBounds(enemy.getX()+50,enemy.getY(),50,50); }

Chapitre 6


} else { if(arene[enemy.getY()/50][(enemy.getX()/50)-1].equals(" ")) { enemy.setBounds(enemy.getX()-50,enemy.getY(),50,50); } } //si Oiram saute sur un ennemi, supprime l’ennemi if(enemy.getY()-50==character.getY() && enemy.getX() „ ==character.getX()) { enemy.setBounds(1000,1000,50,50); cont.remove(enemy); nbEnnemis--; score+=200; } //si un ennemi mange Oiram, affiche l’image de défaite if(enemy.getY()==character.getY() &&enemy.getX()==character.getX()) { defaite.setBounds(0,0,500,500); cont.setComponentZOrder(defaite,0); for(int j=2; j < cont.getComponentCount(); j++) { cont.remove(j); } cont.validate(); } } } //allez au niveau 5 pour gagner ! if(niveau>=5) { victoire.setBounds(0,0,500,500); cont.setComponentZOrder(victoire,0); for(int i = 2; i < cont.getComponentCount(); i++) { cont.remove(i); } cont.validate(); } //niveau suivant if(nbEnnemis<=0 && etoilesRestantes<=0) { niveau++; genereEtoiles(); genereEnnemis(); lblNiveau.setText("Niveau "+niveau+"/5"); } //vérifie ce qui suit pour toutes les étoiles for(int i = 0; i < stars.size(); i++) { JLabel star = (JLabel) stars.get(i); //si Oiram capture une étoile, on la supprime if(star.getBounds().intersects(character.getBounds())) { score+=100; cont.remove(star); stars.remove(star); etoilesRestantes--; } }

210


}

//Oiram tombe if(!saut) { if(arene[(character.getY()/50)+1][character.getX()/50].equals(" ")) { character.setBounds(character.getX(),character.getY()+50,50,50); } } //Oiram saute else { saut = false; if(arene[(character.getY()/50)-1][character.getX()/50].equals(" ")) { character.setBounds(character.getX(),character.getY()-50,50,50); } } //temporisation Thread.sleep(250); } catch(Exception e){ }

} } public void keyPressed(KeyEvent e){ } public void keyReleased(KeyEvent e){ } public void keyTyped(KeyEvent e) { //déplacement vers la gauche if(e.getKeyChar()==’q’) { //si Oiram escalade, termine l’escalade if(escalade) { escalade = false; character.setIcon(new ImageIcon("oiram.png")); } //déplace Oiram vers la gauche si possible if(character.getX()>=50 && arene[character.getY()/50][(character.getX()/50)-1] .equals(" ")) { character.setBounds(character.getX()-50,character.getY(),50,50); } } //déplacement vers la droite if(e.getKeyChar()==’d’) { //empêche Oiram de sortir de l’écran if(character.getX()<=400 && arene[character.getY()/50][(character.getX()/50)+1].equals(" ")) { character.setBounds(character.getX()+50,character.getY(),50,50); } //si Oiram touche une échelle, commence à escalader if(arene[character.getY()/50][(character.getX()/50)+1].equals("|")) { character.setBounds(character.getX()+50,character.getY(),50,50); escalade = true; character.setIcon(new ImageIcon("surechelle.png")); } } //saute/escalade if(e.getKeyChar()==’z’) {


Chapitre 6

//if Oiram is not climbing, then jump up! if(!escalade) { if(arene[(character.getY()/50)-1][character.getX()/50].equals(" ")) { if(!saut && !arene[(character.getY()/50)+1][character.getX() „ /50].equals(" ")) { saut = true; character.setBounds(character.getX(),character.getY()-50,50,50); } } } //déplace Oiram sur l’échelle else { character.setBounds(character.getX(),character.getY()-50,50,50); //Oiram a atteint le haut de l’échelle, change son icône et le déplace if(arene[character.getY()/50][character.getX()/50].equals(" ")) { character.setBounds(character.getX()+50,character.getY(),50,50); escalade = false; character.setIcon(new ImageIcon("oiram.png")); } }

} } public static void main(String[] args) { new Oiram(); } }

Les Figures 33.1 à 33.3 illustrent la vie et la mort d’Oiram. Figure 33.1 Affichage du niveau et du score

212


Figure 33.2 Oiram a perdu

Figure 33.3 Oiram a gagné

Chapitre 6


Pour aller plus loin... Modifiez la disposition de l’arène. Ajoutez plus de plates-formes, plus d’échelles, etc. Modifiez l’icône d’Oiram en un ballon dirigeable lui permettant de faire tomber des bombes sur ses ennemis. Ajoutez des effets sonores lorsqu’Oiram récupère une étoile ou tue un ennemi. Programmez des applaudissements pour les victoires et des huées pour les défaites. Ajoutez des super-étoiles permettant à Oiram de voler temporairement. Augmentez la taille du tableau en rétrécissant les zones à des tailles de 10 × 10 pixels. Clonez Oiram afin qu’il y en ait deux ou trois dans l’arène. Ajoutez un ennemi invisible. Lorsqu’il se rapproche, programmez un "tremblement" de l’écran pour alerter Oiram de la présence de son ennemi.

214


Projet 34 : Javaman – L’univers de Javaman Javaman

Java et C++, les deux plus grands langages de programmation, entrent en guerre ! Manœuvrez Javaman pour qu’il récupère tous les points sur le champ avant que C++ ne l’assèche. Projet

• Créez l’univers de Javaman : le plateau de jeu.

Créer le jeu Pour créer le plateau, utilisez un tableau à deux dimensions d’objets String. Les "#" représentent les murs et les espaces représentent les zones vides. On représentera donc une boîte vide sous cette forme : #### # # # # ####

Le plateau de Javaman peut être créé de la même manière : ########## # # # # ## # # # ## # # # # ## # # ## # # # # ## # # # ## # # # # ##########

Dans le constructeur, une boucle permet d’examiner tous les éléments du tableau. La position des éléments dans le tableau à deux dimensions doit correspondre à leur emplacement dans le JFrame. Dessinez des images de 50 × 50 pixels de blocs jaunes solides et des images de 50 × 50 pixels représentant des carrés noirs avec un cercle blanc à l’intérieur. Les blocs jaunes sont utilisés pour les carrés de type "#" et les blocs noirs pour les espaces vides. Utiliser des tableaux facilite la modification de la disposition du plateau.

Chapitre 6


import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; import java.util.*; import java.awt.geom.*; public class Javaman extends JFrame { Container cont; //tableau à deux dimensions String arene[][] = {{"#","#","#","#","#","#","#","#","#","#"}, {"#"," "," "," ","#"," "," "," "," ","#"}, {"#"," ","#"," ","#"," "," ","#"," ","#"}, {"#"," ","#"," ","#"," ","#","#"," ","#"}, {"#"," ","#"," "," "," "," ","#"," ","#"}, {"#"," ","#","#"," "," "," ","#"," ","#"}, {"#"," ","#"," "," ","#"," ","#"," ","#"}, {"#"," ","#"," "," ","#"," ","#"," ","#"}, {"#"," "," "," "," ","#"," "," "," ","#"}, {"#","#","#","#","#","#","#","#","#","#"}}; public Javaman() { super("Javaman"); setSize(500,500); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); cont = getContentPane(); cont.setLayout(null); cont.setBackground(Color.BLACK); //crée le plateau for(int i = 0; i < arene.length; i++) { for(int j = 0; j < arene[0].length; j++) { JLabel lbl = null; if(arene[i][j].equals("#")) { lbl = new JLabel(new ImageIcon("mur.png")); } else { lbl = new JLabel(new ImageIcon("pastille.png")); } cont.add(lbl); lbl.setBounds(i*50,j*50,50,50); } } repaint(); cont.validate(); setContentPane(cont); }

216


}

public static void main (String[] args) { new Javaman(); }

La Figure 34.1 illustre l’univers de Javaman. Dans le projet suivant, nous insufflerons la vie à Javaman. Préparez-le à se battre pour sa vie en le rendant mobile. Figure 34.1 Plateau de Javaman


Chapitre 6

Projet 35 : Javaman – Javaman vit ! Projet

• Placez Javaman sur le plateau de jeu. Puis, offrez-lui la vie en ajoutant des contrôles au clavier pour modifier sa direction.

Créer le jeu Le plateau de jeu est en place ; on peut ajouter Javaman. Créez une image 50 × 50 d’une tasse de café. Dans le constructeur, ajoutez cette image avant d’ajouter le plateau. Placez-le dans le coin en haut à droite, en position (50, 50), comme le montre la Figure 35.1. Offrez le mouvement à Javaman. Commencez par ajouter un KeyListener à la classe. N’oubliez pas d’ajouter les trois méthodes obligatoires. Comme dans le jeu la course du courage, utilisez des variables pour garder trace de l’orientation de Javaman (1 vers le haut, 2 vers le bas, 3 vers la droite et 4 vers la gauche). Dans la méthode keyPressed, changez alors la direction de Javaman. Ensuite, créez un fil d’exécution pour faire avancer JavaMan en ajoutant ou en soustrayant 50 à ses coordonnées x et y. Pour éviter que Javaman ne passe à travers les murs, vérifiez la valeur de l’élément correspondant à sa position dans le tableau à deux dimensions. Si l’élément est #, redéplacez Javaman à sa position précédente. Figure 35.1 Javaman : position de départ

import import import import import import

javax.swing.*; javax.swing.event.*; java.awt.*; java.awt.event.*; java.util.*; java.awt.geom.*;

218


public class Javaman extends JFrame implements KeyListener { Container cont; int HAUT = 0, BAS = 1, DROITE = 2, GAUCHE = 3; int direction = DROITE; int positionX = 1, positionY = 1; String arene[][] = {{"#","#","#","#","#","#","#","#","#","#"}, {"#"," "," "," ","#"," "," "," "," ","#"}, {"#"," ","#"," ","#"," "," ","#"," ","#"}, {"#"," ","#"," ","#"," ","#","#"," ","#"}, {"#"," ","#"," "," "," "," ","#"," ","#"}, {"#"," ","#","#"," "," "," ","#"," ","#"}, {"#"," ","#"," "," ","#"," ","#"," ","#"}, {"#"," ","#"," "," ","#"," ","#"," ","#"}, {"#"," "," "," "," ","#"," "," "," ","#"}, {"#","#","#","#","#","#","#","#","#","#"}}; JLabel javaMan = new JLabel(new ImageIcon("javaman.png")); public Javaman() { super("JavaMan"); setSize(500,500); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); cont = getContentPane(); cont.setLayout(null); addKeyListener(this); cont.setBackground(Color.BLACK); //ajoute Javaman cont.add(javaMan); javaMan.setBounds(50,50,50,50); for(int i = 0; i < arene.length; i++) { for(int j = 0; j < arene[0].length; j++) { JLabel lbl = null; if(arene[i][j].equals("#")) { lbl = new JLabel(new ImageIcon("mur.png")); } else { lbl = new JLabel(new ImageIcon("pastille.png")); } cont.add(lbl); lbl.setBounds(i*50,j*50,50,50); System.out.println("X : "+i*50+" -- Y : "+j*50); } }

Chapitre 6


repaint(); cont.validate(); Jeu jeu = new Jeu(); jeu.start(); setContentPane(cont); } public class Jeu extends Thread { public void run() { while(true) { try { if(direction == DROITE) { javaMan.setBounds(javaMan.getX()+50,javaMan.getY(),50,50); positionX++; if(arene[positionX][positionY].equals("#")) { javaMan.setBounds(javaMan.getX()-50,javaMan.getY(),50,50); positionX--; } cont.setComponentZOrder(javaMan,1); } if(direction == GAUCHE) { javaMan.setBounds(javaMan.getX()-50,javaMan.getY(),50,50); positionX--; if(arene[positionX][positionY].equals("#")) { javaMan.setBounds(javaMan.getX()+50,javaMan.getY(),50,50); positionX++; } cont.setComponentZOrder(javaMan,1); } if(direction == HAUT) { javaMan.setBounds(javaMan.getX(),javaMan.getY()-50,50,50); positionY--; if(arene[positionX][positionY].equals("#")) { javaMan.setBounds(javaMan.getX(),javaMan.getY()+50,50,50); positionY++; } cont.setComponentZOrder(javaMan,1); }

220


if(direction == BAS) { javaMan.setBounds(javaMan.getX(),javaMan.getY()+50,50,50); positionY++; if(arene[positionX][positionY].equals("#")) { javaMan.setBounds(javaMan.getX(),javaMan.getY()-50,50,50); positionY--; } cont.setComponentZOrder(javaMan,1); } cont.validate(); Thread.sleep(500); } catch(Exception e){ } }

} } public void keyTyped(KeyEvent e) { if(e.getKeyChar()==’z’) direction = HAUT; if(e.getKeyChar()==’q’) direction = GAUCHE; if(e.getKeyChar()==’s’) direction = BAS; if(e.getKeyChar()==’d’) direction = DROITE; } public void keyPressed(KeyEvent e){ } public void keyReleased(KeyEvent e){ } public static void main (String[] args) { new Javaman(); }

}

Les Figures 35.2 et 35.3 illustrent les déplacements de Javaman. L’entraînement de Javaman est terminé... Il est temps d’ajouter des C++ ennemis !

Chapitre 6

Figure 35.2 Javaman est vivant

Figure 35.3 Javaman se déplace


222


Projet 36 : Javaman – L’attaque du C++ Projet

• Créez et relâchez des ennemis. Les C++ ennemis se déplacent en aveugle, mais ils sont rapides et acharnés.

Créer le jeu Dessinez d’abord une image de 50 × 50 pixels du criminel C++. Pour garder trace de ses clones, créez un tableau de trois éléments. Chaque élément sera un ennemi occupant un coin du plateau. N’oubliez pas que les mouvements des C++ clonés sont aléatoires. Pour créer le mouvement, créez un autre tableau de trois éléments dans le fil d’exécution. Chacun de ces éléments contient l’orientation de chaque élément C++ grâce à des nombres aléatoires entre 1 et 4. Puis, déplacez chaque ennemi dans la direction indiquée par le nombre aléatoire (1 vers le haut, 2 vers le bas, 3 vers la gauche, 4 vers la droite). Pour éviter que les ennemis n’entrent dans les murs, utilisez la même technique que celle que vous avez utilisée dans le projet précédent. Ensuite, ajoutez une instruction if dans la boucle. Comparez la position des C++ avec la position de Javaman. Si elles sont identiques, Javaman perd. Affichez alors un JOptionPane pour annoncer la triste nouvelle au joueur. Javaman évite les C++ mais il essaie aussi de dévorer les cercles sur le plateau. Lorsque Javaman passe sur un cercle, remplacez la tuile correspondante par une image de 50 × 50 pixels noire. Décrémentez aussi la variable qui garde trace du nombre de cercles restants. Une instruction if permet de détecter la victoire. Si Javaman gagne, ajoutez un JOptionPane pour indiquer au joueur sa victoire. import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; import java.util.*; import java.awt.geom.*; public class Javaman extends JFrame implements KeyListener { Container cont; //direction int HAUT = 0, BAS = 1, DROITE = 2, GAUCHE = 3; int direction = DROITE; int score = 0; int positionX = 1, positionY = 1; //tableau à deux dimensions


Chapitre 6

String arene[][] = {{"#","#","#","#","#","#","#","#","#","#"}, {"#"," "," "," ","#"," "," "," "," ","#"}, {"#"," ","#"," ","#"," "," ","#"," ","#"}, {"#"," ","#"," ","#"," ","#","#"," ","#"}, {"#"," ","#"," "," "," "," ","#"," ","#"}, {"#"," ","#","#"," "," "," ","#"," ","#"}, {"#"," ","#"," "," ","#"," ","#"," ","#"}, {"#"," ","#"," "," ","#"," ","#"," ","#"}, {"#"," "," "," "," ","#"," "," "," ","#"}, {"#","#","#","#","#","#","#","#","#","#"}}; //icônes JLabel javaMan = new JLabel(new ImageIcon("javaman.png")); JLabel ennemis[ ] = {new JLabel(new ImageIcon("monstre.png")),new JLabel „ (new ImageIcon("monstre.png")),new JLabel(new ImageIcon("monstre.png"))}; int pastillesrestantes = 44; public Javaman() { super("JavaMan"); setSize(500,500); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); cont = getContentPane(); cont.setLayout(null); addKeyListener(this); cont.setBackground(Color.BLACK); //ajoute Javaman cont.add(javaMan); javaMan.setBounds(50,50,50,50); //ajoute le plateau for(int i = 0; i < arene.length; i++) { for(int j = 0; j < arene[0].length; j++) { JLabel lbl = null; if(arene[i][j].equals("#")) { lbl = new JLabel(new ImageIcon("mur.png")); } else { lbl = new JLabel(new ImageIcon("pastille.png")); } cont.add(lbl); lbl.setBounds(i*50,j*50,50,50); System.out.println("X: "+i*50+" — Y: "+j*50);

}

} //position des ennemis cont.add(ennemis[0]); ennemis[0].setBounds(400,50,50,50); cont.setComponentZOrder(ennemis[0],1); cont.add(ennemis[1]); ennemis[1].setBounds(50,400,50,50); cont.setComponentZOrder(ennemis[1],1); cont.add(ennemis[2]);

224


ennemis[2].setBounds(400,400,50,50); cont.setComponentZOrder(ennemis[2],1); repaint(); cont.validate(); Jeu jeu = new Jeu(); jeu.start(); setContentPane(cont); } public class Jeu extends Thread { public void run() { while(true) { try { //cherche une victoire de Javaman if(pastillesrestantes<=0) { JOptionPane.showMessageDialog(null,"Gagné !"); } //boucle de mouvement des ennemis int dir[] = new int[3]; for(int i = 0; i < dir.length; i++) { dir[i] = (int)(Math.random()*4); if(dir[i]==HAUT) { ennemis[i].setBounds(ennemis[i].getX(),ennemis[i].getY()-50,50,50); if(arene[ennemis[i].getX()/50] [ennemis[i].getY()/50].equals("#")) { ennemis[i].setBounds(ennemis[i].getX(), „ ennemis[i].getY()+50,50,50); } } if(dir[i]==BAS) { ennemis[i].setBounds(ennemis[i].getX(),ennemis[i].getY()+50,50,50); if(arene[ennemis[i].getX()/50] [ennemis[i].getY()/50].equals("#")) { ennemis[i].setBounds(ennemis[i].getX(),ennemis[i].getY()-50,50,50); } } if(dir[i]==GAUCHE) { ennemis[i].setBounds(ennemis[i].getX()-50,ennemis[i].getY(),50,50); if(arene[ennemis[i].getX()/50] [ennemis[i].getY()/50].equals("#")) { ennemis[i].setBounds(ennemis[i].getX()+50, „ ennemis[i].getY(),50,50); } } if(dir[i]==DROITE) { ennemis[i].setBounds(ennemis[i].getX()+50,ennemis[i].getY(),50,50); if(arene[ennemis[i].getX()/50][ennemis[i].getY()/50].equals("#")) { ennemis[i].setBounds(ennemis[i].getX()-50, „ ennemis[i].getY(),50,50); } }

Chapitre 6


//perdu ! if(ennemis[i].getX()/50==positionX && ennemis[i].getY()/50==positionY) { JOptionPane.showMessageDialog(null,"Perdu !"); } cont.setComponentZOrder(ennemis[i],1); } //supprime le cercle if(arene[positionX][positionY].equals(" ")) { arene[positionX][positionY] = "."; pastillesrestantes--; JLabel lbl = new JLabel(new ImageIcon("chemin.png")); cont.add(lbl); lbl.setBounds(positionX*50,positionY*50,50,50); cont.setComponentZOrder(lbl,1); score++; } //déplace Javaman if(direction == DROITE) { javaMan.setBounds(javaMan.getX()+50,javaMan.getY(),50,50); positionX++; if(arene[positionX][positionY].equals("#")) { javaMan.setBounds(javaMan.getX()-50,javaMan.getY(),50,50); positionX--; } cont.setComponentZOrder(javaMan,1); } if(direction == GAUCHE) { javaMan.setBounds(javaMan.getX()-50,javaMan.getY(),50,50); positionX--; if(arene[positionX][positionY].equals("#")) { javaMan.setBounds(javaMan.getX()+50,javaMan.getY(),50,50); positionX++; } cont.setComponentZOrder(javaMan,1); } if(direction == HAUT) { javaMan.setBounds(javaMan.getX(),javaMan.getY()-50,50,50); positionY--; if(arene[positionX][positionY].equals("#")) { javaMan.setBounds(javaMan.getX(),javaMan.getY()+50,50,50); positionY++; } cont.setComponentZOrder(javaMan,1); } if(direction == BAS) { javaMan.setBounds(javaMan.getX(),javaMan.getY()+50,50,50); positionY++; if(arene[positionX][positionY].equals("#")) { javaMan.setBounds(javaMan.getX(),javaMan.getY()-50,50,50); positionY--; }

226


cont.setComponentZOrder(javaMan,1); } cont.validate(); Thread.sleep(500); } catch(Exception e){ }

} }

} public void keyTyped(KeyEvent e) { if(e.getKeyChar()==’z’) direction = HAUT; if(e.getKeyChar()==’q’) direction = GAUCHE; if(e.getKeyChar()==’s’) direction = BAS; if(e.getKeyChar()==’d’) direction = DROITE; } public void keyPressed(KeyEvent e){ } public void keyReleased(KeyEvent e){ } public static void main(String[] args) { new Javaman(); }

}

Les Figures 36.1 et 36.2 illustrent la lutte de Javaman pour sa survie. Figure 36.1 Javaman mange les points

Chapitre 6


Figure 36.2 C++ a gagné...

Pour aller plus loin... Modifiez les panneaux de fin de jeu et ajoutez des images lors de la victoire ou de la défaite. Modifiez les chemins du tableau ou faites-en un terrain de jeu ouvert. Ajoutez des ennemis. Modifiez les icônes des joueurs : vaisseaux à lasers ou formes géométriques. Accélérez ou ralentissez le jeu... ou encore créez des zones pour les fous de vitesse dans le jeu. Ajoutez des points spéciaux pour donner des super-pouvoirs à Javaman. Plutôt que de déplacer les C++ aléatoirement, faites-les chasser Javaman. Ajoutez des sons correspondants à la victoire ou à la défaite de Javaman. Ajoutez un trou noir sur le plateau pour aspirer tout ce qui le traverse.

7 Jeux de réflexion Au sommaire de ce chapitre :

Jeu de mémoire ●

Projet 37 : Dessin de la grille

●

Projet 38 : Correspondances

●

Projet 39 : Battez le chronomètre

Ian a dit ●

Projet 40 : Jeu de couleurs

●

Projet 41 : Surchauffe de cerveau

●

Projet 42 : Plus de niveaux !

●

Projet 43 : Accessoires de jeu

230


Projet 37 : Jeu de mémoire – Dessin de la grille Jeu de mémoire

Même si les processus biochimiques de la mémoire demeurent un mystère, vous pouvez tester la vôtre en jouant à ce jeu. Un ensemble d’images s’affiche devant vos yeux. Le défi consiste à faire correspondre les images identiques avant la fin du décompte du chronomètre. Projet

• Concevez et développez la grille de 16 cartes.

Créer le jeu Le jeu de mémoire est une grille 4 × 4 contenant huit paires d’images. Créez huit images différentes de format 100 × 100 pixels : dessins, photos, etc. Pour obtenir des photos de la bonne taille, photographiez huit objets quelconques et ouvrez les photos dans Microsoft Paint. Appuyez sur Ctrl+A pour sélectionner les images et faites glisser jusqu’à ce que l’indication "100, 100" apparaisse en bas de l’écran, comme le montre la Figure 37.1. Figure 37.1 Création des images

Chapitre 7

Jeux de réflexion 231

Une fois l’image aux bonnes dimensions, choisissez Sauvegardez sous... et enregistrez l’image. Une fois les images créées, enregistrez-les dans un tableau à deux dimensions de JButton de taille 4 × 4. Dans le constructeur, ajoutez les JButton au JFrame grâce à deux boucles for. N’y attachez pas encore les images que vous avez créées ; dessinez à la place une nouvelle image, comme celle de la Figure 37.2, et associez-la au bouton. Figure 37.2 Image "Jeu de mémoire"

Programmez ensuite une méthode pour attribuer aléatoirement les images aux JButton. Pour cela, faites une pause d’une demi-seconde grâce à la méthode Thread.sleep. Puis, initialisez un tableau d’entiers pour enregistrer le nombre de fois que chaque image est utilisée. Ceci évitera que les images n’apparaissent plus de deux fois. Utilisez ensuite deux boucles pour traverser le tableau de JButton. À chaque itération, générez un nombre aléatoire entre 1 et 8 inclus. Le tableau initialisé précédemment vous permettra de vérifier si l’image correspondant au nombre aléatoire a été utilisée plus d’une fois. Si oui, générez un nouveau nombre aléatoire. Une fois qu’un nombre aléatoire satisfaisant a été généré, incrémentez la valeur correspondante dans le tableau. N’oubliez pas d’attribuer la nouvelle icône au JButton correspondant. Comment garder trace de l’emplacement de chaque image ? Il suffit de créer un tableau bidimensionnel de huit entiers. Donnez à l’élément adéquat la valeur du nombre aléatoire. Une fois les images affichées, il faut les cacher. La méthode Thread.sleep permet de mettre le jeu en pause pendant trois secondes pour donner aux joueurs le temps de mémoriser les images. Puis, dans un nouveau nid de deux boucles for, replacez les icônes du jeu (le dos des cartes). import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; public class Memoire extends JFrame { //l’image vide ImageIcon vide = new ImageIcon("vide.png");

232


//les boutons JButton boutons[][] = {{new JButton(vide),new JButton(vide), new JButton(vide),new JButton(vide)}, {new JButton(vide),new JButton(vide), new JButton(vide),new JButton(vide)}, {new JButton(vide),new JButton(vide), new JButton(vide),new JButton(vide)}, {new JButton(vide),new JButton(vide), new JButton(vide),new JButton(vide)}}; //emplacement des boutons int emplacements[][] = {{0,0,0,0},{0,0,0,0},{0,0,0,0}, {0,0,0,0}}; Container cont; public Memoire() { super("Jeu de Mémoire"); setSize(415,500); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); cont = getContentPane(); cont.setLayout(null); for(int i = 0; i 1) { //cherche un meilleur nombre aléatoire rand = (int)(Math.random()*8)+1; } //ne pas utiliser une image plus de deux fois compteUsage[rand-1]++; //définit l’image boutons[i][j].setIcon(new ImageIcon("img"+rand+".png")); //garde trace des images emplacements[i][j] = rand; cont.validate(); } }


Chapitre 7

//pause Thread.sleep(3000); //deux boucles for for(int i = 0; i < boutons[0].length; i++) { for(int j = 0; j < boutons.length; j++) { //retourne les cartes boutons[i][j].setIcon(vide); cont.validate(); } } } catch(Exception e){} } public static void main(String[ ] args) { new Memoire(); }

}

Les Figures 37.3 et 37.4 illustrent le jeu de mémoire. Dans le projet suivant, nous verrons comment faire pour que les joueurs puissent faire correspondre les images. Figure 37.3 Affichage des images "Jeu de mémoire"

234


Figure 37.4 Images à faire correspondre


Chapitre 7

Projet 38 : Jeu de mémoire – Correspondances Projet

• Programmez le code permettant au joueur de tester sa mémoire en faisant correspondre les images.

Créer le jeu Implémentez d’abord l’interface ActionListener. Ajoutez-la à chaque bouton de la liste. Une proposition est constituée de deux clics : l’image de base et la seconde image, pour laquelle on cherche la correspondance. Déclarez deux booléens : le premier pour représenter un clic sur la première image, le second pour représenter un clic sur la deuxième image. Dans la méthode actionPerformed, le premier booléen indique s’il s’agit du premier clic du joueur. Si c’est le cas, itérez dans l’ensemble des boutons grâce à une boucle for. La méthode e.getSource() permet de vérifier si le bouton sélectionné est le bouton courant de la boucle. Si c’est le cas, enregistrez le numéro de l’image dans une variable globale. Puis, affichez l’image adéquate sur le bouton. N’oubliez pas de garder trace du numéro de ligne et de colonne dans des variables globales et d’initialiser le booléen indiquant qu’il faut choisir un bouton à mettre en correspondance. Lors de cette seconde étape, itérez dans l’ensemble des boutons grâce à une boucle for. La méthode e.getSource() permet de vérifier si le bouton sélectionné est le bouton courant de la boucle. Si c’est le cas, modifiez l’icône et placez le bouton et les numéros de colonne et de ligne dans des variables globales. Initialisez le booléen indiquant à l’ordinateur s’il doit chercher une correspondance à true et repassez le booléen indiquant s’il s’agit de la première carte retournée à true. Créez maintenant un nouveau Thread. Dans la boucle de ce fil d’exécution, une instruction if détermine s’il faut chercher une éventuelle victoire sur le plateau. Si c’est le cas, mettez le jeu en pause pour une demi-seconde. Puis, regardez si les deux images choisies par le joueur sont différentes, auquel cas il faut les retourner, c’està-dire rétablir l’image neutre. Si les deux images sont identiques, les images restent affichées. import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; public class Memoire extends JFrame implements ActionListener { //image vide ImageIcon vide = new ImageIcon("vide.png");

236


//tableau de boutons JButton boutons[ ][ ] = {{new JButton(vide),new JButton(vide), new JButton(vide),new JButton(vide)}, {new JButton(vide),new JButton(vide), new JButton(vide),new JButton(vide)}, {new JButton(vide),new JButton(vide), new JButton(vide),new JButton(vide)}, {new JButton(vide),new JButton(vide), new JButton(vide),new JButton(vide)}}; //l’image de tous les boutons int emplacements[ ][ ] = {{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}}; Container cont; //le joueur a-t-il déjà cliqué boolean dejaClique = false; boolean aVerifier = false; //première carte retournée int premiereCarte; //position 1 de la première carte int premiereCartePos1; //position 2 de la première carte int premiereCartePos2; //deuxième carte retournée int deuxiemeCarte; //position 1 de la deuxième carte int deuxiemeCartePos1; //position 2 de la deuxième carte int deuxiemeCartePos2; public Memoire() { super("Jeu de Mémoire"); setSize(415,500); setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); cont = getContentPane(); cont.setLayout(null); //images du jeu for(int i = 0; i

Chapitre 7

try { sleep(500); } catch(Exception ex){ } if(premiereCarte!=deuxiemeCarte) { //si les images ne correspondent pas, on re-retourne les images boutons[premiereCartePos1][premiereCartePos2].setIcon(vide); boutons[deuxiemeCartePos1][deuxiemeCartePos2].setIcon(vide); } aVerifier = false;

} } }

} public void melange() { try { //pause Thread.sleep(500); //évite qu’une image soit utilisée plus de deux fois int compteUsage[ ] = {0,0,0,0,0,0,0,0}; for(int i = 0; i < boutons[0].length; i++) { for(int j = 0; j < boutons.length; j++) { //nombre aléatoire int rand = (int)(Math.random()*8)+1; while(compteUsage[rand -1]>1) { //trouve un meilleur nombre aléatoire rand = (int)(Math.random()*8)+1; } //ne pas utiliser une image plus de deux fois compteUsage[rand-1]++; //définit l’image boutons[i][j].setIcon(new ImageIcon("img"+rand+".png")); //keep track of the images emplacements[i][j] = rand; cont.validate(); } } //pause Thread.sleep(3000); //deux boucles for for(int i = 0; i < boutons[0].length; i++) { for(int j = 0; j < boutons.length; j++) { //retourne les cartes boutons[i][j].setIcon(vide); cont.validate(); } } } catch(Exception e){} }

238


public void actionPerformed(ActionEvent e) { //s’il s’agit de la première carte retournée if(!dejaClique) { for(int i = 0; i < boutons[0].length; i++) { for(int j = 0; j < boutons.length; j++) { if(e.getSource()==boutons[i][j]) { //affiche l’image int numImage = emplacements[i][j]; boutons[i][j].setIcon(new ImageIcon("img"+numImage+".png")); premiereCarte = numImage; premiereCartePos1 = i; premiereCartePos2 = j; } } } dejaClique = true; } //s’il s’agit de la deuxième carte retournée else { for(int i = 0; i < boutons[0].length; i++) { for(int j = 0; j < boutons.length; j++) { if(e.getSource()==boutons[i][j]) { //affiche l’image int numImage = emplacements[i][j]; boutons[i][j].setIcon(new ImageIcon("img"+numImage+".png")); deuxiemeCarte = numImage; deuxiemeCartePos1 = i; deuxiemeCartePos2 = j; cont.validate(); } } //le fil d’exécution cherche une victoire dejaClique = false; aVerifier = true; } } } public static void main(String[ ] args) { new Memoire(); } }

La Figure 38.1 illustre le jeu de mémoire en cours de jeu. Mais la satisfaction du joueur lorsqu’il a terminé un niveau est de courte durée lorsque l’on crée de nouveaux niveaux avec plus de défis...

Chapitre 7

Figure 38.1 La victoire est proche


240


Projet 39 : Jeu de mémoire – Battez le chronomètre Projet

• Des complications... et une astuce. Le joueur doit battre son propre score du niveau précédent. Plus vous êtes doué, plus le jeu devient difficile. Ajoutez également des images pour indiquer au joueur comment il s’en sort.

Créer le jeu Pour ajouter un chronomètre, déclarez deux variables globales. La première contient le temps alloué à un niveau et la seconde contient le temps restant pour le niveau. Puis, dans la méthode qui mélange les icônes, incrémentez une nouvelle variable pour le numéro de niveau. Le temps maximum est obtenu en soustrayant la valeur de la variable du temps restant à celle du temps maximal. Réinitialisez la variable tempsRestant au nouveau temps maximum. Créez un nouveau fil d’exécution. Dans sa boucle infinie, faites une pause d’une seconde et diminuez la variable du temps restant de 1. Affichez le temps restant dans un JLabel. Modifiez la police de ce libellé afin qu’il ressemble à celui de la Figure 39.1. Figure 39.1 Un JLabel affiche le temps restant

Dans le fil d’exécution créé dans le projet précédent, vérifiez avec une nouvelle instruction si la tentative du joueur est couronnée de succès. Si c’est le cas, soustrayez 1 de la variable qui garde trace du nombre de paires restantes. Si ce nombre est 0, on peut commencer un nouveau niveau. Appelez la méthode qui mélange les images. Si le temps restant est inférieur ou égal à une seconde, le joueur a perdu. Supprimez tous les composants du conteneur grâce à une boucle et créez un nouveau JLabel pour afficher le nombre de niveaux terminés par le joueur. Ce libellé est placé au milieu du JFrame. Vous pouvez alors afficher une image différente selon le niveau terminé. Si le joueur dépasse le niveau 7, il s’agit du rang le plus élevé (voir Figure 39.3). Les niveaux 3 à 6 correspondent à un niveau intermédiaire (Figure 39.4). Les niveaux 0 à 2 représentent le rang le plus faible (Figure 39.5). N’oubliez pas de placer le JLabel au-dessus de l’image grâce à la méthode setComponentZOrder.

Chapitre 7


import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; public class Memoire extends JFrame implements ActionListener { //image vide ImageIcon vide = new ImageIcon("vide.png"); //tableau de boutons JButton boutons[][] = {{new JButton(vide),new JButton(vide), new JButton(vide),new JButton(vide)}, {new JButton(vide),new JButton(vide), new JButton(vide),new JButton(vide)}, {new JButton(vide),new JButton(vide), new JButton(vide),new JButton(vide)}, {new JButton(vide),new JButton(vide), new JButton(vide),new JButton(vide)}}; //l’image à chaque bouton int emplacement[][] = {{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}}; Container cont; //le joueur a-t-il déjà cliqué boolean dejaClique = false; //le joueur a-t-il déjà retourné une carte boolean carteRetournee = false; //première carte retournée int premiereCarte; //position 1 de la première carte retournée int premiereCartePos1; //position 2 de la première carte retournée int premiereCartePos2; //seconde carte retournée int deuxiemeCarte; //position 1 de la deuxième carte retournée int deuxiemeCartePos1; //position 2 de la deuxième carte retournée int deuxiemeCartePos2; //nombre de paires restantes int pairesrestantes = 8; //le fil d’exécution doit-il chercher une victoire ? boolean aVerifier = false; //temps total int tempsMax = 90; //temps restant int tempsRestant = 0; //niveau actuel int niveau = 0; JLabel temps = new JLabel("Temps restant : " + tempsRestant); public Memoire() { super("Jeu de Mémoire"); setSize(415,500); setVisible(true);

242


setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); cont = getContentPane(); cont.setLayout(null); //images du jeu for(int i = 0; i < boutons[0].length; i++) { for(int j = 0; j

Chapitre 7

if(pairesrestantes<=0) { //si l’utilisateur gagne, démarre le niveau suivant melange(); } //s’il n’y a plus de temps, affiche un message if(tempsRestant<0) { //supprime les autres composants for(int i = 0; i =7) { //niveau : génie du mal JLabel fin = new JLabel(new ImageIcon("genie.png")); cont.add(fin); fin.setBounds(0,0,415,500); } else if (niveau>=3) { //diabolique, mais pas un génie JLabel fin = new JLabel(new ImageIcon("pasGenie.png")); cont.add(fin); fin.setBounds(0,0,415,500); } else { //vous avez besoin de pratique JLabel fin = new JLabel(new ImageIcon("aide.png")); cont.add(fin); fin.setBounds(0,0,415,500); } cont.setComponentZOrder(lblNiveau,0); cont.validate(); break; }

} }

} public void melange() { niveau++; tempsMax = tempsMax-tempsRestant; tempsRestant = tempsMax; pairesrestantes = 8; try { //pause Thread.sleep(500);

244


//ceci empêche qu’une image soit utilisée plus de deux fois int compteUsage[ ] = {0,0,0,0,0,0,0,0}; for(int i = 0; i < boutons[0].length; i++) { for(int j = 0; j < boutons.length; j++) { //nombre aléatoire int rand = (int)(Math.random()*8)+1; while(compteUsage[rand-1]>1) { //trouve un meilleur nombre aléatoire rand = (int)(Math.random()*8)+1; } //ne pas utiliser une image plus de deux fois compteUsage[rand-1]++; //définit l’image boutons[i][j].setIcon(new ImageIcon("img"+rand+".png")); //garde trace des images emplacement[i][j] = rand; cont.validate(); } } //pause Thread.sleep(3000); //deux boucles for for(int i = 0; i < boutons[0].length; i++) { for(int j = 0; j < boutons.length; j++) { //retourne les cartes boutons[i][j].setIcon(vide); cont.validate(); } } } catch(Exception e){} } public void actionPerformed(ActionEvent e) { //s’il s’agit de la première carte if(!carteRetournee) { for(int i = 0; i < boutons[0].length; i++) { for(int j = 0; j < boutons.length; j++) { if(e.getSource()==boutons[i][j]) { //affiche l’image int numImage = emplacement[i][j]; boutons[i][j].setIcon(new ImageIcon("img"+numImage+".png")); premiereCarte = numImage; premiereCartePos1 = i; premiereCartePos2 = j; } } } carteRetournee = true; }


Chapitre 7

//s’il s’agit de la deuxième carte else { for(int i = 0; i < boutons[0].length; i++) { for(int j = 0; j < boutons.length; j++) { if(e.getSource()==boutons[i][j]) { //affiche l’image int numImage = emplacement[i][j]; boutons[i][j].setIcon(new ImageIcon("img"+numImage+".png")); deuxiemeCarte = numImage; deuxiemeCartePos1 = i; deuxiemeCartePos2 = j; cont.validate(); } } //le fil d’exécution cherche une victoire carteRetournee = false; aVerifier = true; } } } public static void main(String[ ] args) { new Memoire(); }

}

Les Figures 39.2 à 39.5 illustrent le jeu terminé. Figure 39.2 Le chronomètre descend...

246


Figure 39.3 Un vrai petit génie !

Figure 39.4 Rang du milieu

Chapitre 7


Figure 39.5 Encore des efforts à faire...

Pour aller plus loin... Utilisez des couleurs aléatoires à la place des images. Passez d’une grille 4 × 4 de 16 images à une grille 10 × 10 de 100 images. Ajoutez ou retranchez aléatoirement du temps. Remélangez les images au milieu du jeu. Changez d’images à chaque niveau. Remplacez les images par des sons... bien plus difficiles à faire correspondre ! Déconcentrez les joueurs avec de la musique, le bruit d’un bébé qui pleure ou d’un chien qui aboie.

248


Projet 40 : Ian a dit – Jeu de couleurs Ian a dit

Ne clignez pas des yeux : l’ordinateur montre une série de couleurs que le joueur doit mémoriser et répéter. Ian a dit devient de plus en plus difficile à chaque niveau car les suites de couleurs deviennent de plus en plus longues. Combien de couleurs pouvezvous mémoriser ? Attention, une petite erreur vous fera tout recommencer ! Projet

• Construisez le plateau de jeu et programmez la séquence de couleurs du niveau 1.

Créer le jeu Le plateau de Ian a dit se compose de quatre carrés de couleurs différentes de 200 × 200 pixels. Créez d’abord un JFrame de 400 × 400 pixels. Puis, programmez une méthode paint, dans laquelle vous dessinerez quatre carrés de 200 × 200 pixels. Les carrés sont rouge, bleu, vert et jaune. Faites alors une pause d’une seconde pour que le joueur puisse se préparer au jeu. Programmez ensuite une méthode choisissant aléatoirement une des quatre couleurs. La méthode doit retourner un char représentant la couleur choisie. La méthode paint appelle cette nouvelle méthode. Passez le carré choisi dans une couleur plus claire et ajoutez un texte affichant le nom de la couleur (voir Figure 40.1). Figure 40.1 Bleu apparaît sur le carré bleu clair

Mettez le jeu en pause pendant un quart de seconde avant de rétablir les couleurs d’origine sur le tableau. Pour cela, vous devez créer une nouvelle méthode qui réinitialise le plateau de jeu.

Chapitre 7

import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; public class IanADit extends JFrame { public IanADit() { super("Ian A Dit"); setSize(400,400); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setVisible(true); } public void paint(Graphics g) { super.paint(g); //carré rouge g.setColor(new Color(200,50,50)); g.fillRect(0,0,200,200); //carré bleu g.setColor(new Color(50,50,200)); g.fillRect(200,0,200,200); //carré vert g.setColor(new Color(50,200,50)); g.fillRect(0,200,200,200); //carré jaune g.setColor(new Color(200,200,0)); g.fillRect(200,200,200,200); try { Thread.sleep(1000); } catch(Exception e){} String nouvelleCouleur = nouvelleCouleur(); //dessine la bonne couleur if(nouvelleCouleur.equals("r")) { g.setColor(new Color(255,0,0)); g.fillRect(0,0,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, 40)); g.drawString("Rouge",50,80); } if(nouvelleCouleur.equals("b")) { g.setColor(new Color(0,0,250)); g.fillRect(200,0,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, 40)); g.drawString("Bleu",250,80); } if(nouvelleCouleur.equals("v")) { g.setColor(new Color(0,255,0)); g.fillRect(0,200,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, 40)); g.drawString("Vert",50,280); }


250


if(nouvelleCouleur.equals("j")) { g.setColor(new Color(255,255,0)); g.fillRect(200,200,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, 40)); g.drawString("Jaune",250,280); } try { Thread.sleep(250); } catch(Exception e){} reinitialise(g); } //génère un nouveau nombre aléatoire public String nouvelleCouleur() { int rand = (int)(Math.random()*4); if(rand==0) { return "r"; } if(rand==1) { return "b"; } if(rand==2) { return "v"; } if(rand==3) { return "j"; } return " "; } public void reinitialise(Graphics g) { //réinitialise les couleurs g.setColor(new Color(200,50,50)); g.fillRect(0,0,200,200); g.setColor(new Color(50,50,200)); g.fillRect(200,0,200,200); g.setColor(new Color(50,200,50)); g.fillRect(0,200,200,200); g.setColor(new Color(200,200,0)); g.fillRect(200,200,200,200); } public static void main(String[]args) { new IanADit(); }

}

Les Figures 40.2 et 40.3 illustrent le déroulement de cette première étape de Ian a dit. La première partie de la séquence de couleurs a été affichée. Dans le projet suivant, nous verrons comment tester la mémoire du joueur.

Chapitre 7

Figure 40.2 Le plateau de jeu avec des couleurs standard

Figure 40.3 Le carré bleu est éclairé


252


Projet 41 : Ian a dit – Surchauffe de cerveau Projet

• C’est ici que commence l’action. Programmez l’ordinateur pour savoir si le joueur a saisi la bonne séquence de couleurs.

Créer le jeu Afin que l’utilisateur puisse répéter la séquence, implémentez MouseListener. N’oubliez pas d’ajouter les cinq méthodes obligatoires. Dans la méthode mouseClicked, initialisez un booléen, indiquant si l’ordinateur est en train d’afficher la séquence, à false. Puis, incrémentez la variable représentant le nombre d’essais du joueur. Vous devez déterminer dans quel carré le joueur clique. Si les positions X et Y du clic sont inférieures à 200, le joueur clique en haut à gauche. Si X est supérieur à 200 et Y inférieur à 200, le joueur clique dans le carré en haut à droite. Si Y est supérieur à 200 et X inférieur à 200, le joueur clique dans le carré en bas à gauche. Si les deux coordonnées X et Y sont supérieures à 200, le joueur clique en bas à droite. Donnez à la variable dernierClic la valeur du carré dans lequel le joueur a cliqué. Ajoutez aussi la couleur sur laquelle le joueur a cliqué à un String représentant la tentative du joueur. Appelez la méthode repaint();. Vous devez alors modifier la méthode paint. Examinez le booléen indiquant si l’ordinateur est en train d’afficher une séquence. Si ce n’est pas le cas, éclaircissez le dernier carré sur lequel le joueur a cliqué grâce à la variable dernierClic. Dans la méthode mouseClicked, regardez si la séquence du joueur correspond à celle de l’ordinateur. Pour cela, extrayez la partie de la séquence que l’utilisateur a tapée et comparez-la à la tentative de l’utilisateur. Si ces deux chaînes sont différentes, le joueur s’est trompé : affichez un JOptionPane pour annoncer au joueur qu’il a perdu. Si les chaînes sont identiques et si elles sont de la même taille, le JOptionPane annonce que le joueur a bien terminé la séquence. import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; public class IanADit extends JFrame implements MouseListener { Container cont; String code = ""; String essai = ""; int nbLettres = 0; String derniereLettre; boolean normal = true;

Chapitre 7

public IanADit() { super("Ian A Dit"); setSize(400,400); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setVisible(true); addMouseListener(this); } public void paint(Graphics g) { super.paint(g); if(!normal) { reinitialise(g); String nouvelleCouleur = derniereLettre; //light up the correct square when clicked if(nouvelleCouleur.equals("r")) { g.setColor(new Color(255,0,0)); g.fillRect(0,0,200,200); } if(nouvelleCouleur.equals("b")) { g.setColor(new Color(0,0,250)); g.fillRect(200,0,200,200); } if(nouvelleCouleur.equals("v")) { g.setColor(new Color(0,255,0)); g.fillRect(0,200,200,200); } if(nouvelleCouleur.equals("j")) { g.setColor(new Color(255,255,0)); g.fillRect(200,200,200,200); } try { Thread.sleep(250); } catch(Exception ex){} reinitialise(g); } else { //crée les carrés g.setColor(new Color(200,50,50)); g.fillRect(0,0,200,200); g.setColor(new Color(50,50,200)); g.fillRect(200,0,200,200); g.setColor(new Color(50,200,50)); g.fillRect(0,200,200,200); g.setColor(new Color(200,200,0)); g.fillRect(200,200,200,200); try { Thread.sleep(1000); } catch(Exception e){ } //itère dans le code for(int i = 0; i

254


//allume le carré suivant char letter = code.toCharArray()[i]; if(letter==’r’) { g.setColor(new Color(255,0,0)); g.fillRect(0,0,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, g.drawString("Rouge",50,80); } if(letter==’b’) { g.setColor(new Color(0,0,250)); g.fillRect(200,0,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, g.drawString("Bleu",250,80); } if(letter==’v’) { g.setColor(new Color(0,255,0)); g.fillRect(0,200,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, g.drawString("Vert",50,280); } if(letter==’j’) { g.setColor(new Color(255,255,0)); g.fillRect(200,200,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, g.drawString("Jaune",250,280); } try { Thread.sleep(250); } catch(Exception e){} reinitialise(g);

40));

40));

40));

40));

} try { Thread.sleep(250); } catch(Exception e){ } String nouvelleCouleur = nouvelleCouleur(); //display the appropriate color if(nouvelleCouleur.equals("r")) { g.setColor(new Color(255,0,0)); g.fillRect(0,0,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, 40)); g.drawString("Rouge",50,80); } if(nouvelleCouleur.equals("b")) { g.setColor(new Color(0,0,250)); g.fillRect(200,0,200,200); g.setColor(Color.black);


Chapitre 7

g.setFont(new Font("arial", Font.BOLD, 40)); g.drawString("Bleu",250,80);

} if(nouvelleCouleur.equals("g")) { g.setColor(new Color(0,255,0)); g.fillRect(0,200,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, 40)); g.drawString("Vert",50,280); } if(nouvelleCouleur.equals("y")) { g.setColor(new Color(255,255,0)); g.fillRect(200,200,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, 40)); g.drawString("Jaune",250,280); } try { Thread.sleep(250); } catch(Exception e){} reinitialise(g);

}

} public String nouvelleCouleur() { //génère la couleur aléatoire int rand = (int)(Math.random()*4); if(rand==0) { code+="r"; return "r"; } if(rand==1) { code+="b"; return "b"; } if(rand==2) { code+="v"; return "v"; } if(rand==3) { code+="j"; return "j"; } return " "; } public void reinitialise(Graphics g) { //carré rouge g.setColor(new Color(200,50,50)); g.fillRect(0,0,200,200); //carré bleu g.setColor(new Color(50,50,200)); g.fillRect(200,0,200,200);

256


//carré vert g.setColor(new Color(50,200,50)); g.fillRect(0,200,200,200); //carré jaune g.setColor(new Color(200,200,0)); g.fillRect(200,200,200,200); } public void mouseExited(MouseEvent e){ } public void mouseEntered(MouseEvent e){ } public void mouseReleased(MouseEvent e){ } public void mousePressed(MouseEvent e){ } public void mouseClicked(MouseEvent e) { normal = false; nbLettres++; //détecte le carré cliqué par le joueur if(e.getX()<200 && e.getY()<200) { derniereLettre = "r"; essai+="r"; } if(e.getX()>200 && e.getY()<200) { derniereLettre = "b"; essai+="b"; } if(e.getX()<200 && e.getY()>200) { derniereLettre = "v"; essai+="v"; } if(e.getX()>200 && e.getY()>200) { derniereLettre = "j"; essai+="j"; } repaint(); String boutCode = code.substring(0,nbLettres); if(!boutCode.equals(essai)) { //perdu JOptionPane.showMessageDialog(null,"PERDU !"); } else { //le joueur peut continuer if(nbLettres==code.length()) { JOptionPane.showMessageDialog(null,"Correct !"); } } } public static void main(String[] args) { new IanADit(); }

}

Les Figures 41.1 à 41.3 illustrent le déroulement du jeu. Jusqu’ici, tout est facile. Mais attention... les choses vont se compliquer très rapidement.

Chapitre 7

Figure 41.1 Séquence de l’ordinateur

Figure 41.2 Répétition correcte


258


Figure 41.3 Répétition incorrecte, perdu !


Chapitre 7

Projet 42 : Ian a dit – Plus de niveaux ! Projet

• Concevez un nombre infini de niveaux contenant des séquences de plus en plus longues à mémoriser.

Créer le jeu Dans la méthode mouseClicked, supprimez le code créant le JOptionPane qui félicite le joueur. Remplacez-le par du code réinitialisant la tentative du joueur et la longueur de la séquence. Donnez également au booléen indiquant si l’ordinateur est en train d’afficher la séquence la valeur true. Puis, appelez la méthode repaint. Dans la méthode paint, programmez une boucle for qui itère à travers toutes les lettres du code. À chaque itération, utilisez cette ligne de code pour déterminer la couleur à utiliser : .toCharArray()[]; La méthode ci-dessus retourne un caractère qui peut ensuite être comparé dans une instruction if pour savoir s’il contient un "r" (rouge), un "b" (bleu), un "v" (vert) ou un "j" (jaune). Éclairez le carré correspondant et affichez le texte pour indiquer la couleur. Maintenant que vous disposez de plusieurs niveaux, il faut indiquer au joueur à quel niveau il se trouve. Pour cela, écrivez une méthode qui dessine un rond blanc entourant du texte noir, comme sur la Figure 42.1. Figure 42.1 Cercle indiquant le numéro du niveau : niveau 6 260 Devenez un petit génie des jeux vidéo Dans la méthode paint, appelez la méthode qui affiche le cercle et le numéro du niveau avant d’exécuter les méthodes Thread.sleep. import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; public class IanADit extends JFrame implements MouseListener { Container cont; String code = ""; String essai = ""; int lettres = 0; int niveau = 0; String derniereLettre; boolean normal = true; public IanADit() { super("Ian A Dit"); setSize(400,400); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setVisible(true); Container cont = getContentPane(); cont.setLayout(null); addMouseListener(this); } public void paint(Graphics g) { super.paint(g); if(!normal) { reinitialise(g); String nouvelleCouleur = derniereLettre; //allume le carré sur lequel on a cliqué if(nouvelleCouleur.equals("r")) { g.setColor(new Color(255,0,0)); g.fillRect(0,0,200,200); } if(nouvelleCouleur.equals("b")) { g.setColor(new Color(0,0,250)); g.fillRect(200,0,200,200); } if(nouvelleCouleur.equals("v")) { g.setColor(new Color(0,255,0)); g.fillRect(0,200,200,200); } if(nouvelleCouleur.equals("j")) { g.setColor(new Color(255,255,0)); g.fillRect(200,200,200,200); } dessineNiveau(g); try { Thread.sleep(250); } catch(Exception ex){} Jeux de réflexion 261 Chapitre 7 reinitialise(g); } else { niveau++; //affiche les carrés g.setColor(new Color(200,50,50)); g.fillRect(0,0,200,200); g.setColor(new Color(50,50,200)); g.fillRect(200,0,200,200); g.setColor(new Color(50,200,50)); g.fillRect(0,200,200,200); g.setColor(new Color(200,200,0)); g.fillRect(200,200,200,200); dessineNiveau(g); try { Thread.sleep(1000); } catch(Exception e){ } //itère dans le code for(int i = 0; i 40)); 40)); 40)); 40)); 262 Devenez un petit génie des jeux vidéo dessineNiveau(g); try { Thread.sleep(250); } catch(Exception e){} reinitialise(g); } try { Thread.sleep(250); } catch(Exception e){} String nouvelleCouleur = nouvelleCouleur(); //affiche la bonne couleur if(nouvelleCouleur.equals("r")) { g.setColor(new Color(255,0,0)); g.fillRect(0,0,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, 40)); g.drawString("Rouge",50,80); } if(nouvelleCouleur.equals("b")) { g.setColor(new Color(0,0,250)); g.fillRect(200,0,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, 40)); g.drawString("Bleu",250,80); } if(nouvelleCouleur.equals("v")) { g.setColor(new Color(0,255,0)); g.fillRect(0,200,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, 40)); g.drawString("Vert",50,280); } if(nouvelleCouleur.equals("j")) { g.setColor(new Color(255,255,0)); g.fillRect(200,200,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, 40)); g.drawString("Jaune",250,280); } dessineNiveau(g); try { Thread.sleep(250); } catch(Exception e){} reinitialise(g); } } public void dessineNiveau(Graphics g) { //dessinle le cercle et le texte qui affichent le niveau g.setColor(Color.white); g.fillOval(160,160,80,80); g.setColor(Color.black); Jeux de réflexion 263 Chapitre 7 g.setFont(new Font("arial", Font.BOLD, 15)); g.drawString("Niveau "+niveau,175,205); } public String nouvelleCouleur() { //génère la couleur aléatoire int rand = (int)(Math.random()*4); if(rand==0) { code+="r"; return "r"; } if(rand==1) { code+="b"; return "b"; } if(rand==2) { code+="v"; return "v"; } if(rand==3) { code+="j"; return "j"; } return " "; } public void reinitialise(Graphics g) { //carré rouge g.setColor(new Color(200,50,50)); g.fillRect(0,0,200,200); //carré bleu g.setColor(new Color(50,50,200)); g.fillRect(200,0,200,200); //carré vert g.setColor(new Color(50,200,50)); g.fillRect(0,200,200,200); //carré jaune g.setColor(new Color(200,200,0)); g.fillRect(200,200,200,200); dessineNiveau(g); } public void mouseExited(MouseEvent e){} public void mouseEntered(MouseEvent e){} public void mouseReleased(MouseEvent e){} public void mousePressed(MouseEvent e){} public void mouseClicked(MouseEvent e) { normal = false; lettres++; //détermine quel carré a été cliqué if(e.getX()<200 && e.getY()<200) { derniereLettre = "r"; essai += "r"; } 264 Devenez un petit génie des jeux vidéo } if(e.getX()>200 && e.getY()<200) { derniereLettre = "b"; essai+="b"; } if(e.getX()<200 && e.getY()>200) { derniereLettre = "v"; essai+="v"; } if(e.getX()>200 && e.getY()>200) { derniereLettre = "j"; essai+="j"; } repaint(); String codeSeg = code.substring(0,lettres); if(!codeSeg.equals(essai)) { JOptionPane.showMessageDialog(null,"Perdu !"); } else { //le joueur peut continuer if(lettres==code.length()) { essai = ""; lettres = 0; normal = true; //niveau suivant repaint(); } } } public static void main(String[] args) { new IanADit(); } Dans le projet suivant, nous verrons comment ajouter une image de fond et un bouton de démarrage pour que les joueurs puissent se préparer mentalement à affronter Ian a dit. Jeux de réflexion 265 Chapitre 7 Projet 43 : Ian a dit – Accessoires de jeu Projet • Construisez une image de démarrage alertant le joueur du début du jeu. Ajoutez également des images et des messages apparaissant lorsque le joueur termine des niveaux. Créer le jeu Dessinez dans un logiciel de dessin une image de démarrage de 400 × 400 pixels. Dans le constructeur, ajoutez cette image au JFrame. Ajoutez un JButton en haut de l’image, sans oublier son ActionListener, comme représenté en Figure 43.1 Figure 43.1 Image de démarrage et son bouton Déclarez un booléen indiquant si le jeu doit démarrer et initialisez-le à false. Dans la méthode actionPerformed du JButton, donnez au booléen la valeur true et déplacez le bouton en dehors de l’écran. Dans la méthode paint, regardez si le booléen a la valeur true. Si oui, commencez le jeu. À la fin du jeu, remplacez le JOptionPane par du texte. Affichez différentes phrases correspondant au niveau que l’utilisateur a atteint. Par exemple, si le joueur échoue à se rappeler la moindre couleur, affichez le texte de la Figure 43.2. S’il se souvient de séquences entre une et cinq couleurs, affichez le texte de la Figure 43.3. S’il réussit à 266 Devenez un petit génie des jeux vidéo mémoriser des séquences de taille supérieure à cinq couleurs, affichez le texte de la Figure 43.4. Figure 43.2 Aucune mémoire Figure 43.3 Bon départ... mais continuez à vous entraîner Chapitre 7 Jeux de réflexion 267 Figure 43.4 Une bonne mémoire... indispensable pour un véritable petit génie des jeux vidéo import javax.swing.*; import javax.swing.event.*; import java.awt.*; import java.awt.event.*; public class IanADit extends JFrame implements MouseListener, ActionListener { Container cont; String code = ""; String essai = ""; int lettres = 0; int niveau = 0; String derniereLettre; boolean termine = false; boolean normal = true; boolean debut = false; JButton demarrage = new JButton("Démarrer"); public IanADit() { super("Ian A Dit"); setSize(400,400); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setVisible(true); Container cont = getContentPane(); cont.setLayout(null); cont.add(demarrage); demarrage.addActionListener(this); demarrage.setFont(new Font("arial",Font.BOLD,20)); demarrage.setBounds(95,250,200,50); JLabel titre = new JLabel(new ImageIcon("titre.png")); cont.add(titre); titre.setBounds(0,0,400,400); 268 Devenez un petit génie des jeux vidéo addMouseListener(this); } public void paint(Graphics g) { super.paint(g); if(!debut) return; if(termine) { //FIN DE JEU reinitialise(g); g.setColor(Color.black); g.setFont(new Font("Arial", Font.BOLD,50)); g.drawString("PERDU !",60,150); g.setFont(new Font("Arial", Font.BOLD,20)); if((niveau-1) ==0) { g.drawString("Vous n’avez rien mémorisé !!",50,285); } else if((niveau-1)<=5) { g.drawString("Vous n’avez mémorisé qu’une séquence de ",15,275); g.drawString((niveau -1)+" couleur(s):(",130,300); } else { g.drawString("Bravo ! Vous avez mémorisé une",45,275); g.drawString("séquence de " +<(niveau-1)+" couleurs aléatoires :)",15,300); } } else { if(!normal) { reinitialise(g); String nouvelleCouleur = derniereLettre; //allume le bon carré lorsqu’on clique dessus if(nouvelleCouleur.equals("r")) { g.setColor(new Color(255,0,0)); g.fillRect(0,0,200,200); } if(nouvelleCouleur.equals("b")) { g.setColor(new Color(0,0,250)); g.fillRect(200,0,200,200); } if(nouvelleCouleur.equals("v")) { g.setColor(new Color(0,255,0)); g.fillRect(0,200,200,200); } if(nouvelleCouleur.equals("j")) { g.setColor(new Color(255,255,0)); g.fillRect(200,200,200,200); } dessineNiveau(g); try { Thread.sleep(250); } catch(Exception ex){} reinitialise(g); } else { Jeux de réflexion 269 Chapitre 7 niveau++; //crée les carrés g.setColor(new Color(200,50,50)); g.fillRect(0,0,200,200); g.setColor(new Color(50,50,200)); g.fillRect(200,0,200,200); g.setColor(new Color(50,200,50)); g.fillRect(0,200,200,200); g.setColor(new Color(200,200,0)); g.fillRect(200,200,200,200); dessineNiveau(g); try { Thread.sleep(1000); } catch(Exception e){} //itère à travers le code for(int i = 0; i 40)); 40)); 40)); 40)); 270 Devenez un petit génie des jeux vidéo try { Thread.sleep(250); } catch(Exception e){ } reinitialise(g); } try { Thread.sleep(250); } catch(Exception e){ } String nouvelleCouleur = nouvelleCouleur(); //affiche la bonne couleur if(nouvelleCouleur.equals("r")) { g.setColor(new Color(255,0,0)); g.fillRect(0,0,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, 40)); g.drawString("Rouge",50,80); } if(nouvelleCouleur.equals("b")) { g.setColor(new Color(0,0,250)); g.fillRect(200,0,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, 40)); g.drawString("Bleu",250,80); } if(nouvelleCouleur.equals("g")) { g.setColor(new Color(0,255,0)); g.fillRect(0,200,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, 40)); g.drawString("Vert",50,280); } if(nouvelleCouleur.equals("y")) { g.setColor(new Color(255,255,0)); g.fillRect(200,200,200,200); g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, 40)); g.drawString("Jaune",250,280); } dessineNiveau(g); try { Thread.sleep(250); } catch(Exception e){} reinitialise(g); } } } public void dessineNiveau(Graphics g) { //dessine l’ovale et le texte qui affichent le niveau g.setColor(Color.white); g.fillOval(160,160,80,80); Jeux de réflexion 271 Chapitre 7 g.setColor(Color.black); g.setFont(new Font("arial", Font.BOLD, 15)); g.drawString("Niveau "+niveau,175,205); } public String nouvelleCouleur() { //génère une couleur aléatoire int rand = (int)(Math.random()*4); if(rand==0) { code+="r"; return "r"; } if(rand==1) { code+="b"; return "b"; } if(rand==2) { code+="v"; return "v"; } if(rand==3) { code+="j"; return "j"; } return " "; } public void reinitialise(Graphics g) { //carré rouge g.setColor(new Color(200,50,50)); g.fillRect(0,0,200,200); //carré bleu g.setColor(new Color(50,50,200)); g.fillRect(200,0,200,200); //carré vert g.setColor(new Color(50,200,50)); g.fillRect(0,200,200,200); //carré jaune g.setColor(new Color(200,200,0)); g.fillRect(200,200,200,200); dessineNiveau(g); } public void actionPerformed(ActionEvent e) { //démarre le jeu demarrage.setBounds(500,500,50,50); debut = true; repaint(); } public void mouseExited(MouseEvent e){} public void mouseEntered(MouseEvent e){} public void mouseReleased(MouseEvent e){} public void mousePressed(MouseEvent e){} 272 Devenez un petit génie des jeux vidéo public void mouseClicked(MouseEvent e) { normal = false; lettres++; //détermine sur quel carré le joueur a cliqué if(e.getX()<200 && e.getY()<200) { derniereLettre = "r"; essai+="r"; } if(e.getX()>200 && e.getY()<200) { derniereLettre = "b"; essai+="b"; } if(e.getX()<200 && e.getY()>200) { derniereLettre = "v"; essai+="v"; } if(e.getX()>200 && e.getY()>200) { derniereLettre = "j"; essai+="j"; } repaint(); String boutCode = code.substring(0,lettres); if(!boutCode.equals(essai)) { //game over! termine = true; repaint(); } else { //le joueur peut continuer if(lettres==code.length()) { essai = ""; lettres = 0; normal = true; //niveau suivant repaint(); } } } public static void main(String[ ]args) { new IanADit(); } } Pour aller plus loin... Remplacez les couleurs par des indices sonores. Modifiez le dessin du jeu pour remplacer les quatre carrés par des touches de piano. Ajoutez des carrés supplémentaires de couleurs différentes après chaque niveau passé avec succès. Chapitre 7 Jeux de réflexion 273 Ajoutez une limite de temps. Gérez un nombre limité de niveaux, mais ajoutez une course contre la montre pour les terminer. Demandez aux joueurs droitiers de jouer de la main gauche et aux gauchers de jouer de la main droite. Forcez les joueurs à retarder leur réponse en mettant le jeu en pause pendant plusieurs secondes. Félicitations ! Vous maîtrisez maintenant l’art de la programmation de jeux vidéo. Vous êtes intelligent, créatif et un magicien de l’informatique. Bref, vous êtes un vrai petit génie des jeux vidéo ! Index Symboles - 15 != 16 % 15 * 15 + 15 < 16 <= 16 == 15 > 16 >= 16 A Accéder à un fichier 3 Accolades 11 ActionEvent 97 getSource 97, 235 ActionListener 97 actionPerformed 97 exemple 97, 106, 235 JButton 97 add, ArrayList 31 Afficher un score, JLabel 98 API 73 ArrayList 3, 31 accéder à un élément 31 add 31 ajouter un élément 31 création 31 exemple 74, 129, 175 get 31 transtypage 32 AudioClip 62 loop 62 play 62 B Boîte de dialogue, saisie 17 Bonus 135 boolean 14 Boucle 24 break 25 do... while 25 exemple 32, 35 fonctionnement 25 exemple 110 276 Devenez un petit génie des jeux vidéo Boucle (suite) for 24 condition 24 exemple 180, 189 fonctionnement 24 format 24 itérateur 24 variable 24 while 24 fonctionnement 25 BoutonVoir JButton 93 break 25 BufferedReader 19 C Cast Voir Transtypage 17 char 14 Chasse aux mauvais génies apparition des génies 97 création du plateau 92 niveaux de difficulté 101 Chronomètre 83, 149 Classe constructeur 40 contenu 11 créer dans NetBeans 7 délimiter 11 interne 47 créer 47 méthode main 11 nommer 11 Clavier contrôler la direction 166 détecter l’appui sur une touche 53 Collisions 53 Color 42 Commentaire 3, 10 Compilateur 5 Compiler un projet 12 Composant 92 détecter une action 97 Composant graphique 92 bouton 93 disposition 92, 105 JButton 93 JLabel 94 libellé 94 placer sur une image 148 setBounds 105 setComponentZOrder 170 TextField 148 Concaténation 15 Condition 15 != 16 < 16 <= 16 == 15 > 16 >= 16 égalité 15 de deux String 16 inégalité 16 de deux String 16 inférieur ou égal 16 strictement inférieur 16 strictement supérieur 16 supérieur ou égal 16 Constructeur 40 syntaxe 40 Container 92 add 93 ajouter un composant 93 création 92 FlowLayout 92 getComponentCount 180 JFrame 92 NullLayout 105 setLayout 92 ConteneurVoir Container 92 Contrôle de flux 3, 10 Couleurs 42 disponibles, afficher 42 Course du courage 40 environnement 40 voitures 47 Création d’un fichier 18 Index 277 D Déclaration 10 Démineurs affichage des indices 148 création de la bombe 144 explosion de la bombe 153 niveaux 159 Destructeurs de l’espace ajout des aliens et des lasers 129 bonus 135 création du paysage 126 Détecter une action sur un composant 97 Détection de victoire 110 des collisions 53 exemple 54, 130, 175 Directions, gérer au clavier 53 Disposition des composants 92, 105 algorithme 106 FlowLayout 92 NullLayout 105 Division par 0 26 do... while Voir Boucle do... while Double 14 drawImage, Graphics 62 drawString, Graphics 83 E Écran de bienvenue, JOptionPane 63 Élément de tableau, numérotation 30 else 16 Ennemis 198, 222 Exécuter un projet 12 F Fichier accès 3, 19 création 18 File 18, 19 FileOutputStream 18 FileReader 19 fillRect, Graphics 42 FlowLayout 92 Flux, contrôle 3, 10 Font 84 for Voir Boucle for G get, ArrayList 31 getKeyChar, KeyEvent 54 getResource 62 getSource, ActionEvent 235 Graphics 41 couleur 42 drawImage 62 drawString 83 fillRect 42 police 84 setColor 42 setFont 84 Gravité, gestion 77 I Ian a dit création du plateau 248 détection des mouvements du joueur 252 niveaux 259 personnalisation 265 if 3 condition 15 else et else if 16 exemple 35 Image 61, 62 création 230 de fond 180 placer des composants 148 Toolkit 62 ImageIcon 93 Instruction 3, 10 if 3 int 14 Intelligence artificielle 116, 198 278 Devenez un petit génie des jeux vidéo Interface graphique 40 bouton 93 composant 92 Container 92 disposition des composants 92, 105 JButton 93 JFrame 40 JLabel 94 libellé 94 placer des composants sur un fond 148 Intersects, rectangle 53 J Javaman déplacements 217 ennemis 222 plateau 214 JButton 93 ActionListener 97 activer et désactiver 94 ajouter au conteneur 93 création 93 exemple 95, 231 image 93 setEnabled 94 texte 93 Jeu de mémoire ajout des correspondances 235 conception du plateau 230 niveaux 240 JFrame 40 Container 92 création 40 image de fond 144 paint 41 repaint 43 JLabel 94 affichage d’un score 98, 159 de statistiques 135 création 94 exemple 95 image 95 modifier le texte 95 score 205 setText 95 texte 94 JOptionPane 3, 17, 20 écran de bienvenue 63 exemple 32, 35, 63 saisie de l’utilisateur 17 K KeyEvent 54 getKeyChar 54 KeyListener 53 exemple 54, 77, 129, 166, 192, 217 keyPressed 54 keyReleased 54 keyTyped 54 L Libellé Voir JLabel 94 Line2D.Double 73 exemple 74 M main, méthode 11 Math.random() 23 Méthode 43 appeler 44 arguments 44 création 43 main 11 nom 44 syntaxe 43 type de retour 43 Morpion boxeur création du plateau 105 détecter les victoires 110 intelligence artificielle 116 MouseEvent 72, 126 getX 72, 126 getY 72, 126 Index 279 MouseListener 72 exemple 74, 252 mouseClicked 72 mouseEntered 72 mouseExited 72 mousePressed 72 mouseReleased 72 MouseMotionListener 126 exemple 126 mouseDragged 126 mouseMoved 126 Murs, gestion 217 N NetBeans 5 compiler un projet 12 création d’un projet 5 créer une classe 7 exécuter un projet 12 Niveaux 101, 159, 205, 240, 259 Nombres aléatoires 3, 23 NullLayout 105 O Oiram ajout des ennemis 198 création de la plate-forme 188 déplacements et étoiles 192 niveaux 205 Opérateurs 15 P paint, JFrame 41 Pause 3, 23 Personnalisation écran de bienvenue 63 exemple 180, 265 images 61 sons 62 Pièges ajout des traces 170 détection des collisions 175 effets graphiques 180 plateau et personnages 166 Plateau de jeu ajout d’éléments aléatoires 193 définir dans un tableau à deux dimensions 189, 214 Point2D.Double 73 exemple 74 println 11 PrintWriter 18 Projet compiler 12 création d’un projet 5 créer dans NetBeans 5 exécuter 12 R Rafraîchissement de l’écran 48 random 23 Rectangle 42 dessiner 42 exemple 48, 77 intersects 53 repaint JFrame 43 run Thread 47 S Saisie clavier, KeyListener 53 de l’utilisateur 17 Score 205 JLabel 98, 159, 205 setBounds composant graphique 105 exemple 126 setColor, Graphics 42 setComponentZOrder 170 setEnabled, JButton 94 280 Devenez un petit génie des jeux vidéo setFont, Graphics 84 setText, JLabel 95 Skieur, création de la piste 72 sleep 23 Souris détecter les mouvements 126 détection des clics 72 Statistiques, affichage dans un JLabel 135 String 14 concaténation 15 égalité 16 toCharArray 259 System.out.println 11 T Tableau 3, 30 à deux dimensions 188 accéder à un élément 188 création 188 exemple 189, 214, 231 taille 189 accès à un élément 30 création 30 déclaration 30 initialisation 30 modifier une valeur 30 TextField 148 Thread 47 appeler 48 chronomètre 83, 149 classe interne 47 créer 47 exemple 48, 77, 98, 149, 166 run 47 Thread.sleep 23 exemple 193 Tir 129 Toolkit 62 Transtypage 17 ArrayList 32 d’un String en double 17 en int 17 try... catch 48 Types de variables 14 U URL 62 getResource 62 V Variable 3 boolean 14 char 14 créer 14 déclaration 10, 14 décrémenter 15 double 14 incrémenter 15 initialisation 14 int 14 modifier la valeur 15 opérateurs 15 String 14 tester 15 types 14 Vitesse, gestion 77 W while Voir Boucle while

Devenez Un Petit Gu00e9nie Des Jeux Vidu00e9o

Recommend Documents