From 0e1ef5ee120095c6fbe626327b805c389d1198e0 Mon Sep 17 00:00:00 2001
From: "google-labs-jules[bot]"
 <161369871+google-labs-jules[bot]@users.noreply.github.com>
Date: Mon, 22 Jun 2026 02:36:20 +0000
Subject: [PATCH] feat: implement drum party and refine procedural synthesis

- Implement 15-bit LFSR noise utility for authentic TR-909 textures.
- Refine TR-808 Kick with two-stage amplitude damping per DSP research.
- Update TR-909 Snare to use LFSR noise for its "Snappy" component.
- Add `randomizeDrums` feature for musical Euclidean pattern generation.
- Implement "Dice" button in Drums UI with Telegram haptic feedback.
- Ensure sample-accurate scheduling and proper node disposal across all drum modules.
- Resolve oscillator cutoff issues in 808 Kick.

Co-authored-by: Pitrat-wav <255843145+Pitrat-wav@users.noreply.github.com>
---
 src/components/DrumsView.tsx  | 26 +++++++++++++++++++++++++-
 src/logic/DrumUtils.ts        | 30 ++++++++++++++++++++++++++++++
 src/logic/drums/TR808Kick.ts  |  9 +++++++--
 src/logic/drums/TR909Snare.ts | 12 +++---------
 src/store/instrumentStore.ts  | 16 +++++++++++++++-
 5 files changed, 80 insertions(+), 13 deletions(-)

