NOISK8

# Introducción

FoxDot crea música al crear objetos de jugador a los que se les da un conjunto de instrucciones a seguir. En Python, los objetos usualmente son instanciados (creados) con un conjunto de argumentos y asignándolos a una variable, así:

>>> clase Animal:
>>> def __init __ (self, animal):
>>> self.type = animal
>>>
>>> monty = Animal ('perro')
>>> print monty.type
perro

Si desea obtener más información sobre cómo programar en Python, hay muchos recursos en línea y un buen lugar para comenzar sería el sitio web oficial de Python. FoxDot está escrito en Python y hereda todas las excelentes funciones de Python, pero hace las cosas de forma ligeramente diferente, sin embargo, cuando se trata de crear instancias de un objeto de jugador.

## Creación de un objeto de jugador

FoxDot en realidad no produce ningún sonido en sí mismo, pero usa SuperCollider para sintetizar sonidos. SuperCollider es una herramienta enormemente poderosa cuando se trata de síntesis y procesamiento de señal digital, pero va acompañada de una curva de aprendizaje empinada. SuperCollider utiliza algo llamado SynthDef (esencialmente un instrumento digital) que contiene información sobre cómo debe sonar una nota cuando se reproduce. Los objetos del jugador apuntan a un SynthDef deseado y se les dan algunas instrucciones sobre cómo usarlos. Para instanciar un objeto de jugador, podría ejecutar el siguiente código:

p1 = PlayerObject ()

El único problema es que si quieres cambiar los atributos de `p1` necesitas usar un método de actualización, que requiere tipeo extra, porque volver a ejecutar el código anterior crea un nuevo objeto de jugador llamado` p1` y olvida la referencia a el primer `p1`! Esto te deja con dos objetos de jugador y uno de ellos no se puede (fácilmente) acceder. Para evitar que esto suceda, FoxDot asigna `PlayerObject`s vacías a todas las variables de uno y dos caracteres inferiores al inicio. Para usar uno de estos `PlayerObject`s necesitas asignarle un SynthDef, como pads, usando la sintaxis de doble flecha como sigue:

p1 >> pads ()

Si un usuario vuelve a ejecutar el código, FoxDot actualizará `p1` en lugar de crear un` PlayerObject`, lo que significa que puede hacer cambios en su música con solo una línea de código.

## Dando las instrucciones de tu reproductor

La creación de un objeto de jugador sin argumentos reproducirá una sola nota en la parte central de C, por defecto, repetidamente hasta que se detenga. El primer argumento debe ser el grado de la nota que se tocará (el valor predeterminado es la nota más baja de la octava 5 de la escala principal) y no necesita especificarse por su nombre. Python, como la mayoría de los lenguajes de programación, usa indexación cero al acceder a valores en una matriz, lo que significa que 0 se refiere a la primera nota de la escala. Otros argumentos útiles que se pueden especificar son la octava, la duración, el sostenido y la amplitud:

p1 >> pads ([0,4,2,4], dur = 1/2, sus = [2,1 / 2,1 / 2,1 / 2], oct = (5,6), amp = 0,4 )

Los argumentos pueden ser puntos flotantes, fracciones, listas e incluso tuplas. Las listas de valores se repiten cuando el reproductor reproduce notas, mientras que los valores en tuplas se usan simultáneamente, es decir, `p1` tocará notas en la 5ta y 6ta octava juntas.

## Jugadores siguientes jugadores

Es posible que un jugador objete jugar exactamente lo que es otro jugador. Para que un jugador siga a otro, solo usa el método `follow`:

b1 >> bajo ([0,1,2,3])
b2 >> bell (). follow (b1)

No importa lo que hagas con `b1`,` b2` siempre reproducirá la misma nota.

## Manipulación algorítmica

El siguiente código reproduce las primeras cuatro notas de la escala predeterminada al repetir:

p1 >> pads ([0,1,2,3])

Es posible manipular esto agregando una matriz de números al objeto Player como tal

p1 >> pads ([0,1,2,3]) + [0,0,2]

En el código de psedo, esto podría escribirse como "cada 3 notas, tocar dos grados más arriba". Estos valores pueden combinarse y agruparse:

p1 >> pads ([0,1,2,3]) + [0,1, [0, (0,2)]]

Este comportamiento es particularmente útil cuando se usa el método `follow`.

b1 >> bajo ([0,4,5,3], dur = 2)

p1 >> pads (). follow (b1) + [2,4,7]

## Cambio de escala

Por defecto, los objetos del jugador usan la escala C mayor. Estos se pueden cambiar utilizando los argumentos de la palabra clave 'scale' y 'root'. Las escalas se pueden definir como una matriz de semitonos, de modo que la escala Mayor es [0,2,4,5,7,9,11] o una de las escalas predefinidas del módulo Escala, p. Scale.minor. La raíz se refiere a la tónica de la escala; 0 es C, 1 es C #, 2 es D y así sucesivamente.

La escala predeterminada se puede cambiar de manera que cualquier jugador que no use una escala específica se actualice. Esto se hace usando la siguiente sintaxis (cada línea es técnicamente equivalente):

Scale.default.set ("principal")
Scale.default.set (Scale.major)
Scale.default.set ([0,2,4,5,7,9,11])

Esto es lo mismo para la raíz:

Root.default.set (1)
Root.default.set ("C #")

## Grupos

Los atributos de los jugadores, como el grado o la escala, también se pueden cambiar asignándole valores directamente de manera que

p1 >> pads ([0,2,4,2], scale = Scale.majorPentatonic)

es equivalente a

p1 >> pads ()
p1.degree = [0,2,4,2]
p1.scale = Scale.majorPentatonic

Esto es útil si desea asignar los mismos valores a múltiples objetos de jugador simultáneamente, de esta manera:

p1 >> almohadillas ([0,2,4,2])
p2 >> almohadillas ([2,1,0,4])
p3 >> pads ([2,3])
413/5000
p3 >> pads ([2,3])
p1.dur = p2.dur = p3.dur = [1,1 / 2,1 / 4,1 / 4]

p1.stop ()
p2.stop ()
p3.stop ()

Para reducir la cantidad de tipeo, los objetos del jugador pueden agruparse y sus atributos modificarse de una manera más simple:

p1 >> almohadillas ([0,2,4,2])
p2 >> almohadillas ([2,1,0,4])
p3 >> pads ([2,3])
g1 = grupo (p1, p2, p3)
g1.dur = [1,1 / 2,1 / 4,1 / 4]

g1.stop ()


----------

Para obtener más documentación sobre el módulo Players, consulte Players.py.