Rapport de projet : jeu de serpent en JAVA

1. Rapport de projet
LE JEU DE
SERPENT
Réalisé par :
AIT TALGHALIT Hicham
IRIFI Faiçal
ZAKI Simohamed
Encadré par :
GHENNOU Mohamed
1

2. Remerciements
Nous tenons tout particulièrement à remercier M. Mohamed
GHENNOU, notre encadreur, qui nous a aidé à comprendre le cours
de java en fournissant beaucoup d'efforts.
Merci également à l’ensemble du corps enseignant pour
l’encadrement des projets de troisième année, qui nous permet de
découvrir la gestion de projets, le travail en groupe et les moyens de
communications mis en œuvre.
Et enfin nous adressons nos remerciements et notre respect à
nos parents qui sont la cause que nous soyons ici.
2

3. Sommaire
Introduction
1- Le jeu de serpent
2- La stratégie à suivre
3- Les classes du jeu
Conclusion
3

4. Introduction
Swing permet de concevoir des interfaces graphiques en Java.
C'est une librairie fournie avec la JDK (Java Developpement Kit).
Mais Swing n'est pas la première librairie graphique à proposer
des composants. En fait c'est la deuxième bibliothèque de classes, après
AWT, qui permet de créer une Interface Utilisateur et de la gérer. La
procédure de construction d’une interface Swing est similaire à celle
d’AWT : créer un cadre, des composants dans un cadre, une mise en
page pour ces composants dans ce cadre, des méthodes en réponse aux
actions de l’utilisateur.
On peut donc considérer que Swing est une évolution d'AWT,
une des principales différentes est que les noms des composants de
Swing commencent par un J.
Alors pour bien exploiter les composants swing nous avons créer
un jeu de serpent afin de montrer comment charger des images et
travailler avec le Timer, et pour bien exploiter les composants AWT
nous avons utilisé des évènements, des couleurs et Font ...etc.
4

5. 1- Le jeu de serpent
Jeu de serpent est un jeu vidéo plus ancienne
classique. Il a été créé en fin des années 70.
Plus tard, il a été porté à PC. Dans ce jeu, le
joueur contrôle un serpent. L'objectif est de
manger autant de pommes que possible.
Chaque fois que le serpent mange une pomme,
son corps se développe. Le serpent doit éviter les
murs et son propre corps. Ce jeu est parfois
appelé Snake ou Nibbles.
5

6. 2- La stratégie à suivre
La taille de chacune des articulations
d'un serpent est 10px. Le serpent est
contrôlé par les touches de curseur.
Initialement, le serpent a trois
articulations. Le jeu est lancé en
appuyant sur une des touches de curseur.
Si le jeu est fini, nous affichons Game
Over message dans le milieu de la
Commission.
6

7. 3- Les classes de jeu
Board.java
package chamhi;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import javax.swing.ImageIcon;
import javax.swing.JPanel;
import javax.swing.Timer;
public class Board extends JPanel implements ActionListener {
private final int WIDTH = 300;
private final int HEIGHT = 300;
private final int DOT_SIZE = 10;
private final int ALL_DOTS = 900;
private final int RAND_POS = 29;
private final int DELAY = 140;
private int x[] = new int[ALL_DOTS];
private int y[] = new int[ALL_DOTS];
private int dots;
private int apple_x;
private int apple_y;
private boolean left = false;
private boolean right = true;
private boolean up = false;
private boolean down = false;
private boolean inGame = true;
private Timer timer;
private Image ball;
private Image apple;
private Image head;
public Board() {
addKeyListener(new TAdapter());
setBackground(Color.black);
7

8. ImageIcon iib = new
ImageIcon(this.getClass().getResource("dot.png"));
ball = iib.getImage();
ImageIcon iia = new
ImageIcon(this.getClass().getResource("apple.png"));
apple = iia.getImage();
ImageIcon iih = new
ImageIcon(this.getClass().getResource("head.png"));
head = iih.getImage();
setFocusable(true);
initGame();
}
public void initGame() {
dots = 3;
for (int z = 0; z < dots; z++) {
x[z] = 50 - z*10;
y[z] = 50;
}
locateApple();
timer = new Timer(DELAY, this);
timer.start();
}
public void paint(Graphics g) {
super.paint(g);
if (inGame) {
g.drawImage(apple, apple_x, apple_y, this);
for (int z = 0; z < dots; z++) {
if (z == 0)
g.drawImage(head, x[z], y[z], this);
else
g.drawImage(ball, x[z], y[z], this);
}
Toolkit.getDefaultToolkit().sync();
g.dispose();
} else {
gameOver(g);
}
}
public void gameOver(Graphics g) {
String msg = "Game Over";
Font small = new Font("Helvetica", Font.BOLD, 14);
FontMetrics metr = this.getFontMetrics(small);
g.setColor(Color.white);
g.setFont(small);
8

9. g.drawString(msg, (WIDTH - metr.stringWidth(msg)) / 2,
HEIGHT / 2);
}
public void checkApple() {
if ((x[0] == apple_x) && (y[0] == apple_y)) {
dots++;
locateApple();
}
}
public void move() {
for (int z = dots; z > 0; z--) {
x[z] = x[(z - 1)];
y[z] = y[(z - 1)];
}
if (left)
x[0] -= DOT_SIZE;
if (right)
x[0] += DOT_SIZE;
if (up)
y[0] -= DOT_SIZE;
if (down)
y[0] += DOT_SIZE;
}
public void checkCollision() {
for (int z = dots; z > 0; z--)
if ((z > 4) && (x[0] == x[z]) && (y[0] == y[z]))
inGame = false;
if (y[0] > HEIGHT)
inGame = false;
if (y[0] < 0)
nGame = false;
if (x[0] > WIDTH)
inGame = false;
if (x[0] < 0)
inGame = false;
}
public void locateApple() {
int r = (int) (Math.random() * RAND_POS);
apple_x = ((r * DOT_SIZE));
r = (int) (Math.random() * RAND_POS);
apple_y = ((r * DOT_SIZE));
}
9

10. public void actionPerformed(ActionEvent e) {
if (inGame) {
checkApple();
checkCollision();
move();
}
repaint();
}
private class TAdapter extends KeyAdapter {
public void keyPressed(KeyEvent e) {
int key = e.getKeyCode();
if ((key == KeyEvent.VK_LEFT) && (!right)) {
left = true;
up = false;
down = false;
}
if ((key == KeyEvent.VK_RIGHT) && (!left)) {
right = true;
up = false;
down = false;
}
if ((key == KeyEvent.VK_UP) && (!down)) {
up = true;
right = false;
left = false;
}
if ((key == KeyEvent.VK_DOWN) && (!up)) {
down = true;
right = false;
left = false;
}
}
}
}
10

