Annonce

>>> Bienvenue sur codelab! >>> Première visite ? >>> quelques mots sur codelab //// une carte des membres//// (apéros) codelab


Pages: 1

 

#1 2016-05-14 19:05:26 reset mon tableau deux dimensions ou reset mon programme

lenzone
nouveau membre
Date d'inscription: 2016-04-21
Messages: 6

reset mon tableau deux dimensions ou reset mon programme



bonjour/bonsoir, j'avais déjà fait un topic pour que l'on m'aide pour faire les murs de mon jeu PacMan, mais aujourd'hui j'ai un nouveau problème.
Alors voilà, mon jeu est fait à partir d'un tableau à deux dimensions, il y a 4 cases différentes.

-La premiere(case 0) sont des murs que pacman et les fantômes ne peuvent pas traverser.
-La deuxieme(case1) sont des cases noires, toutes simples que tout le monde peut traverser.
-La troisieme(case2) sont des cases comme les cases 2, mis à part qu'elles ont un point beige au centre.
-Et la quatrieme(case3) est une case que seuls les fantômes peuvent traverser.

Ensuite, à chaque fois que Pacman passe sur une case 2, elle se transforme en case 1.
j'ai aussi rajouter un système qui permet des compter le nombre de case 2 qu'il reste. Et quand le compteur arrive à 0 (qu'il n'y a plus de case 2) alors un écran s'affiche avec marqué "you win" et un peut plus bas, il y a écrit "restart". mon problème est le suivant, j'aimerai que lorsque l'on clique sur le "restart", le tableau reparte de 0 (qu'il soit comme il était au début car pendant le jeu, les valeurs ont changées). Et je ne vois que deux solutions.

la première, est de mettre mon tableau dans le void setup(). Comme cela je pourrai le reset. Mais comme mon tableau est très grand, cela me prendrais des heures. C'est pour cela qu'il y a une deuxième solution.
Cette deuxième solution, est de relancer mon programme. J'ai donc voulu essayer avec la commande launch() mais je n'arrive pas à l'utiliser et je ne suis même pas sur que cela soit la bonne solutions.

Donc si quelqu'un aurait la réponse elle me serait très utile merci d'avance big_smile

ps: vous pouvez télécharger mon programme juste en dessous pour vous rendre mieux compte de mon problème.

Dernière modification par lenzone (2016-05-14 19:06:35)

Hors ligne

 

#2 2016-05-15 19:06:37 Re : reset mon tableau deux dimensions ou reset mon programme

hekmil
membre
Date d'inscription: 2016-05-15
Messages: 17

Re: reset mon tableau deux dimensions ou reset mon programme



Je peux te passer un pac man terminé sur processing si tu veux mais à part ça je ne sais pas ^^

Hors ligne

 

#3 2016-05-16 13:37:27 Re : reset mon tableau deux dimensions ou reset mon programme

Olivier
N°4
Lieu: Chalon sur la Saône
Date d'inscription: 2009-04-07
Messages: 1471
Site web

Re: reset mon tableau deux dimensions ou reset mon programme



citation :

la première, est de mettre mon tableau dans le void setup()

Le setup() n'est lu qu'une seule fois, au lancement du sketch. Donc ce n'est pas une idée pertinente.

citation :

Mais comme mon tableau est très grand, cela me prendrais des heures.

De ce que je peux voir, ton tableau contient 180 valeurs.
Quand tu auras a traiter avec des tableaux contenant des centaines de milliers de valeur, tu pourras éventuellement dire qu'il est grand, mais pas pas encore "très grands"... tongue

Concernant ton problème, je t'invite à essayer de créer une variable "terrainInitial" qui correspond à... et bien ton terrain initial... et a en copier les valeurs dans une autre variable "terrainPartieEnCours", par exemple...

Ainsi, pourras-tu à la la fin d'une partie, facilement retrouver l'état initiale en re plâtrant les les valeurs de l'une dans l'autre...

Attention, il te faudra utiliser fonction arrayCopy() pour cela, et non "terrainPartieEnCours = terrainInitial" sinon tu n'interviendras que sur des "pointeurs".

