@scratch/scratch-vm 11.0.0-UEPR-176

package/src/blocks/scratch3_sensing.js

@@ -0,0 +1,336 @@
+const Cast = require('../util/cast');
+const Timer = require('../util/timer');
+const getMonitorIdForBlockWithArgs = require('../util/get-monitor-id');
+
+class Scratch3SensingBlocks {
+    constructor (runtime) {
+        /**
+         * The runtime instantiating this block package.
+         * @type {Runtime}
+         */
+        this.runtime = runtime;
+
+        /**
+         * The "answer" block value.
+         * @type {string}
+         */
+        this._answer = '';
+
+        /**
+         * The timer utility.
+         * @type {Timer}
+         */
+        this._timer = new Timer();
+
+        /**
+         * The stored microphone loudness measurement.
+         * @type {number}
+         */
+        this._cachedLoudness = -1;
+
+        /**
+         * The time of the most recent microphone loudness measurement.
+         * @type {number}
+         */
+        this._cachedLoudnessTimestamp = 0;
+
+        /**
+         * The list of queued questions and respective `resolve` callbacks.
+         * @type {!Array}
+         */
+        this._questionList = [];
+
+        this.runtime.on('ANSWER', this._onAnswer.bind(this));
+        this.runtime.on('PROJECT_START', this._resetAnswer.bind(this));
+        this.runtime.on('PROJECT_STOP_ALL', this._clearAllQuestions.bind(this));
+        this.runtime.on('STOP_FOR_TARGET', this._clearTargetQuestions.bind(this));
+        this.runtime.on('RUNTIME_DISPOSED', this._resetAnswer.bind(this));
+    }
+
+    /**
+     * Retrieve the block primitives implemented by this package.
+     * @return {object.<string, Function>} Mapping of opcode to Function.
+     */
+    getPrimitives () {
+        return {
+            sensing_touchingobject: this.touchingObject,
+            sensing_touchingcolor: this.touchingColor,
+            sensing_coloristouchingcolor: this.colorTouchingColor,
+            sensing_distanceto: this.distanceTo,
+            sensing_timer: this.getTimer,
+            sensing_resettimer: this.resetTimer,
+            sensing_of: this.getAttributeOf,
+            sensing_mousex: this.getMouseX,
+            sensing_mousey: this.getMouseY,
+            sensing_setdragmode: this.setDragMode,
+            sensing_mousedown: this.getMouseDown,
+            sensing_keypressed: this.getKeyPressed,
+            sensing_current: this.current,
+            sensing_dayssince2000: this.daysSince2000,
+            sensing_loudness: this.getLoudness,
+            sensing_loud: this.isLoud,
+            sensing_askandwait: this.askAndWait,
+            sensing_answer: this.getAnswer,
+            sensing_username: this.getUsername,
+            sensing_userid: () => {} // legacy no-op block
+        };
+    }
+
+    getMonitored () {
+        return {
+            sensing_answer: {
+                getId: () => 'answer'
+            },
+            sensing_loudness: {
+                getId: () => 'loudness'
+            },
+            sensing_timer: {
+                getId: () => 'timer'
+            },
+            sensing_current: {
+                // This is different from the default toolbox xml id in order to support
+                // importing multiple monitors from the same opcode from sb2 files,
+                // something that is not currently supported in scratch 3.
+                getId: (_, fields) => getMonitorIdForBlockWithArgs('current', fields) // _${param}`
+            }
+        };
+    }
+
+    _onAnswer (answer) {
+        this._answer = answer;
+        const questionObj = this._questionList.shift();
+        if (questionObj) {
+            const [_question, resolve, target, wasVisible, wasStage] = questionObj;
+            // If the target was visible when asked, hide the say bubble unless the target was the stage.
+            if (wasVisible && !wasStage) {
+                this.runtime.emit('SAY', target, 'say', '');
+            }
+            resolve();
+            this._askNextQuestion();
+        }
+    }
+
+    _resetAnswer () {
+        this._answer = '';
+    }
+
+    _enqueueAsk (question, resolve, target, wasVisible, wasStage) {
+        this._questionList.push([question, resolve, target, wasVisible, wasStage]);
+    }
+
+    _askNextQuestion () {
+        if (this._questionList.length > 0) {
+            const [question, _resolve, target, wasVisible, wasStage] = this._questionList[0];
+            // If the target is visible, emit a blank question and use the
+            // say event to trigger a bubble unless the target was the stage.
+            if (wasVisible && !wasStage) {
+                this.runtime.emit('SAY', target, 'say', question);
+                this.runtime.emit('QUESTION', '');
+            } else {
+                this.runtime.emit('QUESTION', question);
+            }
+        }
+    }
+
+    _clearAllQuestions () {
+        this._questionList = [];
+        this.runtime.emit('QUESTION', null);
+    }
+
+    _clearTargetQuestions (stopTarget) {
+        const currentlyAsking = this._questionList.length > 0 && this._questionList[0][2] === stopTarget;
+        this._questionList = this._questionList.filter(question => (
+            question[2] !== stopTarget
+        ));
+
+        if (currentlyAsking) {
+            this.runtime.emit('SAY', stopTarget, 'say', '');
+            if (this._questionList.length > 0) {
+                this._askNextQuestion();
+            } else {
+                this.runtime.emit('QUESTION', null);
+            }
+        }
+    }
+
+    askAndWait (args, util) {
+        const _target = util.target;
+        return new Promise(resolve => {
+            const isQuestionAsked = this._questionList.length > 0;
+            this._enqueueAsk(String(args.QUESTION), resolve, _target, _target.visible, _target.isStage);
+            if (!isQuestionAsked) {
+                this._askNextQuestion();
+            }
+        });
+    }
+
+    getAnswer () {
+        return this._answer;
+    }
+
+    touchingObject (args, util) {
+        return util.target.isTouchingObject(args.TOUCHINGOBJECTMENU);
+    }
+
+    touchingColor (args, util) {
+        const color = Cast.toRgbColorList(args.COLOR);
+        return util.target.isTouchingColor(color);
+    }
+
+    colorTouchingColor (args, util) {
+        const maskColor = Cast.toRgbColorList(args.COLOR);
+        const targetColor = Cast.toRgbColorList(args.COLOR2);
+        return util.target.colorIsTouchingColor(targetColor, maskColor);
+    }
+
+    distanceTo (args, util) {
+        if (util.target.isStage) return 10000;
+
+        let targetX = 0;
+        let targetY = 0;
+        if (args.DISTANCETOMENU === '_mouse_') {
+            targetX = util.ioQuery('mouse', 'getScratchX');
+            targetY = util.ioQuery('mouse', 'getScratchY');
+        } else {
+            args.DISTANCETOMENU = Cast.toString(args.DISTANCETOMENU);
+            const distTarget = this.runtime.getSpriteTargetByName(
+                args.DISTANCETOMENU
+            );
+            if (!distTarget) return 10000;
+            targetX = distTarget.x;
+            targetY = distTarget.y;
+        }
+
+        const dx = util.target.x - targetX;
+        const dy = util.target.y - targetY;
+        return Math.sqrt((dx * dx) + (dy * dy));
+    }
+
+    setDragMode (args, util) {
+        util.target.setDraggable(args.DRAG_MODE === 'draggable');
+    }
+
+    getTimer (args, util) {
+        return util.ioQuery('clock', 'projectTimer');
+    }
+
+    resetTimer (args, util) {
+        util.ioQuery('clock', 'resetProjectTimer');
+    }
+
+    getMouseX (args, util) {
+        return util.ioQuery('mouse', 'getScratchX');
+    }
+
+    getMouseY (args, util) {
+        return util.ioQuery('mouse', 'getScratchY');
+    }
+
+    getMouseDown (args, util) {
+        return util.ioQuery('mouse', 'getIsDown');
+    }
+
+    current (args) {
+        const menuOption = Cast.toString(args.CURRENTMENU).toLowerCase();
+        const date = new Date();
+        switch (menuOption) {
+        case 'year': return date.getFullYear();
+        case 'month': return date.getMonth() + 1; // getMonth is zero-based
+        case 'date': return date.getDate();
+        case 'dayofweek': return date.getDay() + 1; // getDay is zero-based, Sun=0
+        case 'hour': return date.getHours();
+        case 'minute': return date.getMinutes();
+        case 'second': return date.getSeconds();
+        }
+        return 0;
+    }
+
+    getKeyPressed (args, util) {
+        return util.ioQuery('keyboard', 'getKeyIsDown', [args.KEY_OPTION]);
+    }
+
+    daysSince2000 () {
+        const msPerDay = 24 * 60 * 60 * 1000;
+        const start = new Date(2000, 0, 1); // Months are 0-indexed.
+        const today = new Date();
+        const dstAdjust = today.getTimezoneOffset() - start.getTimezoneOffset();
+        let mSecsSinceStart = today.valueOf() - start.valueOf();
+        mSecsSinceStart += ((today.getTimezoneOffset() - dstAdjust) * 60 * 1000);
+        return mSecsSinceStart / msPerDay;
+    }
+
+    getLoudness () {
+        if (typeof this.runtime.audioEngine === 'undefined') return -1;
+        if (this.runtime.currentStepTime === null) return -1;
+
+        // Only measure loudness once per step
+        const timeSinceLoudness = this._timer.time() - this._cachedLoudnessTimestamp;
+        if (timeSinceLoudness < this.runtime.currentStepTime) {
+            return this._cachedLoudness;
+        }
+
+        this._cachedLoudnessTimestamp = this._timer.time();
+        this._cachedLoudness = this.runtime.audioEngine.getLoudness();
+        return this._cachedLoudness;
+    }
+
+    isLoud () {
+        return this.getLoudness() > 10;
+    }
+
+    getAttributeOf (args) {
+        let attrTarget;
+
+        if (args.OBJECT === '_stage_') {
+            attrTarget = this.runtime.getTargetForStage();
+        } else {
+            args.OBJECT = Cast.toString(args.OBJECT);
+            attrTarget = this.runtime.getSpriteTargetByName(args.OBJECT);
+        }
+
+        // attrTarget can be undefined if the target does not exist
+        // (e.g. single sprite uploaded from larger project referencing
+        // another sprite that wasn't uploaded)
+        if (!attrTarget) return 0;
+
+        // Generic attributes
+        if (attrTarget.isStage) {
+            switch (args.PROPERTY) {
+            // Scratch 1.4 support
+            case 'background #': return attrTarget.currentCostume + 1;
+
+            case 'backdrop #': return attrTarget.currentCostume + 1;
+            case 'backdrop name':
+                return attrTarget.getCostumes()[attrTarget.currentCostume].name;
+            case 'volume': return attrTarget.volume;
+            }
+        } else {
+            switch (args.PROPERTY) {
+            case 'x position': return attrTarget.x;
+            case 'y position': return attrTarget.y;
+            case 'direction': return attrTarget.direction;
+            case 'costume #': return attrTarget.currentCostume + 1;
+            case 'costume name':
+                return attrTarget.getCostumes()[attrTarget.currentCostume].name;
+            case 'size': return attrTarget.size;
+            case 'volume': return attrTarget.volume;
+            }
+        }
+
+        // Target variables.
+        const varName = args.PROPERTY;
+        const variable = attrTarget.lookupVariableByNameAndType(varName, '', true);
+        if (variable) {
+            return variable.value;
+        }
+
+        // Otherwise, 0
+        return 0;
+    }
+
+    getUsername (args, util) {
+        return util.ioQuery('userData', 'getUsername');
+    }
+}
+
+module.exports = Scratch3SensingBlocks;

