code : séance 4
- Voici la quatrième étape de notre codage. L'objectif de cette étape sera de :
- Faire apparaître un/des niveau(x). ( deuxième partie la plus compliquée du codage de notre jeux)
- Affiner la précision de la zone de collision.
- Faire apparaître le chronomètre.
- Mettre un mode 'souris' et un mode 'clavier' afin de se déplacer et de tirer.
- Gérer l'activité du programme lorsque l'on perd ou lorsque l'on gagne, ainsi qu'afficher une message dans ces deux cas.
CODE:
import ddf.minim.*; // importation de la bibliothèque audio
import ddf.minim.analysis.*;
import ddf.minim.effects.*;
import ddf.minim.signals.*;
import ddf.minim.spi.*;
import ddf.minim.ugens.*;
Minim minim;
AudioPlayer SI; // son en arrière plan
AudioPlayer Tir;
AudioPlayer Hit; // son lors de la collision
PImage espace; //image du fond d'ecran
PImage vaisseau; //image du tireur
PImage invaders; //image des cibles
int monTableauX [] = new int [60]; // déclaration d'un tableau contenant 60 valeurs de x
int [] monTableauY = new int [60]; //déclaration d'un tableau contenant 60 valeurs de y
int [] monTableauR = new int [60]; //déclaration d'un tableau contenant 60 valeurs de r
int [] monTableauVitesse = new int [60]; //déclaration d'un tableau contenant 60 valeurs de v
int x = 370; //position initiale en x du tireur
int y = 530; //position initiale en y du tireur
int z = 20; //nombre de balles
int low = 0; // position la plus basse ( en y )
int compteur = 0; // compteur de cibles détruites
int Total = 0; // score total initialisé à 0
int Niveaux = 1;
int s = 0 ; // déclaration d'une variable nommée s (seconde)
//int m = 0 ; // déclaration d'une variable nommée m (minute)
boolean tir = false;
void setup() {
size(800, 600); //taille de la fenêtre
frameRate(20); // nombre d'execution du draw par seconde
textSize(20); // taille du texte
vaisseau = loadImage("vaisseau.png");
espace = loadImage("espace.jpg");
invaders = loadImage("invaders.png");
minim = new Minim(this);
SI = minim.loadFile("SI.mp3");
Tir = minim.loadFile("Tir.mp3");
Hit = minim.loadFile("Hit.mp3");
for (int i=0; i
{
monTableauY[i] = (int)random(20, 300);
monTableauR[i] = (int)random(15, 20);
monTableauVitesse[i] = (int)random(1, 10);
}
}
void draw() {
image(espace, 0, 0, width, height);
dessinerTireur();
deplacerTireur();
dessinerCibles();
deplacerCibles();
dessinerTir();
detruireCibles();
afficherScore();
afficherNiveaux();
niveaux();
modeSouris();
modeClavier();
menu();
chronometre();
SI.play();
win();
gameOver();
}
void keyPressed() {
if (keyCode == LEFT) {
x=x-10;
} else {
if (keyCode == RIGHT) {
x=x+10;
} else {
if (key == ' ' ) {
tir = true;
//Tir.play();
//Tir.rewind();
println("true");
}
}
}
}
void keyReleased() {
if ( key == ' ') {
tir = false;
println("false");
}
}
void dessinerTireur() {
image(vaisseau, x, y, 70, 70);
}
void deplacerTireur() {
if ( x > 730) {
x = 730;
}
if ( x < 10) {
x = 25;
}
}
void dessinerCibles() {
for (int i=0; i
{
fill(#FFFCFC);
image(invaders, monTableauX[i], monTableauY[i], monTableauR[i], monTableauR[i]);
}
}
void deplacerCibles() {
for (int i=0; i
{
monTableauX[i] = monTableauX[i]+ monTableauVitesse[i];
if (monTableauX[i] > 780 ) {
monTableauVitesse[i] = - monTableauVitesse[i];
monTableauY[i] = monTableauY[i] +30;
}
if (monTableauX[i] < 1) {
monTableauVitesse[i] = - monTableauVitesse[i];
monTableauY[i] = monTableauY[i] +30;
}
}
}
void dessinerTir() {
if (tir ==true) {
rect(x+33, low, 2, 532);
}
}
void detruireCibles() {
low = 0;
for (int i=0; i
{
if (tir==true) {
if (monTableauX[i]
monTableauX[i] = -60;
compteur = compteur + 1;
Total = Total + 1;
println(z);
if ( monTableauY[i] > low) {
low = monTableauY[i];
}
Hit.play();
Hit.rewind();
}
}
}
}
void afficherScore() {
text("SCORE PAR NIVEAU:" +compteur, 570, 575, 400, 200);
text("Score Total:" +Total, 5, 575, 200, 100);
fill(#FFFFFF);
text("Space Invaders", 5, 5, 200, 100);
}
void afficherNiveaux() {
text("Niveau:" +Niveaux, 350, 5, 200, 200);
}
void niveaux() {
if (compteur == 20) {
compteur = 0;
Niveaux= 2;
z = 40;
println(z);
for (int i=0; i
{
monTableauY[i] = (int)random(20, 300);
monTableauR[i] = 20;
monTableauVitesse[i] = (int)random(5, 12);
dessinerCibles();
deplacerCibles();
}
}
}
void modeSouris() {
if (key == 's') {
x = mouseX;
if ( mousePressed ) {
tir = true;
} else {
tir = false;
}
}
}
void modeClavier() {
if (key == 'c') {
keyPressed();
keyReleased();
}
}
void menu ()
{
rect ( 700, 5, 90, 20);
fill (#0004BF);
text ("quitter", 710, 22);
if (mousePressed)
{
if (mouseX > 700 && mouseX < 790)
{
if (mouseY > 5 && mouseY < 25)
{
exit(); //ferme le programme
}
}
}
}
void chronometre() {
s = millis()/1000;
fill(#FFFFFF);
text("Temps:"+s, 530, 5, 200, 100);
}
void win() {
if ( Total == 40) {
fill(#F53B0C);
text("CONGRATULATIONS YOU WIN", 260, 270, 400, 200);
tir = false;
}
}
void gameOver() {
for (int i=0; i
{
if (s >= 90 ) { // supérieur ou égal = 1,30min
fill(#0C5BF5);
text("GAME OVER EARTH WAS INVADED!!", 260, 270, 400, 200);
tir = false;
monTableauVitesse[i] = monTableauVitesse[i] - monTableauVitesse[i];
println(monTableauVitesse[i]);
}
}
}
void stop() {
//Tir.close();
minim.stop();
super.stop();
}
- Nous nous sommes attaqué à la deuxième partie la plus compliquée du codage de notre jeux : faire apparaître un/des niveau(x). C'est-à- dire, lorsque toutes les cibles initialisées en début de partie ( niveau 1 ) sont détruites alors nous passons au niveau 2, des nouvelles cibles arrivent, elles se déplacent plus rapidement et ont un diamètre plus grand. Nous avons fait apparaître deux niveaux . Ce fut assez problématique car il a fallu, en amont, réfléchir à comment effectuer ceci. Ainsi, nous avons commencé par déclarer une variable entière nommée « Niveaux » et nous lui avons affecté la valeur 1. Ensuite, il a fallu réfléchir à la structure générale du code qui vas nous permettre de changer de niveau. Nous avons alors dans un « void niveaux » utilisé une structure condtionnelle la condition étant d'éliminer le nombre de cibles initialisées au niveau 1 soit 20. Donc une fois que la variable « compteur » a pour valeur 20, alors on affecte a cette variable la valeur 0, on affecte a la variable « Niveaux » la valeur 2 ( pour montrer que l'on passe au niveau 2 ) et on affecte a la variable « z » le nombre 40 ( 20 cibles supplémentaires apparaitront au niveau 2, et enfin nous utilison une boucle « for » pour faire réapparaitre les cibles, nous réappellons nos tableaux d'entiers et nos fonctions « dessinercibles » et « deplacercibles ». On affecte à notre tableau « monTableauR [i] » la valeur 20 (des cibles de plus grand diamètre apparaitront ) .
---> Travail effectué par Christopher.
-
Une des parties compliquées fut aussi de reduire la zone de collision au maximum pour rendre le tir le plus précis possible, en essayant de réduire l'intervalle de destruction et ainsi procéder à de nombreux tests . Cependant nous nous sommes heurté à certains soucis : en réduisant trop la zone de collision lorsque les cibles vont à une vitesse trop importante ou ont un diamètre trop grand alors elles traversent cette zone et ne sont pas détruites. Nous avons alors du trouvé un bon intervalle afin de rendre un tir précis et donc un jeu plaisant et fluide.
---> Travail effectué par Nicolas.
-
Pour afficher le temps écoulé nous avons pensé à faire apparaître un chronomètre. Pour cela, grâce à l'aide de Processing nous sommes appercu que nous pouvons utiliser les fonctions "millis()" "second()" et eventuellement "minute()". La fonction "millis()" fait apparâitre les millisecondes passées depuis l'ouverture de la fenêtre. Ainsi, pour faire apparaître des secondes, il faudra diviser ce résultat par 1000. Donc, premièrement nous avons déclaré une variable entière nommée « s » et nous lui avons affecté la valeur 0. Ensuite dans notre « void chronomètre » nous avons affecté à cette variable : « millis()/1000 ». C'est-à-dire que la variable prendra comme valeur les millis-secondes passées depuis l'ouverture du programme que l'on divise par 1000 pour afficher des secondes. Ainsi, il nous reste plus qu'a afficher cette variable avec la méthode « text » avec la méthode « +s » ainsi que les coordonnées et la taille voulu pour afficher le chronomètre où l'on souhaite dans la fenêtre.
- Nous avons fait face à des difficultés pour faire apparaître le chronomètre. Au début, nous avons seulement utilisé la fonction « second() » qui affichait seulement les seconde actuelles de l'horloge de l'ordinateur et donc pas les secondes écoulées depuis l'ouverture du programme. Nous avons essayer de réinitialiser cette variable à 0 lorsque le programme s'ouvre mais en vint. Donc, grâce à l'aide de processing nous avons trouvé la fonction « millis() », cependant un problème persiste, lorsque les secondes arrivent à 60, elles ne se réinitialisent pas à 0 mais elles continuent. Il faudra donc trouver une solution pour cela. Il n'y a aucune gêne pour jouer car nous avons su adapté cette difficultée au jeu.
▬►Travail commencé par Nicolas et Christopher l'a ensuite aidé à terminer.
-
- Nous avons décider d'instaurer des règles de jeu .C'est-à-dire la possibilité de gagner (win) ou de perdre (Game Over). Pour gagner il faut réussir les deux niveaux en moins de 1,30 minute soit détruire les 40 cibles. Nous faisons alors apparaître un texte « CONGRATULATIONS YOU WIN ». Dans le cas inverse, si l'on dépasse le temps imparti alors on a perdu et s'affiche « GAME OVER EARTH WAS INVADED ».
- Pour cela, dans un « void win » nous avons mis une structure conditionnelle « if » avec pour condition « Total == 40 » c'est-à-dire, si la variable « Total » a comme valeur 40 soit le nombre de cibles alors on fait apparaître un texte. Pour cela, dans l'instruction on utilise la méthode « text » avec des coordonnées et des tailles choisie.
- Dans le cas contraire, dans un « void gameOver », nous avons mis une structure conditionnelle « if » avec pour condition « if (s >= 90 ) » c'est-à-dire si la variable « s » est supérieurs ou égale à 90 secondes soit 1,30 minutes alors deux instruction son ordonnées :
- le message avec la méthode « text » suivie de ses pamètres choisis.
- On stoppe le déplacement des cibles en annulant la variable qui s'occupe de la vitesse de déplacement des cibles. On s'assure que la vitesse de déplacement des cibles est nulle en utilisant la méthode « println » qui afficher la valeur d'une variable sur la console. Elle n'est visible que du programmeur.
---> Travail effectué par Nicolas.
-
Enfin, nous avons décidé de proposer deux modes de jeux afin de rendre le jeux le plus attractif et complet possible. Un mode « souris » et un mode « clavier » sera alors a disposition du joueur.
Nous avons séparé le mode souris et le mode clavier dans deux fonctions différentes. Premièrement, dans un « void modeSouris », nous avons utilisé une structure conditionnelle « if » et la fonction prédéfinie dans processing « key » . Ainsi, lorsque l'on appuie sur la touche « s » (minuscule ou majuscule ) alors la variable « x » qui s'occupe de l'abscisse du joueur dépendra de la position de lz souris, grâce à la fonction prédéfinie dans processing « mouseX » qui récupère la positon en X de la souris. On peux alors déplacer le joueur avec la souris. Afin de pouvoir tirer, dans une structure conditionnelle « if » si l'on clique avec la souris alors la variable booléen « tir » est vraie et le tir apparaît, sinon la variable booléen est fausse et le tir disparaît (lorsque l'on ne clique plus ). Processing est capable de reconnaître lorsque l'on clique avec la souris grâce à la fonction « mousePressed » elle aussi prédéfinie dans processing. Ensuite, pour repasser au mode clavier, il suffit de cliquer sur la touche 'c' (minuscle ou majuscule une fois encore) en utilisant la même procedure que pour la touche 's'. Ainsi, si la condition est validée alors on rappelle nos deux fonctions de départ « keyPressed » et « keyReleased » afin de réutiliser normalement le clavier.
- Nous avons décider de reconnaître les touches en majuscules et minuscule afin de rendre notre jeux le moins contraignant et le plus fonctionnel possible.
---> Travail effectué par Christopher
- Le but de la prochaine séance sera de :
- Faire apparaître les boutons "quitter" et "info".
- Faire apparaître le fenêtre "info".
- Faire apparaître le nombre de tirs effectués dans l'affichage final.
- Faire apparaître le nombre de cibles tuées dans l'affichage final.