Update src/blocks/scratch3_event.js

src/blocks/scratch3_event.js

@@ -1,10 +1,7 @@
 const Cast = require('../util/cast');
-const Timer = require('../util/timer');
-const MathUtil = require('../util/math-util');
-const getMonitorIdForBlockWithArgs = require('../util/get-monitor-id');
-const { validateRegex } = require('../util/json-block-utilities');
+const SandboxRunner = require('../util/sandboxed-javascript-runner.js');
 
-class Scratch3SensingBlocks {
+class Scratch3EventBlocks {
     constructor (runtime) {
         /**
          * The runtime instantiating this block package.
@@ -12,47 +9,67 @@ class Scratch3SensingBlocks {
          */
         this.runtime = runtime;
 
-        /**
-         * The "answer" block value.
-         * @type {string}
-         */
-        this._answer = ''; // used by compiler
+        this.runtime.on('KEY_PRESSED', key => {
+            this.runtime.startHats('event_whenkeypressed', {
+                KEY_OPTION: key
+            });
+            this.runtime.startHats('event_whenkeypressed', {
+                KEY_OPTION: 'any'
+            });
+        });
 
-        /**
-         * The timer utility.
-         * @type {Timer}
-         */
-        this._timer = new Timer();
+        this.runtime.on('KEY_HIT', key => {
+            this.runtime.startHats('event_whenkeyhit', {
+                KEY_OPTION: key
+            });
+            this.runtime.startHats('event_whenkeyhit', {
+                KEY_OPTION: 'any'
+            });
+        });
 
-        /**
-         * The stored microphone loudness measurement.
-         * @type {number}
-         */
-        this._cachedLoudness = -1;
+        this.isStarting = false;
+        this.stopEventNeedsInit = true;
+        this.runtime.on('PROJECT_START_BEFORE_RESET', () => {
+            // we need to remember that the project is starting
+            // otherwise the stop block will run when flag is clicked
+            this.isStarting = true;
 
-        /**
-         * The time of the most recent microphone loudness measurement.
-         * @type {number}
-         */
-        this._cachedLoudnessTimestamp = 0;
+            // we need to check if this is the first time we run the stop event
+            // otherwise it interferes with the green flag on project load
+            if (this.stopEventNeedsInit) this.stopEventNeedsInit = false;
+        });
+        this.runtime.on('PROJECT_STOP_ALL', () => {
+            // if green flag is clicked, dont bother starting the hat
+            if (this.isStarting) {
+                this.isStarting = false;
+                return;
+            }
 
-        /**
-         * The list of loudness values to determine the average.
-         * @type {!Array}
-         */
-        this._loudnessList = [];
+            // if this is part of loading the project, do nothing
+            if (this.stopEventNeedsInit) return;
 
-        /**
-         * The list of queued questions and respective `resolve` callbacks.
-         * @type {!Array}
-         */
-        this._questionList = [];
+            // we need to wait for runtime to step once
+            // otherwise the hat will be stopped as soon as it starts
+            this.runtime.once('RUNTIME_STEP_START', () => {
+                this.runtime.startHats('event_whenstopclicked');
+            })
+            this.isStarting = false;
+        });
+        this.runtime.on('RUNTIME_STEP_START', () => {
+            this.runtime.startHats('event_always');
+        });
 
-        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));
+        this.runtime.on("AFTER_EXECUTE", () => {
+            // Use a timeout as regular Block Threads and Events Blocks dont run at the Same Speed
+            setTimeout(() => {
+                const stage = this.runtime.getTargetForStage();
+                if (!stage) return; // happens when project is loading
+                const stageVars = stage.variables;
+                for (const key in stageVars) {
+                    if (stageVars[key].isSent !== undefined) stageVars[key].isSent = false;
+                }
+            }, 10);
+        });
     }
 
     /**
@@ -61,600 +78,151 @@ class Scratch3SensingBlocks {
      */
     getPrimitives () {
         return {
-            sensing_objecttouchingobject: this.objectTouchingObject,
-            sensing_objecttouchingclonesprite: this.objectTouchingCloneOfSprite,
-            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_loggedin: this.getLoggedIn,
-            sensing_userid: () => {}, // legacy no-op block
-            sensing_regextest: this.regextest,
-            sensing_thing_is_number: this.thing_is_number,
-            sensing_thing_has_number: this.thing_has_number,
-            sensing_mobile: this.mobile,
-            sensing_thing_is_text: this.thing_is_text,
-            sensing_getspritewithattrib: this.getspritewithattrib,
-            sensing_directionTo: this.getDirectionToFrom,
-            sensing_distanceTo: this.getDistanceToFrom,
-            sensing_isUpperCase: this.isCharecterUppercase,
-            sensing_mouseclicked: this.mouseClicked,
-            sensing_keyhit: this.keyHit,
-            sensing_mousescrolling: this.mouseScrolling,
-            sensing_fingerdown: this.fingerDown,
-            sensing_fingertapped: this.fingerTapped,
-            sensing_fingerx: this.getFingerX,
-            sensing_fingery: this.getFingerY,
-            sensing_setclipboard: this.setClipboard,
-            sensing_getclipboard: this.getClipboard,
-            sensing_getdragmode: this.getDragMode,
-            sensing_getoperatingsystem: this.getOS,
-            sensing_getbrowser: this.getBrowser,
-            sensing_geturl: this.getUrl,
-            sensing_getxyoftouchingsprite: this.getXYOfTouchingSprite
+            event_whenanything: this.whenanything,
+            event_whenjavascript: this.whenjavascript,
+            event_whentouchingobject: this.touchingObject,
+            event_broadcast: this.broadcast,
+            event_broadcastandwait: this.broadcastAndWait,
+            event_whengreaterthan: this.hatGreaterThanPredicate
         };
     }
 
