Bonjour à tous,

Alors voilà, je développe depuis quelque temps déjà une petite application android qui se résume à un jeu dans le cadre de ma spécialité au lycée. Il consiste a ammené une petite boule d'un point de départ à un point d'arrivé sans tomber dans des trous générés aléatoirement.

Pour développer ce programme, j'utilise principalement processing et également l'application APDE directement sur téléphone, qui me permet de compiler et de tester l'appli directement.

Le fonctionnement, il est simple, pour se déplacer, il ne suffit que de tourner son téléphone de droite à gauche et d'avant en arrière. J'utilise donc les capteurs de mon téléphone.

Mais malgré ça, j'ai un gros soucis que je ne suis pas capable de résoudre. Je vous montre le code et j'explique ensuite.

/*-----------------------------------------LIBRAIRIE--------------------------------------------------*/
import ketai.sensors.*;
KetaiSensor sensor;

/*-----------------------------------------INITIALISATION VARIABLES--------------------------------------------------*/
int colonnes = 10;
int lignes= 10;
int[][] plateau; // tableau 2D
int posX_tabl;
int posY_tabl;

/*----------------------------------------VARIABLES POUR CAPTEURS----------------------------------------------------*/
float accelerometerX, accelerometerY, accelerometerZ;
float xx=width/2;
float yy=height-(height/10);
float vxx=0;
float vyy=0;
float axx=0;
float ayy=0;

/*---------------------------------------VARIABLES MENUS-----------------------------------------------*/
boolean jouer =false;
boolean menu = true;
boolean reco = false;
boolean option = false;
boolean mouseReleased;


/*-----------------------------------------SETUP--------------------------------------------------*/
void setup() {
  smooth();
  sensor = new KetaiSensor(this);
  sensor.start();
  orientation(LANDSCAPE);
  plateau = new int[colonnes][lignes];
  creer_plateau();
}

/*-----------------------------------------DRAW--------------------------------------------------*/
void draw() {
  //Création du menu principal
  if (menu == true) {
    creer_plateau();
    menu();
  }
  //Création du jeu
  else if (jouer==true) {
    nettoyer();
    bouger_boule();
    dessine_plateau();
    calcul_gravite();
    ellipse( xx+width/11, - yy+height-25, 40, 40);
    calculer_position();
    definir_balle();
  //Création des menus recommencer et option
  } else if (reco==true) {
    reco();
  } else if (option == true) {
    background(0);
    option();
  }
  mouseReleased = false;
}


//Fonction permettant l'activation du clic lorsque celui ci est relaché.
void mousePressed() {
  mouseReleased = false;
}
void mouseReleased() {
  mouseReleased = true;
}

/*-----------------------------------------NETTOYER--------------------------------------------------*/
void nettoyer() {
  background(0, 0, 0, 250);
}

/*-----------------------------------------INITIALLISATION TABLEAU--------------------------------------------------*/
//Création des valeurs de chaque case du tableau (elles sont générées aléatoirement sauf pour les cases départs et arrivées)
void creer_plateau() {
  int aleacouleur;
  for (int i=0; i < colonnes; i++) {
    for (int j=0; j < lignes; j++) {
      aleacouleur = (int)(random(0, 3));
      if (aleacouleur == 0) {
        plateau[i][j]=0;
      } else {
        plateau[i][j]=1;
      }
    }
    plateau[0][9] = 2;
    plateau[9][0] = 3;
  }
}

/*-----------------------------------------DESSINER TABLEAU--------------------------------------------------*/
//On dessine le tableau sur l'écran à l'aide des valeurs données ci_dessus
void dessine_plateau() {
  float largeurColonne = width/colonnes;
  float hateurRangee = height/lignes;
  for (int i=0; i < colonnes; i++) {
    for (int j=0; j < lignes; j++) {
      if (plateau[i][j] == 0) {
        fill(0);
      }
      if (plateau[i][j] == 1) {
        fill(255);
      }
      if (plateau[i][j]==2) {
        fill(255, 255, 0);
      }
      if (plateau[i][j]==3) {
        fill(0, 255, 0);
      }
      float x = i*largeurColonne;
      float y = j*hateurRangee;
      rect( x+1, y+1, largeurColonne-2, hateurRangee-2 );
    }
  }
}