Bon courage.

L'Amour au Peuple !

Hors ligne

 

#4 2016-05-16 16:35:24 Re : reset mon tableau deux dimensions ou reset mon programme

lenzone
nouveau membre
Date d'inscription: 2016-04-21
Messages: 6

Re: reset mon tableau deux dimensions ou reset mon programme



hekmil a écrit:

Je peux te passer un pac man terminé sur processing si tu veux mais à part ça je ne sais pas ^^

c'est très gentil de ta part hekmil mais je préfère me casser la tête et essayer de faire mon pacman tout seul même si parfois j'ai besoin d'aide merci ^^

Et Olivier, ton aide m'a était très utile et ta solution marche très bien mais (parce qu’il y a toujours un mais:lol:), quand j’appuie sur restart, la fonction arrayCopy() marche mais seulement une fois hmm c'est comme si la fonction arrayCopy() ne s’exécutait que la première fois où j’appuie sur restart.

Pacman p;
Fantome[] f;
float nombreDeCase2 =180;
int caseX;
int caseY;
int[][] terrainInitial = {
  {0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0}, 
  {0, 2, 2, 2, 0, 1, 0, 2, 0, 1, 0, 2, 2, 2, 0}, 
  {0, 2, 0, 2, 0, 0, 0, 2, 0, 0, 0, 2, 0, 2, 0}, 
  {0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0}, 
  {0, 2, 0, 2, 0, 2, 0, 0, 0, 2, 0, 2, 0, 2, 0}, 
  {0, 2, 0, 2, 0, 2, 0, 0, 0, 2, 0, 2, 0, 2, 0}, 
  {0, 2, 0, 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 2, 0}, 
  {0, 2, 2, 2, 0, 0, 2, 2, 2, 0, 0, 2, 2, 2, 0}, 
  {0, 0, 0, 2, 0, 0, 2, 0, 2, 0, 0, 2, 0, 0, 0}, 
  {1, 1, 0, 2, 0, 0, 2, 0, 2, 0, 0, 2, 0, 1, 1}, 
  {0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0}, 
  {0, 2, 2, 2, 0, 2, 0, 0, 0, 2, 0, 2, 2, 2, 0}, 
  {0, 2, 0, 2, 0, 2, 0, 1, 0, 2, 0, 2, 0, 2, 0}, 
  {0, 2, 0, 2, 0, 2, 3, 1, 0, 2, 0, 2, 0, 2, 0}, 
  {0, 2, 0, 2, 0, 2, 0, 1, 0, 2, 0, 2, 0, 2, 0}, 
  {0, 2, 2, 2, 0, 2, 0, 0, 0, 2, 0, 2, 2, 2, 0}, 
  {0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0}, 
  {1, 1, 0, 2, 0, 0, 2, 0, 2, 0, 0, 2, 0, 1, 1}, 
  {0, 0, 0, 2, 0, 0, 2, 0, 2, 0, 0, 2, 0, 0, 0}, 
  {0, 2, 2, 2, 0, 0, 2, 2, 2, 0, 0, 2, 2, 2, 0}, 
  {0, 2, 0, 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 2, 0}, 
  {0, 2, 0, 2, 0, 2, 0, 0, 0, 2, 0, 2, 0, 2, 0}, 
  {0, 2, 0, 2, 0, 2, 0, 0, 0, 2, 0, 2, 0, 2, 0}, 
  {0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0}, 
  {0, 2, 0, 2, 0, 0, 0, 2, 0, 0, 0, 2, 0, 2, 0}, 
  {0, 2, 2, 2, 0, 1, 0, 2, 0, 1, 0, 2, 2, 2, 0}, 
  {0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0}, 
};
int[][] terrain = {
  {0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0}, 
  {0, 2, 2, 2, 0, 1, 0, 2, 0, 1, 0, 2, 2, 2, 0}, 
  {0, 2, 0, 2, 0, 0, 0, 2, 0, 0, 0, 2, 0, 2, 0}, 
  {0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0}, 
  {0, 2, 0, 2, 0, 2, 0, 0, 0, 2, 0, 2, 0, 2, 0}, 
  {0, 2, 0, 2, 0, 2, 0, 0, 0, 2, 0, 2, 0, 2, 0}, 
  {0, 2, 0, 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 2, 0}, 
  {0, 2, 2, 2, 0, 0, 2, 2, 2, 0, 0, 2, 2, 2, 0}, 
  {0, 0, 0, 2, 0, 0, 2, 0, 2, 0, 0, 2, 0, 0, 0}, 
  {1, 1, 0, 2, 0, 0, 2, 0, 2, 0, 0, 2, 0, 1, 1}, 
  {0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0}, 
  {0, 2, 2, 2, 0, 2, 0, 0, 0, 2, 0, 2, 2, 2, 0}, 
  {0, 2, 0, 2, 0, 2, 0, 1, 0, 2, 0, 2, 0, 2, 0}, 
  {0, 2, 0, 2, 0, 2, 3, 1, 0, 2, 0, 2, 0, 2, 0}, 
  {0, 2, 0, 2, 0, 2, 0, 1, 0, 2, 0, 2, 0, 2, 0}, 
  {0, 2, 2, 2, 0, 2, 0, 0, 0, 2, 0, 2, 2, 2, 0}, 
  {0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0}, 
  {1, 1, 0, 2, 0, 0, 2, 0, 2, 0, 0, 2, 0, 1, 1}, 
  {0, 0, 0, 2, 0, 0, 2, 0, 2, 0, 0, 2, 0, 0, 0}, 
  {0, 2, 2, 2, 0, 0, 2, 2, 2, 0, 0, 2, 2, 2, 0}, 
  {0, 2, 0, 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 2, 0}, 
  {0, 2, 0, 2, 0, 2, 0, 0, 0, 2, 0, 2, 0, 2, 0}, 
  {0, 2, 0, 2, 0, 2, 0, 0, 0, 2, 0, 2, 0, 2, 0}, 
  {0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0}, 
  {0, 2, 0, 2, 0, 0, 0, 2, 0, 0, 0, 2, 0, 2, 0}, 
  {0, 2, 2, 2, 0, 1, 0, 2, 0, 1, 0, 2, 2, 2, 0}, 
  {0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0}, 
};
int tailleCase;

