From a17a07c1ad6fe8b7d7d79b3d7317637bb277b173 Mon Sep 17 00:00:00 2001
From: Jimmy MacGregor <jimmy.macgregor@futurenet.com>
Date: Mon, 3 May 2021 15:37:26 +0100
Subject: [PATCH 1/6] Improve global soundControls management

---
 src/App.js                                    | 76 +++++++++----------
 .../segment-component/segment.js              | 29 ++++++-
 src/music/segments/chords.js                  |  3 +
 3 files changed, 64 insertions(+), 44 deletions(-)

diff --git a/src/App.js b/src/App.js
index db243c0..bdfccb9 100644
--- a/src/App.js
+++ b/src/App.js
@@ -67,16 +67,17 @@ const light_theme = createMuiTheme({
  * - 'Regenerate all' button to force all notes to regenerate in a track
  * - Add help system to assist with all parts of the app
  * Options Menu:
+ * - Overall direction (determine root note by increasing/decreasing from source)
+ *    - just generally keep track of lower down things from higher up rather than trying to do things strictly hierarchically!
+ * - Allow/add multiple generators per pattern
+ * Synths:
  * - Make attack/decay/sustain/release more formalized (i.e. specify sustain!) (& ensure that the values _are able to_ scale to the length of time)!
  * - Import/export wavetables as JSON 1
+ * - Import wavetables as mathematical formulae* - can't be free text entry to be eval'ed!
  * - Allow converting from ifft form to wavetable*
  * - Use display to input back into wavetable*
- * - Overall direction (determine root note by increasing/decreasing from source)
- *    - just generally keep track of things rather than trying to do things hierarchically!
- * - Allow/add multiple generators per pattern
  * - Allow composing synths together
- * - Allow specifying chord bias
- * - Allow distortion
+ * - Allow distortion in synths
  * Sections:
  * - Allow specifying the mood of subsections*
  * - Allow inserting specfic runs of notes
@@ -125,7 +126,6 @@ const light_theme = createMuiTheme({
  * - POST-BETA FEATURE
  * - on pasting notes, locks the segment index and reverse engineers the tension/release patterns
  * Code:
- * - Refactor to generate sound controls from just one array 1
  * - Bugfix: keep track of global state/BPM better
  * 
  */
@@ -137,7 +137,14 @@ const App = () => {
   const [context,] = useState(new AudioContext());
   const [oscillators, setOscillators] = useState([]);
   const [customSynths, setCustomSynths] = useState([]);
-  const [additionalSoundControls, setSoundControls] = useState([]);
+  const [soundControls, setSoundControls] = useState([{
+    key: uuidv4(),
+    primary: true,
+    notes: [],
+    context: null,
+    synth: null,
+    ...defaultGlobalOptions
+  }]);
   const [globalOptions, setGlobalOptions] = useState(defaultGlobalOptions);
   const synthControls = {
     addCustomSynth: () => synth => setCustomSynths(prev => [...prev, synth]),
@@ -163,8 +170,7 @@ const App = () => {
     notes: [],
     context: null,
     synth: null,
-    ...defaultGlobalOptions,
-    addNewSoundControls
+    ...defaultGlobalOptions
   }]);
   const addToAdditionalNotes = (key) => ({ value, context, synth, bpm }) => {
     setSoundControls(prev => prev.map(
@@ -187,8 +193,8 @@ const App = () => {
   const clearOscillators = () => setOscillators([]);
   const playAdditionalNotes = () => {
     clearOscillators();
-    console.log('playing additional:', additionalSoundControls)
-    additionalSoundControls.forEach(
+    console.log('playing additional:', soundControls)
+    soundControls.forEach(
       ({ notes, context, synth, bpm }, _, __) => {
         if(notes && context && synth){
           playNotes(notes.flat(), context, synth, bpm, replaceOscillator);
@@ -200,38 +206,24 @@ const App = () => {
   return (
     <ThemeProvider theme={dark_theme}>
       <CssBaseline/>
-      <SoundControls
-        key='alpha-and-omega'
-        context={ context }
-        addNewSoundControls={ addNewSoundControls }
-        customSynths={ customSynths }
-        synthControls={ synthControls }
-        primary={ true }
-        clearOscillators={ clearOscillators }
-        useOscillator={ replaceOscillator }
-        addToAdditionalNotes={ () => {} }
-        playAdditionalNotes={ playAdditionalNotes }
-        setGlobalOption={ setGlobalOption }
-        globalOptions={ globalOptions }
-         />
       {
-        additionalSoundControls.length > 0 &&
-          additionalSoundControls.map(
-            desc =>
-              <SoundControls
-                key={ desc.key }
-                context={ context }
-                customSynths={ customSynths }
-                synthControls={ synthControls }
-                addNewSoundControls={ desc.addNewSoundControls }
-                clearOscillators={ clearOscillators }
-                useOscillator={ replaceOscillator }
-                addToAdditionalNotes={ addToAdditionalNotes(desc.key) }
-                primary={ desc.primary }
-                setGlobalOption={ setGlobalOption }
-                globalOptions={ globalOptions }
-                removeSelf={ () => removeSelf(desc.key) } />
-          )
+        soundControls.map(
+          desc =>
+            <SoundControls
+              key={ desc.key }
+              context={ context }
+              customSynths={ customSynths }
+              synthControls={ synthControls }
+              addNewSoundControls={ addNewSoundControls }
+              clearOscillators={ clearOscillators }
+              useOscillator={ replaceOscillator }
+              addToAdditionalNotes={ addToAdditionalNotes(desc.key) }
+              playAdditionalNotes={ playAdditionalNotes }
+              primary={ desc.primary }
+              setGlobalOption={ setGlobalOption }
+              globalOptions={ globalOptions }
+              removeSelf={ () => removeSelf(desc.key) } />
+        )
       }
       <Oscilloscope context={ context } source={ oscillators[oscillators.length-1] }/>
     </ThemeProvider>
diff --git a/src/music/segment-components/segment-component/segment.js b/src/music/segment-components/segment-component/segment.js
index 3306fd2..f48d36d 100644
--- a/src/music/segment-components/segment-component/segment.js
+++ b/src/music/segment-components/segment-component/segment.js
@@ -6,8 +6,10 @@ import {
     MenuItem,
     InputLabel,
     TextField,
-    Typography
+    Typography,
+    ListSubheader
 } from '@material-ui/core';
+import chordStrategies from '../../segments/chords';
 import { Chord } from 'octavian';
 import { RELEASE, TENSION } from '../../segments/constants';
 
@@ -80,7 +82,30 @@ const Segment = ({
                 }
              } } label={'Repeats'} id={`repeat-${ name }-${ repeats }`} placeholder={'1'} value={ repeats } type={ 'number' } />
         </Grid>
-
+        {/* <Grid item>
+            <Tooltip placement={ 'top' } title={ 'SELECT CHORD STRATEGY' } aria-label={ 'select a strategy for creating chords' }>
+                <InputLabel style={{ color }} id="chord-strategy-select">Chord Strategy</InputLabel>
+            </Tooltip>
+            <Select
+                style={{ color }}
+                labelId="chord-strategy-select"
+                id="chord-strategy-selector">
+                {
+                    Object.entries(chordStrategies).map(
+                        ([chordStrategyGroupName, chordStrategyGroup])  => 
+                            Object.keys(chordStrategyGroup).map(
+                                chordStrategyName => {
+                                    console.log(chordStrategyGroupName, chordStrategyName);
+                                    return <MenuItem value={[chordStrategyGroupName,chordStrategyName]}>
+                                        <small>{ `${ chordStrategyGroupName.toUpperCase() }:` }&nbsp;</small>
+                                        { chordStrategyName.toUpperCase() }
+                                    </MenuItem>
+                                    
+                                }
+                            ))
+                }
+            </Select>
+        </Grid> */}
         <Grid item>
             <Button style={{ color }} onClick={ removeSegment }>REMOVE {name}</Button>
         </Grid>
diff --git a/src/music/segments/chords.js b/src/music/segments/chords.js
index 9050126..da6f3f1 100644
--- a/src/music/segments/chords.js
+++ b/src/music/segments/chords.js
@@ -2,6 +2,9 @@ import { TENSION, RELEASE, EITHER, tenseMoves, releaseMoves } from './constants'
 import { pick } from './index';
 
 const chordStrategies = {
+    none: {
+        default: chord => chord
+    },
     random: {
         withMood: ({ chord, mood, threshold = 0.5 }) => {
             let interval;

From 3bd4b036d2f002284ac191761f88f1f3e260b17b Mon Sep 17 00:00:00 2001
From: Jimmy MacGregor <jimmy.macgregor@futurenet.com>
Date: Mon, 3 May 2021 16:54:48 +0100
Subject: [PATCH 2/6] Fix for BPM; not the cleanest

---
 src/App.js                                    | 20 ++++++++++----
 src/music/index.js                            | 27 ++++++++++++++-----
 src/music/options/global.js                   | 16 ++++++-----
 src/music/options/index.js                    |  9 ++++++-
 .../segment-components/segment-container.js   |  8 ++++--
 5 files changed, 59 insertions(+), 21 deletions(-)

diff --git a/src/App.js b/src/App.js
index bdfccb9..1702d48 100644
--- a/src/App.js
+++ b/src/App.js
@@ -126,12 +126,18 @@ const light_theme = createMuiTheme({
  * - POST-BETA FEATURE
  * - on pasting notes, locks the segment index and reverse engineers the tension/release patterns
  * Code:
- * - Bugfix: keep track of global state/BPM better
+ * - Refactor: global and local state.
  * 
  */
+
+/**
+ * Move to own config file
+ */
 const defaultGlobalOptions = {
-  bpm: 120
+  bpm: 120,
+  useGlobalBPM: true
 }
+// Config ends
 
 const App = () => {
   const [context,] = useState(new AudioContext());
@@ -172,17 +178,20 @@ const App = () => {
     synth: null,
     ...defaultGlobalOptions
   }]);
-  const addToAdditionalNotes = (key) => ({ value, context, synth, bpm }) => {
+  const addToAdditionalNotes = (key) => ({ value, context, synth, bpm, useGlobalBPM }) => {
     setSoundControls(prev => prev.map(
       soundControls => soundControls.key !== key ?
-        soundControls :
+        soundControls.useGlobalBPM && useGlobalBPM ? 
+          { ...soundControls, bpm } :
+          soundControls :
         Object.assign(
           { ...soundControls },
           {
             notes: value(soundControls.notes),
             context,
             synth,
-            bpm
+            bpm,
+            useGlobalBPM
           }
         )
     ))
@@ -220,6 +229,7 @@ const App = () => {
               addToAdditionalNotes={ addToAdditionalNotes(desc.key) }
               playAdditionalNotes={ playAdditionalNotes }
               primary={ desc.primary }
+              useGlobalBPM={ desc.useGlobalBPM }
               setGlobalOption={ setGlobalOption }
               globalOptions={ globalOptions }
               removeSelf={ () => removeSelf(desc.key) } />
diff --git a/src/music/index.js b/src/music/index.js
index 4dc6b0f..92345bd 100644
--- a/src/music/index.js
+++ b/src/music/index.js
@@ -36,8 +36,7 @@ const playNotes = (notes, context, synth, bpm, useOscillator=()=>{}) => {
 // Note helpers ends
 
 //Config to go in own file
-const soundControlsShouldUpdateOn = ['bpm'];
-
+const soundControlsShouldUpdateOn = ['bpm', 'useGlobalBPM'];
 // Config ends
 
 const SoundControls = ({
@@ -75,7 +74,7 @@ const SoundControls = ({
     ));
     }
 
-    const { bpm } = deFactoOptions;
+    const { bpm, useGlobalBPM } = deFactoOptions;
     const soundControlValues = soundControlsShouldUpdateOn.reduce((acc, curr) => {
         acc[curr] = deFactoOptions[curr];
         return acc;
@@ -87,12 +86,12 @@ const SoundControls = ({
     }
 
     const handleSetNotes = value => {
-        addToAdditionalNotes({ value, context, synth, bpm });
+        addToAdditionalNotes({ value, context, synth, bpm, useGlobalBPM });
         setNotes( value );
     }
 
     const handleSetSynth = value => {
-        addToAdditionalNotes({ value: id=>id, context, synth: value, bpm });
+        addToAdditionalNotes({ value: id=>id, context, synth: value, bpm, useGlobalBPM });
         setSynth( value );
     }
 
@@ -111,9 +110,23 @@ const SoundControls = ({
         }
         setDeFactoOption(key, value);
     }
+    const setDefactoOptions = (opts) => {
+        const updateObject = Object.entries(opts).reduce((acc, [key, value]) => {
+            setDeFactoOption(key, value);
+            if(soundControlsShouldUpdateOn.includes(key)) {
+                return Object.assign(acc, { [key]: value });
+            }
+            return acc;
+        }, {
+            value: id=>id,
+            context,
+            synth,
+            ...soundControlValues
+        });
+        addToAdditionalNotes(updateObject);
+    }
     
     const handlePlayAll = () => {
-        handlePlay();
         playAdditionalNotes();
     }
 
@@ -139,9 +152,11 @@ const SoundControls = ({
                 synthControls={ synthControls }
                 globalOptions={ globalOptions }
                 setGlobalOption={ setGlobalOption }
+                useGlobalBPM={ useGlobalBPM }
                 localOptions={ localOptions }
                 setLocalOption={ setLocalOption }
                 setDeFactoOption={ handleSetDeFactoOption }
+                setDeFactoOptions={ setDefactoOptions }
                 addNewSoundControls={ addNewSoundControls }
                 />
         </Grid>
diff --git a/src/music/options/global.js b/src/music/options/global.js
index 14a74d2..de98ffa 100644
--- a/src/music/options/global.js
+++ b/src/music/options/global.js
@@ -5,10 +5,15 @@ import {
     FormControlLabel,
     Switch
 } from '@material-ui/core';
-import React, { useState } from 'react';
+import React from 'react';
 
-const Option = ({ global, setGlobal, setOpt, Type, tooltipDetails, options=false, setLocal, local, ...props }) => {
-    const [useGlobal, setUseGlobal] = useState(true);
+const Option = ({
+    global, setGlobal,
+    useGlobal, setUseGlobal,
+    setLocal, local,
+    setOpt,
+    Type, tooltipDetails, options=false,
+    ...props }) => {
     const value = useGlobal ? global : local;
     const nextValue = useGlobal ? local : global;
     const setValue = useGlobal ? setGlobal : setLocal;
@@ -42,10 +47,7 @@ const Option = ({ global, setGlobal, setOpt, Type, tooltipDetails, options=false
             control={
             <Switch
                 checked={useGlobal}
-                onChange={() => {
-                    setUseGlobal(prev => !prev)
-                    setOpt({ target: { value: nextValue }});
-                }}
+                onChange={setUseGlobal(nextValue, !useGlobal)}
                 name="useGlobal"
                 color="primary"
             />
diff --git a/src/music/options/index.js b/src/music/options/index.js
index 2578816..2ed04c8 100644
--- a/src/music/options/index.js
+++ b/src/music/options/index.js
@@ -48,9 +48,11 @@ const OptionMenu = ({
     setDefaultRootNote,
     globalOptions,
     setGlobalOption,
+    useGlobalBPM,
     localOptions,
     setLocalOption,
-    setOpt
+    setOpt,
+    setOpts
 }) => {
     const [ customSynthOpen, setCustomSynthOpen ] = useState(false);
     const [ synthMethodReplace, setSynthMethodReplace ] = useState(false);
@@ -252,6 +254,11 @@ const OptionMenu = ({
                 Type={ TextField }
                 global={ bpm }
                 setGlobal={ setGlobalOption('bpm') }
+                useGlobal={ useGlobalBPM }
+                setUseGlobal={ (next, useGlobalBPM) => () => setOpts({
+                    bpm: next,
+                    useGlobalBPM
+                }) }
                 tooltipDetails={{ placement: 'top', title: 'Beats Per Minute', label: 'BPM:', aria_label: 'beats per minute' }}
                 setLocal={ setLocalOption('bpm') } local={ localBPM } type={ 'number' }
                 setOpt={ setOpt('bpm') }/>
diff --git a/src/music/segment-components/segment-container.js b/src/music/segment-components/segment-container.js
index e7eeb37..5960fe7 100644
--- a/src/music/segment-components/segment-container.js
+++ b/src/music/segment-components/segment-container.js
@@ -37,9 +37,11 @@ const SegmentContainer = ({
     addNewSoundControls,
     globalOptions,
     setGlobalOption,
+    useGlobalBPM,
     localOptions,
     setLocalOption,
-    setDeFactoOption
+    setDeFactoOption,
+    setDeFactoOptions
 }) => {
     const [Menu, setMenu] = useState(false);
     const [segments, setSegments] = useState([]);
@@ -141,9 +143,11 @@ const SegmentContainer = ({
                 setDefaultRootNote={ setDefaultRootNote}
                 globalOptions={ globalOptions }
                 setGlobalOption={ setGlobalOption }
+                useGlobalBPM={ useGlobalBPM }
                 localOptions={ localOptions }
                 setLocalOption={ setLocalOption }
-                setOpt={ setDeFactoOption }/> : ''
+                setOpt={ setDeFactoOption }
+                setOpts={ setDeFactoOptions }/> : ''
             }
         </Grid>
         <Accordion style={{ width: '100%' }} defaultExpanded>

From 4a1a2020bf91b438fcb185c99e07d10a4628f082 Mon Sep 17 00:00:00 2001
From: Jimmy MacGregor <jimmy.macgregor@futurenet.com>
Date: Mon, 3 May 2021 18:38:40 +0100
Subject: [PATCH 3/6] Give in and use strings

---
 .../segment-component/segment.js                  |  8 ++++----
 src/music/segments/chords.js                      | 15 ++++++++++++++-
 src/music/segments/constants.js                   |  4 ++--
 src/music/segments/index.js                       |  4 ++--
 4 files changed, 22 insertions(+), 9 deletions(-)

diff --git a/src/music/segment-components/segment-component/segment.js b/src/music/segment-components/segment-component/segment.js
index f48d36d..bf318c4 100644
--- a/src/music/segment-components/segment-component/segment.js
+++ b/src/music/segment-components/segment-component/segment.js
@@ -82,11 +82,12 @@ const Segment = ({
                 }
              } } label={'Repeats'} id={`repeat-${ name }-${ repeats }`} placeholder={'1'} value={ repeats } type={ 'number' } />
         </Grid>
-        {/* <Grid item>
+        <Grid item>
             <Tooltip placement={ 'top' } title={ 'SELECT CHORD STRATEGY' } aria-label={ 'select a strategy for creating chords' }>
                 <InputLabel style={{ color }} id="chord-strategy-select">Chord Strategy</InputLabel>
             </Tooltip>
             <Select
+                value={`none,default`}
                 style={{ color }}
                 labelId="chord-strategy-select"
                 id="chord-strategy-selector">
@@ -95,8 +96,7 @@ const Segment = ({
                         ([chordStrategyGroupName, chordStrategyGroup])  => 
                             Object.keys(chordStrategyGroup).map(
                                 chordStrategyName => {
-                                    console.log(chordStrategyGroupName, chordStrategyName);
-                                    return <MenuItem value={[chordStrategyGroupName,chordStrategyName]}>
+                                    return <MenuItem value={`${chordStrategyGroupName},${chordStrategyName}`}>
                                         <small>{ `${ chordStrategyGroupName.toUpperCase() }:` }&nbsp;</small>
                                         { chordStrategyName.toUpperCase() }
                                     </MenuItem>
@@ -105,7 +105,7 @@ const Segment = ({
                             ))
                 }
             </Select>
-        </Grid> */}
+        </Grid>
         <Grid item>
             <Button style={{ color }} onClick={ removeSegment }>REMOVE {name}</Button>
         </Grid>
diff --git a/src/music/segments/chords.js b/src/music/segments/chords.js
index da6f3f1..04fc890 100644
--- a/src/music/segments/chords.js
+++ b/src/music/segments/chords.js
@@ -1,12 +1,25 @@
 import { TENSION, RELEASE, EITHER, tenseMoves, releaseMoves } from './constants';
+import { Note, Chord } from 'octavian';
 import { pick } from './index';
 
+const gospel9 = chord => {
+    // Move 'root' down to major Seventh below
+    const chordRoot = new Note(chord.signatures[0]);
+    const seventhBase = chordRoot.downOctave().majorSeventh().toChord();
+    // From the major, so this is just 1-3-5-7-9 voiced dramatically
+    return seventhBase // 7
+        .addInterval('minorSecond') // 1
+        .addInterval('minorThird') // 9
+        .addInterval('perfectFourth') // 3
+        .addInterval('minorSixth') // 5
+}
+
 const chordStrategies = {
     none: {
         default: chord => chord
     },
     random: {
-        withMood: ({ chord, mood, threshold = 0.5 }) => {
+        "with mood": ({ chord, mood, threshold = 0.5 }) => {
             let interval;
             switch(mood) {
                 case TENSION:
diff --git a/src/music/segments/constants.js b/src/music/segments/constants.js
index f5eba84..9f7fac3 100644
--- a/src/music/segments/constants.js
+++ b/src/music/segments/constants.js
@@ -12,13 +12,13 @@ const tenseMoves = [
     'diminishedFifth',
     'minorSixth',
     'majorSixth',
-    'minorSeventh',
-    'majorSeventh'
+    'minorSeventh'
 ];
 
 const releaseMoves = [
     'majorThird',
     'perfectFifth',
+    'majorSeventh',
     'downOctave',
     // 'perfectOctave',
     false
diff --git a/src/music/segments/index.js b/src/music/segments/index.js
index a8ecc26..d5e2c9b 100644
--- a/src/music/segments/index.js
+++ b/src/music/segments/index.js
@@ -56,7 +56,7 @@ const diatom = (root, mood) => {
         if(method === false) {
             console.log('false; selecting root',  root);
             let next = root.toChord();
-            next = chordStrategies.random.withMood({ chord: next, mood });
+            next = chordStrategies.random['with mood']({ chord: next, mood });
             return [root, next];
         }
         // Falling more likely for release
@@ -70,7 +70,7 @@ const diatom = (root, mood) => {
     const alteredRoot = alterMethod ? root[alterMethod]() : root;
     try {
         next = alteredRoot[method]().toChord();
-        next = chordStrategies.random.withMood({ chord: next, mood });
+        next = chordStrategies.random['with mood']({ chord: next, mood });
     } catch (error) {
         console.log('error, method:', method, alteredRoot);
         const safeNote = new Chord(pick(startingNotes));

From 4a2a7b1ccbf19d4fe95b278b0d73a1accc2e7edd Mon Sep 17 00:00:00 2001
From: Jimmy MacGregor <jimmy.macgregor@futurenet.com>
Date: Mon, 3 May 2021 21:18:57 +0100
Subject: [PATCH 4/6] select chord strategies

---
 .../segment-component/segment.js              | 26 ++++++++----
 .../segment-components/segment-container.js   | 40 +++++++++++++-----
 src/music/segments/chords.js                  | 17 +++++++-
 src/music/segments/index.js                   | 42 +++++++++----------
 4 files changed, 84 insertions(+), 41 deletions(-)

diff --git a/src/music/segment-components/segment-component/segment.js b/src/music/segment-components/segment-component/segment.js
index bf318c4..767c1b7 100644
--- a/src/music/segment-components/segment-component/segment.js
+++ b/src/music/segment-components/segment-component/segment.js
@@ -6,8 +6,7 @@ import {
     MenuItem,
     InputLabel,
     TextField,
-    Typography,
-    ListSubheader
+    Typography
 } from '@material-ui/core';
 import chordStrategies from '../../segments/chords';
 import { Chord } from 'octavian';
@@ -15,12 +14,13 @@ import { RELEASE, TENSION } from '../../segments/constants';
 
 const Segment = ({
     color,
-    segmentType: { name, gridSize, root, repeats, mood },
+    segmentType: { name, gridSize, root, repeats, mood, chordStrategy },
     removeSegment,
     regenerateNotes,
     setRootNote,
     setMood,
-    setRepeats
+    setRepeats,
+    setChordStrategy
 }) => {
     return <Grid
         container
@@ -36,7 +36,7 @@ const Segment = ({
             <TextField onChange={ ({ target: { value }}) => {
                 try {
                     const rootNote = new Chord(value);
-                    regenerateNotes(mood, rootNote, repeats);
+                    regenerateNotes(mood, rootNote, repeats, chordStrategy);
                 } catch {
                     console.warn(`Invalid root note: ${ value }`)
                 } finally {
@@ -57,7 +57,7 @@ const Segment = ({
                 onChange={ ({ target: { value }}) => {
                     console.log('Changing value: ', value);
                     try {
-                        regenerateNotes(value, new Chord(root), repeats);
+                        regenerateNotes(value, new Chord(root), repeats, chordStrategy);
                         setMood(value);
                     } catch {
                         console.warn(`Invalid mood: ${ value }`)
@@ -73,7 +73,7 @@ const Segment = ({
                 console.log('Changing repeats: ', value);
                 try {
                     if(value > 0) {
-                        regenerateNotes(mood, new Chord(root), value);
+                        regenerateNotes(mood, new Chord(root), value, chordStrategy);
                     }
                 } catch {
                     console.warn(`Invalid repeat value: ${ value }`)
@@ -87,7 +87,17 @@ const Segment = ({
                 <InputLabel style={{ color }} id="chord-strategy-select">Chord Strategy</InputLabel>
             </Tooltip>
             <Select
-                value={`none,default`}
+                value={chordStrategy}
+                onChange={ ({ target: { value }}) => {
+                    console.log('Changing chord strategy: ', value);
+                    try {
+                        regenerateNotes(mood, new Chord(root), repeats, value);
+                    } catch {
+                        console.warn(`Invalid chord strategy value: ${ value }`)
+                    } finally {
+                        setChordStrategy(value);
+                    }
+                 }  }
                 style={{ color }}
                 labelId="chord-strategy-select"
                 id="chord-strategy-selector">
diff --git a/src/music/segment-components/segment-container.js b/src/music/segment-components/segment-container.js
index 5960fe7..d39707e 100644
--- a/src/music/segment-components/segment-container.js
+++ b/src/music/segment-components/segment-container.js
@@ -16,8 +16,8 @@ import { repeatNotes } from '../segments';
 import { RELEASE } from '../segments/constants';
 import OptionMenu from '../options';
 
-const generateNotes = (f, mood, rootNote, repeats) => {
-    const notes = f(rootNote, mood);
+const generateNotes = (f, mood, rootNote, repeats, chordStrategy) => {
+    const notes = f(rootNote, mood, chordStrategy);
 
     return repeatNotes(notes, repeats);
 }
@@ -46,25 +46,39 @@ const SegmentContainer = ({
     const [Menu, setMenu] = useState(false);
     const [segments, setSegments] = useState([]);
 
-    const addNewNotes = (f, mood, rootNote, repeats) => {
-        const notes = generateNotes(f, mood, rootNote, repeats);
+    const addNewNotes = (f, mood, rootNote, repeats, chordStrategy) => {
+        const notes = generateNotes(f, mood, rootNote, repeats, chordStrategy);
         setNotes(prev => prev.concat([notes]));
     }
 
     const addSegment = (segmentType) => {
         setSegments(prev => {
-            const segment = {...segmentType, root: defaultRootNote, repeats: 1, mood: defaultMood };
+            const segment = {...segmentType, root: defaultRootNote, repeats: 1, mood: defaultMood,
+                chordStrategy: 'none,default' };
             const next = prev.concat({
                 segment,
                 uuid: uuidv4()
             });
-            addNewNotes(segment.action, segment.mood, new Chord(segment.root), segment.repeats);
+            addNewNotes(segment.action, segment.mood, new Chord(segment.root), segment.repeats, segment.chordStrategy);
             return next;
         })
     }
 
-    const regenerateNotes = (segmentType, i, mood = RELEASE, rootNote='C3', repeats=1) => {
-        const nextNotes = generateNotes(segmentType.action, mood, rootNote, repeats);
+    const regenerateNotes = (
+            segmentType,
+            i,
+            mood = RELEASE,
+            rootNote='C3',
+            repeats=1,
+            chordStrategy='none,default'
+        ) => {
+        const nextNotes = generateNotes(
+            segmentType.action,
+            mood,
+            rootNote,
+            repeats,
+            chordStrategy
+        );
         setNotes(prev => {
             const next = [...prev];
             next[i] = nextNotes;
@@ -153,8 +167,8 @@ const SegmentContainer = ({
         <Accordion style={{ width: '100%' }} defaultExpanded>
         <AccordionSummary
             expandIcon={<ExpandMoreIcon />}
-            aria-controls="panel1c-content"
-            id="panel1c-header">
+            aria-controls="track-details"
+            id="track-details-header">
             <Typography>Track Details</Typography>
         </AccordionSummary>
         <AccordionDetails>
@@ -181,7 +195,11 @@ const SegmentContainer = ({
                         setRootNote={ setSegmentField(i, 'root') }
                         setMood={ setSegmentField(i, 'mood') }
                         setRepeats={ setSegmentField(i, 'repeats') }
-                        regenerateNotes={ (mood, rootNote, repeats = 1) => regenerateNotes(segment.segment, i, mood, rootNote, repeats) }
+                        setChordStrategy={ setSegmentField(i, 'chordStrategy') }
+                        regenerateNotes={
+                            (mood, rootNote, repeats, chordStrategy) =>
+                                regenerateNotes(segment.segment, i, mood, rootNote, repeats, chordStrategy)
+                        }
                         removeSegment={ () => removeSegment(i) } />;
                 }) :
                 ''
diff --git a/src/music/segments/chords.js b/src/music/segments/chords.js
index 04fc890..445b9d1 100644
--- a/src/music/segments/chords.js
+++ b/src/music/segments/chords.js
@@ -16,7 +16,7 @@ const gospel9 = chord => {
 
 const chordStrategies = {
     none: {
-        default: chord => chord
+        default: ({ chord }) => chord
     },
     random: {
         "with mood": ({ chord, mood, threshold = 0.5 }) => {
@@ -49,4 +49,19 @@ const chordStrategies = {
     }
 }
 
+const getStrategy = strategy => {
+    if(typeof strategy === 'string') {
+        strategy = strategy.split(',');
+    }
+    if(Array.isArray(strategy)) {
+        let objectPath = chordStrategies;
+        strategy.forEach(path => {
+            objectPath = objectPath[path];
+        })
+        strategy = objectPath;
+    }
+    return strategy;
+}
+
+export { getStrategy };
 export default chordStrategies;
\ No newline at end of file
diff --git a/src/music/segments/index.js b/src/music/segments/index.js
index d5e2c9b..b2acb9a 100644
--- a/src/music/segments/index.js
+++ b/src/music/segments/index.js
@@ -3,7 +3,7 @@ import {
     TENSION, RELEASE,
     startingNotes,
     tenseMoves, releaseMoves } from './constants';
-import chordStrategies from './chords';
+import chordStrategies, { getStrategy } from './chords';
 
 // Move to utilities folder
 const pick = (array) => array[Math.floor(Math.random()*array.length)];
@@ -38,7 +38,7 @@ const pickBiasLate = (array) => {
 }
 // utilities
 
-const diatom = (root, mood) => {
+const diatom = (root, mood, chordStrategy='none,default') => {
     let method, alterMethod;
     // Determine this with a max octave setting
     const aboveMiddle = root.octave > 5 ? root.octave - 2 : 0;
@@ -56,7 +56,7 @@ const diatom = (root, mood) => {
         if(method === false) {
             console.log('false; selecting root',  root);
             let next = root.toChord();
-            next = chordStrategies.random['with mood']({ chord: next, mood });
+            next = getStrategy(chordStrategy)({ chord: next, mood });
             return [root, next];
         }
         // Falling more likely for release
@@ -70,7 +70,7 @@ const diatom = (root, mood) => {
     const alteredRoot = alterMethod ? root[alterMethod]() : root;
     try {
         next = alteredRoot[method]().toChord();
-        next = chordStrategies.random['with mood']({ chord: next, mood });
+        next = getStrategy(chordStrategy)({ chord: next, mood });
     } catch (error) {
         console.log('error, method:', method, alteredRoot);
         const safeNote = new Chord(pick(startingNotes));
@@ -79,10 +79,10 @@ const diatom = (root, mood) => {
     return [root,next];
 }
 
-const createDiatoms = (rootNote, moods = []) => {
+const createDiatoms = (rootNote, moods = [], chordStrategy) => {
     const notes = moods.reduce(
         (accumulator, mood) => {
-            const next = diatom(accumulator[accumulator.length-1].notes[0], mood);
+            const next = diatom(accumulator[accumulator.length-1].notes[0], mood, chordStrategy);
             return [...accumulator, next[1]];
         },
         [rootNote]
@@ -121,25 +121,25 @@ const moodsFromMood = (mood, n = 2) => {
     return moods;
 }
 
-const noteChange = (rootNote, mood) => {
-    return createDiatoms(rootNote, [mood]);
+const noteChange = (rootNote, mood, chordStrategy) => {
+    return createDiatoms(rootNote, [mood], chordStrategy);
 }
 
-const shortPhrase = (rootNote, mood) => {
+const shortPhrase = (rootNote, mood, chordStrategy) => {
     const moods = moodsFromMood(mood);
-    return createDiatoms(rootNote, moods);
+    return createDiatoms(rootNote, moods, chordStrategy);
 }
 
-const createComplex = (rootNote, moods, f) => {
+const createComplex = (rootNote, moods, chordStrategy, f) => {
     const notes = moods.reduce(
         (accumulator, mood) => {
             let next;
             if(mood === TENSION) {
                 // Allow moving away from root for sake of tension
-                next = f(accumulator[accumulator.length-1], mood);
+                next = f(accumulator[accumulator.length-1], mood, chordStrategy);
             } else {
                 // Check with both these; else revert to using rootNote
-                next = f(accumulator[accumulator.length-1], mood);
+                next = f(accumulator[accumulator.length-1], mood, chordStrategy);
             }
             return [...accumulator, ...next.slice(1)];
         },
@@ -148,24 +148,24 @@ const createComplex = (rootNote, moods, f) => {
     return notes;
 }
 
-const longPhrase = (rootNote, mood) => {
+const longPhrase = (rootNote, mood, chordStrategy) => {
     const moods = moodsFromMood(mood);
-    return createComplex(rootNote, moods, shortPhrase);
+    return createComplex(rootNote, moods, chordStrategy, shortPhrase);
 }
 
-const passage = (rootNote, mood, n = 4) => {
+const passage = (rootNote, mood, chordStrategy, n = 4) => {
     const moods = moodsFromMood(mood, n);
-    return createComplex(rootNote, moods, longPhrase);
+    return createComplex(rootNote, moods, chordStrategy, longPhrase);
 }
 
-const section = (rootNote, mood, n = 2) => {
+const section = (rootNote, mood, chordStrategy, n = 2) => {
     const moods = moodsFromMood(mood, n);
-    return createComplex(rootNote, moods, passage);
+    return createComplex(rootNote, moods, chordStrategy, passage);
 }
 
-const piece = (rootNote, mood, n = 2) => {
+const piece = (rootNote, mood, chordStrategy, n = 2) => {
     const moods = moodsFromMood(mood, n);
-    return createComplex(rootNote, moods, section);
+    return createComplex(rootNote, moods, chordStrategy, section);
 }
 
 const repeatNotes = (notes, n) => {

From f41e9f9649fa243b904a3b7ae698dc6bf2fd88d6 Mon Sep 17 00:00:00 2001
From: Jimmy MacGregor <jimmy.macgregor@futurenet.com>
Date: Mon, 3 May 2021 22:49:35 +0100
Subject: [PATCH 5/6] Add controls for chord options (non-functional)

---
 .../segment-component/segment.js              | 89 ++++++++++++++++++-
 .../segment-components/segment-container.js   | 37 ++++++--
 src/music/segments/chords.js                  | 14 ++-
 src/music/segments/index.js                   |  8 +-
 4 files changed, 129 insertions(+), 19 deletions(-)

diff --git a/src/music/segment-components/segment-component/segment.js b/src/music/segment-components/segment-component/segment.js
index 767c1b7..fbcfa8f 100644
--- a/src/music/segment-components/segment-component/segment.js
+++ b/src/music/segment-components/segment-component/segment.js
@@ -14,13 +14,29 @@ import { RELEASE, TENSION } from '../../segments/constants';
 
 const Segment = ({
     color,
-    segmentType: { name, gridSize, root, repeats, mood, chordStrategy },
+    segmentType: {
+        name,
+        gridSize,
+        root,
+        repeats,
+        mood,
+        chordStrategy,
+        chordOptions,
+        chordOptions: {
+            threshold,
+            maxStack,
+            minStack
+        }
+    },
     removeSegment,
     regenerateNotes,
     setRootNote,
     setMood,
     setRepeats,
-    setChordStrategy
+    setChordStrategy,
+    setChordThreshold,
+    setChordMaxStack,
+    setChordMinStack
 }) => {
     return <Grid
         container
@@ -116,6 +132,75 @@ const Segment = ({
                 }
             </Select>
         </Grid>
+        {
+        chordStrategy.startsWith('none') ? '' :
+        <Grid>
+            <Grid item>
+                <TextField
+                    type={ 'number' }
+                    onChange={ ({ target: { value }}) => {
+                        try {
+                            if(value > 0) {
+                                regenerateNotes(mood, new Chord(root), repeats, chordStrategy, {
+                                    ...chordOptions,
+                                    threshold: value
+                                });
+                            }
+                        } catch {
+                            console.warn(`Invalid chord threshold value: ${ value }`)
+                        } finally {
+                            setChordThreshold(parseFloat(value));
+                        }
+                        } }
+                    label={'Chord Threshold'} id={`chord-threshold-${ name }-${ threshold }`}
+                    placeholder={'0.5'} value={ threshold }  />
+            </Grid>
+            <Grid item>
+                <TextField
+                    type={ 'number' }
+                    onChange={ ({ target: { value }}) => {
+                        const val = parseInt(value);
+                        try {
+                            regenerateNotes(mood, new Chord(root), repeats, chordStrategy, {
+                                ...chordOptions,
+                                maxStack: value
+                            });
+                        } catch {
+                            console.warn(`Invalid chord threshold value: ${ value }`)
+                        } finally {
+                            setChordMaxStack(value);
+                            if(val < minStack) {
+                                setChordMinStack(value);
+                            }
+                        }
+                        } }
+                    label={'Max Chord Stack'} id={`chord-max-stack-${ name }-${ maxStack }`}
+                    placeholder={'3'} value={ maxStack }  />
+            </Grid>
+            <Grid item>
+                <TextField
+                    type={ 'number' }
+                    onChange={ ({ target: { value }}) => {
+                        const val = parseInt(value);
+                        try {
+                            regenerateNotes(mood, new Chord(root), repeats, chordStrategy, {
+                                ...chordOptions,
+                                minStack: value
+                            });
+                        } catch {
+                            console.warn(`Invalid chord threshold value: ${ value }`)
+                        } finally {
+                            setChordMinStack(value);
+                            if(val > maxStack) {
+                                setChordMaxStack(value);
+                            }
+                        }
+                        } }
+                    label={'Min Chord Stack'} id={`chord-min-stack-${ name }-${ minStack }`}
+                    placeholder={'0'} value={ minStack }  />
+            </Grid>
+        </Grid>
+        }
         <Grid item>
             <Button style={{ color }} onClick={ removeSegment }>REMOVE {name}</Button>
         </Grid>
diff --git a/src/music/segment-components/segment-container.js b/src/music/segment-components/segment-container.js
index d39707e..86a3b83 100644
--- a/src/music/segment-components/segment-container.js
+++ b/src/music/segment-components/segment-container.js
@@ -15,10 +15,10 @@ import { v4 as uuidv4 } from 'uuid';
 import { repeatNotes } from '../segments';
 import { RELEASE } from '../segments/constants';
 import OptionMenu from '../options';
+import { defaultChordOptions } from '../segments/chords.js';
 
 const generateNotes = (f, mood, rootNote, repeats, chordStrategy) => {
     const notes = f(rootNote, mood, chordStrategy);
-
     return repeatNotes(notes, repeats);
 }
 
@@ -46,20 +46,27 @@ const SegmentContainer = ({
     const [Menu, setMenu] = useState(false);
     const [segments, setSegments] = useState([]);
 
-    const addNewNotes = (f, mood, rootNote, repeats, chordStrategy) => {
-        const notes = generateNotes(f, mood, rootNote, repeats, chordStrategy);
+    const addNewNotes = (f, mood, rootNote, repeats, chordStrategy,chordOptions=defaultChordOptions) => {
+        const notes = generateNotes(f, mood, rootNote, repeats, chordStrategy, chordOptions);
         setNotes(prev => prev.concat([notes]));
     }
 
     const addSegment = (segmentType) => {
         setSegments(prev => {
             const segment = {...segmentType, root: defaultRootNote, repeats: 1, mood: defaultMood,
-                chordStrategy: 'none,default' };
+                chordStrategy: 'none,default', chordOptions: defaultChordOptions };
             const next = prev.concat({
                 segment,
                 uuid: uuidv4()
             });
-            addNewNotes(segment.action, segment.mood, new Chord(segment.root), segment.repeats, segment.chordStrategy);
+            addNewNotes(
+                segment.action,
+                segment.mood,
+                new Chord(segment.root),
+                segment.repeats,
+                segment.chordStrategy,    
+                segment.chordOptions
+            );
             return next;
         })
     }
@@ -70,7 +77,8 @@ const SegmentContainer = ({
             mood = RELEASE,
             rootNote='C3',
             repeats=1,
-            chordStrategy='none,default'
+            chordStrategy='none,default',
+            chordOptions=defaultChordOptions
         ) => {
         const nextNotes = generateNotes(
             segmentType.action,
@@ -95,6 +103,15 @@ const SegmentContainer = ({
             return result;
         }));
     }
+    const setChordOption = (index, field) => (value) => {
+        setSegments(prev => prev.map((seg, i) => {
+            const result = seg;
+            if(i === index) {
+                result.segment.chordOptions[field] = value;
+            }
+            return result;
+        }));
+    }
     const removeSegment = (i) => {
         setSegments(filterIndex(i));
         setNotes(filterIndex(i));
@@ -103,7 +120,6 @@ const SegmentContainer = ({
     const toggleOnClick = (Menu) => () => {
         setMenu(prevMenu =>  prevMenu === Menu ? false : Menu);
     }
-
     return <Grid container spacing={1} alignContent={'flex-start'} alignItems={'flex-start'} justify={'space-evenly'}>
         <Grid item xs={1}>
         <Tooltip placement={ 'bottom' } title={ 'ADD TRACK COMPONENT' } aria-label={ 'add track component' }>
@@ -196,9 +212,12 @@ const SegmentContainer = ({
                         setMood={ setSegmentField(i, 'mood') }
                         setRepeats={ setSegmentField(i, 'repeats') }
                         setChordStrategy={ setSegmentField(i, 'chordStrategy') }
+                        setChordThreshold={ setChordOption(i, 'threshold') }
+                        setChordMaxStack={ setChordOption(i, 'maxStack') }
+                        setChordMinStack={ setChordOption(i, 'minStack') }
                         regenerateNotes={
-                            (mood, rootNote, repeats, chordStrategy) =>
-                                regenerateNotes(segment.segment, i, mood, rootNote, repeats, chordStrategy)
+                            (mood, rootNote, repeats, chordStrategy, chordOptions) =>
+                                regenerateNotes(segment.segment, i, mood, rootNote, repeats, chordStrategy, chordOptions)
                         }
                         removeSegment={ () => removeSegment(i) } />;
                 }) :
diff --git a/src/music/segments/chords.js b/src/music/segments/chords.js
index 445b9d1..a522327 100644
--- a/src/music/segments/chords.js
+++ b/src/music/segments/chords.js
@@ -16,10 +16,10 @@ const gospel9 = chord => {
 
 const chordStrategies = {
     none: {
-        default: ({ chord }) => chord
+        default: () => chord => chord
     },
     random: {
-        "with mood": ({ chord, mood, threshold = 0.5 }) => {
+        "with mood": ({ mood, threshold = 0.5 }) => chord => {
             let interval;
             switch(mood) {
                 case TENSION:
@@ -38,7 +38,7 @@ const chordStrategies = {
             chord.addInterval(interval);
             return chord;
         },
-        default: ({ chord, threshold = 0.5 }) => {
+        default: ({ threshold = 0.5 }) => chord => {
             if(Math.random() < threshold) {
                 return chord;
             }
@@ -63,5 +63,11 @@ const getStrategy = strategy => {
     return strategy;
 }
 
-export { getStrategy };
+const defaultChordOptions = {
+    threshold: 0.5,
+    maxStack: 3,
+    minStack: 0
+}
+
+export { getStrategy, defaultChordOptions };
 export default chordStrategies;
\ No newline at end of file
diff --git a/src/music/segments/index.js b/src/music/segments/index.js
index b2acb9a..b734935 100644
--- a/src/music/segments/index.js
+++ b/src/music/segments/index.js
@@ -3,7 +3,7 @@ import {
     TENSION, RELEASE,
     startingNotes,
     tenseMoves, releaseMoves } from './constants';
-import chordStrategies, { getStrategy } from './chords';
+import { getStrategy } from './chords';
 
 // Move to utilities folder
 const pick = (array) => array[Math.floor(Math.random()*array.length)];
@@ -56,7 +56,7 @@ const diatom = (root, mood, chordStrategy='none,default') => {
         if(method === false) {
             console.log('false; selecting root',  root);
             let next = root.toChord();
-            next = getStrategy(chordStrategy)({ chord: next, mood });
+            next = getStrategy(chordStrategy)({ mood })( next );
             return [root, next];
         }
         // Falling more likely for release
@@ -70,7 +70,7 @@ const diatom = (root, mood, chordStrategy='none,default') => {
     const alteredRoot = alterMethod ? root[alterMethod]() : root;
     try {
         next = alteredRoot[method]().toChord();
-        next = getStrategy(chordStrategy)({ chord: next, mood });
+        next = getStrategy(chordStrategy)({ mood })(next);
     } catch (error) {
         console.log('error, method:', method, alteredRoot);
         const safeNote = new Chord(pick(startingNotes));
@@ -170,7 +170,7 @@ const piece = (rootNote, mood, chordStrategy, n = 2) => {
 
 const repeatNotes = (notes, n) => {
     const newNotes = [...notes];
-    while(--n) newNotes.push(...notes);
+    while(--n > 0) newNotes.push(...notes);
     return newNotes;
 }
 

From b938de7c20783156174e95e67493fe2b030bb553 Mon Sep 17 00:00:00 2001
From: Jimmy MacGregor <jimmy.macgregor@futurenet.com>
Date: Tue, 4 May 2021 22:11:46 +0100
Subject: [PATCH 6/6] Fix bpm, add chord strategies

---
 src/App.js                                    | 19 +++----
 .../segment-component/segment.js              | 55 +++++++++++++------
 .../segment-components/segment-container.js   |  8 ++-
 src/music/segments/chords.js                  | 45 +++++++++++----
 src/music/segments/constants.js               |  2 -
 src/music/segments/index.js                   | 42 +++++++-------
 6 files changed, 107 insertions(+), 64 deletions(-)

diff --git a/src/App.js b/src/App.js
index 1702d48..5aa059c 100644
--- a/src/App.js
+++ b/src/App.js
@@ -64,7 +64,7 @@ const light_theme = createMuiTheme({
  * - accessibility review (aria+contrast-focused)! 1
  * - Make light theme look better (Note, passage colors)
  * - Light/dark theme toggle
- * - 'Regenerate all' button to force all notes to regenerate in a track
+ * - 'Regenerate all' button to force all notes to regenerate
  * - Add help system to assist with all parts of the app
  * Options Menu:
  * - Overall direction (determine root note by increasing/decreasing from source)
@@ -90,7 +90,6 @@ const light_theme = createMuiTheme({
  * - Allow starting section after delay of x notes
  * - Allow sections to be played backwards
  * Ornaments:
- * - Chord control (max depth, depth probability/lock, etc.) 1
  * - Arpeggios
  * - Acciaccatura/trills etc.
  * - Microtonal shifts
@@ -98,19 +97,19 @@ const light_theme = createMuiTheme({
  * - Allow 'skipped' notes
  * Rhythm:
  * - drop in replacement for 'setTimeout' with greater accuracy https://stackoverflow.com/questions/196027/is-there-a-more-accurate-way-to-create-a-javascript-timer-than-settimeout
- *  - time signature
- *  - accents
- *  - change individual note lengths (use American quarter note system) 1
- *  - allow use of hemisemidemiquaver system
- *  - syncopation
- * - Update global 
+ * - time signature
+ * - accents
+ * - change individual note lengths (use American quarter note system) 1
+ * - allow use of hemisemidemiquaver system
+ * - syncopation
  * Dynamics:
  * - vary dynamics based on mood 1
  * - vary dynamics based on time signature
  * Motifs:
  *  - Enable inserting motifs to be repeated, consisting of smaller sections with interval changes & chords specified
  * Generation:
- *  - Improve generation by using pickBiasLate to descend slowly 1
+ *  - Improve generation by using pickBiasLate to descend slowly
+ *  - Ensure that generation is always valid by checking octave against octavian 1
  *  - Allow user to force ending the passage on the root note
  *  - Improve generation by remembering _first_ root Note of series
  *    (e.g. for Passage, remember real rootNote into the children and use to modify generation)
@@ -126,7 +125,7 @@ const light_theme = createMuiTheme({
  * - POST-BETA FEATURE
  * - on pasting notes, locks the segment index and reverse engineers the tension/release patterns
  * Code:
- * - Refactor: global and local state.
+ * - Refactor: global and local state, remove unnecessary local state in segments wherever possible
  * 
  */
 
diff --git a/src/music/segment-components/segment-component/segment.js b/src/music/segment-components/segment-component/segment.js
index fbcfa8f..b1aa74a 100644
--- a/src/music/segment-components/segment-component/segment.js
+++ b/src/music/segment-components/segment-component/segment.js
@@ -8,7 +8,7 @@ import {
     TextField,
     Typography
 } from '@material-ui/core';
-import chordStrategies from '../../segments/chords';
+import chordStrategies, { getStrategy } from '../../segments/chords';
 import { Chord } from 'octavian';
 import { RELEASE, TENSION } from '../../segments/constants';
 
@@ -25,7 +25,8 @@ const Segment = ({
         chordOptions: {
             threshold,
             maxStack,
-            minStack
+            minStack,
+            chanceFalloff
         }
     },
     removeSegment,
@@ -35,9 +36,12 @@ const Segment = ({
     setRepeats,
     setChordStrategy,
     setChordThreshold,
+    setChordChanceFalloff,
     setChordMaxStack,
     setChordMinStack
 }) => {
+
+    const nextRootNote = value => getStrategy(chordStrategy)({ ...chordOptions, mood })(new Chord(value));
     return <Grid
         container
         spacing={ 3 }
@@ -51,10 +55,9 @@ const Segment = ({
         <Grid item>
             <TextField onChange={ ({ target: { value }}) => {
                 try {
-                    const rootNote = new Chord(value);
-                    regenerateNotes(mood, rootNote, repeats, chordStrategy);
-                } catch {
-                    console.warn(`Invalid root note: ${ value }`)
+                    regenerateNotes(mood, nextRootNote(value), repeats, chordStrategy, chordOptions);
+                } catch (error) {
+                    console.warn(`Invalid root note: ${ value }`, error)
                 } finally {
                     setRootNote(value);
                 }
@@ -73,7 +76,7 @@ const Segment = ({
                 onChange={ ({ target: { value }}) => {
                     console.log('Changing value: ', value);
                     try {
-                        regenerateNotes(value, new Chord(root), repeats, chordStrategy);
+                        regenerateNotes(value, nextRootNote(root), repeats, chordStrategy, chordOptions);
                         setMood(value);
                     } catch {
                         console.warn(`Invalid mood: ${ value }`)
@@ -89,7 +92,7 @@ const Segment = ({
                 console.log('Changing repeats: ', value);
                 try {
                     if(value > 0) {
-                        regenerateNotes(mood, new Chord(root), value, chordStrategy);
+                        regenerateNotes(mood, nextRootNote(root), value, chordStrategy, chordOptions);
                     }
                 } catch {
                     console.warn(`Invalid repeat value: ${ value }`)
@@ -107,7 +110,7 @@ const Segment = ({
                 onChange={ ({ target: { value }}) => {
                     console.log('Changing chord strategy: ', value);
                     try {
-                        regenerateNotes(mood, new Chord(root), repeats, value);
+                        regenerateNotes(mood, nextRootNote(root), repeats, value, chordOptions);
                     } catch {
                         console.warn(`Invalid chord strategy value: ${ value }`)
                     } finally {
@@ -141,32 +144,52 @@ const Segment = ({
                     onChange={ ({ target: { value }}) => {
                         try {
                             if(value > 0) {
-                                regenerateNotes(mood, new Chord(root), repeats, chordStrategy, {
+                                regenerateNotes(mood, nextRootNote(root), repeats, chordStrategy, {
                                     ...chordOptions,
                                     threshold: value
                                 });
                             }
                         } catch {
-                            console.warn(`Invalid chord threshold value: ${ value }`)
+                            console.warn(`Invalid chord threshold chance value: ${ value }`)
                         } finally {
                             setChordThreshold(parseFloat(value));
                         }
                         } }
-                    label={'Chord Threshold'} id={`chord-threshold-${ name }-${ threshold }`}
+                    label={'Chord Chance'} id={`chord-chance-threshold-${ name }-${ threshold }`}
                     placeholder={'0.5'} value={ threshold }  />
             </Grid>
+            <Grid item>
+                <TextField
+                    type={ 'number' }
+                    onChange={ ({ target: { value }}) => {
+                        try {
+                            if(value > 0) {
+                                regenerateNotes(mood, nextRootNote(root), repeats, chordStrategy, {
+                                    ...chordOptions,
+                                    chanceFalloff: value
+                                });
+                            }
+                        } catch {
+                            console.warn(`Invalid chord chance falloff value: ${ value }`)
+                        } finally {
+                            setChordChanceFalloff(parseFloat(value));
+                        }
+                        } }
+                    label={'Chord Chance Falloff'} id={`chord-chance-falloff-${ name }-${ threshold }`}
+                    placeholder={'0.05'} value={ chanceFalloff }  />
+            </Grid>
             <Grid item>
                 <TextField
                     type={ 'number' }
                     onChange={ ({ target: { value }}) => {
                         const val = parseInt(value);
                         try {
-                            regenerateNotes(mood, new Chord(root), repeats, chordStrategy, {
+                            regenerateNotes(mood, nextRootNote(root), repeats, chordStrategy, {
                                 ...chordOptions,
                                 maxStack: value
                             });
                         } catch {
-                            console.warn(`Invalid chord threshold value: ${ value }`)
+                            console.warn(`Invalid max stack value: ${ value }`)
                         } finally {
                             setChordMaxStack(value);
                             if(val < minStack) {
@@ -183,12 +206,12 @@ const Segment = ({
                     onChange={ ({ target: { value }}) => {
                         const val = parseInt(value);
                         try {
-                            regenerateNotes(mood, new Chord(root), repeats, chordStrategy, {
+                            regenerateNotes(mood, nextRootNote(root), repeats, chordStrategy, {
                                 ...chordOptions,
                                 minStack: value
                             });
                         } catch {
-                            console.warn(`Invalid chord threshold value: ${ value }`)
+                            console.warn(`Invalid min stack value: ${ value }`)
                         } finally {
                             setChordMinStack(value);
                             if(val > maxStack) {
diff --git a/src/music/segment-components/segment-container.js b/src/music/segment-components/segment-container.js
index 86a3b83..57c299f 100644
--- a/src/music/segment-components/segment-container.js
+++ b/src/music/segment-components/segment-container.js
@@ -17,8 +17,8 @@ import { RELEASE } from '../segments/constants';
 import OptionMenu from '../options';
 import { defaultChordOptions } from '../segments/chords.js';
 
-const generateNotes = (f, mood, rootNote, repeats, chordStrategy) => {
-    const notes = f(rootNote, mood, chordStrategy);
+const generateNotes = (f, mood, rootNote, repeats, chordStrategy, chordOptions) => {
+    const notes = f(rootNote, mood, chordStrategy, chordOptions);
     return repeatNotes(notes, repeats);
 }
 
@@ -85,7 +85,8 @@ const SegmentContainer = ({
             mood,
             rootNote,
             repeats,
-            chordStrategy
+            chordStrategy,
+            chordOptions
         );
         setNotes(prev => {
             const next = [...prev];
@@ -215,6 +216,7 @@ const SegmentContainer = ({
                         setChordThreshold={ setChordOption(i, 'threshold') }
                         setChordMaxStack={ setChordOption(i, 'maxStack') }
                         setChordMinStack={ setChordOption(i, 'minStack') }
+                        setChordChanceFalloff={ setChordOption(i, 'chanceFalloff') }
                         regenerateNotes={
                             (mood, rootNote, repeats, chordStrategy, chordOptions) =>
                                 regenerateNotes(segment.segment, i, mood, rootNote, repeats, chordStrategy, chordOptions)
diff --git a/src/music/segments/chords.js b/src/music/segments/chords.js
index a522327..26440cf 100644
--- a/src/music/segments/chords.js
+++ b/src/music/segments/chords.js
@@ -1,4 +1,4 @@
-import { TENSION, RELEASE, EITHER, tenseMoves, releaseMoves } from './constants';
+import { TENSION, RELEASE, EITHER, tenseMoves, releaseMoves, octaveMoves } from './constants';
 import { Note, Chord } from 'octavian';
 import { pick } from './index';
 
@@ -19,7 +19,7 @@ const chordStrategies = {
         default: () => chord => chord
     },
     random: {
-        "with mood": ({ mood, threshold = 0.5 }) => chord => {
+        "with mood": ({ mood, threshold = 0.2, maxStack, minStack, chanceFalloff = 0 }) => chord => {
             let interval;
             switch(mood) {
                 case TENSION:
@@ -30,21 +30,42 @@ const chordStrategies = {
                     break;
                 case EITHER:
                 default:
-                    return chordStrategies.random.default({ chord, threshold });
+                    return chordStrategies.random.default({
+                        threshold: threshold-chanceFalloff, chanceFalloff, maxStack, minStack })(chord);
             }
-            if(interval === false || Math.random() < threshold) {
+            if(interval === false) {
+                interval = pick(octaveMoves);
+            }
+            if(Math.random() > threshold && minStack <= 0) {
                 return chord;
+            } else {
+                if(maxStack <= 0) {
+                    return chord;
+                }
+                chord.addInterval(interval);
+                return chordStrategies.random['with mood']({
+                    mood, threshold: threshold-chanceFalloff, chanceFalloff,
+                    maxStack: maxStack-1,
+                    minStack: minStack-1 })(chord);
             }
-            chord.addInterval(interval);
-            return chord;
         },
-        default: ({ threshold = 0.5 }) => chord => {
-            if(Math.random() < threshold) {
+        default: ({ threshold = 0.2, maxStack, minStack, chanceFalloff }) => chord => {
+            if(Math.random() > threshold && minStack <= 0) {
+                return chord;
+            } else {
+                if(maxStack <= 0) {
+                    return chordStrategies.random.default({
+                        threshold: threshold-chanceFalloff, chanceFalloff,
+                        maxStack: maxStack-1,
+                        minStack: minStack-1 })(chord);;
+                }
+                let interval = pick([...tenseMoves, ...releaseMoves, ...octaveMoves]);
+                if(interval === false) {
+                    interval = pick(octaveMoves);
+                }
+                chord.addInterval(interval); // Caution: mutation!
                 return chord;
             }
-            const interval = pick([...tenseMoves, ...releaseMoves]);
-            chord.addInterval(interval); // Caution: mutation!
-            return chord;
         }
     }
 }
@@ -64,7 +85,7 @@ const getStrategy = strategy => {
 }
 
 const defaultChordOptions = {
-    threshold: 0.5,
+    threshold: 0.2,
     maxStack: 3,
     minStack: 0
 }
diff --git a/src/music/segments/constants.js b/src/music/segments/constants.js
index 9f7fac3..46d62ca 100644
--- a/src/music/segments/constants.js
+++ b/src/music/segments/constants.js
@@ -19,8 +19,6 @@ const releaseMoves = [
     'majorThird',
     'perfectFifth',
     'majorSeventh',
-    'downOctave',
-    // 'perfectOctave',
     false
 ];
 
diff --git a/src/music/segments/index.js b/src/music/segments/index.js
index b734935..43573bd 100644
--- a/src/music/segments/index.js
+++ b/src/music/segments/index.js
@@ -15,7 +15,7 @@ const getRandBias = (length, bias, influence) => {
     return clamped;
 }
 const pickBiasEarly = (array) => {
-    const picked = getRandBias(array.length, 0, 1.1);
+    const picked = getRandBias(array.length, 0, 2);
     let result = array[picked];
     if(typeof(result) === 'undefined') {
         console.log('error selecting: ', picked, array);
@@ -38,7 +38,7 @@ const pickBiasLate = (array) => {
 }
 // utilities
 
-const diatom = (root, mood, chordStrategy='none,default') => {
+const diatom = (root, mood, chordStrategy='none,default', chordOptions) => {
     let method, alterMethod;
     // Determine this with a max octave setting
     const aboveMiddle = root.octave > 5 ? root.octave - 2 : 0;
@@ -56,7 +56,7 @@ const diatom = (root, mood, chordStrategy='none,default') => {
         if(method === false) {
             console.log('false; selecting root',  root);
             let next = root.toChord();
-            next = getStrategy(chordStrategy)({ mood })( next );
+            next = getStrategy(chordStrategy)({ ...chordOptions, mood })( next );
             return [root, next];
         }
         // Falling more likely for release
@@ -70,7 +70,7 @@ const diatom = (root, mood, chordStrategy='none,default') => {
     const alteredRoot = alterMethod ? root[alterMethod]() : root;
     try {
         next = alteredRoot[method]().toChord();
-        next = getStrategy(chordStrategy)({ mood })(next);
+        next = getStrategy(chordStrategy)({...chordOptions, mood })(next);
     } catch (error) {
         console.log('error, method:', method, alteredRoot);
         const safeNote = new Chord(pick(startingNotes));
@@ -79,10 +79,10 @@ const diatom = (root, mood, chordStrategy='none,default') => {
     return [root,next];
 }
 
-const createDiatoms = (rootNote, moods = [], chordStrategy) => {
+const createDiatoms = (rootNote, moods = [], chordStrategy, chordOptions) => {
     const notes = moods.reduce(
         (accumulator, mood) => {
-            const next = diatom(accumulator[accumulator.length-1].notes[0], mood, chordStrategy);
+            const next = diatom(accumulator[accumulator.length-1].notes[0], mood, chordStrategy, chordOptions);
             return [...accumulator, next[1]];
         },
         [rootNote]
@@ -121,25 +121,25 @@ const moodsFromMood = (mood, n = 2) => {
     return moods;
 }
 
-const noteChange = (rootNote, mood, chordStrategy) => {
-    return createDiatoms(rootNote, [mood], chordStrategy);
+const noteChange = (rootNote, mood, chordStrategy, chordOptions) => {
+    return createDiatoms(rootNote, [mood], chordStrategy, chordOptions);
 }
 
-const shortPhrase = (rootNote, mood, chordStrategy) => {
+const shortPhrase = (rootNote, mood, chordStrategy, chordOptions) => {
     const moods = moodsFromMood(mood);
-    return createDiatoms(rootNote, moods, chordStrategy);
+    return createDiatoms(rootNote, moods, chordStrategy, chordOptions);
 }
 
-const createComplex = (rootNote, moods, chordStrategy, f) => {
+const createComplex = (rootNote, moods, chordStrategy, chordOptions, f) => {
     const notes = moods.reduce(
         (accumulator, mood) => {
             let next;
             if(mood === TENSION) {
                 // Allow moving away from root for sake of tension
-                next = f(accumulator[accumulator.length-1], mood, chordStrategy);
+                next = f(accumulator[accumulator.length-1], mood, chordStrategy, chordOptions);
             } else {
                 // Check with both these; else revert to using rootNote
-                next = f(accumulator[accumulator.length-1], mood, chordStrategy);
+                next = f(accumulator[accumulator.length-1], mood, chordStrategy, chordOptions);
             }
             return [...accumulator, ...next.slice(1)];
         },
@@ -148,24 +148,24 @@ const createComplex = (rootNote, moods, chordStrategy, f) => {
     return notes;
 }
 
-const longPhrase = (rootNote, mood, chordStrategy) => {
+const longPhrase = (rootNote, mood, chordStrategy, chordOptions) => {
     const moods = moodsFromMood(mood);
-    return createComplex(rootNote, moods, chordStrategy, shortPhrase);
+    return createComplex(rootNote, moods, chordStrategy, chordOptions, shortPhrase);
 }
 
-const passage = (rootNote, mood, chordStrategy, n = 4) => {
+const passage = (rootNote, mood, chordStrategy, chordOptions, n = 4) => {
     const moods = moodsFromMood(mood, n);
-    return createComplex(rootNote, moods, chordStrategy, longPhrase);
+    return createComplex(rootNote, moods, chordStrategy, chordOptions, longPhrase);
 }
 
-const section = (rootNote, mood, chordStrategy, n = 2) => {
+const section = (rootNote, mood, chordStrategy, chordOptions, n = 2) => {
     const moods = moodsFromMood(mood, n);
-    return createComplex(rootNote, moods, chordStrategy, passage);
+    return createComplex(rootNote, moods, chordStrategy, chordOptions, passage);
 }
 
-const piece = (rootNote, mood, chordStrategy, n = 2) => {
+const piece = (rootNote, mood, chordStrategy, chordOptions, n = 2) => {
     const moods = moodsFromMood(mood, n);
-    return createComplex(rootNote, moods, chordStrategy, section);
+    return createComplex(rootNote, moods, chordStrategy, chordOptions, section);
 }
 
 const repeatNotes = (notes, n) => {