/*-----------------------------------------CHECK POSITION BALLE--------------------------------------------------*/
//On regarde ou ce situe la balle dans le tableau
void calculer_position() {
  for ( int j=0; j< 10; j++) {
    for (int i=0; i<10; i++) {
      if ( xx+width/11> i*40 && xx+width/11< i*40+40 && - yy+height-25 > j*40 && - yy+height-25 < j*40+40) {
        posX_tabl = i;
        posY_tabl = j;
      }

    }
    //if ( xx+width/2> i*40 &&  xx+width/2 < i*40+40 && - yy+height/2 > j*40 && - yy+height/2 < j*40+40)
  }
}

/*----------------------------------------CALCUL GRAVITE-------------------------------------------------*/
void calcul_gravite() {
  vxx=vxx+axx;
  vyy=vyy+ayy;
  xx=xx+vxx*0.1;
  yy=yy+vyy*0.1;
  fill(0, 250, 0);
  text(vxx, 100, 100);
  if (xx+width/11 >= width || xx+width/11 <= 0) {
    vxx=-0.8*vxx;
  }
  if (-yy+height-25 >= height || -yy+height-25 <= 0) {
    vyy=-0.8*vyy;
  }
}

/*-----------------------------------------DEF BALLE--------------------------------------------------*/
//Là est le problème, j'explique le tout sur hors du code
void definir_balle() {
 if (plateau[posX_tabl][posY_tabl]==0)
 {
 print("game over \n");
 text("loose",50,50);
 jouer=false;
 reco=true;
 menu=false;
 }     else if  (plateau[posX_tabl][posY_tabl]==1){
 //print("courage \n");

 }
 else if (plateau[posX_tabl][posY_tabl]==3){
 //print("gg wp \n");
 }
 
 }

/*-----------------------------------------INIT VAR CAPTEUR--------------------------------------------------*/
//Initialisation du capteur
void onAccelerometerEvent(float x, float y, float z)
{
  axx = y*0.03;
  ayy = z*0.03;
}
/*----------------------------------------CREATION DES DIFFERENTS MENUS---------------------------------------*/
void reco() {
  background(6, 56, 177);
  fill(0, 230, 200);
  rect(width/3, height/6, 200, 80);
  rect(width/3, height/1.5, 200, 80);

  fill(255);
  if (width/3<= mouseX && mouseX <= width/1.36 && height/6 <= mouseY && mouseY <=height/2.3) {
    rect(width/3, height/6, 200, 80);
  } else if (width/3<= mouseX && mouseX <=width/1.36 && height/1.5 <= mouseY && mouseY <= height/1.07) {
    rect(width/3, height/1.5, 200, 80);
  }
  fill(0);
  textSize(32);
  text("TryAgain", width/2.5, height/3);
  text("Menu OKLM", width/2.9, height/1.2);

  if (mouseReleased==true && width/3<= mouseX && mouseX <= width/1.36 && height/6 <= mouseY && mouseY <=height/2.3) {
    reco = false;
    jouer = true;
  }

  if (mouseReleased==true && width/3<= mouseX && mouseX <=width/1.36 && height/1.5 <= mouseY && mouseY <= height/1.07) {
    reco = false;
    menu = true;
  }
}