void setup() {
  fullScreen();
  tailleCase = 50;
  p = new Pacman(1, 1, tailleCase);
  f = new Fantome[3];
  f[0] = new Fantome(12, 7, tailleCase, color(255, 0, 0));
  f[1] = new Fantome(13, 7, tailleCase, color(0, 255, 0));
  f[2] = new Fantome(14, 7, tailleCase, color(0, 0, 255));
}

void draw() {
  if(nombreDeCase2==0){
    fill(0);
    rect(0,0,width,height);
    fill(250);
    textSize(300);
    text("YOU WIN", 50,height/6*4-50);
    textSize(100);
    text("restart", width/4*3,height/4*3+50);
  if(mousePressed == true){
    if((width/4*3<=mouseX)&&(mouseX<=width/4*3+320)&&(height/4*3-50<=mouseY)&&(mouseY<=height/4*3+100)){
      arrayCopy(terrainInitial,terrain);
      nombreDeCase2 = 180;
      int caseX = 75;
      int caseY = 75;
      p.position.x=caseX;
      p.position.y=caseY;
      p.direction.set(0, 0);
      
 }}
  }else{
  background(0);
  for (int i = 0; i < terrain.length; i++) {
    for (int j = 0; j < terrain[i].length; j++) {
      pushMatrix();
      translate(i * tailleCase, j * tailleCase);
      switch (terrain[i][j]) {
      case 0:
        fill(#1811F7);
        stroke(#000000);
        strokeWeight(2.5);
        rect(0, 0, tailleCase, tailleCase);
        strokeWeight(1);
        break;
      case 2:
        fill(#FCD5A1);
        noStroke();
        ellipse(tailleCase / 2, tailleCase / 2, 8, 8);
        break;
      case 3:
        fill(255, 0, 0);
        stroke(#000000);
        strokeWeight(2.5);
        rect(0, 0, tailleCase, tailleCase);
        strokeWeight(1);
        break;
      }
      popMatrix();
    }
  }
  p.deplacement(terrain);
  p.affichage();
  for (int i = 0; i < f.length; i++) {
    f[i].deplacement(terrain);
    f[i].affichage();
  }  
}}

void keyPressed() {
  int caseX = tailleCase * (p.getX() / tailleCase) + tailleCase / 2;
  int caseY = tailleCase * (p.getY() / tailleCase) + tailleCase / 2;
  int intervalle = 10;
  if (keyCode == DOWN) {
    if ((p.getX() > caseX - intervalle) && (p.getX() < caseX + intervalle) && (terrain[p.getX() / tailleCase][p.getY() / tailleCase + 1] != 0) && (terrain[p.getX() / tailleCase][p.getY() / tailleCase + 1] != 3)) {
      p.position.x = caseX;
      p.direction.set(0, 1);
    if(terrain[caseX/tailleCase][caseY/tailleCase]==2){
      nombreDeCase2= nombreDeCase2-1;}
      terrain[caseX/tailleCase][caseY/tailleCase]=1;
    }
  }
  if (keyCode == UP) {
    if ((p.getX() > caseX - intervalle) && (p.getX() < caseX + intervalle) && (terrain[p.getX() / tailleCase][p.getY() / tailleCase - 1] != 0) && (terrain[p.getX() / tailleCase][p.getY() / tailleCase - 1] != 3)) {
      p.position.x = caseX;
      p.direction.set(0, -1);
    if(terrain[caseX/tailleCase][caseY/tailleCase]==2){
      nombreDeCase2= nombreDeCase2-1;}
      terrain[caseX/tailleCase][caseY/tailleCase]=1;
    }
  }
  if (keyCode == RIGHT) {
    if ((p.getY() > caseY - intervalle) && (p.getY() < caseY + intervalle) && (terrain[p.getX() / tailleCase + 1][p.getY() / tailleCase] != 0) && (terrain[p.getX() / tailleCase + 1][p.getY() / tailleCase] != 3)) {
      p.position.y = caseY;
      p.direction.set(1, 0);
    if(terrain[caseX/tailleCase][caseY/tailleCase]==2){
      nombreDeCase2= nombreDeCase2-1;}
      terrain[caseX/tailleCase][caseY/tailleCase]=1;
    }
  }
  if (keyCode == LEFT) {
    if ((p.getY() > caseY - intervalle) && (p.getY() < caseY + intervalle) && (terrain[p.getX() / tailleCase - 1][p.getY() / tailleCase] != 0) && (terrain[p.getX() / tailleCase - 1][p.getY() / tailleCase] != 3)) {
      p.position.y = caseY;
      p.direction.set(-1, 0);
    if(terrain[caseX/tailleCase][caseY/tailleCase]==2){
      nombreDeCase2= nombreDeCase2-1;}
      terrain[caseX/tailleCase][caseY/tailleCase]=1;
    }
  }
  println(nombreDeCase2);
}

class Pacman {
  int taille;
  int vitesse;
  PVector position, direction;

  Pacman(int x, int y, int t) {
    position = new PVector(x * t + t / 2, y * t + t / 2);
    direction = new PVector(0, 0);
    taille = t;
    vitesse = 2;
  }

  void deplacement(int[][] t) {
    int caseX = taille * ((int)position.x / taille) + taille / 2;
    int caseY = taille * ((int)position.y / taille) + taille / 2;
    if ((direction.x == 1) && (position.x == caseX)) {
      if (t[(int)position.x / taille + 1][(int)position.y / taille] == 0) {
        direction.set(0, 0);
      }
    }
    if ((direction.x == -1) && (position.x == caseX)) {
      if (t[(int)position.x / taille - 1][(int)position.y / taille] == 0) {
        direction.set(0, 0);
      }
    }
    if ((direction.y == 1) && (position.y == caseY)) {
      if (t[(int)position.x / taille][(int)position.y / taille + 1] == 0) {
        direction.set(0, 0);
      }
    }
    if ((direction.y == -1) && (position.y == caseY)) {
      if (t[(int)position.x / taille][(int)position.y / taille - 1] == 0) {
        direction.set(0, 0);
      }
    }
    position.add(PVector.mult(direction, vitesse));
  }

  void affichage() {
    float r = 0;
    float o = 0;
    if (frameCount % 40 >= 30) {
      r = QUARTER_PI;
      o = 0.3;
    }

    stroke(1);
    fill(255, 255, 0);
    pushMatrix();
    translate(position.x, position.y);
    rotate(direction.y * PI / 2);
    if (direction.x == -1) {
      arc(0, 0, 45, 45, PI + o, TWO_PI + PI - r, PIE);
      fill(0);
      ellipse(-3, -10, 5, 5);
    } else {
      arc(0, 0, 45, 45, r, TWO_PI - o, PIE);
      fill(0);
      ellipse(3, -10, 5, 5);
    }
    popMatrix();
    noStroke();
  }

  int getX() {
    return (int)position.x;
  }

  int getY() {
    return (int)position.y;
  }
}

class Fantome {
  color couleur;
  PVector position, direction;
  int etat, taille, vitesse;

  Fantome(int x, int y, int t, color c) {
    position = new PVector(x * t + t / 2, y * t + t / 2);
    direction = new PVector(2 * int(random(2)) - 1, 0);
    couleur = c;
    etat = 0;
    taille = t;
    vitesse = 2;
  }

  PVector croisement(int[][] t, int x, int y) {
    byte dir = 0;
    byte n = 0;
    if (t[x][y - 1] != 0) {
      dir |= (1 << 0);
      n++;
    }
    if (t[x + 1][y] != 0) {
      dir |= (1 << 1);
      n++;
    }
    if (t[x][y + 1] != 0) {
      dir |= (1 << 2);
      n++;
    }
    if (t[x - 1][y] != 0) {
      dir |= (1 << 3);
      n++;
    }
    if (n == 1) {
     //println(direction);
      return PVector.mult(direction, -1);
    } else {
      int choix = 0;
      PVector res = new PVector(0, 0);
      while (choix == 0) {
        choix = dir & (1 << int(random(4)));
        switch (choix) {
          case 1 :
          res.set(0, -1);
          break;
          case 2 :
          res.set(1, 0);
          break;
          case 4 : 
          res.set(0, 1);
          break;
          case 8 :
          res.set(-1, 0);
          break;
        }
        if (res.dist(direction) == 2) {
          choix = 0;
        }
      }
      
      return res;
    }
  }

  void deplacement(int[][] t) {
    int caseX = taille * ((int)position.x / taille) + taille / 2;
    int caseY = taille * ((int)position.y / taille) + taille / 2;
    if ((position.x == caseX) && (position.y == caseY)) {
      direction.set(croisement(t, (int)position.x / taille, (int)position.y / taille));
    }
    position.add(PVector.mult(direction, vitesse));
  }

  void affichage() {
    pushMatrix();
    translate(position.x, position.y);
    switch (etat) {
    case 0:
      fill(couleur);
      arc(taille / 2-25, taille / 2-32, 30, 30, -PI, 0);
      rect(taille / 2- 40, taille / 2 - 32, 30, 15);
      triangle(taille/2 - 40,taille/2-17 , taille/2 -30, taille/2-17, taille/2 -40, taille/2-10);
      triangle(taille/2 - 33,taille/2-17 , taille/2 -18, taille/2-17, taille/2 -25, taille/2-10);
      triangle(taille/2 - 20,taille/2-17 , taille/2 -10, taille/2-17, taille/2 -10, taille/2-10);
          fill(0);
    ellipse(taille/2-30, taille/2-33, 8,8);
    ellipse(taille/2-20, taille/2-33, 8,8);
    fill(#2B45EA);
    ellipse(taille/2-31, taille/2-32, 3,4);
    ellipse(taille/2-21, taille/2-32, 3,4);
    }
    popMatrix();
  };
}

Hors ligne

 

 

Pages: 1


fil rss de cette discussion : rss

Pied de page des forums

Powered by FluxBB

codelab, graphisme & code : emoc / 2008-2024