Annonce

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


#1 2016-04-21 19:53:38 problème pour faire des murs, processing.

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

problème pour faire des murs, processing.



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 big_smile (les murs ne sont pas mes murs définitifs mais juste des murs de test pour vérifier si le programme fonctionne)

Dernière modification par lenzone (2016-04-21 19:54:10)

Hors ligne

 

#2 2016-04-21 23:35:21 Re : problème pour faire des murs, processing.

Mushussu
membre
Lieu: Orléans
Date d'inscription: 2012-05-24
Messages: 753

Re: problème pour faire des murs, processing.



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;
  }
}

Hors ligne

 

#3 2016-04-22 15:34:22 Re : problème pour faire des murs, processing.

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

Re: problème pour faire des murs, processing.



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 big_smile

j'ai un peu modifier le programme -->

Hors ligne

 

#4 2016-04-26 06:19:37 Re : problème pour faire des murs, processing.

Mushussu
membre
Lieu: Orléans
Date d'inscription: 2012-05-24
Messages: 753

Re: problème pour faire des murs, processing.



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();
  }
}

Dernière modification par Mushussu (2016-04-26 06:54:39)

Hors ligne

 

#5 2016-05-14 16:31:06 Re : problème pour faire des murs, processing.

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

Re: problème pour faire des murs, processing.



merci beaucoup Mushussu ça m'a vraiment bien aidé big_smilesmile

Hors ligne

 

fil rss de cette discussion : rss

Pied de page des forums

Powered by FluxBB

codelab, graphisme & code : emoc / 2008-2017