void menu() {
  background(6, 56, 177);
  fill(0, 230, 200);
  rect(width/3, height/6, 200, 80);
  rect(width/3, height/1.5, 200, 80);

  fill(255);
  if (width/3<= mouseX && mouseX <= width/1.36 && height/6 <= mouseY && mouseY <=height/2.3) {
    rect(width/3, height/6, 200, 80);
  } else if (width/3<= mouseX && mouseX <=width/1.36 && height/1.5 <= mouseY && mouseY <= height/1.07) {
    rect(width/3, height/1.5, 200, 80);
  }
  fill(0);
  textSize(48);
  text("Jouer", width/2.5, height/3);
  text("Options", width/2.8, height/1.2);

  if (mouseReleased==true && width/3<= mouseX && mouseX <= width/1.36 && height/6 <= mouseY && mouseY <=height/2.3) {
    menu = false;
    jouer = true;
  }
  if (menu==true) {
    if (mouseReleased==true && width/3<= mouseX && mouseX <=width/1.36 && height/1.5 <= mouseY && mouseY <= height/1.07) {
      menu = false;
      option = true;
    }
  }
}
void option() {
  fill(255, 255, 0);
  text("ERREUR 404 \n", width/4, height/2.5);
  text("Travail non trouvé", width/10, height/1.5);
  if (mouseReleased==true) {
    menu=true;
    option=false;
  }
}
void victory() {
  reco();
  textSize(19);
  text("bravo vous avez gagné", width/10, height/3) ;
}

Alors voilà, lorsque ma boule rentre dans une case noire, on est censé avoir perdu la partie. Cependant j'utilise un tableau qui est initialisé de deux façons: -Aléatoirement pour les cases blanches et noires.

                          -Manuellement pour les cases de départs et d'arrivées.

/*-----------------------------------------INITIALLISATION TABLEAU--------------------------------------------------*/
//Création des valeurs de chaque case du tableau (elles sont générées aléatoirement sauf pour les cases départs et arrivées)
void creer_plateau() {
  int aleacouleur;
  for (int i=0; i < colonnes; i++) {
    for (int j=0; j < lignes; j++) {
      aleacouleur = (int)(random(0, 3));
      if (aleacouleur == 0) {
        plateau[i][j]=0;
      } else {
        plateau[i][j]=1;
      }
    }
    plateau[0][9] = 2;
    plateau[9][0] = 3;
  }
}

A l'aide des valeurs initialisé juste au dessus, je dessine alors le tableau:

/*-----------------------------------------DESSINER TABLEAU--------------------------------------------------*/
//On dessine le tableau sur l'écran à l'aide des valeurs données ci_dessus
void dessine_plateau() {
  float largeurColonne = width/colonnes;
  float hateurRangee = height/lignes;
  for (int i=0; i < colonnes; i++) {
    for (int j=0; j < lignes; j++) {
      if (plateau[i][j] == 0) {
        fill(0);
      } 
      if (plateau[i][j] == 1) {
        fill(255);
      }
      if (plateau[i][j]==2) {
        fill(255, 255, 0);
      }
      if (plateau[i][j]==3) {
        fill(0, 255, 0);
      }
      float x = i*largeurColonne;
      float y = j*hateurRangee;
      rect( x+1, y+1, largeurColonne-2, hateurRangee-2 );
    }
  }
}

Il me faut alors définir ce que fait chaque case, et c'est là où je bloque, je ne vois pas comment je peux définir l'action de ces cases lorsque la balle passe dessus.

J'avais essayé de le faire avec les coordonnées mais c'est tout bonnement impossible étant donné que le niveau est généré aléatoirement.

Bref, je suis bien coincé et je post mon problème ici, si quelqu'un sait comment il pourrait le résoudre, je lui serais très reconaissant !

Bonne soirée à tous !

Bonjour, 

Si j'ai bien compris, à tout moment : si la balle se trouve sur une case noire , le jeu se termine.

Pour cela il suffit de rajouter un test dans la fonction calculer_position() :

void calculer_position() {
  for ( int j=0; j< 10; j++) {
    for (int i=0; i<10; i++) {
      if ( xx+width/11> i*40 && xx+width/11< i*40+40 && - yy+height-25 > j*40 && - yy+height-25 < j*40+40) {
        posX_tabl = i;
        posY_tabl = j;
        if( plateau[posX_tabl][posY_tabl] == 0 )
        {
                // code si PERDU !
        }
      }
 
    }
  }
}

J’espère avoir répondu à ta question !