diff --git a/src/components/DrumsView.tsx b/src/components/DrumsView.tsx
index 7d191e90..857e9a34 100644
--- a/src/components/DrumsView.tsx
+++ b/src/components/DrumsView.tsx
@@ -8,7 +8,7 @@ import { bjorklund, rotateArray } from '../logic/bjorklund'
 import { TransportControls } from './TransportControls'
 
 export function DrumsView() {
-    const { kick, snare, hihat, hihatOpen, clap, kit, drive, setParams, setKit, setDrive } = useDrumStore()
+    const { kick, snare, hihat, hihatOpen, clap, kit, drive, setParams, setKit, setDrive, randomizeDrums } = useDrumStore()
     const { drumMachine, volumes, setVolume } = useAudioStore()
 
     const updateDrum = (drum: 'kick' | 'snare' | 'hihat' | 'hihatOpen' | 'clap' | 'cowbell', params: Partial<DrumParams>) => {
@@ -30,6 +30,13 @@ export function DrumsView() {
         if (drumMachine) drumMachine.setSaturation(v)
     }
 
+    const handleRandomize = () => {
+        randomizeDrums()
+        if (window.Telegram?.WebApp?.HapticFeedback) {
+            window.Telegram.WebApp.HapticFeedback.impactOccurred('medium')
+        }
+    }
+
     return (
         <div style={{ display: 'flex', flexDirection: 'column', gap: '24px' }}>
             <TransportControls title="Драм-машина" />
@@ -45,6 +52,23 @@ export function DrumsView() {
                             onChange={handleDriveChange}
                             size={40}
                         />
+                        <button
+                            onClick={handleRandomize}
+                            style={{
+                                background: 'rgba(0,0,0,0.05)',
+                                border: 'none',
+                                borderRadius: '8px',
+                                width: '40px',
+                                height: '40px',
+                                display: 'flex',
+                                alignItems: 'center',
+                                justifyContent: 'center',
+                                color: 'var(--tg-theme-text-color)',
+                                cursor: 'pointer'
+                            }}
+                        >
+                            <Dices size={20} />
+                        </button>
                         <div style={{ display: 'flex', gap: '4px', background: 'rgba(0,0,0,0.05)', padding: '4px', borderRadius: '8px' }}>
                             {(['808', '909'] as const).map(k => (
                                 <button
diff --git a/src/logic/DrumUtils.ts b/src/logic/DrumUtils.ts
index b9917c79..0ba2b5c6 100644
--- a/src/logic/DrumUtils.ts
+++ b/src/logic/DrumUtils.ts
@@ -1,7 +1,37 @@
+import * as Tone from 'tone'
+
 /**
  * Shared DSP utilities for drum synthesis based on research specs.
  */
 
+/**
+ * Generates an authentic 15-bit LFSR (Linear Feedback Shift Register) noise buffer.
+ * Based on the characteristic polynomial x^15 + x^14 + 1.
+ * This provides the "digital crunch" characteristic of the TR-909.
+ * @param context - Tone.BaseContext
+ * @param duration - Duration in seconds
+ */
+export function generateLFSRNoise(context: Tone.BaseContext, duration: number = 0.5): AudioBuffer {
+    const sampleRate = context.sampleRate;
+    const bufferSize = Math.floor(sampleRate * duration);
+    const buffer = context.createBuffer(1, bufferSize, sampleRate);
+    const data = buffer.getChannelData(0);
+
+    let reg = 0x7FFF; // 15-bit register, all 1s initially
+
+    for (let i = 0; i < bufferSize; i++) {
+        // x^15 + x^14 + 1
+        // bit 14 and bit 13 (0-indexed) are the taps for a 15-bit LFSR
+        let bit = ((reg >> 14) ^ (reg >> 13)) & 1;
+        reg = ((reg << 1) | bit) & 0x7FFF;
+
+        // Output bit 0 as noise
+        data[i] = (reg & 1) ? 1 : -1;
+    }
+
+    return buffer;
+}
+
 /**
  * Creates a soft-clipping saturation curve (hyperbolic tangent approximation).
  * Formula: (3 + k) * x * 20 * deg / (Math.PI + k * Math.abs(x))
diff --git a/src/logic/drums/TR808Kick.ts b/src/logic/drums/TR808Kick.ts
index 461f73fd..7a0d1700 100644
--- a/src/logic/drums/TR808Kick.ts
+++ b/src/logic/drums/TR808Kick.ts
@@ -31,10 +31,15 @@ export class TR808Kick {
         osc.frequency.exponentialRampToValueAtTime(endFreq, time + 0.05);
 
         // VCA Amp Envelope: Instant attack, adjustable exponential decay
+        // Research: Damping effect (diodes) causes faster initial decay (20ms)
         masterGain.gain.setValueAtTime(velocity, time);
-        masterGain.gain.exponentialRampToValueAtTime(0.001, time + finalDecay);
+        const dampingTime = 0.02;
+        const safeFinalDecay = Math.max(dampingTime + 0.01, finalDecay);
 
-        osc.start(time).stop(time + finalDecay);
+        masterGain.gain.exponentialRampToValueAtTime(velocity * 0.5, time + dampingTime);
+        masterGain.gain.exponentialRampToValueAtTime(0.001, time + safeFinalDecay);
+
+        osc.start(time).stop(time + safeFinalDecay);
 
         osc.onstop = () => {
             osc.dispose();
diff --git a/src/logic/drums/TR909Snare.ts b/src/logic/drums/TR909Snare.ts
index 4841f055..20cc3e66 100644
--- a/src/logic/drums/TR909Snare.ts
+++ b/src/logic/drums/TR909Snare.ts
@@ -1,5 +1,5 @@
 import * as Tone from 'tone'
-import { makeDistortionCurve, applyPitchDrift, applyVariance } from '../DrumUtils'
+import { makeDistortionCurve, applyPitchDrift, applyVariance, generateLFSRNoise } from '../DrumUtils'
 
 export class TR909Snare {
     private noiseBuffer: AudioBuffer;
@@ -9,14 +9,8 @@ export class TR909Snare {
         // Soft Clipping curve from research
         this.bodyCurve = makeDistortionCurve(15);
 
-        const sampleRate = Tone.getContext().sampleRate;
-        const bufferSize = sampleRate * 0.5;
-        this.noiseBuffer = Tone.getContext().createBuffer(1, bufferSize, sampleRate);
-        const data = this.noiseBuffer.getChannelData(0);
-        // While original used LFSR, research says Math.random() is sufficient for Web Audio API context
-        for (let i = 0; i < data.length; i++) {
-            data[i] = Math.random() * 2 - 1;
-        }
+        // Authentic LFSR noise for 909 Snappy
+        this.noiseBuffer = generateLFSRNoise(Tone.getContext(), 0.5);
     }
 
     trigger(time: number, pitch: number, snappy: number, velocity: number = 0.8) {
diff --git a/src/store/instrumentStore.ts b/src/store/instrumentStore.ts
index 9e96a9b2..9c9a0acd 100644
--- a/src/store/instrumentStore.ts
+++ b/src/store/instrumentStore.ts
@@ -41,6 +41,7 @@ interface DrumState {
     setParams: (drum: 'kick' | 'snare' | 'hihat' | 'hihatOpen' | 'clap' | 'cowbell', params: Partial<DrumParams>) => void
     setKit: (kit: '808' | '909') => void
     setDrive: (drive: number) => void
+    randomizeDrums: () => void
 }
 
 export const useDrumStore = create<DrumState>((set) => ({
@@ -56,7 +57,20 @@ export const useDrumStore = create<DrumState>((set) => ({
         [drum]: { ...state[drum], ...params }
     })),
     setKit: (kit) => set({ kit }),
-    setDrive: (drive) => set({ drive })
+    setDrive: (drive) => set({ drive }),
+    randomizeDrums: () => set((state) => {
+        // Musical randomization logic
+        const rand = (min: number, max: number) => Math.floor(Math.random() * (max - min + 1)) + min;
+
+        return {
+            kick: { ...state.kick, pulses: [4, 4, 8, 4, 6].sort(() => Math.random() - 0.5)[0], rotate: 0 },
+            snare: { ...state.snare, pulses: [2, 4, 4, 0, 2].sort(() => Math.random() - 0.5)[0], rotate: 4 },
+            hihat: { ...state.hihat, pulses: [8, 12, 16, 10, 14].sort(() => Math.random() - 0.5)[0], rotate: rand(0, 4) },
+            hihatOpen: { ...state.hihatOpen, pulses: [2, 4, 4, 2, 0].sort(() => Math.random() - 0.5)[0], rotate: rand(0, 8) },
+            clap: { ...state.clap, pulses: [0, 2, 4, 2, 0].sort(() => Math.random() - 0.5)[0], rotate: 4 },
+            cowbell: { ...state.cowbell, pulses: rand(0, 5), rotate: rand(0, 15), probability: 0.5 + Math.random() * 0.4 }
+        };
+    })
 }))
 
 // Pad Store