# Astuces

- Booster la mémoire

FoxDot.stop
Server.local.options.memSize = 8192
s.reboot
FoxDot.start

#### Astuce 1 : samples et effets

print(Samples)

b1 >> play("x")
b1.stop()
Clock.clear()

# On choisit une trame rock simple : des charlets, une grosse caisse et une caisse claire
d1 >> play("x o ")
d2 >> play("----")

# Cette forme est la plus simple pour combiner deux motifs percussifs en un seul, il en existe d’autres :
# L’utilisation de patterns, qui ont la forme P[] : nous y reviendrons plus tard
d0 >> play(P["x o "] & P["----"])

# L’utilisation de chevrons, comme suit :
d0 >> play("<x o ><->",sample=4)


# Si je veux donner plus de pep’s à d2, je peux lui permettre de jouer différents charlets dans le temps nécessaire à en jouer un seul, pour cela je les groupe avec des crochets :
d2 >> play("([--]---)")

# Tout sample situé entre crochets est compressé autant de fois que nécessaire pour rester dans le timing voulu;
# Cet effet de compression peut être très utile pour jouer des patterns cadencés de type breakcore ou drum’n’bass
# Enfin, une autre option permettant d’ajouter de la vie à un pattern, est de jouer aléatoirement un élément par rapport à un autre :
    
d0 >> play("<x o x o ><{-[--]}------->")
# Ici mon premier sample de charlet peut

# Which is the same as
d1 >> play("x[--]xu[--]x", sample=d1.degree.map({"x":2, "-":5}))

#### Astuce 2 : melodies et accords, effets

* https://foxdot.org/docs/player-effects/

#### Astuce 3 : python, liste et tupple

# FoxDot utilise les listes de python :
a = [1,2,3,4,5,6]
# Cependant un autre système a dû être mis en place à cause de la méthode
de calcul par défaut lorsque l'on ajoute deux listes ensemble :
a = [1,2,3,4,5,6]
b = [7,8,9]
print(b*2) # retourne [7,8,9,7,8,9]
print(a+b) # retourne [1,2,3,4,5,7,8,9]
# En effet il s'opère un ajout des éléments dans la liste, mais aucun
opération sur chacun des éléments n'est possible. Il faudrait donc un
algorithme capable d'itérer les opérations voulues sur chaque élément
# ...Et cet algorithme est déjà en place, il se nome Pattern et s'écrit P[] :
c = P[1,2,3]
d = P[4,5,6]
print(c+d) # Retourne [1+4,2+5,3+6]
print(c-d) # Retourne [1-4,2-5,3-6]
# Et cela est possible avec chacun des opérateurs : *, /, %, +, -, &, |,...
# Mais que se passe-t-il lorsqu'on met en relation deux listes de longueurs
différentes ?
# L'itérateur Pattern parcourt à nouveau le début de la liste la plus
courte afin de terminer toutes les opérations demandées à la liste la plus
longue : le résultat est un pattern ayant le PPCM des deux patterns
initiaux comme longueur
e = P[4,7,8,9,5,6]
f = P[3,3,4]
print(e+f) # Retourne [4+3,7+3,8+4,9+3,5+3,6+4] : 6 éléments
# On peut aussi imbriquer plusieurs patterns l'un dans l'autre, les listes
imbriquées sont automatiquement interprétées reconnues comme patterns :
g = P[1,2,[3,4],5] # identique à [1,2,3,5,1,2,4,5]
h = P[1,[3,4],[5,6,7]] # identique à [1,3,5,1,4,6,1,3,7]
# On peut aussi fabriquer des listes et des patterns à partir d'une syntaxe
python spécifique aux listes d'entiers :
print(P[:8]) # Retourne P[0,1,2,3,4,5,6,7] (de 0 à 8-1)
print(P[2:4]) # Identique à P[2,3] (de 2 à 4-1)
print(P[2:15:3]) # Retourne P[2,5,8,11,14] (de 2 à 15-1 avec un pas de 3)

#### Astuce 4 : gestion du temps, event

now – represents the current clock beat
nextbar – represents the beat at the start of the next bar

d1 >> play("x-o-", amp=linvar([0, 1], 8, start=now))
Clock.bpm = 120

https://foxdot.org/docs/timevar-basics/
https://foxdot.org/docs/timevar-advanced/
https://foxdot.org/docs/using-the-tempoclock/

* les exemples de bases, only, solo, reset, p_all.amplify=0

* utiliser 'every'pour caler des interventions à intervalles réguliers

Clock.schedule()
p1 >> pluck(P[:8], dur=1/2)
p1.every(4,"reverse")
p1.every(4, "stutter",4,oct=4, pan=[-1,1])
p1.stop_calling("reverse)

* voilà un code pour jouer seulement une partie d'un sample.wav

seconds = Clock.seconds_to_beats
p1 >> loop("foxdot", seconds(5), dur=seconds(3)) #le sample commence à 5sc et dure 3sc.

* Vous pouvez également jouer et stoper un sample.wav au moment où vous le souhaitez.

seconds = Clock.seconds_to_beats
f1 >> loop('foxdot', dur=seconds(4)).after(seconds(4), "stop")

* encore Mieux

Added stretch synth for timestretching samples, similar to loop but better and only plays the whole file. Stretches the audio's duration to the sus attribute without affecting pitch and does not require the tempo to be known. Stretches the audio to 4 beats without affecting pitch

p1 >> stretch("Basic_Rock_135", dur=4)

* Vous pouvez utiliser les TimeVars à changement progressif type ++linvar++, ++sinvar++ et ++expvar++ pour les assigner à une variable et ensuite récupérer leurs valeurs pour piloter les différents Player Attributes.

c = linvar([1,8],8)
b = sinvar([0.1,0.5],6)
d = expvar([1,20],20)
m1 >> loop ('foxdot', dur=c, amp=b)
m2 >> play("x-o-x-x-O-",  sample=c,  amp=b)
d1 >> dirt([0,4,2,1], dur=1/2, hpf=linvar([0,4000],8), hpr=P[1,1,0.3].stretch(8))

* Attendre, déclencher,... après un certain laps de temps

https://github.com/Qirky/FoxDot/blob/master/FoxDot/demo/13_advanced_clock.py

* Lire des samples longs

seconds = Clock.seconds_to_beats
print(PDelta([1/8])[:41])
m1 >> loop("foxdot", seconds(PDelta([1/8])[:41]), dur=1/4)

il faut connaître la longueur en seconde de ton fichier, ici c'est 5secondes. La ligne print te permet d'ajuster le nombre de boucle nécessaire pour arriver à la fin de ton sample. Tu dois donc changer la dernière valeur pour arriver à ce que le dernier chiffre de la liste corresponde à la durée du fichier. Ici 41 qui permet d'atteindre 5.0.
print(PDelta([1/8])[:41])
P[0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, ..., 4.125, 4.25, 4.375, 4.5, 4.625, 4.75, 4.875, 5.0]

m1 >> loop("foxdot", seconds(PDelta([1/8])[:41]), dur=1/4)
Voilà avec ça tu peux ajouter les effets instantanément sans avoir à attendre la fin de la boucle et ça pour des fichiers de plusieurs secondes.

#### Astuce 4 : gestion de groupes et du Master

* Grouper des players

Group(p1, p2, p3).amp = 0.25
ou	
my_group = Group(p1, p2, p3)
my_group.amp = 1/2
my_group.hpf = 500
ou
p_all.amplify=0

* Gérer les effets sur la totalité des lignes actives

Master().lpf= var([0,1400],[28,4])
#pour annuler l'effet
Master().lpf=0

* Connaître les lignes actives

print(Master())