-    getOS () {
-        if (!('userAgent' in navigator)) return 'Unknown';
-        const agent = navigator.userAgent;
-        if (agent.includes('Windows')) {
-            return 'Windows';
-        }
-        if (agent.includes('Android')) {
-            return 'Android';
-        }
-        if (agent.includes('iPad') || agent.includes('iPod') || agent.includes('iPhone')) {
-            return 'iOS';
-        }
-        if (agent.includes('Linux')) {
-            return 'Linux';
-        }
-        if (agent.includes('CrOS')) {
-            return 'ChromeOS';
-        }
-        if (agent.includes('Mac OS')) {
-            return 'MacOS';
-        }
-        return 'Unknown';
-    }
-    getBrowser () {
-        if (!('userAgent' in navigator)) return 'Unknown';
-        const agent = navigator.userAgent;
-        if ('userAgentData' in navigator) {
-            const agentData = JSON.stringify(navigator.userAgentData.brands);
-            if (agentData.includes('Google Chrome')) {
-                return 'Chrome';
-            }
-            if (agentData.includes('Opera')) {
-                return 'Opera';
-            }
-            if (agentData.includes('Microsoft Edge')) {
-                return 'Edge';
-            }
-        }
-        if (agent.includes('Chrome')) {
-            return 'Chrome';
-        }
-        if (agent.includes('Firefox')) {
-            return 'Firefox';
-        }
-        // PenguinMod cannot be loaded in IE 11 (the last supported version)
-        // if (agent.includes('MSIE') || agent.includes('rv:')) {
-        //     return 'Internet Explorer';
-        // }
-        if (agent.includes('Safari')) {
-            return 'Safari';
-        }
-        return 'Unknown';
-    }
-    getUrl () {
-        if (!('href' in location)) return '';
-        return location.href;
-    }
-
-    setClipboard (args) {
-        const text = Cast.toString(args.ITEM);
-        if (!navigator) return;
-        if (('clipboard' in navigator) && ('writeText' in navigator.clipboard)) {
-            navigator.clipboard.writeText(text);
-        }
-    }
-    getClipboard () {
-        if (!navigator) return '';
-        if (('clipboard' in navigator) && ('readText' in navigator.clipboard)) {
-            return navigator.clipboard.readText();
-        } else {
-            return '';
-        }
+    whenanything (args) {
+        return Cast.toBoolean(args.ANYTHING);
     }
 
-    getDragMode (_, util) {
-        return util.target.draggable;
+    whenjavascript (args) {
+        return new Promise((resolve) => {
+            const js = Cast.toString(args.JS);
+            SandboxRunner.execute(js).then(result => {
+                resolve(result.value === true);
+            })
+        })
     }
 
-    mouseClicked (_, util) {
-        return util.ioQuery('mouse', 'getIsClicked');
-    }
-    keyHit (args, util) {
-        return util.ioQuery('keyboard', 'getKeyIsHit', [args.KEY_OPTION]);
-    }
-    mouseScrolling (args, util) {
-        const delta = util.ioQuery('mouseWheel', 'getScrollDelta');
-        const option = args.SCROLL_OPTION;
-        switch (option) {
-            case "up":
-                return delta < 0;
-            case "down":
-                return delta > 0;
-            default:
-                return false;
-        }
-    }
-
-    isCharecterUppercase (args) {
-        return (/[A-Z]/g).test(args.text);
-    }
-
-    getDirectionToFrom (args) {
-        const dx = args.x2 - args.x1;
-        const dy = args.y2 - args.y1;
-        const direction = MathUtil.wrapClamp(90 - MathUtil.radToDeg(Math.atan2(dy, dx)), -179, 180);
-        return direction;
-    }
-
-    getDistanceToFrom (args) {
-        const dx = args.x2 - args.x1;
-        const dy = args.y2 - args.y1;
-        return Math.sqrt((dx * dx) + (dy * dy));
-    }
-
-    getspritewithattrib (args, util) {
-        // strip out usless data
-        const sprites = util.runtime.targets.map(x => ({
-            id: x.id,
-            name: x.sprite ? x.sprite.name : "Unknown",
-            variables: Object.values(x.variables).reduce((obj, value) => {
-                if (!value.name) return obj;
-                obj[value.name] = String(value.value);
-                return obj;
-            }, {})
-        }));
-        // get the target with variable x set to y
-        let res = "No sprites found";
-        for (
-            // define the index and the sprite
-            let idx = 1, sprite = sprites[0];
-            // standard for loop thing
-            idx < sprites.length;
-            // set sprite to a new item
-            sprite = sprites[idx++]
-        ) {
-            if (sprite.variables[args.var] === args.val) {
-                res = `{"id": "${sprite.id}", "name": "${sprite.name}"}`;
-                break;
-            }
-        }
-
-        return res;
-    }
-    thing_is_number (args) {
-        // i hate js
-        // i also hate regex
-        // so im gonna do this the lazy way
-        // no. String(Number(value)) === value does infact do the job X)
-        // also what was originaly here was inificiant as hell
-
-        // jg: why dont you literally just do what "is text" did but the opposite
-        // except also account for numbers that end with . (that aint a number)
-        if (Cast.toString(args.TEXT1).trim().endsWith(".")) {
-            return false;
-        }
-        return !this.thing_is_text(args);
-    }
-    thing_is_text (args) {
-        // WHY IS NAN NOT EQUAL TO ITSELF
-        // HOW IS NAN A NUMBER
-        // because nan is how numbers say the value put into me is not a number
-        return isNaN(Number(args.TEXT1));
-    }
-
-    thing_has_number(args) {
-        return /\d/.test(Cast.toString(args.TEXT1));
-    }
-
-    mobile () {
-        return typeof window !== 'undefined' && 'ontouchstart' in window;
-    }
-
-    regextest (args) {
-        if (!validateRegex(args.reg, args.regrule)) return false;
-        const regex = new RegExp(args.reg, args.regrule);
-        return regex.test(args.text);
-    }
-
-    getMonitored () {
+    getHats () {
         return {
-            sensing_answer: {
-                getId: () => 'answer'
+            event_whenflagclicked: {
+                restartExistingThreads: true
             },
-            sensing_mousedown: {
-                getId: () => 'mousedown'
+            event_whenstopclicked: {
+                restartExistingThreads: true
             },
-            sensing_mouseclicked: {
-                getId: () => 'mouseclicked'
+            event_always: {
+                restartExistingThreads: false
             },
-            sensing_mousex: {
-                getId: () => 'mousex'
+            event_whenkeypressed: {
+                restartExistingThreads: false
             },
-            sensing_mousey: {
-                getId: () => 'mousey'
+            event_whenkeyhit: {
+                restartExistingThreads: false
             },
-            sensing_getclipboard: {
-                getId: () => 'getclipboard'
+            event_whenmousescrolled: {
+                restartExistingThreads: false
             },
-            sensing_getdragmode: {
-                isSpriteSpecific: true,
-                getId: targetId => `${targetId}_getdragmode`
+            event_whenanything: {
+                restartExistingThreads: false,
+                edgeActivated: true
             },
-            sensing_loudness: {
-                getId: () => 'loudness'
+            event_whenjavascript: {
+                restartExistingThreads: false,
+                edgeActivated: true
             },
-            sensing_loud: {
-                getId: () => 'loud'
+            event_whenthisspriteclicked: {
+                restartExistingThreads: true
             },
-            sensing_timer: {
-                getId: () => 'timer'
+            event_whentouchingobject: {
+                restartExistingThreads: false,
+                edgeActivated: true
             },
-            sensing_dayssince2000: {
-                getId: () => 'dayssince2000'
+            event_whenstageclicked: {
+                restartExistingThreads: true
             },
-            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}`
+            event_whenbackdropswitchesto: {
+                restartExistingThreads: true
             },
-            sensing_loggedin: {
-                getId: () => 'loggedin'
+            event_whengreaterthan: {
+                restartExistingThreads: false,
+                edgeActivated: true
             },
-        };
-    }
-
-    _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);
+            event_whenbroadcastreceived: {
+                restartExistingThreads: true
             }
-        }
-    }
-
-    _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;
-    }
-
-    objectTouchingObject (args, util) {
-        const object1 = (args.FULLTOUCHINGOBJECTMENU) === "_myself_" ? util.target.getName() : args.FULLTOUCHINGOBJECTMENU;
-        const object2 = args.SPRITETOUCHINGOBJECTMENU;
-        if (object2 === "_myself_") {
-            return util.target.isTouchingObject(object1);
-        }
-        const target = this.runtime.getSpriteTargetByName(object2);
-        if (!target) return false;
-        return target.isTouchingObject(object1);
-    }
-    objectTouchingCloneOfSprite (args, util) {
-        const object1 = args.FULLTOUCHINGOBJECTMENU;
-        let object2 = args.SPRITETOUCHINGOBJECTMENU;
-        if (object2 === "_myself_") {
-            object2 = util.target.getName();
-        }
-        if (object1 === "_myself_") {
-            return util.target.isTouchingObject(object2, true);
-        }
-
-        const target = this.runtime.getSpriteTargetByName(object2);
-        if (!target) return false;
-        if (object1 === "_mouse_") {
-            if (!this.runtime.ioDevices.mouse) return false;
-            const mouseX = this.runtime.ioDevices.mouse.getClientX();
-            const mouseY = this.runtime.ioDevices.mouse.getClientY();
-            const clones = target.sprite.clones.filter(clone => !clone.isOriginal && clone.isTouchingPoint(mouseX, mouseY));
-            return clones.length > 0;
-        } else if (object1 === '_edge_') {
-            const clones = target.sprite.clones.filter(clone => !clone.isOriginal && clone.isTouchingEdge());
-            return clones.length > 0;
-        }
-
-        const originalSprite = this.runtime.getSpriteTargetByName(object1);
-        if (!originalSprite) return false;
-        return originalSprite.isTouchingObject(object2, true);
+        };
     }
 
     touchingObject (args, util) {
         return util.target.isTouchingObject(args.TOUCHINGOBJECTMENU);
     }
 
-    getXYOfTouchingSprite (args, util) {
-        const object = args.SPRITE;
-        if (object === '_mouse_') {
-            // we can just return mouse pos
-            // if mouse is touching us, the mouse size is practically 1x1 anyways
-            const x = util.ioQuery('mouse', 'getScratchX');
-            const y = util.ioQuery('mouse', 'getScratchY');
-            if (args.XY === 'y') return y;
-            return x;
-        }
-        const point = util.target.spriteTouchingPoint(object);
-        if (!point) return '';
-        if (args.XY === 'y') return point[1];
-        return point[0];
-    }
-
-    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');
-    }
-
-    getFingerX (args, util) {
-        return util.ioQuery('touch', 'getScratchX', [Cast.toNumber(args.FINGER_OPTION) - 1]);
-    }
-
-    getFingerY (args, util) {
-        return util.ioQuery('touch', 'getScratchY', [Cast.toNumber(args.FINGER_OPTION) - 1]);
-    }
-
-    fingerDown (args, util) {
-        return util.ioQuery('touch', 'getIsDown', [Cast.toNumber(args.FINGER_OPTION) - 1]);
-    }
-
-    fingerTapped (args, util) {
-        return util.ioQuery('touch', 'getIsTapped', [Cast.toNumber(args.FINGER_OPTION) - 1]);
-    }
-
-    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();
-        case 'timestamp': return Date.now();
-        }
-        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();
-        this.pushLoudness(this._cachedLoudness);
-        return this._cachedLoudness;
-    }
-
-    isLoud () {
-      this.pushLoudness();
-      let sum = this._loudnessList.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
-      sum /= this._loudnessList.length;
-      return this.getLoudness() > sum + 15;
-    }
-    pushLoudness (value) {
-      if (this._loudnessList.length >= 30) this._loudnessList.shift(); // remove first item
-      this._loudnessList.push(value ?? this.getLoudness());
-    }
-
-    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;
+    hatGreaterThanPredicate (args, util) {
+        const option = Cast.toString(args.WHENGREATERTHANMENU).toLowerCase();
+        const value = Cast.toNumber(args.VALUE);
+        switch (option) {
+        case 'timer':
+            return util.ioQuery('clock', 'projectTimer') > value;
+        case 'loudness':
+            return this.runtime.audioEngine && this.runtime.audioEngine.getLoudness() > value;
+        }
+        return false;
+    }
+
+    broadcast (args, util) {
+        const broadcastVar = util.runtime.getTargetForStage().lookupBroadcastMsg(
+            args.BROADCAST_OPTION.id, args.BROADCAST_OPTION.name);
+        if (broadcastVar) {
+            const broadcastOption = broadcastVar.name;
+            broadcastVar.isSent = true;
+            util.startHats('event_whenbroadcastreceived', {
+                BROADCAST_OPTION: broadcastOption
+            });
+        }
+    }
+
+    broadcastAndWait (args, util) {
+        if (!util.stackFrame.broadcastVar) {
+            util.stackFrame.broadcastVar = util.runtime.getTargetForStage().lookupBroadcastMsg(
+                args.BROADCAST_OPTION.id, args.BROADCAST_OPTION.name);
+        }
+        if (util.stackFrame.broadcastVar) {
+            const broadcastOption = util.stackFrame.broadcastVar.name;
+            // Have we run before, starting threads?
+            if (!util.stackFrame.startedThreads) {
+                broadcastVar.isSent = true;
+                // No - start hats for this broadcast.
+                util.stackFrame.startedThreads = util.startHats(
+                    'event_whenbroadcastreceived', {
+                        BROADCAST_OPTION: broadcastOption
+                    }
+                );
+                if (util.stackFrame.startedThreads.length === 0) {
+                    // Nothing was started.
+                    return;
+                }
             }
-        } 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 'layer': return attrTarget.getLayerOrder();
-            case 'size': return attrTarget.size;
-            case 'volume': return attrTarget.volume;
+            // We've run before; check if the wait is still going on.
+            const instance = this;
+            // Scratch 2 considers threads to be waiting if they are still in
+            // runtime.threads. Threads that have run all their blocks, or are
+            // marked done but still in runtime.threads are still considered to
+            // be waiting.
+            const waiting = util.stackFrame.startedThreads
+                .some(thread => instance.runtime.threads.indexOf(thread) !== -1);
+            if (waiting) {
+                // If all threads are waiting for the next tick or later yield
+                // for a tick as well. Otherwise yield until the next loop of
+                // the threads.
+                if (
+                    util.stackFrame.startedThreads
+                        .every(thread => instance.runtime.isWaitingThread(thread))
+                ) {
+                    util.yieldTick();
+                } else {
+                    util.yield();
+                }
             }
         }
-
-        // 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');
-    }
-
-    getLoggedIn(args, util) {
-        return util.ioQuery('userData', 'getLoggedIn');
     }
 }
 
-module.exports = Scratch3SensingBlocks;
+module.exports = Scratch3EventBlocks;