Daphné Chamot-Rooke (contact : daphne.chamot-rooke@etu.upmc.fr)
Himany Seri (contact : himany.seri@etu.upmc.fr)

Début : Février 2019
Fin : mai 2019

Objectif : créer un dispositif qui modifie la perception d'autrui

Matériel :

• plusieurs PC avec souris
• une connexion internet
• logiciel Processing installé

De nos jours l’étude des mouvements de foule permet de simuler la mécanique des foule : ses mouvements semblables à la physique des fluides et sa psychologie sociale. Dans de nombreuses situations nous avons affaire à des mouvements de foule, que ce soit dans des concerts, des conventions, des manifestations, et même sur les réseaux sociaux.
Comment l’individu influence-t-il la foule et comment celle-ci influence telle l’individu ? Comment initie-t-on un mouvement de foule ?
Nous avons décidé d'orienter notre projet sur comment percevoir la foule et comment *se* percevoir dans la foule. Les mécanismes de l'individu à la foule sont en effet des allers-retours, comme lors d'un croisement de regard.

Nous avions d'abord pensé à travailler sur les émotions, les émotions dans la foule. Nous avions eu l'idée d'un bracelet retranscrivant l'émotion globale de la foule. Puis nous nous sommes orientées vers des applications, car cela nous semblait plus réalisable pour travailler avec de nombreuses personnes. Nous avons choisi de créer un programme pour ordinateur, un jeu multijoueur qui permettrait de retranscrire des mouvements de foule.
Notre jeu se compose d'un avatar représentant soi-même à la 3e personne, vu du dessus. Un “monstre” invisible “mange” les avatars lorsqu'il croise leur chemin. Il faut donc faire attention à son entourage, suivre les autres.
Nous voulons faire plusieurs “salles” avec plusieurs consignes, peut-être en faire une où l'on se voit à la première personne, et une autre avec des consignes différentes pour chaque individu afin de créer un tout avec l'action de chaque individu.

Code Java (Processing) :

//déclaration de variables
Blob blob;                  //personnage
Monster monstre;            //monstre
boolean jeu = false;        //bool pour le jeu
boolean intro = true;       //bool pour l'intro
String temps, score;        //string pour stocker le temps et le temps final
Timer timer;                //timer

void setup() {

  fullScreen();             //s'affiche en plein écran
  timer = new Timer();      //nouveaux blob, monstre et timer
  blob = new Blob();
  monstre = new Monster();
}

void draw() {
  background(0);            //fond noir, taille du texte 30 et écrit en blanc
  textSize(30);
  fill(255);
  temps = timer.minute() + ":" + timer.second();    //on stocke les secondes et les minutes dans un string

  if (jeu) {
    timer.stop();          //démarre le timer
    blob.show();           //dessine le blob
    blob.update();         
    monstre.show();        //dessine le monstre
    monstre.deflect();     //empêche que le monstre sorte des bords
    monstre.move();        //le monstre bouge
    monstre.manger(blob);  //mange le blob si ils se rencontrent
    text(temps, width/2 - 50, 50);  //affiche le temps en haut de l'écran
    score = temps;
  } else {                
    timer.start();
    fill(255);
    stroke(255);
    textSize(50);

    if (intro) {
      text("Foule", width/2 - 170, height/2 - 100);          //si c'est l'intro : titre du jeu et démarrer
      text("Cliquer pour jouer", width/2 - 300, height/2);
    } else {
      text("Game Over", width/2 - 170, height/2 - 100);      //si c'est la fin du jeu : Game Over et le temps final s'affichent
      text("Temps : " + score, width/2 - 180, height/2);
    }
  }
}

void reset() {          //quand c'est la fin du jeu, permet de redémarrer une partie juste en clickant
  jeu=true;
  blob.pos.x = random(width);      //réinitialise les positions du blob et du monstre aléatoirement
  blob.pos.y = random(height);
  monstre.x = random(width);
  monstre.y = random(height);
  blob.c = color((int) (Math.random() * 266), (int) (Math.random() * 266), (int) (Math.random() * 266), 170);   //réinitialise la couleur aléatoire
  timer.stop();        //redémarre le timer à 0
}

void mousePressed() {    //on passe l'intro et la fin du jeu en cliquant 
  intro=false;
  if (jeu==false) {
    reset();
  }
}

class Blob {               //classe du blob 
  PVector pos, vel, acc;   //avec une position, une vitesse et une accélaration
  color c;                 //couleur du blob
  float topspeed;          //valeur limite de la vitesse

  Blob() {
    pos = new PVector(width/2, height/2);  
    vel = new PVector(0, 0);
    topspeed = 5;
    c = color((int) (Math.random() * 266), (int) (Math.random() * 266), (int) (Math.random() * 266), 170);
  }

  void update() {
    PVector mouse = new PVector(mouseX, mouseY);      //position en fonction du curseur
    PVector acc = PVector.sub(mouse, pos);            //on définit le vecteur accélération
    acc.setMag(0.2);                                  //magnitude de l'accélération à 0.2
    vel.add(acc);                                     //on ajoute l'accélération au vecteur vitesse
    mouse.sub(this.pos);                              //
    mouse.setMag(7);                                  //magnitude à 7, c'est le retour entre le curseur et le blob à cause de l'accélération (petite par rapport à 0.2)
    this.pos.add(mouse);                              
    vel.limit(topspeed);                              //valeur limite à la vitesse
    pos.add(vel);                                     //on ajoute la vitesse au vecteur position
  }

  void show() {          //dessine le blob
    fill(c);
    stroke(c);
    circle(this.pos.x, this.pos.y, 20);
  }
}

class Monster {            //classe du monstre

  float x, y;
  float xVel, yVel;
  int radius;

  Monster() {
    xVel = random(2, 4);
    yVel = random(2, 4);

    if (int(random(0, 2)) == 1) {
      xVel *= -1;
    }
    if (int(random(0, 2)) == 1) {
      yVel *= -1;
    }

    x = random(radius, width-radius);
    y = random(radius, height-radius);

    radius = 30;
  }

  void move() {        //permet au monstre de bouger
    x += xVel; 
    y += yVel;
  } 

  void manger(Blob blob) {    //le monstre "mange" le blob si ils se rencontrent et le jeu est fini
    if (blob.pos.x <= this.x + radius && blob.pos.x >= this.x - radius && blob.pos.y <= this.y + radius && blob.pos.y >= this.y - radius) {
      jeu = false;
    }
  }

  void show() {          //dessine le monstre
    strokeWeight(1);
    noFill();
    ellipse(this.x, this.y, this.radius*2, this.radius*2);
  }

  void deflect() {      //permet au monstre de ne pas sortir des bords, il "rebondit"
    if (x + radius > width || x - radius < 0) {
      xVel *= -1;
    } 
    if (y + radius > height || y - radius < 0) {
      yVel *= -1;
    }
  }
}

class Timer {      //classe du timer
  int startTime = 0, stopTime = 0;
  boolean running = false;  


  void start() {
    startTime = millis();
    running = true;
  }
  void stop() {
    stopTime = millis();
    running = false;
  }
  int getElapsedTime() {
    int elapsed;
    if (running) {
      elapsed = (millis() - startTime);
    } else {
      elapsed = (stopTime - startTime);
    }
    return elapsed;
  }
  int second() {
    return (getElapsedTime() / 1000) % 60;
  }
  int minute() {
    return (getElapsedTime() / (1000*60)) % 60;
  }
}

cronewd.pdf

à télécharger ici (jusqu'au 17/05/19) https://we.tl/t-cNHGPTQB55