30 ans du Tamagotchi

/*  Diaporama - Karaoke
    Récupérer le son du micro pour faire défiler un diaporama
      chaque slide est associé à un court texte
    Utilisé pour la CND «30 ans du Tamagotchi» / 27 octobre 2026
    processing 4.0b2 @ Tenko / pierre@lesporteslogiques.net
 
    2 paramètres :
      - durée minimum (ms) : une slide reste affichée au moins ce temps là
      - seuil : seuil sonore de déclenchement (0 à 1)
    Modifiables au clavier
      - haut/bas : augmenter/réduire la durée (tranches de 0.1 entre 0 et 1)
      - gauche/droite : baisser/augmenter le seuil (tranches de 500ms, min 0, max 10000ms)
      - p : affichage ou pas des valeurs de paramètres et du niveau sonore capté
      - t : affichage ou pas du texte de légende
    Un clic souris fait aussi passer à la slide suivante
 
    Notes : le réaffichage de l'image ne se fait que si nécessaire, cad :
      - nouvelle image
      - affichage des paramètres affichés
 */
 
 
import processing.sound.*;         // Importer la bibliothèque dédiée au son
 
boolean DISPLAY_PARAMS  = true;    // affichage des paramètres 
boolean REFRESH_DISPLAY = false;   // faut-il rafraîchir l'affichage ?
boolean DISPLAY_TEXT    = true;    // faut-il afficher le texte de légende ?
 
AudioIn micro;                     // Créer un objet nommé micro de type AudioIn
Amplitude volume;                  // Créer un objet nommé volume de type Amplitude
 
float niveau_sonore = 0;           // niveau sonore lissé
float seuil = 0.1;                 // seuil sonore à atteindre
long changed_last = 0;             // instant du dernier changement de slide
long duree_mini = 3000;            // durée minimale d'affichage d'une slide
 
PImage[] images;                   // Tableau d'images
int slideCourante = 0;             // index de l'image en cours du tableau
boolean suivant = false;           // état utilisé pour le changement d'image
 
 
// ****************** Images et légende *********
 
// Tableau de données : { nom de fichier, texte à afficher }
String[][] slides = {
  { "debatchi.png", "debatchi" },
  { "dorotchi.png", "dorotchi" },
  { "hanatchi.png", "hanatchi" },
  { "kabutchi.png", "kabutchi" },
  { "kiwitchi.png", "kiwitchi" },
  { "kusatchi.png", "kusatchi" },
  { "mimitchi.png", "mimitchi" },
  { "oniontchi.png", "oniontchi" },
  { "propellertchi.png", "propellertchi" },
  { "takotchi.png", "takotchi" },
  { "tarakotchi.png", "tarakotchi" },
  { "marumimitchi.png", "marumimitchi" }
};
 
 
void setup() {
  fullScreen(); //
  //size(1200, 675);
  background(255);
  frameRate(20);
  noSmooth();                   // Pas d'interpolation pour agrandir les images
  Sound.list();                 // Debug : liste des devices sonores
 
  micro = new AudioIn(this, 0); // Créer une entrée micro  
  micro.start();                // Démarrer l'écoute du micro
  volume = new Amplitude(this); // Démarrer l'analyseur de volume
  volume.input(micro);          // Brancher l'entrée micro sur l'analyseur de volume
 
  // Chargement de toutes les images une seule fois
  images = new PImage[slides.length];
  for (int i = 0; i < slides.length; i++) {
    images[i] = loadImage(slides[i][0]);
  }
}
 
 
void draw() {
 
  // Mesurer le volume sonore **************************
  float niveau_actuel = volume.analyze(); // renvoie une valeur entre 0 et 1
  // lissage des valeurs pour «gommer» les aberrations
  niveau_sonore = (niveau_sonore * 0.95) + (niveau_actuel * 0.05); 
 
 
  // Tester si on change de slide **********************
  if (niveau_sonore > seuil && (millis() - changed_last > duree_mini)) {
    suivant = true;
    niveau_sonore = 0;
  }
  if (suivant) {
    changed_last = millis();
    slideCourante = (slideCourante + 1) % slides.length;
    REFRESH_DISPLAY = true;
    suivant = false;
  }
 
  // Faut il rafraîchir l'écran ? ***********************
  if (DISPLAY_PARAMS) {
    REFRESH_DISPLAY = true;
  } 
  if (REFRESH_DISPLAY) {
    afficherSlide(slideCourante, DISPLAY_TEXT);
    REFRESH_DISPLAY = false;
  }
 
  // Indications des valeurs de paramètres ***************
  if (DISPLAY_PARAMS) {
    float diametre = map(niveau_sonore, 0, 1, 1, 500);
    noStroke();
    fill(255, 0, 150);
    ellipse(55, 100, diametre, diametre);
    textSize(14);
    textAlign(LEFT, CENTER);
    text(niveau_sonore, 20, 20);
    text(seuil, 60, 20);
    text(duree_mini, 20, 40);
    text(millis() - changed_last, 20, 60);
  }
 
}
 
void afficherSlide(int n, boolean display_text ) {
  background(255);
 
  // Image centrée, redimensionnée pour tenir dans la fenêtre
  PImage img = images[n];
  if (img != null && suivant == false) {
    imageMode(CENTER);
    float ratio = min((float) width / img.width, (float) height / img.height);
    image(img, width/2, height/2, img.width * ratio, img.height * ratio);
  }
 
  // Afficher le texte
  if (display_text) {
 
    /* // Bandeau semi-transparent pour la lisibilité du texte
    noStroke();
    fill(0, 150);
    rectMode(CORNER);
    rect(0, height - 80, width, 80);
    */
 
    fill(255, 0, 150);
    textSize(64);
    textAlign(CENTER, CENTER);
    text(slides[n][1], width/2, height - 100);
  }
}
 
void keyPressed() {
  if (key == 'p') {
    DISPLAY_PARAMS = !DISPLAY_PARAMS;
  }
  if (key == 't') {
    DISPLAY_TEXT = !DISPLAY_TEXT;
  }
  if (key == CODED) {
    if (keyCode == RIGHT) {
      seuil += 0.1;
      if (seuil > 0.9) seuil = 0.9;
    } else if (keyCode == LEFT) {
      seuil -= 0.1;
      if (seuil < 0.1) seuil = 0.1;
    } else if (keyCode == UP) {
      duree_mini += 500;
      if (duree_mini < 0) duree_mini = 0;
    } else if (keyCode == DOWN) {
      duree_mini -= 500;
      if (duree_mini > 10000) duree_mini = 10000;
    }
  }
}
 
void mousePressed() {
  suivant = true;
}