_     _                           _ _               _____  _____  _   _   _____           _      
| |   (_)                         | (_)             /  __ \/  __ \| \ | | /  __ \         | |     
| |    ___   _____    ___ ___   __| |_ _ __   __ _  | /  \/| /  \/|  \| | | /  \/ ___   __| | ___ 
| |   | \ \ / / _ \  / __/ _ \ / _` | | '_ \ / _` | | |    | |    | . ` | | |    / _ \ / _` |/ _ \
| |___| |\ V /  __/ | (_| (_) | (_| | | | | | (_| | | \__/\| \__/\| |\  | | \__/\ (_) | (_| |  __/
\_____/_| \_/ \___|  \___\___/ \__,_|_|_| |_|\__, |  \____/ \____/\_| \_/  \____/\___/ \__,_|\___|
                                              __/ |                                               
                                             |___/                                               


  ; Ce document contient toutes les informations sur les fonctions (mots) utilisables 
  ; dans la plateforme de livecoding. 
  ; Vous pouvez copier-coller les exemples dans le fichier "livecode.orc". 


 _                             
| |                            
| |_ ___ _ __ ___  _ __   ___  
| __/ _ \ '_ ` _ \| '_ \ / _ \ 
| ||  __/ | | | | | |_) | (_) |
 \__\___|_| |_| |_| .__/ \___/ 
                  | |          
                  |_|          


  ; Pour modifier le tempo, il faut utiliser la fonction de tempo
  ; Par défaut, le tempo est de 1, ce qui signifie 1 pulsation par seconde
  ; Si on met 2, la pulsation est donc de ... 2 pulsations par secondes 
  tempo(2) ; [0.001 - 10]
  ; La modification du tempo modifiera la vitesse du rythme de TOUS les sons en train d'être joués

  ; Un attracteur chaotique gère d'autres paramètres du temps, on peut changer sa vitesse en écrivant 
  ; Il influence notamment la vitesse d'évolution des modes "sauvages" (voir les Sons)
  chaos_speed(4) ; [0.1 - 100]

  ; Pour entendre le tempo, on peut utiliser le metronome (sans accent ici pour éviter l'erreur)
  metronome


 _____                 
/  ___|                
\ `--.  ___  _ __  ___ 
 `--. \/ _ \| '_ \/ __|
/\__/ / (_) | | | \__ \
\____/ \___/|_| |_|___/
                                            
  ; "ping" - son artificiel percussif brillant
  ; Paramètres : 
  ; - Rythme
  ; - Volume [0-1]
  ; - Hauteur (note) [0-100]
  ; - Durée [>0]
  ping(beat(4), 0.3, 50, 1/4)

  ; "buzzy" - Un son plus doux que Ping et dont le rythme interne peut être imprévisible
  ; Paramètres : 
  ; - Rythme
  ; - Volume [0-1]
  ; - Hauteur (note de base de l'accord) [0-100] 
  ; - Durée [>0]
  buzzy(beat(1/4), 0.5, 50, 4)

  ; "glidy" - un son qui glisse vers la note choisie 
  ; - Rythme
  ; - Volume [0-1]
  ; - Hauteur (note de base de l'accord) [0-100] 
  ; - Durée [>0]
  glidy(beat(1), 0.5, 60, 1)

  ; "darkwave" - une vague sombre, qui gronde quand elle devient forte 
  ; - Rythme
  ; - Volume [0-1]
  ; - Hauteur (note de base de l'accord) [0-100] 
  ; - Durée [>0]
  darkwave(beat(1/4), 0.6, 30, 4)

  ; "brightwave" - une vague brillante et lumineuse  
  ; - Rythme
  ; - Volume [0-1]
  ; - Hauteur (note de base de l'accord) [0-100] 
  ; - Durée [>0]
  brightwave(beat(1/4), 0.6, 30, 4)

  ; "buzzwave" - une vague qui fait bzzz 
  ; - Rythme
  ; - Volume [0-1]
  ; - Hauteur (note de base de l'accord) [0-100] 
  ; - Durée [>0]
  buzzwave(beat(1/4), 0.6, 30, 4)
  
  ; "noisywave" - une vague avec un bruit de fond, comme l'écume de la mer
  ; - Rythme
  ; - Volume [0-1]
  ; - Hauteur (note de base de l'accord) [0-100] 
  ; - Durée [>0]
  noisywave(beat(1/4), 0.6, 30, 4)

  ; "crunchy" - un son percussif qui croustille 
  ; - Rythme
  ; - Volume [0-1]
  ; - Hauteur (note de base de l'accord) [0-100] 
  ; - Durée [>0]
  crunchy(beat(4), 0.6, 20, 1/4)

  ; Strike : un son percussif et très saturé (distordu, sauvage)
  ; Paramètres : 
  ; - Rythme
  ; - Volume [0-1]
  ; - Hauteur (note) [0-100]
  ; - Durée [>0]
  strike(beat(1), 0.9, 8, 1)

  ; Smooth : un son doux, assez rond 
  ; Paramètres : 
  ; - Rythme
  ; - Volume [0-1]
  ; - Hauteur (note) [0-100]
  ; - Durée [>0]
  smooth(beat(1/3), 0.5, 20, 4)

  ; Bounce : un son qui rebondit et qui brille ! 
  ; Paramètres : 
  ; - Rythme
  ; - Volume [0-1]
  ; - Hauteur (note) [0-100]
  ; - Durée [>0]
  bounce(beat(1/2), 0.5, 30, 3)

______               _   _                       _                   _   _                    
|  ___|             | | (_)                     | |                 | | | |                   
| |_ ___  _ __   ___| |_ _  ___  _ __  ___    __| | ___   _ __ _   _| |_| |__  _ __ ___   ___ 
|  _/ _ \| '_ \ / __| __| |/ _ \| '_ \/ __|  / _` |/ _ \ | '__| | | | __| '_ \| '_ ` _ \ / _ \
| || (_) | | | | (__| |_| | (_) | | | \__ \ | (_| |  __/ | |  | |_| | |_| | | | | | | | |  __/
\_| \___/|_| |_|\___|\__|_|\___/|_| |_|___/  \__,_|\___| |_|   \__, |\__|_| |_|_| |_| |_|\___|
                                                                __/ |                         
                                                               |___/                          


  ; "beat" - pulsation régulière
  ;Paramètres : 
  ; - Vitesse (par rapport au tempo) [> 0]
  beat(2) // 2 pulsations par temps

  ; "swing" - pulsation régulière + une pulsation swing 
  ; Paramètres :
  ; - Vitesse (par rapport au tempo) [> 0]
  ; - Swing [0 - 1]
  swing(2, 0.75)
  swing(2, 3/4)
  
  ; "rhythm" - rythme écrit sous la forme d'une liste
  ; Paramètres : 
  ; - liste de 1 et 0 sous forme d'un "array"
  ; - Vitesse (par rapport au tempo) [> 0]
  rhythm(array(1, 0, 0, 1, 0, 0, 1, 1 ), 1)
  ; Peut aussi s'écrire 
  rhythm(
    array(1, 0, 0, 1),
    1)

  ; "drunk" - rythme aléatoire mais quand même lié au tempo
  ; Paramètres : 
  ; - Vitesse (par rapport au tempo) [> 0]
  ; - Taux d'aléatoire [0 - 1]
  drunk(2, 0.8)

  ; "euclidian" - rythmes basés sur la division euclidienne 
  ; (voir https://dbkaplun.github.io/euclidean-rhythm/)
  ; Paramètres : 
  ; - Vitesse [> 0]
  ; - Nombre de "steps" [> 0]
  ; - Division du cercle [> 0]
  ; - Rotation [0 - 1]
  euclidian(2, 3, 7, 0)

  ; "chaos_rhythm" - rythmes basés sur l'horloge chaotique principale
  ; Paramètres 
  ; - Choix de l'horloge [1, 2 ou 3]
  ; - Seuil de détection [0 - 1]
  chaos_rhythm(1, 0.6)


______               _   _                       _                        _             _      
|  ___|             | | (_)                     | |                      | |           | |     
| |_ ___  _ __   ___| |_ _  ___  _ __  ___    __| | ___    ___ ___  _ __ | |_ _ __ ___ | | ___ 
|  _/ _ \| '_ \ / __| __| |/ _ \| '_ \/ __|  / _` |/ _ \  / __/ _ \| '_ \| __| '__/ _ \| |/ _ \
| || (_) | | | | (__| |_| | (_) | | | \__ \ | (_| |  __/ | (_| (_) | | | | |_| | | (_) | |  __/
\_| \___/|_| |_|\___|\__|_|\___/|_| |_|___/  \__,_|\___|  \___\___/|_| |_|\__|_|  \___/|_|\___|
                                                                                               
                                                                                               

  ; "chance" - fait évoluer un paramètre aléatoirement - comme un lancer de dé
  ; Paramètres : 
  ; - Minimum - valeur minimum possible [< Maximum]
  ; - Maximum - valeur maximum possible [> Minimum]
  chance(1, 5) // Donnera à chaque fois un nombre (décimal) entre 1 et 5 différent 

  ; "trajectory" - part d'une valeur et évolue progressivement vers une autre
  ; Paramètres : 
  ; - Départ - valeur de départ
  ; - Durée - Durée totale de l'évolution (en nombre de temps) [> 0]
  ; - Arrivée - Valeur finale
  trajectory(0, 10, 1) // évolue de 0 à 1 progressivement en 10 temps

  ; "oscillation" - va et vient entre deux valeurs 
  ; Paramètres : 
  ; - Minimum : valeur minimum [< Maximum]
  ; - Maximum : valeur maximum [> Minimum]
  ; - Vitesse (par rapport au tempo) [> 0]
  oscillation(10, 30, 1/2) // évolue progressivement entre 10 et 30  avec un cycle de 2 temps

  ; "alternate" - alterne entre deux valeurs à une certaine vitesse et avec une proportion
  ; Paramètres : 
  ; - Valeur 1 
  ; - Valeur 2 
  ; - Vitesse (par rapport au tempo) [> 0]
  ; - Proportion de la valeur 1 [0 - 1] - 
  ; par exemple une proportion de 0.75 fait qu'on restera 3/4 du temps sur la valeur 1, et 1/4 du temps sur la valeur 2 
  alternate(50, 55, 1, 0.75) // alterne entre 50 et 55 tous les temps (75% du temps sur valeur 1)

  ; "sequence" - lit une suite de valeurs (utile pour les notes et mélodies)
  ; Paramètres : 
  ; - liste de valeurs 
  ; - Vitesse (par rapport au tempo) [> 0] 
  sequence(array(30, 33, 35), 1)

  ; "chaos_control" - génère une valeur qui change en permanence en fonction de l'attracteur 
  ; chaotique principal 
  ; Paramètres : 
  ; - Choix de l'attracteur [1, 2 ou 3]
  ; - Valeur minimum
  ; - Valeur maximum 
  chaos_control(1, 0.5, 1) ; Pour du volume 
  chaos_control(2, 40, 60) ; Pour une note 


                               _           
                              | |          
  _____  _____ _ __ ___  _ __ | | ___  ___ 
 / _ \ \/ / _ \ '_ ` _ \| '_ \| |/ _ \/ __|
|  __/>  <  __/ | | | | | |_) | |  __/\__ \
 \___/_/\_\___|_| |_| |_| .__/|_|\___||___/
                        | |                
                        |_|                

  crunchy(beat(4), 0.5, 10, 1)
  tempo(0.5)
  darkwave(beat(1/2), 0.5, 30, 2)
  darkwave(beat(1/2), 0.5, 33, 2)
  darkwave(beat(1/4), 0.5, 40, 4)

  chaos_speed(1)

  noisywave(beat(1/4), 0.5, 50, 4)
  noisywave(beat(1/4), 0.5, 55, 4)

  brightwave(beat(1/2), 0.7, 70, 1)
  buzzwave(beat(1/2), 0.8, 60, 2, 2)
    _       _       _       _       _       _       _    
 /\| |/\ /\| |/\ /\| |/\ /\| |/\ /\| |/\ /\| |/\ /\| |/\ 
 \ ` ' / \ ` ' / \ ` ' / \ ` ' / \ ` ' / \ ` ' / \ ` ' / 
|_     _|_     _|_     _|_     _|_     _|_     _|_     _|
 / , . \ / , . \ / , . \ / , . \ / , . \ / , . \ / , . \ 
 \/|_|\/ \/|_|\/ \/|_|\/ \/|_|\/ \/|_|\/ \/|_|\/ \/|_|\/ 
                                                         
  /*
  crunchy(beat(4), 0.6, 10, 1, 2)
  crunchy(beat(8), 0.6, 50, 1, 2)
  crunchy(beat(8), 0.6, 55, 1)
  */
  ;crunchy(beat(8), 0.8, sequence(array(60, 57, 57, 63, 58), 8), 1)
  
  tempo(.5)
  chaos_speed(7)
/*
  brightwave(beat(1/8), 0.5, 50, 3, 3)
  brightwave(beat(1/8), 0.5, 53, 3)
  brightwave(beat(1/8), 0.5, 57, 3, 3)
  */

  /*
  glidy(beat(1/2), 0.7, 60, 2)
  glidy(beat(1/3), 0.7, 64, 2)
  glidy(beat(1/4), 0.7, 65, 2)
  */

  /*
  darkwave(beat(1/4), 0.6, 30, 5, 1)
  darkwave(beat(1/4), 0.6, 32, 5, 1)
  darkwave(beat(1/4), 0.6, 27, 5)
  darkwave(beat(1/4), 0.6, 20, 5)
  */                                              

    _       _       _       _       _       _       _    
 /\| |/\ /\| |/\ /\| |/\ /\| |/\ /\| |/\ /\| |/\ /\| |/\ 
 \ ` ' / \ ` ' / \ ` ' / \ ` ' / \ ` ' / \ ` ' / \ ` ' / 
|_     _|_     _|_     _|_     _|_     _|_     _|_     _|
 / , . \ / , . \ / , . \ / , . \ / , . \ / , . \ / , . \ 
 \/|_|\/ \/|_|\/ \/|_|\/ \/|_|\/ \/|_|\/ \/|_|\/ \/|_|\/ 

  /*
  darkwave(beat(1/4), .7, 60, 4)
  darkwave(beat(1/6), .7, 42, 4)
  darkwave(beat(1/4), .7, 67, 4)
  darkwave(beat(1/6), .7, 10, 4) 

  
  crunchy(beat(4), 0.9, 10, 1, 2)
  crunchy(beat(8), 0.7, 50, 1, 2)
  crunchy(beat(8), 0.7, 55, 1)
  
  crunchy(beat(8), 0.7, sequence(array(60, 57, 57, 63, 58), 8), 1)
  
  tempo(.125)
  chaos_speed(8)

  ping(beat(4), 1, sequence(array(50, 55, 50, 57, 50, 58), 1), 1)
  */
  /*
  brightwave(beat(1/8), 0.5, 50, 3, 3)
  brightwave(beat(1/8), 0.5, 53, 3)
  brightwave(beat(1/8), 0.5, 57, 3, 3)
  */
/*
  brightwave(beat(1/8), 0.5, 50, 3, 3)
  brightwave(beat(1/8), 0.5, 53, 3)
  brightwave(beat(1/8), 0.5, 57, 3, 3)
  */
  /*
  tempo(1)
  glidy(beat(1/2), 0.3, 60, 2)
  glidy(beat(1/3), 0.3, 64, 3)
  glidy(beat(1/4), 0.4, 65, 4)
  glidy(beat(1/7), 0.5, 40, 5)
  glidy(beat(1/5), 0.4, 44, 6)
  glidy(beat(1/6), 0.5, 45, 7)
 */
  /* 
  noisywave(beat(1/4), 0.9, 20, 6)
  noisywave(beat(1/4), 0.9, 48, 6)  
  noisywave(beat(1/8), 0.9, 34, 6)
  noisywave(beat(1/8), 0.9, 39, 6)  
*/







    _       _       _       _       _       _       _    
 /\| |/\ /\| |/\ /\| |/\ /\| |/\ /\| |/\ /\| |/\ /\| |/\ 
 \ ` ' / \ ` ' / \ ` ' / \ ` ' / \ ` ' / \ ` ' / \ ` ' / 
|_     _|_     _|_     _|_     _|_     _|_     _|_     _|
 / , . \ / , . \ / , . \ / , . \ / , . \ / , . \ / , . \ 
 \/|_|\/ \/|_|\/ \/|_|\/ \/|_|\/ \/|_|\/ \/|_|\/ \/|_|\/ 



  tempo(1)
  chaos_speed(1)
  darkwave(beat(1/4), .5, 60, 4)
  darkwave(beat(1/6), .65, 36, 6)
  darkwave(beat(1/8), .65, 38, 8)
  darkwave(beat(1/4), .65, 67, 4)
  darkwave(beat(1/6), .65, 24, 6) 
  darkwave(beat(1/3), .65, 40, 4)
  darkwave(beat(1/5), .65, 31, 5) 

  crunchy(beat(4), 1, 12, 1/2, 2)
  crunchy(beat(1), 1, 22, 1)
  crunchy(beat(8), 0.6, 50, 1/2, 2)
  crunchy(beat(8), 0.6, 55, 1/2)
  
  crunchy(beat(8), 0.7, sequence(array(60, 57, 57, 63, 58), 8), 1/2)
  crunchy(beat(8), 0.8, sequence(array(72, 48, 74, 75, 46, 50, 78), 8), 1/2)


 /* 
  tempo(.125)
  chaos_speed(8)

  ping(beat(4), 1, sequence(array(50, 55, 50, 57, 50, 58), 1), 1)
  */
  /*
  brightwave(beat(1/8), 0.5, 50, 3, 3)
  brightwave(beat(1/8), 0.5, 53, 3)
  brightwave(beat(1/8), 0.5, 57, 3, 3)
  */
/*
  brightwave(beat(1/8), 0.5, 50, 3, 3)
  brightwave(beat(1/8), 0.5, 53, 3)
  brightwave(beat(1/8), 0.5, 57, 3, 3)
  */
  /*
  tempo(1)
  glidy(beat(1/2), 0.3, 60, 2)
  glidy(beat(1/3), 0.3, 64, 3)
  glidy(beat(1/4), 0.4, 65, 4)
  glidy(beat(1/7), 0.5, 40, 5)
  glidy(beat(1/5), 0.4, 44, 6)
  glidy(beat(1/6), 0.5, 45, 7)
 */
  /* 
  noisywave(beat(1/4), 0.9, 20, 6)
  noisywave(beat(1/4), 0.9, 48, 6)  
  noisywave(beat(1/8), 0.9, 34, 6)
  noisywave(beat(1/8), 0.9, 39, 6)  
*/



/*
Exemple réalisé en première séance à l'école du Centre 
  crunchy(beat(2), 0.9, chance(15, 80), 0.5)
  buzzy(beat(1/4), 0.8, 10, 4)
  tempo(4)
  glidy(beat(1), 0.6, 60, 1)
  darkwave(beat(1/4), 0.9, 30, 4)
*/




/*

  ping(beat(8), 1, 10, 1/8)
  ping(beat(8), 1, sequence(array(20, 22), 1/4), 1/8)
  crunchy(beat(4), 0.9, chance(30, 80), 1/6)
  crunchy(beat(4), 0.8, chance(30, 80), 1/6)
  kick(beat(2), 0.5)
  snare(beat(1), 0.8, 100, 1/10)

*/

/*
  noisywave(beat(1/4), 0.6, 80, 4)
  noisywave(beat(1/8), 0.6, 60, 8)
  noisywave(beat(1/6), 0.6, 40, 6)
  snare(rhythm(array(1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1), 8), 0.5)
  kick(rhythm(array(0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0), 8), 0.7)
*/

/*
  ; MELODY
  ping(beat(2), oscillation(.5, 1, 1/2), sequence(array(52, 55, 50, 48, 50)+sequence(array(2, 0), 2), 2), oscillation(.5, 2, 1/2))

  ; CHORD
  buzzwave(beat(4), oscillation(0, .5, 1/6), sequence(array(52, 55, 50, 48, 50)-24, 1/2), 1)
  buzzwave(beat(4), oscillation(0, .5, 1/3), sequence(array(52, 55, 50, 48, 50)-7, 1/2), 2)

  ; BUZZ
  noisywave(beat(1/4), .5, sequence(array(52, 55), 2), 8)
*/



    _       _       _       _       _       _       _    
 /\| |/\ /\| |/\ /\| |/\ /\| |/\ /\| |/\ /\| |/\ /\| |/\ 
 \ ` ' / \ ` ' / \ ` ' / \ ` ' / \ ` ' / \ ` ' / \ ` ' / 
|_     _|_     _|_     _|_     _|_     _|_     _|_     _|
 / , . \ / , . \ / , . \ / , . \ / , . \ / , . \ / , . \ 
 \/|_|\/ \/|_|\/ \/|_|\/ \/|_|\/ \/|_|\/ \/|_|\/ \/|_|\/ 

  ; Rythme 1 
  kick(swing(1, 0.75), 0.5)
  snare(swing(0.5, 0.25), 0.7)
  hihat( rhythm(array(1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1), 4), 0.5, 95, 0.1)




; Ping à corriger
; Noisywave avec mode sauvage ou son grave avec mode sauvage aussi