Drone strategy and fixed MIDI panic

2026-02-22 23:03:03 +01:00
parent 33c6329f0b
commit 4e4ba0d0e4
7 changed files with 172 additions and 10 deletions
@@ -0,0 +1,99 @@
+#ifndef DRONE_STRATEGY_H
+#define DRONE_STRATEGY_H
+
+#include "MelodyStrategy.h"
+#include <Arduino.h>
+
+class DroneStrategy : 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;
+
+        // Intensity 1: Very long notes (1-2 per sequence)
+        // Intensity 10: Short notes (active)
+        
+        // Map intensity to duration range
+        // Low intensity (1) -> Max duration is full sequence
+        // High intensity (10) -> Max duration is short (e.g. 4 steps)
+        int maxDur = map(intensity, 1, 10, numSteps, 4);
+        int minDur = map(intensity, 1, 10, numSteps, 1);
+        
+        if (minDur < 1) minDur = 1;
+        if (maxDur < minDur) maxDur = minDur;
+
+        int currentStep = 0;
+        
+        while (currentStep < numSteps) {
+            int duration = random(minDur, maxDur + 1);
+            
+            // Pick a note from the scale
+            // Prefer lower octaves for drones (3 and 4)
+            int octave = 3 + random(2); 
+            int noteIndex = random(numScaleNotes);
+            int note = 12 * octave + scaleNotes[noteIndex];
+            
+            for (int k = 0; k < duration; k++) {
+                int stepIndex = currentStep + k;
+                if (stepIndex >= numSteps) break;
+                
+                sequence[track][stepIndex].note = note;
+                // Tie notes to create continuous sound (legato)
+                sequence[track][stepIndex].tie = true;
+                // Accent only the start of the note
+                sequence[track][stepIndex].accent = (k == 0);
+            }
+            
+            currentStep += duration;
+        }
+        randomSeed(micros());
+    }
+
+    void generateScale(int* scaleNotes, int& numScaleNotes) override {
+        // Drones work well with fewer notes (Pentatonic or Triad)
+        numScaleNotes = random(3, 6);
+        for (int i = 0; i < 12; i++) {
+            scaleNotes[i] = i;
+        }
+        // Shuffle
+        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 {
+        // Mutate by shifting the pitch of a random segment
+        int s = random(numSteps);
+        if (sequence[track][s].note != -1) {
+            int originalNote = sequence[track][s].note;
+            
+            // Find the bounds of this note
+            int start = s;
+            while (start > 0 && sequence[track][start-1].note == originalNote && sequence[track][start-1].tie) {
+                start--;
+            }
+            int end = s;
+            while (end < numSteps - 1 && sequence[track][end].tie && sequence[track][end+1].note == originalNote) {
+                end++;
+            }
+            
+            // Pick a new note
+            int octave = 3 + random(2);
+            int newNote = 12 * octave + scaleNotes[random(numScaleNotes)];
+            
+            for (int i = start; i <= end; i++) {
+                sequence[track][i].note = newNote;
+            }
+        }
+    }
+
+    const char* getName() override {
+        return "Drone";
+    }
+};
+
+#endif