Además de manipular a tus reproductores cambiando sus atributos, también puedes utilizar métodos para cambiar sus comportamientos. Algunos métodos simplemente aplican un preset a atributos específicos para ahorrar tiempo de escritura. Por ejemplo, el método spread equivale a ajustar la panorámica de un reproductor tanto a la izquierda como a la derecha y a compensar la afinación, utilizando el atributo pshift, en 0,125 semitonos en cada canal:
# Difundiendo un sonido a través de canales estéreo fuera de fase
d1 >> play("x-o-", pan=(-1, 1), pshift=(0, 0.125))
# Esto se puede hacer usando el método spread
d1 >> play("x-o-").spread()
# Las instrucciones se interpretan de izquierda a derecha, de modo que la dispersión anula el "pan=[-1, 0, 1]".
d1 >> play("x-o-", pan=[-1, 0, 1]).spread()
# Usando "spread" *antes* el >> establecerá el paneo en[-1, 0, 1] pero pshift seguirá siendo (0, 0.125)
d1.spread() >> play("x-o-", pan=[-1, 0, 1])
A continuación se muestra una lista de métodos que se pueden utilizar con el código de ejemplo adjunto. Esta lista está incompleta, así que por favor, ten paciencia conmigo mientras actualizo esta lista con más información.
Devuelve una lista de los posibles atributos del reproductor que se pueden cambiar.
print(Player.get_attributes())
('degree', 'oct', 'freq', 'dur', 'delay', 'blur', 'amplify', 'scale', 'bpm', 'sample', 'sus', 'fmod', 'pan', 'rate', 'amp', 'vib', 'vibdepth', 'slide', 'sus', 'slidedelay', 'slidefrom', 'bend', 'benddelay', 'coarse', 'striate', 'buf', 'rate', 'pshift', 'hpf', 'hpr', 'lpf', 'lpr', 'chop', 'echo', 'decay', 'spin', 'cut', 'room', 'mix', 'formant', 'shape')
Imprime la cadena de documentos de la clase de reproductor en la consola.
print help()
"FoxDot genera música creando instancias de `Player` y dándoles instrucciones para seguir..."
Inicia un nuevo objeto de reproductor que puede asignar instrucciones. Puede darle un nombre para que sea más fácil identificarlo al imprimir el contenido del reloj de programación, por ejemplo.
# Crea un nuevo reproductor (el nombre puede ser diferente al nombre de la variable)
foo = Player("bar")
foo >> pluck()
#Imprimir contenidos del Clock
print(Clock.playing)
Devuelve la representación de la cadena del reproductor (llamada cuando se utiliza la impresión para mostrar información en la consola). Si se le ha dado un nombre, devolverá el nombre seguido del sintetizador que se está utilizando. Si no es así, sólo devolverá información sobre el synthdef.
#Con un nombre
p1 = Player("p1")
p1 >> pads()
print(p1)
p1 - pads
# sin nombre
p1 = Player()
p1 >> pads()
print(p1)
Esto agrega valor al grado del Reproductor. Si está utilizando el play synthdef, el valor se añade al atributo de muestreo en su lugar.
#Las dos líneas son equivalentes
p1 >> pads(P[0, 1, 2, 3] + (0, 4))
p1 >> pads(P[0, 1, 2, 3]) + (0, 4)
#Puede ser un patrón, PGroup, var, o un solo número
p1 >> pads(P[0, 1, 2, 3]) + [0, 0, 4]
p1 >> pads(P[0, 1, 2, 3]) + var([0, -2], 8)
#El uso de 'play' alterará los valores de la muestra de manera que estas líneas sean equivalentes
p2 >> play("x-o-", sample=P[2, 3] + [0, 0, 1])
p2 >> play("x-o-", sample=[2, 3]) + [0, 0, 1]
El __getattr__ se llama cuando se recupera un atributo, como la amplitud, de un reproductor usando p1.amp. Esto devuelve un objeto PlayerKey, que actúa de forma similar a un TimeVar.
Abreviatura del método de reset
#Restablece todos los atributos y luego actualiza el reproductor con el nuevo 'rate'.
p1.reset() >> play("x-o-", rate=2)
#Equivalente a la línea anterior
p1 >> play("x-o-", rate=2)
Elimina el Reproductor del reloj de programación para que ya no pueda escucharlo.
#Si un reproductor está sonando, use .stop() para detenerlo!
p1 >> pluck()
p1.stop()
#También puede añadir el método al final de la línea
p1 >> pluck().stop()
Restablece todos los valores de atributo a sus valores originales. Esto es cero para todos los valores excepto oct, rate y amp, que son 5, 1 y 1 respectivamente.
#Inicia el reproductor
p1 >> play("x-o-", dur=1, rate=2, hpf=4000)
#Restablecer los atributos a los valores predeterminados
p1.reset()
#Útil cuando no se desea ajustar manualmente los valores a 0, por ejemplo
p2 >> pluck([0, 2, 4, 7], dur=1/4, hpf=500, pan=[-1,1])
#Ajusta el dur a 1, hpf a 0 y pan a 0
p2.reset() >> pluck([0, 2, 4, 7])
Silencia a todos los demás Reproductores activos de manera que este Reproductor sea el único que se escuche. Para anular el silenciamiento de un reproductor individual, simplemente vuelva a evaluar una línea de código. Para desactivar el silenciamiento de todos los reproductores, llame a este método con el conmutador puesto en 0 o Falso.
#Empieza con algunos reproductores
d1 >> play("x-o-")
p1 >> pluck([0,2], dur=PDur(3,8))
#Solo p1
p1.solo()
#Re-agregar otros reproductores
p1.solo(0)
Detiene a todos los demás reproductores activos. A diferencia de solo, este efecto no puede deshacerse usando sólo(0) ya que la parada es permanente. Necesita reintroducir manualmente los reproductores.
#Empieza con algunos reproductores
d1 >> play("x-o-")
p1 >> pluck([0,2], dur=PDur(3,8))
p2 >> pads([0,3], dur=8, oct=4)
#Parar p1 y p2 con d1.only()
d1.only()
Devuelve el valor actual (es decir, el último valor reproducido) para un atributo dado. Por defecto, éste es el grado (tono o carácter de ejemplo), pero puede especificar el nombre del atributo como una cadena.
#Comienza un reproductor
p1 >> pluck([0, 2, 4], dur=[1, 2, 5])
#Imprime el pitch y la duración
print(p1.now(), p1.now("dur"))
0, 1
print(p1.now(), p1.now("dur"))
2, 2
print(p1.now(), p1.now("dur"))
4, 5
Utilícelo para llamar a un método cada n número de latidos. Especifique el nombre del método como una cadena y, a continuación, los argumentos y los argumentos de palabra clave para proporcionar el método. Consulte Manipulación algorítmica para obtener información más detallada sobre cada
#Comienza un reproductor
p1 >> pluck([0,1,2,3,4,5,6,7,8])
#Invierte el orden cada 8 latidos
p1.every(8, "reverse")
#Las llamadas a múltiples métodos pueden ser encadenadas entre sí
p1 >> pluck([0,2,4,7]).every(4, "reverse").every(8, "rotate")
Similar every, pero sólo llama al método una vez después de n número de latidos. Esto puede ser útil, por ejemplo, para reproducir en bucle una secuencia durante un tiempo determinado:
# deten un loop de drum despues de 8 latidos
d1 >> play("x-o-").after(8, "stop")
Repita el último evento musical n veces. Puede especificar argumentos de palabras clave, ya que normalmente actualizaría un reproductor para controlar el tartamudeo. La palabra clave dur cambia la duración durante la cual se extienden los eventos tartamudeados (por defecto es el valor de duración actual del Jugador).
#comienza un reproductor
d1 >> play("x-o-")
d1.stutter()
#tartamudea 4 veces (3 eventos extra)
d1.stutter(4)
#Tartamudear 8 veces más de 2 latidos y paneo alternativo
d1.stutter(8, dur=2, pan=[-1,1])
#Muy útil cuando se combina con 'every'
d1.every(8, "stutter", 4, dur=3)
Reproduce el evento que está un número de pasos por delante de la posición actual del reproductor, tal y como se especifica en el argumento ahead. Esto se utiliza mejor en conjunción con cada método:
#Toca el drum de la caja medio segundo después de 6.5 golpes
d1 >> play("x-o-").every(6.5, "jump", cycle=8)
Ajusta la panoramización tanto a la izquierda como a la derecha y compensa la afinación en 0,125 semitonos de forma predeterminada para obtener un sonido estéreo más denso.
# sin spread
p1 >> pluck([0, 4], oct=4, dur=PDur(3,8), sus=2)
#con spread
p1 >> pluck([0, 4], oct=4, dur=PDur(3,8), sus=2).spread()
Crea un efecto de diapositivas alternado con el reproductor. Fijar inicio a 1 para cambiar el orden de las diapositivas de arriba hacia abajo. Utilice switch=0 para desactivar el efecto o el método de reinicio.
#Reproductor basico
p1 >> saw([7, 0, 3, 1, 7, 4, 5, 2], dur=1/4, oct=4)
# con slider added
p1 >> saw([7, 0, 3, 1, 7, 4, 5, 2], dur=1/4, oct=4).slider()
Establece la escala en el modo pentatónico de la escala por defecto. Use switch=0 para volver a la escala por defecto.
#escala por defecto
p1 >> pluck([0, 1, 2, 3, 4, 5, 6, 7])
#pentatonica
p1 >> pluck([0, 1, 2, 3, 4, 5, 6, 7]).penta()
Establece la amplitud a elegir entre 1 y 0 de forma aleatoria. El argumento de la cantidad es la probabilidad de que la amplitud sea 0 como una fracción, es decir, una degradación de 0,5 (por defecto) significa que cada evento tiene un 50% de probabilidad de ser un 0 y a 0,1 tiene un 10% de probabilidad de ser un 0.
#empieza un reproductor
p1 >> dirt ()
#Comenzar a disminuir el número de eventos
p1.degrade()
#Puede ser llamado repetidamente para degradarse en un 25% cada 8 latidos
p1.every(8, "degrade", 0.25)
Establece el dur a n y el retardo a n / 2 para que cada nota se toque en el offbeat.
#Usa la percusión para escuchar la diferencia
d1 >> play("x-o-")
p1 >> pluck()
#Ajustar la duración a 1 y offbeat
p1.offbeat()
#Ajuste la duración a 2 y desactívela cada 2 latidos
p1.offbeat(2)
Invierte el orden de todos los atributos en el momento actual. Este método no invierte las listas de valores, sino que invierte el orden en que se utilizan.
#toca una octava
p1 >> pluck([0, 1, 2, 3, 4, 5, 6, 7])
# Llamada inversa y las notas empiezan a descender
p1.reverse()
#Llamada usando "every" para movimiento orgánico arriba y abajo
p1.every([6,3], "reverse")
Mueve todos los elementos de la cartografía de afinación/muestreo en n pasos de tal forma que la nueva lista de datos se inicia de forma equivalente, pero comienza en el enésimo elemento de la lista original.
#empieza un reproductor
p1 >> pluck([0,1,2,3])
Rotando [0,1,2,3] cambiando esto por [1,2,3,0]
p1.rotate()
Aleatoriza el orden del atributo del carácter de afinación / ejemplo.
#comienza un reproductor
p1 >> pluck([0,1,2,3])
#Cambia la orden una vez
p1.shuffle()
#Cambia el orden cada 8 latidos
p1.every(8, "shuffle")
Sigue el terreno de juego del reproductor. Es equivalente a ajustar la afinación de un reproductor, por ejemplo, p1, a la afinación de otro usando p2.pitch.
#comienza un reproductor
p1 >> pluck([0, 1, 2, 3], dur=2)
#siguiendo el pitch en p2
p2 >> blip().follow(p1)
#agregando valores de cambio al pitch
p2 >> blip().follow(p1) + [0, 2]
De forma similar a la siguiente, este método obliga al jugador a tocar notas derivadas de la afinación de otro reproductor. El campo será el vecino más cercano al último campo utilizado, es decir, el nuevo campo del reproductor fuente más 0, 2 ó 4.
#comienza un repructor
p1 >> pluck([0, 1, 2, 3], dur=2)
p2 >> blip().accompany(p1)
#Play acompañando pitches
p2 >> blip().accompany(p1)
agregando valores para acompañar el pitch
p2 >> blip().accompany(p1) + [0, 2]
indocumentada
indocumentada
indocumentada
indocumentada