11. Nous allons d'abord définir les constantes utilisées dans notre jeu.
private final int WIDTH = 300;
private final int HEIGHT = 300;
private final int DOT_SIZE = 10;
private final int ALL_DOTS = 900;
private final int RAND_POS = 29;
private final int DELAY = 140;
Les constantes de WIDTH et HEIGHT déterminer la taille du
conseil d'administration. Le DOT_SIZE est la taille de la pomme et le
point du serpent. Le ALL_DOTS constante définit le nombre maximal
de points possibles au sein du Conseil. (900 = 300 * 300/10 * 10) Le
RAND_POS constante est utilisée pour calculer une position
aléatoire d'une pomme. Le retard constant détermine la vitesse du jeu.
private int x[] = new int[ALL_DOTS];
private int y[] = new int[ALL_DOTS];
Ces deux tableaux stocker les coordonnées x, y de toutes les
articulations d'un serpent.
Dans la méthode move () nous avons l'algorithme à clé de la partie. Pour le
comprendre, regardez comment le serpent est en mouvement. Vous contrôlez
la tête du serpent. Vous pouvez changer sa direction avec les touches de
curseur. Le reste des articulations se déplacer d'une position dans la chaîne.
La deuxième articulation se déplace là où la première a été, la troisième
articulation où le deuxième a été etc.
for (int z = dots; z > 0; z--) {
x[z] = x[(z - 1)];
y[z] = y[(z - 1)];
}
11

12. Ce code déplace les articulations de la chaîne.
if (left)
x[0] -= DOT_SIZE;
Déplacer la tête vers la gauche.
Dans le checkCollision () la méthode, nous déterminons si le serpent s'est
frappé ou l'un des murs.
for (int z = dots; z > 0; z--)
if ((z > 4) && (x[0] == x[z]) && (y[0] == y[z]))
inGame = false;
Terminez le jeu, si le serpent frappe une de ses articulations avec la tête.
if (y[0] > HEIGHT)
nGame = false;
Terminez le jeu, si les coups de serpent au bas de la Commission .
12

13. Snake.java
package chamhi;
import javax.swing.JFrame;
public class Snake extends JFrame {
public Snake() {
add(new Board());
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(320, 340);
setLocationRelativeTo(null);
setTitle("Snake Game V1.0");
setResizable(false);
setVisible(true);
}
public static void main(String[] args) {
new Snake();
}
}
C'est la class main.
13

14. Conclusion
Et voilà maintenant vous avez un petit jeu,
vraiment c’est un jeu très simple et un peu
compliqué si on le fait avec ses vraies conditions.
Parmi les problèmes qui nous avons
découvert, c'est d'avoir une arrière plan mobile
avec des bulles colorées qui apparaissent au
hasard et disparaissent à l'écran.
14