3 new melody strategies
This commit is contained in:
Dejvino
parent
7da78f5fb9
commit
bbe6c4ff2f
91
CallAndResponseStrategy.h
Normal file
91
CallAndResponseStrategy.h
Normal file
@ -0,0 +1,91 @@
|
||||
#include "MelodyStrategy.h"
|
||||
#include <Arduino.h>
|
||||
|
||||
#ifndef CALL_AND_RESPONSE_STRATEGY_H
|
||||
#define CALL_AND_RESPONSE_STRATEGY_H
|
||||
|
||||
class CallAndResponseStrategy : public MelodyStrategy {
|
||||
public:
|
||||
void generate(Step (*sequence)[NUM_STEPS], int track, int numSteps, int* scaleNotes, int numScaleNotes, int seed, int intensity) override {
|
||||
randomSeed(seed);
|
||||
if (numScaleNotes == 0) return;
|
||||
|
||||
int halfSteps = numSteps / 2;
|
||||
if (halfSteps < 1) halfSteps = 1;
|
||||
|
||||
// Generate Call (First Half)
|
||||
for (int i = 0; i < halfSteps; i++) {
|
||||
// Simple random generation for the call, weighted by intensity
|
||||
if (random(100) < (intensity * 8 + 20)) {
|
||||
int octave = 3 + random(3);
|
||||
sequence[track][i].note = 12 * octave + scaleNotes[random(numScaleNotes)];
|
||||
sequence[track][i].accent = (random(100) < 30);
|
||||
sequence[track][i].tie = (random(100) < 10);
|
||||
} else {
|
||||
sequence[track][i].note = -1;
|
||||
sequence[track][i].accent = false;
|
||||
sequence[track][i].tie = false;
|
||||
}
|
||||
}
|
||||
|
||||
// Generate Response (Second Half)
|
||||
for (int i = halfSteps; i < numSteps; i++) {
|
||||
int srcIndex = i - halfSteps;
|
||||
Step srcStep = sequence[track][srcIndex];
|
||||
|
||||
// Default: Copy
|
||||
sequence[track][i] = srcStep;
|
||||
|
||||
// Variation based on intensity
|
||||
if (srcStep.note != -1) {
|
||||
int r = random(100);
|
||||
if (r < intensity * 5) {
|
||||
// Transpose / Shift
|
||||
int shift = random(-2, 3);
|
||||
int octave = srcStep.note / 12;
|
||||
int noteVal = srcStep.note % 12;
|
||||
|
||||
// Find index in scale
|
||||
int idx = 0;
|
||||
for(int k=0; k<numScaleNotes; k++) if(scaleNotes[k] == noteVal) idx = k;
|
||||
|
||||
idx = (idx + shift + numScaleNotes) % numScaleNotes;
|
||||
sequence[track][i].note = 12 * octave + scaleNotes[idx];
|
||||
} else if (r < intensity * 8) {
|
||||
// New random note (Variation)
|
||||
int octave = 3 + random(3);
|
||||
sequence[track][i].note = 12 * octave + scaleNotes[random(numScaleNotes)];
|
||||
}
|
||||
}
|
||||
}
|
||||
randomSeed(micros());
|
||||
}
|
||||
|
||||
void generateScale(int* scaleNotes, int& numScaleNotes) override {
|
||||
numScaleNotes = random(5, 8);
|
||||
for (int i = 0; i < 12; i++) scaleNotes[i] = i;
|
||||
for (int i = 0; i < 12; i++) {
|
||||
int j = random(12);
|
||||
int temp = scaleNotes[i];
|
||||
scaleNotes[i] = scaleNotes[j];
|
||||
scaleNotes[j] = temp;
|
||||
}
|
||||
sortArray(scaleNotes, numScaleNotes);
|
||||
}
|
||||
|
||||
void mutate(Step (*sequence)[NUM_STEPS], int track, int numSteps, int* scaleNotes, int numScaleNotes, int intensity) override {
|
||||
// Swap call and response halves
|
||||
int half = numSteps / 2;
|
||||
for(int i=0; i<half; i++) {
|
||||
Step temp = sequence[track][i];
|
||||
sequence[track][i] = sequence[track][i+half];
|
||||
sequence[track][i+half] = temp;
|
||||
}
|
||||
}
|
||||
|
||||
const char* getName() override {
|
||||
return "CallResp";
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
102
IsorhythmStrategy.h
Normal file
102
IsorhythmStrategy.h
Normal file
@ -0,0 +1,102 @@
|
||||
#ifndef ISORHYTHM_STRATEGY_H
|
||||
#define ISORHYTHM_STRATEGY_H
|
||||
|
||||
#include "MelodyStrategy.h"
|
||||
#include <Arduino.h>
|
||||
|
||||
class IsorhythmStrategy : public MelodyStrategy {
|
||||
public:
|
||||
void generate(Step (*sequence)[NUM_STEPS], int track, int numSteps, int* scaleNotes, int numScaleNotes, int seed, int intensity) override {
|
||||
randomSeed(seed);
|
||||
if (numScaleNotes == 0) return;
|
||||
|
||||
// 1. Create the Color (pitch pattern)
|
||||
// Intensity affects color length. Higher intensity = longer, more complex color.
|
||||
int colorLength = 2 + random(intensity + 2); // 2 to intensity+3 notes
|
||||
if (colorLength > numScaleNotes) colorLength = numScaleNotes;
|
||||
if (colorLength > 8) colorLength = 8; // Keep it reasonable
|
||||
|
||||
int color[8];
|
||||
// Pick unique notes from the scale for the color
|
||||
int scaleIndices[12];
|
||||
for(int i=0; i<numScaleNotes; i++) scaleIndices[i] = i;
|
||||
for(int i=0; i<numScaleNotes; i++) { // shuffle
|
||||
int r = random(numScaleNotes);
|
||||
int temp = scaleIndices[i];
|
||||
scaleIndices[i] = scaleIndices[r];
|
||||
scaleIndices[r] = temp;
|
||||
}
|
||||
for(int i=0; i<colorLength; i++) {
|
||||
color[i] = scaleIndices[i];
|
||||
}
|
||||
|
||||
// 2. Create the Talea (rhythmic pattern)
|
||||
// Intensity affects talea length and density.
|
||||
int taleaLength = 4 + random(numSteps / 2); // 4 to 12 steps for a 16-step sequence
|
||||
if (taleaLength > numSteps) taleaLength = numSteps;
|
||||
|
||||
bool talea[NUM_STEPS];
|
||||
int pulses = 2 + random(taleaLength - 2); // At least 2 pulses
|
||||
|
||||
// Euclidean distribution for a nice rhythm
|
||||
int bucket = 0;
|
||||
for(int i=0; i<taleaLength; i++) {
|
||||
bucket += pulses;
|
||||
if (bucket >= taleaLength) {
|
||||
bucket -= taleaLength;
|
||||
talea[i] = true;
|
||||
} else {
|
||||
talea[i] = false;
|
||||
}
|
||||
}
|
||||
|
||||
// 3. Apply Color and Talea to the sequence
|
||||
int colorIdx = 0;
|
||||
for (int i = 0; i < numSteps; i++) {
|
||||
int taleaIdx = i % taleaLength;
|
||||
if (talea[taleaIdx]) {
|
||||
int octave = 3 + random(3);
|
||||
int noteScaleIndex = color[colorIdx % colorLength];
|
||||
sequence[track][i].note = 12 * octave + scaleNotes[noteScaleIndex];
|
||||
sequence[track][i].accent = (i % 4 == 0); // Accent on downbeats
|
||||
sequence[track][i].tie = false;
|
||||
colorIdx++;
|
||||
} else {
|
||||
sequence[track][i].note = -1;
|
||||
sequence[track][i].accent = false;
|
||||
sequence[track][i].tie = false;
|
||||
}
|
||||
}
|
||||
randomSeed(micros());
|
||||
}
|
||||
|
||||
void generateScale(int* scaleNotes, int& numScaleNotes) override {
|
||||
numScaleNotes = random(5, 8);
|
||||
for (int i = 0; i < 12; i++) scaleNotes[i] = i;
|
||||
for (int i = 0; i < 12; i++) {
|
||||
int j = random(12);
|
||||
int temp = scaleNotes[i];
|
||||
scaleNotes[i] = scaleNotes[j];
|
||||
scaleNotes[j] = temp;
|
||||
}
|
||||
sortArray(scaleNotes, numScaleNotes);
|
||||
}
|
||||
|
||||
void mutate(Step (*sequence)[NUM_STEPS], int track, int numSteps, int* scaleNotes, int numScaleNotes, int intensity) override {
|
||||
// Mutation: rotate the talea (rhythmic displacement)
|
||||
int rotation = random(1, numSteps);
|
||||
Step temp[NUM_STEPS];
|
||||
for(int i=0; i<numSteps; i++) {
|
||||
temp[i] = sequence[track][(i + rotation) % numSteps];
|
||||
}
|
||||
for(int i=0; i<numSteps; i++) {
|
||||
sequence[track][i] = temp[i];
|
||||
}
|
||||
}
|
||||
|
||||
const char* getName() override {
|
||||
return "Isorhythm";
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
@ -6,6 +6,9 @@
|
||||
#include "CellularAutomataStrategy.h"
|
||||
#include "LSystemStrategy.h"
|
||||
#include "DroneStrategy.h"
|
||||
#include "CallAndResponseStrategy.h"
|
||||
#include "WaveStrategy.h"
|
||||
#include "IsorhythmStrategy.h"
|
||||
|
||||
// Global state variables
|
||||
Step sequence[NUM_TRACKS][NUM_STEPS];
|
||||
@ -130,8 +133,10 @@ extern const uint32_t EEPROM_MAGIC = 0x42424250;
|
||||
|
||||
MelodyStrategy* strategies[] = {
|
||||
new LuckyStrategy(), new ArpStrategy(), new EuclideanStrategy(),
|
||||
new MarkovStrategy(), new CellularAutomataStrategy(), new LSystemStrategy(), new DroneStrategy()};
|
||||
extern const int numStrategies = 7;
|
||||
new MarkovStrategy(), new CellularAutomataStrategy(), new LSystemStrategy(), new DroneStrategy(),
|
||||
new CallAndResponseStrategy(), new IsorhythmStrategy(), new WaveStrategy()
|
||||
};
|
||||
extern const int numStrategies = 10;
|
||||
int currentStrategyIndices[NUM_TRACKS];
|
||||
|
||||
volatile PlayMode playMode = MODE_POLY;
|
||||
|
||||
97
WaveStrategy.h
Normal file
97
WaveStrategy.h
Normal file
@ -0,0 +1,97 @@
|
||||
#include "MelodyStrategy.h"
|
||||
#include <Arduino.h>
|
||||
|
||||
#ifndef WAVE_STRATEGY_H
|
||||
#define WAVE_STRATEGY_H
|
||||
|
||||
class WaveStrategy : public MelodyStrategy {
|
||||
public:
|
||||
void generate(Step (*sequence)[NUM_STEPS], int track, int numSteps, int* scaleNotes, int numScaleNotes, int seed, int intensity) override {
|
||||
randomSeed(seed);
|
||||
if (numScaleNotes == 0) return;
|
||||
|
||||
// Wave parameters
|
||||
// Frequency: How many cycles per sequence
|
||||
float freq = (float)random(1, 4) + (intensity * 0.2f);
|
||||
// Phase offset
|
||||
float phase = random(100) / 100.0f * 2.0f * PI;
|
||||
// Waveform type: 0=Sine, 1=Triangle, 2=Saw
|
||||
int type = random(3);
|
||||
|
||||
// Center pitch (note index)
|
||||
int centerIdx = numScaleNotes * 2; // Middle of 4 octaves roughly
|
||||
int amp = numScaleNotes + (intensity); // Amplitude in scale degrees
|
||||
|
||||
for (int i = 0; i < numSteps; i++) {
|
||||
float t = (float)i / (float)numSteps; // 0.0 to 1.0
|
||||
float val = 0.0f;
|
||||
|
||||
if (type == 0) { // Sine
|
||||
val = sin(t * freq * 2.0f * PI + phase);
|
||||
} else if (type == 1) { // Triangle
|
||||
float x = t * freq + phase / (2.0f*PI);
|
||||
x = x - (int)x; // frac
|
||||
val = (x < 0.5f) ? (4.0f * x - 1.0f) : (3.0f - 4.0f * x);
|
||||
} else { // Saw
|
||||
float x = t * freq + phase / (2.0f*PI);
|
||||
x = x - (int)x;
|
||||
val = 2.0f * x - 1.0f;
|
||||
}
|
||||
|
||||
// Map val (-1 to 1) to note index
|
||||
int noteIdxOffset = (int)(val * amp);
|
||||
int totalIdx = centerIdx + noteIdxOffset;
|
||||
|
||||
// Normalize totalIdx
|
||||
while(totalIdx < 0) totalIdx += numScaleNotes;
|
||||
|
||||
int octave = 2 + (totalIdx / numScaleNotes);
|
||||
int scaleIdx = totalIdx % numScaleNotes;
|
||||
|
||||
if (octave < 0) octave = 0;
|
||||
if (octave > 8) octave = 8;
|
||||
|
||||
// Rhythmic density based on intensity
|
||||
if (random(100) < (40 + intensity * 5)) {
|
||||
sequence[track][i].note = 12 * octave + scaleNotes[scaleIdx];
|
||||
sequence[track][i].accent = (val > 0.8f); // Accent peaks
|
||||
sequence[track][i].tie = false;
|
||||
} else {
|
||||
sequence[track][i].note = -1;
|
||||
sequence[track][i].accent = false;
|
||||
sequence[track][i].tie = false;
|
||||
}
|
||||
}
|
||||
randomSeed(micros());
|
||||
}
|
||||
|
||||
void generateScale(int* scaleNotes, int& numScaleNotes) override {
|
||||
numScaleNotes = random(5, 8);
|
||||
for (int i = 0; i < 12; i++) scaleNotes[i] = i;
|
||||
for (int i = 0; i < 12; i++) {
|
||||
int j = random(12);
|
||||
int temp = scaleNotes[i];
|
||||
scaleNotes[i] = scaleNotes[j];
|
||||
scaleNotes[j] = temp;
|
||||
}
|
||||
sortArray(scaleNotes, numScaleNotes);
|
||||
}
|
||||
|
||||
void mutate(Step (*sequence)[NUM_STEPS], int track, int numSteps, int* scaleNotes, int numScaleNotes, int intensity) override {
|
||||
// Phase shift the sequence
|
||||
int shift = random(1, 4);
|
||||
Step temp[NUM_STEPS];
|
||||
for(int i=0; i<numSteps; i++) {
|
||||
temp[i] = sequence[track][(i + shift) % numSteps];
|
||||
}
|
||||
for(int i=0; i<numSteps; i++) {
|
||||
sequence[track][i] = temp[i];
|
||||
}
|
||||
}
|
||||
|
||||
const char* getName() override {
|
||||
return "Wave";
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue
Block a user