» codelab :    http://codelab.fr/accueil
» Forum : discussions Code :    http://codelab.fr/code
» problème pour faire des murs, processing. :    http://codelab.fr/6246

Ceci est la version imprimable d'un sujet du forum, pour retourner à la version complète : problème pour faire des murs, processing.

lenzone — 2016-04-21 19:53:38

Comme beaucoup je débute, et cela fait plusieurs semaines que je bloque sur un projet de pacman pour mon école, car je n'arrive pas à programmer des murs. Visuellement ils sont bien là mais mon pacman passe au travers. je voulais donc savoir si quelqu'un aurait l’expérience nécessaire pour m'aider. merci !

mon programme est sensé être en dessous je crois :D (les murs ne sont pas mes murs définitifs mais juste des murs de test pour vérifier si le programme fonctionne)

Mushussu — 2016-04-21 23:35:21

Bonsoir,

J'aurais pris une autre approche. Pour moi le terrain du Pacman est un tableau chaque case est soit un mur 0, soit un chemin sans boule 1 et avec une blouse blanche 2. Ainsi l'affichage est rapide.
Ce qui est délicat ensuite est de regarder la position du Pacman avec ces cases. Voici une ébauche :

Pacman p;
int[][] terrain = {{0, 0, 0, 0, 0, 0, 0}, {0, 2, 2, 2, 2, 2, 0}, {0, 2, 0, 2, 0, 2, 0}, {0, 2, 0, 2, 0, 2, 0}, 
  {0, 2, 2, 2, 2, 2, 0}, {0, 0, 0, 2, 0, 0, 0}, {0, 2, 2, 2, 2, 2, 0}, {0, 2, 0, 2, 0, 2, 0}, {0, 2, 2, 2, 2, 2, 0}, {0, 0, 0, 0, 0, 0, 0}};
int tailleCase;

void setup() {
  size(800, 600);
  tailleCase = 20;
  p = new Pacman(1, 1, tailleCase);
  noStroke();
}

void draw() {
  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(255, 0, 0);
        rect(0, 0, tailleCase, tailleCase);
        break;
      case 2:
        fill(255);
        ellipse(tailleCase / 2, tailleCase / 2, 6, 6);
        break;
      }
      popMatrix();
    }
  }
  p.update(terrain);
  p.affichage();
}

void keyPressed() {
  int caseX = tailleCase * (p.getX() / tailleCase) + tailleCase / 2;
  int caseY = tailleCase * (p.getY() / tailleCase) + tailleCase / 2;
  int intervalle = 5;
  if (keyCode == DOWN) {
    if ((p.getX() > caseX - intervalle) && (p.getX() < caseX + intervalle)) {
      p.position.x = caseX;
      p.vitesse.set(0, 1);
    }
  }
  if (keyCode == UP) {
    if ((p.getX() > caseX - intervalle) && (p.getX() < caseX + intervalle)) {
      p.position.x = caseX;
      p.vitesse.set(0, -1);
    }
  }
  if (keyCode == RIGHT) {
    if ((p.getY() > caseY - intervalle) && (p.getY() < caseY + intervalle)) {
      p.position.y = caseY;
      p.vitesse.set(1, 0);
    }
  }
  if (keyCode == LEFT) {
    if ((p.getY() > caseY - intervalle) && (p.getY() < caseY + intervalle)) {
      p.position.y = caseY;
      p.vitesse.set(-1, 0);
    }
  }
}

class Pacman {
  int taille;
  PVector position, vitesse;

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

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

  void affichage() {
    fill(255, 255, 0);
    ellipse(position.x, position.y, 14, 14);
  }

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

  int getY() {
    return (int)position.y;
  }
}
lenzone — 2016-04-22 15:34:22

merci pour ton aide Mushussu, ça m'a beaucoup éclairé. mais j’ai encore une dernière question. je compte créer des fantômes, et je voudrais créer une case 3 que les fantômes peuvent traverser mais pas le Pacman. Sauf que je n'ai aucune idée de comment la rajouter donc si tu peux m'aider :D

j'ai un peu modifier le programme -->

Mushussu — 2016-04-26 06:19:37

Bonjour,

Je ne sais pas si tu as avancé, mais voici ma proposition pour la porte des fantômes :

Pacman p;
Fantome[] f;

int[][] terrain = {
  {0, 0, 0, 0, 0, 1, 0, 2, 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, 2, 0, 1, 0, 0, 0, 0, 0}, 
};
int tailleCase;

void setup() {
  //fullScreen();
  size(1350, 750);
  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() {
  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(#F7780F);
        stroke(#F78D00);
        strokeWeight(2.5);
        rect(0, 0, tailleCase, tailleCase);
        break;
      case 2:
        fill(#FCD5A1);
        noStroke();
        ellipse(tailleCase / 2, tailleCase / 2, 8, 8);
        break;
      case 3:
        fill(255, 0, 0);
        stroke(#F78D00);
        strokeWeight(2.5);
        rect(0, 0, tailleCase, tailleCase);
        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 (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 (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 (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);
    }
  }
}

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);
      rect(-taille / 2, - taille / 2, taille, taille);
    }
    popMatrix();
  }
}
lenzone — 2016-05-14 16:31:06

merci beaucoup Mushussu ça m'a vraiment bien aidé :D:)