pxt-common-packages 10.3.8 → 10.3.9

package/libs/mixer/playable.ts

@@ -0,0 +1,181 @@
+namespace music {
+    export enum PlaybackMode {
+        //% block="until done"
+        UntilDone,
+        //% block="in background"
+        InBackground,
+        //% block="looping in background"
+        LoopingInBackground
+    }
+
+    let stateStack: PlayableState[];
+
+    class PlayableState {
+        looping: Playable[];
+        constructor() {
+            this.looping = [];
+        }
+
+        stopLooping() {
+            for (const p of this.looping) {
+                p.stopped = true;
+            }
+            this.looping = [];
+        }
+    }
+
+    function state() {
+        _init();
+        return stateStack[stateStack.length - 1];
+    }
+
+    function _init() {
+        if (stateStack) return;
+        stateStack = [new PlayableState()];
+
+        game.addScenePushHandler(() => {
+            stateStack.push(new PlayableState());
+        });
+
+        game.addScenePopHandler(() => {
+            stateStack.pop();
+            if (stateStack.length === 0) stateStack.push(new PlayableState());
+        });
+    }
+
+    export class Playable {
+        stopped: boolean;
+        constructor() {
+
+        }
+
+        play(playbackMode: PlaybackMode) {
+            // subclass
+        }
+
+        loop() {
+            state().looping.push(this);
+            this.stopped = false;
+
+            control.runInParallel(() => {
+                while (!this.stopped) {
+                    this.play(PlaybackMode.UntilDone);
+                }
+            });
+        }
+    }
+
+    export class MelodyPlayable extends Playable {
+        constructor(public melody: Melody) {
+            super();
+        }
+
+        play(playbackMode: PlaybackMode) {
+            if (playbackMode === PlaybackMode.InBackground) {
+                this.melody.play(music.volume());
+            }
+            else if (playbackMode === PlaybackMode.UntilDone) {
+                this.melody.playUntilDone(music.volume());
+            }
+            else {
+                this.melody.loop(music.volume());
+            }
+        }
+    }
+
+    export class TonePlayable extends Playable {
+        constructor(public pitch: number, public duration: number) {
+            super();
+        }
+
+        play(playbackMode: PlaybackMode) {
+            if (playbackMode === PlaybackMode.InBackground) {
+                control.runInParallel(() => music.playTone(this.pitch, this.duration));
+            }
+            else if (playbackMode === PlaybackMode.UntilDone) {
+                music.playTone(this.pitch, this.duration);
+                if (this.duration > 2000) {
+                    pause(this.duration);
+                }
+            }
+            else {
+                this.loop();
+            }
+        }
+    }
+
+    //% blockId="music_playable_play"
+    //% block="play $toPlay $playbackMode"
+    //% toPlay.shadow=music_melody_playable
+    //% group="Sounds"
+    export function play(toPlay: Playable, playbackMode: PlaybackMode) {
+        toPlay.play(playbackMode);
+    }
+
+    //% blockId="music_melody_playable"
+    //% block="sound $melody"
+    //% toolboxParent=music_playable_play
+    //% toolboxParentArgument=toPlay
+    //% group="Sounds"
+    //% duplicateShadowOnDrag
+    //% blockHidden
+    export function melodyPlayable(melody: Melody): Playable {
+        return new MelodyPlayable(melody);
+    }
+
+
+    //% blockId="music_string_playable"
+    //% block="melody $melody at tempo $tempo|(bpm)"
+    //% toolboxParent=music_playable_play
+    //% toolboxParentArgument=toPlay
+    //% weight=85 blockGap=8
+    //% help=music/melody-editor
+    //% group="Songs"
+    //% duplicateShadowOnDrag
+    //% melody.shadow=melody_editor
+    //% tempo.min=40 tempo.max=500
+    //% tempo.defl=120
+    export function stringPlayable(melody: string, tempo: number): Playable {
+        let notes: string[] = melody.split(" ").filter(n => !!n);
+        let formattedMelody = "";
+        let newOctave = false;
+
+        // build melody string, replace '-' with 'R' and add tempo
+        // creates format like "C5-174 B4 A G F E D C "
+        for (let i = 0; i < notes.length; i++) {
+            if (notes[i] === "-") {
+                notes[i] = "R";
+            } else if (notes[i] === "C5") {
+                newOctave = true;
+            } else if (newOctave) { // change the octave if necesary
+                notes[i] += "4";
+                newOctave = false;
+            }
+            // add tempo after first note
+            if (i == 0) {
+                formattedMelody += notes[i] + "-" + tempo + " ";
+            } else {
+                formattedMelody += notes[i] + " ";
+            }
+        }
+
+        return new MelodyPlayable(new Melody(formattedMelody));
+    }
+
+    //% blockId="music_tone_playable"
+    //% block="tone $note for $duration"
+    //% toolboxParent=music_playable_play
+    //% toolboxParentArgument=toPlay
+    //% group="Tone"
+    //% duplicateShadowOnDrag
+    //% note.shadow=device_note
+    //% duration.shadow=device_beat
+    //% parts="headphone"
+    export function tonePlayable(note: number, duration: number): Playable {
+        return new TonePlayable(note, duration);
+    }
+
+    export function _stopPlayables() {
+        state().stopLooping();
+    }
+}

package/libs/mixer/pxt.json

@@ -16,6 +16,7 @@
         "soundEffect.ts",
         "instrument.ts",
         "sequencer.ts",
+        "playable.ts",
         "pxtparts.json",
         "headphone.svg"
     ],

package/libs/mixer/soundEffect.ts

@@ -39,7 +39,7 @@ enum SoundExpressionPlayMode {
 }
 
 namespace music {
-    export class SoundEffect {
+    export class SoundEffect extends Playable {
         waveShape: WaveShape;
         startFrequency: number;
         endFrequency: number;
@@ -50,6 +50,7 @@ namespace music {
         interpolation: InterpolationCurve;
 
         constructor() {
+            super();
             this.waveShape = WaveShape.Sine;
             this.startFrequency = 5000;
             this.endFrequency = 1;
@@ -77,6 +78,20 @@ namespace music {
                 volume
             );
         }
+
+        play(playbackMode: PlaybackMode) {
+            const toPlay = this.toBuffer(music.volume());
+            if (playbackMode === PlaybackMode.InBackground) {
+                queuePlayInstructions(0, toPlay);
+            }
+            else if (playbackMode === PlaybackMode.UntilDone) {
+                queuePlayInstructions(0, toPlay);
+                pause(this.duration)
+            }
+            else {
+                this.loop();
+            }
+        }
     }
 
 
@@ -87,11 +102,11 @@ namespace music {
      */
     //% blockId=soundExpression_playSoundEffect
     //% block="play sound $sound $mode"
-    //% sound.shadow=soundExpression_createSoundEffect
     //% weight=30
     //% help=music/play-sound-effect
     //% blockGap=8
     //% group="Sounds"
+    //% deprecated=1
     export function playSoundEffect(sound: SoundEffect, mode: SoundExpressionPlayMode) {
         const toPlay = sound.toBuffer(music.volume());
 
@@ -139,6 +154,8 @@ namespace music {
     //% inlineInputMode="variable"
     //% inlineInputModeLimit=3
     //% expandableArgumentBreaks="3,5"
+    //% toolboxParent=music_playable_play
+    //% toolboxParentArgument=toPlay
     //% weight=20
     //% group="Sounds"
     export function createSoundEffect(waveShape: WaveShape, startFrequency: number, endFrequency: number, startVolume: number, endVolume: number, duration: number, effect: SoundExpressionEffect, interpolation: InterpolationCurve): SoundEffect {