package/src/blocks/scratch3_sound.js

@@ -0,0 +1,350 @@
+const MathUtil = require('../util/math-util');
+const Cast = require('../util/cast');
+const Clone = require('../util/clone');
+
+/**
+ * Occluded boolean value to make its use more understandable.
+ * @const {boolean}
+ */
+const STORE_WAITING = true;
+
+class Scratch3SoundBlocks {
+    constructor (runtime) {
+        /**
+         * The runtime instantiating this block package.
+         * @type {Runtime}
+         */
+        this.runtime = runtime;
+
+        this.waitingSounds = {};
+
+        // Clear sound effects on green flag and stop button events.
+        this.stopAllSounds = this.stopAllSounds.bind(this);
+        this._stopWaitingSoundsForTarget = this._stopWaitingSoundsForTarget.bind(this);
+        this._clearEffectsForAllTargets = this._clearEffectsForAllTargets.bind(this);
+        if (this.runtime) {
+            this.runtime.on('PROJECT_STOP_ALL', this.stopAllSounds);
+            this.runtime.on('PROJECT_STOP_ALL', this._clearEffectsForAllTargets);
+            this.runtime.on('STOP_FOR_TARGET', this._stopWaitingSoundsForTarget);
+            this.runtime.on('PROJECT_START', this._clearEffectsForAllTargets);
+        }
+
+        this._onTargetCreated = this._onTargetCreated.bind(this);
+        if (this.runtime) {
+            runtime.on('targetWasCreated', this._onTargetCreated);
+        }
+    }
+
+    /**
+     * The key to load & store a target's sound-related state.
+     * @type {string}
+     */
+    static get STATE_KEY () {
+        return 'Scratch.sound';
+    }
+
+    /**
+     * The default sound-related state, to be used when a target has no existing sound state.
+     * @type {SoundState}
+     */
+    static get DEFAULT_SOUND_STATE () {
+        return {
+            effects: {
+                pitch: 0,
+                pan: 0
+            }
+        };
+    }
+
+    /**
+     * The minimum and maximum MIDI note numbers, for clamping the input to play note.
+     * @type {{min: number, max: number}}
+     */
+    static get MIDI_NOTE_RANGE () {
+        return {min: 36, max: 96}; // C2 to C7
+    }
+
+    /**
+     * The minimum and maximum beat values, for clamping the duration of play note, play drum and rest.
+     * 100 beats at the default tempo of 60bpm is 100 seconds.
+     * @type {{min: number, max: number}}
+     */
+    static get BEAT_RANGE () {
+        return {min: 0, max: 100};
+    }
+
+    /** The minimum and maximum tempo values, in bpm.
+     * @type {{min: number, max: number}}
+     */
+    static get TEMPO_RANGE () {
+        return {min: 20, max: 500};
+    }
+
+    /** The minimum and maximum values for each sound effect.
+     * @type {{effect:{min: number, max: number}}}
+     */
+    static get EFFECT_RANGE () {
+        return {
+            pitch: {min: -360, max: 360}, // -3 to 3 octaves
+            pan: {min: -100, max: 100} // 100% left to 100% right
+        };
+    }
+
+    /**
+     * @param {Target} target - collect sound state for this target.
+     * @returns {SoundState} the mutable sound state associated with that target. This will be created if necessary.
+     * @private
+     */
+    _getSoundState (target) {
+        let soundState = target.getCustomState(Scratch3SoundBlocks.STATE_KEY);
+        if (!soundState) {
+            soundState = Clone.simple(Scratch3SoundBlocks.DEFAULT_SOUND_STATE);
+            target.setCustomState(Scratch3SoundBlocks.STATE_KEY, soundState);
+            target.soundEffects = soundState.effects;
+        }
+        return soundState;
+    }
+
+    /**
+     * When a Target is cloned, clone the sound state.
+     * @param {Target} newTarget - the newly created target.
+     * @param {Target} [sourceTarget] - the target used as a source for the new clone, if any.
+     * @listens Runtime#event:targetWasCreated
+     * @private
+     */
+    _onTargetCreated (newTarget, sourceTarget) {
+        if (sourceTarget) {
+            const soundState = sourceTarget.getCustomState(Scratch3SoundBlocks.STATE_KEY);
+            if (soundState && newTarget) {
+                newTarget.setCustomState(Scratch3SoundBlocks.STATE_KEY, Clone.simple(soundState));
+                this._syncEffectsForTarget(newTarget);
+            }
+        }
+    }
+
+    /**
+     * Retrieve the block primitives implemented by this package.
+     * @return {object.<string, Function>} Mapping of opcode to Function.
+     */
+    getPrimitives () {
+        return {
+            sound_play: this.playSound,
+            sound_playuntildone: this.playSoundAndWait,
+            sound_stopallsounds: this.stopAllSounds,
+            sound_seteffectto: this.setEffect,
+            sound_changeeffectby: this.changeEffect,
+            sound_cleareffects: this.clearEffects,
+            sound_sounds_menu: this.soundsMenu,
+            sound_beats_menu: this.beatsMenu,
+            sound_effects_menu: this.effectsMenu,
+            sound_setvolumeto: this.setVolume,
+            sound_changevolumeby: this.changeVolume,
+            sound_volume: this.getVolume
+        };
+    }
+
+    getMonitored () {
+        return {
+            sound_volume: {
+                isSpriteSpecific: true,
+                getId: targetId => `${targetId}_volume`
+            }
+        };
+    }
+
+    playSound (args, util) {
+        // Don't return the promise, it's the only difference for AndWait
+        this._playSound(args, util);
+    }
+
+    playSoundAndWait (args, util) {
+        return this._playSound(args, util, STORE_WAITING);
+    }
+
+    _playSound (args, util, storeWaiting) {
+        const index = this._getSoundIndex(args.SOUND_MENU, util);
+        if (index >= 0) {
+            const {target} = util;
+            const {sprite} = target;
+            const {soundId} = sprite.sounds[index];
+            if (sprite.soundBank) {
+                if (storeWaiting === STORE_WAITING) {
+                    this._addWaitingSound(target.id, soundId);
+                } else {
+                    this._removeWaitingSound(target.id, soundId);
+                }
+                return sprite.soundBank.playSound(target, soundId);
+            }
+        }
+    }
+
+    _addWaitingSound (targetId, soundId) {
+        if (!this.waitingSounds[targetId]) {
+            this.waitingSounds[targetId] = new Set();
+        }
+        this.waitingSounds[targetId].add(soundId);
+    }
+
+    _removeWaitingSound (targetId, soundId) {
+        if (!this.waitingSounds[targetId]) {
+            return;
+        }
+        this.waitingSounds[targetId].delete(soundId);
+    }
+
+    _getSoundIndex (soundName, util) {
+        // if the sprite has no sounds, return -1
+        const len = util.target.sprite.sounds.length;
+        if (len === 0) {
+            return -1;
+        }
+
+        // look up by name first
+        const index = this.getSoundIndexByName(soundName, util);
+        if (index !== -1) {
+            return index;
+        }
+
+        // then try using the sound name as a 1-indexed index
+        const oneIndexedIndex = parseInt(soundName, 10);
+        if (!isNaN(oneIndexedIndex)) {
+            return MathUtil.wrapClamp(oneIndexedIndex - 1, 0, len - 1);
+        }
+
+        // could not be found as a name or converted to index, return -1
+        return -1;
+    }
+
+    getSoundIndexByName (soundName, util) {
+        const sounds = util.target.sprite.sounds;
+        for (let i = 0; i < sounds.length; i++) {
+            if (sounds[i].name === soundName) {
+                return i;
+            }
+        }
+        // if there is no sound by that name, return -1
+        return -1;
+    }
+
+    stopAllSounds () {
+        if (this.runtime.targets === null) return;
+        const allTargets = this.runtime.targets;
+        for (let i = 0; i < allTargets.length; i++) {
+            this._stopAllSoundsForTarget(allTargets[i]);
+        }
+    }
+
+    _stopAllSoundsForTarget (target) {
+        if (target.sprite.soundBank) {
+            target.sprite.soundBank.stopAllSounds(target);
+            if (this.waitingSounds[target.id]) {
+                this.waitingSounds[target.id].clear();
+            }
+        }
+    }
+
+    _stopWaitingSoundsForTarget (target) {
+        if (target.sprite.soundBank) {
+            if (this.waitingSounds[target.id]) {
+                for (const soundId of this.waitingSounds[target.id].values()) {
+                    target.sprite.soundBank.stop(target, soundId);
+                }
+                this.waitingSounds[target.id].clear();
+            }
+        }
+    }
+
+    setEffect (args, util) {
+        return this._updateEffect(args, util, false);
+    }
+
+    changeEffect (args, util) {
+        return this._updateEffect(args, util, true);
+    }
+
+    _updateEffect (args, util, change) {
+        const effect = Cast.toString(args.EFFECT).toLowerCase();
+        const value = Cast.toNumber(args.VALUE);
+
+        const soundState = this._getSoundState(util.target);
+        if (!Object.prototype.hasOwnProperty.call(soundState.effects, effect)) return;
+
+        if (change) {
+            soundState.effects[effect] += value;
+        } else {
+            soundState.effects[effect] = value;
+        }
+
+        const {min, max} = Scratch3SoundBlocks.EFFECT_RANGE[effect];
+        soundState.effects[effect] = MathUtil.clamp(soundState.effects[effect], min, max);
+
+        this._syncEffectsForTarget(util.target);
+        // Yield until the next tick.
+        return Promise.resolve();
+    }
+
+    _syncEffectsForTarget (target) {
+        if (!target || !target.sprite.soundBank) return;
+        target.soundEffects = this._getSoundState(target).effects;
+
+        target.sprite.soundBank.setEffects(target);
+    }
+
+    clearEffects (args, util) {
+        this._clearEffectsForTarget(util.target);
+    }
+
+    _clearEffectsForTarget (target) {
+        const soundState = this._getSoundState(target);
+        for (const effect in soundState.effects) {
+            if (!Object.prototype.hasOwnProperty.call(soundState.effects, effect)) continue;
+            soundState.effects[effect] = 0;
+        }
+        this._syncEffectsForTarget(target);
+    }
+
+    _clearEffectsForAllTargets () {
+        if (this.runtime.targets === null) return;
+        const allTargets = this.runtime.targets;
+        for (let i = 0; i < allTargets.length; i++) {
+            this._clearEffectsForTarget(allTargets[i]);
+        }
+    }
+
+    setVolume (args, util) {
+        const volume = Cast.toNumber(args.VOLUME);
+        return this._updateVolume(volume, util);
+    }
+
+    changeVolume (args, util) {
+        const volume = Cast.toNumber(args.VOLUME) + util.target.volume;
+        return this._updateVolume(volume, util);
+    }
+
+    _updateVolume (volume, util) {
+        volume = MathUtil.clamp(volume, 0, 100);
+        util.target.volume = volume;
+        this._syncEffectsForTarget(util.target);
+
+        // Yield until the next tick.
+        return Promise.resolve();
+    }
+
+    getVolume (args, util) {
+        return util.target.volume;
+    }
+
+    soundsMenu (args) {
+        return args.SOUND_MENU;
+    }
+
+    beatsMenu (args) {
+        return args.BEATS;
+    }
+
+    effectsMenu (args) {
+        return args.EFFECT;
+    }
+}
+
+module.exports = Scratch3SoundBlocks;