sambinha algorítmico SCAMP+Python+VST

05_sambinha.py

import scamp
import random

### IDEIA GERAL: criar duas camadas rítmicas, independentes, que façam a base e o tamborim do samba
### além disso, vamos usar um plugin VST (no reaper ou outro programa) e criar uma parte MIDI ao invés de uma parte usual
### (se tiver dificuldade, adapte o código usando notas de um piano apenas para compreender o processo geral)


## sessão SCAMP
s = scamp.Session()

## essa linha pode te ajudar a encontrar as entradas (ports) MIDI às quais você pode conectar o SCAMP. No meu computador usarei a primeira, de índice zero.
s.print_available_midi_input_devices()

## duas partes midi: uma para a base, outra para a parte superior. O número zero refere-se à porta (ver comentário acima)
drum1 = s.new_midi_part("base",0)
drum2 = s.new_midi_part("superior",0)


## criarei uma série de dicionários para agrupar as peças da bateria. 
## posteriormente, é simples concatenar esses dicionários usando o símbolo "|". ex. dictconcat = dict1 | dict2
kicks = {'kick0': 36,
            'kick1': 33,
            'kick1': 35}

snareside = {'snareside': 37}

snares = {
            'snare0':38,
            'snare1':39,
            'snare2':40,
}

floortoms = {
            'floortom0': 41,
            'floortom1': 43,
}

hithats = {'hhclosed0': 42,
            'hhclosed1': 62,
            'hhclosed2': 63,
            'hhhalf0': 44,
            'hhhalf1': 61,
            'hhopen0': 46,
            'hhopen1': 60,
            'hhpedal': 65,
}

lowtoms = {
            'lowtom0': 41,
            'lowtom1': 43}

hitoms = {
            'hitom0': 48,
            'hitom1': 50
}

midtoms = {
            'midtom0': 45,
            'midtom1': 47
}

ride = {'ride': 51,
        'ridebell': 53,}

crashs = {'crashL': 49,
            'crashR': 57,
            'crashRshocked': 58,
            'chinacymbal': 52,
            'splashcymbal': 55}

## função para tocar a base
def base():
    while True: ##tocar em loop
        ritmo = [1, -1/2, 1/2, 1, -1/2, 1/2] ## célula rítmica
        insts = kicks  ## para a base, vamos usar apenas o bumbo
        
        ### iterar nos valores de "ritmo":
        for batida in ritmo:
            ## verificar se é pausa, se for, usar wait:
            if batida < 0:
                scamp.wait(abs(batida)) ## usamos abs(batida) porque o valor da pausa não usará o sinal negativo (não existe duração negativa!)
            else:
                ## vamos escolher um instrumento aleatorio: criamos uma lista com os "keys" do dicioanrio, e escolhemos um aleatoriamente
                random_key = random.choice(list(insts.keys()))
                ## em seguida guardamos o nome escolhido e a nota midi correspondente no VST 
                random_pair = (random_key,insts[random_key])
                ## velocity randomico entre 0.1 e 0.95
                vel = random.uniform(0.8,0.9)
                ## duracao igua à 'batida'
                dur = batida
                drum1.play_note(random_pair[1],vel,dur)
                # print(random_pair[0],vel,dur)


## para criar variações na parte superior, vamos criar celulas de duracoes que contém apenas colcheias, com uma ou duas pausas
## mais a frente vamos fazer duas operações: 1. embaralhar as pausas e batidas; 2. deslocar em uma semicolcheia o padrão, criando síncopas
## importante: valores negativos serão utilizados para identificar pausas (-1/2 é o mesmo que 1/2 beat de pausa)
Afull = [1/2, 1/2, 1/2, 1/2]
A1 = [-1/2, 1/2, 1/2, 1/2]
A2 = [-1/2, -1/2, 1/2, 1/2]


def superior():
    while True:
        ## abaixo, vamos escolher uma cópia de uma das celulas acima para a primeira parte e para a segunda parte do padrão do tamborim 
        ## (é importante 'copiar' a lista porque vamos fazer operações com elas, e isso alteraria o padrão de base que queremos manter intacto a cada vez)
        celula1 = random.choice([Afull.copy(),A1.copy(),A2.copy()]) ## escolher Afull, A1 ou A2 como base para criar celula1
        celula2 = random.choice([Afull.copy(),A1.copy(),A2.copy()]) ## escolher Afull, A1 ou A2 como base para criar celula2
        ## permutar celulas (embaralhar beats)
        random.shuffle(celula1) ##embaralha e salva na própria variável celula1
        random.shuffle(celula2) ##embaralha e salva na própria variável celula2
        ## como vamos separar uma celula da outra por uma semicolcheia (1/4), vamos dividir o último beat da celula2
        celula2[-1] = celula2[-1]/2
        ## concatenar celulas, colocando uma pausa de semicolcheia (-1/4) entre elas
        ritmo = celula1 + [-1/4] + celula2
        print(f"ritmo superior: ", ritmo)
        ## concatenando dicionarios que queremos utilizar para essa celula ritmica
        insts = hithats | ride | snareside
        
        ### iterar nos valores de "ritmo":
        for batida in ritmo:
            ## verificar se é pausa, se for, usar wait:
            if batida < 0:
                scamp.wait(abs(batida)) ## usamos abs(batida) porque o valor da pausa não usará o sinal negativo (não existe duração negativa!)
            else:
                ## vamos escolher um instrumento aleatorio: criamos uma lista com os "keys" do dicioanrio, e escolhemos um aleatoriamente
                random_key = random.choice(list(insts.keys()))
                ## em seguida guardamos o nome escolhido e a nota midi correspondente no VST 
                random_pair = (random_key,insts[random_key])
                ## velocity randomico entre 0.1 e 0.95
                vel = random.uniform(0.1,0.95)
                ## duracao igua à 'batida'
                dur = batida
                drum2.play_note(random_pair[1],vel,dur)

## usando fork e wait forever para tocar sem parar
s.fork(superior)
s.fork(base) 
s.wait_forever()