@scratch/scratch-vm 11.0.0-beta.1

package/src/blocks/scratch3_motion.js

@@ -0,0 +1,288 @@
+const Cast = require('../util/cast');
+const MathUtil = require('../util/math-util');
+const Timer = require('../util/timer');
+
+class Scratch3MotionBlocks {
+    constructor (runtime) {
+        /**
+         * The runtime instantiating this block package.
+         * @type {Runtime}
+         */
+        this.runtime = runtime;
+    }
+
+    /**
+     * Retrieve the block primitives implemented by this package.
+     * @return {object.<string, Function>} Mapping of opcode to Function.
+     */
+    getPrimitives () {
+        return {
+            motion_movesteps: this.moveSteps,
+            motion_gotoxy: this.goToXY,
+            motion_goto: this.goTo,
+            motion_turnright: this.turnRight,
+            motion_turnleft: this.turnLeft,
+            motion_pointindirection: this.pointInDirection,
+            motion_pointtowards: this.pointTowards,
+            motion_glidesecstoxy: this.glide,
+            motion_glideto: this.glideTo,
+            motion_ifonedgebounce: this.ifOnEdgeBounce,
+            motion_setrotationstyle: this.setRotationStyle,
+            motion_changexby: this.changeX,
+            motion_setx: this.setX,
+            motion_changeyby: this.changeY,
+            motion_sety: this.setY,
+            motion_xposition: this.getX,
+            motion_yposition: this.getY,
+            motion_direction: this.getDirection,
+            // Legacy no-op blocks:
+            motion_scroll_right: () => {},
+            motion_scroll_up: () => {},
+            motion_align_scene: () => {},
+            motion_xscroll: () => {},
+            motion_yscroll: () => {}
+        };
+    }
+
+    getMonitored () {
+        return {
+            motion_xposition: {
+                isSpriteSpecific: true,
+                getId: targetId => `${targetId}_xposition`
+            },
+            motion_yposition: {
+                isSpriteSpecific: true,
+                getId: targetId => `${targetId}_yposition`
+            },
+            motion_direction: {
+                isSpriteSpecific: true,
+                getId: targetId => `${targetId}_direction`
+            }
+        };
+    }
+
+    moveSteps (args, util) {
+        const steps = Cast.toNumber(args.STEPS);
+        const radians = MathUtil.degToRad(90 - util.target.direction);
+        const dx = steps * Math.cos(radians);
+        const dy = steps * Math.sin(radians);
+        util.target.setXY(util.target.x + dx, util.target.y + dy);
+    }
+
+    goToXY (args, util) {
+        const x = Cast.toNumber(args.X);
+        const y = Cast.toNumber(args.Y);
+        util.target.setXY(x, y);
+    }
+
+    getTargetXY (targetName, util) {
+        let targetX = 0;
+        let targetY = 0;
+        if (targetName === '_mouse_') {
+            targetX = util.ioQuery('mouse', 'getScratchX');
+            targetY = util.ioQuery('mouse', 'getScratchY');
+        } else if (targetName === '_random_') {
+            const stageWidth = this.runtime.constructor.STAGE_WIDTH;
+            const stageHeight = this.runtime.constructor.STAGE_HEIGHT;
+            targetX = Math.round(stageWidth * (Math.random() - 0.5));
+            targetY = Math.round(stageHeight * (Math.random() - 0.5));
+        } else {
+            targetName = Cast.toString(targetName);
+            const goToTarget = this.runtime.getSpriteTargetByName(targetName);
+            if (!goToTarget) return;
+            targetX = goToTarget.x;
+            targetY = goToTarget.y;
+        }
+        return [targetX, targetY];
+    }
+
+    goTo (args, util) {
+        const targetXY = this.getTargetXY(args.TO, util);
+        if (targetXY) {
+            util.target.setXY(targetXY[0], targetXY[1]);
+        }
+    }
+
+    turnRight (args, util) {
+        const degrees = Cast.toNumber(args.DEGREES);
+        util.target.setDirection(util.target.direction + degrees);
+    }
+
+    turnLeft (args, util) {
+        const degrees = Cast.toNumber(args.DEGREES);
+        util.target.setDirection(util.target.direction - degrees);
+    }
+
+    pointInDirection (args, util) {
+        const direction = Cast.toNumber(args.DIRECTION);
+        util.target.setDirection(direction);
+    }
+
+    pointTowards (args, util) {
+        let targetX = 0;
+        let targetY = 0;
+        if (args.TOWARDS === '_mouse_') {
+            targetX = util.ioQuery('mouse', 'getScratchX');
+            targetY = util.ioQuery('mouse', 'getScratchY');
+        } else if (args.TOWARDS === '_random_') {
+            util.target.setDirection(Math.round(Math.random() * 360) - 180);
+            return;
+        } else {
+            args.TOWARDS = Cast.toString(args.TOWARDS);
+            const pointTarget = this.runtime.getSpriteTargetByName(args.TOWARDS);
+            if (!pointTarget) return;
+            targetX = pointTarget.x;
+            targetY = pointTarget.y;
+        }
+
+        const dx = targetX - util.target.x;
+        const dy = targetY - util.target.y;
+        const direction = 90 - MathUtil.radToDeg(Math.atan2(dy, dx));
+        util.target.setDirection(direction);
+    }
+
+    glide (args, util) {
+        if (util.stackFrame.timer) {
+            const timeElapsed = util.stackFrame.timer.timeElapsed();
+            if (timeElapsed < util.stackFrame.duration * 1000) {
+                // In progress: move to intermediate position.
+                const frac = timeElapsed / (util.stackFrame.duration * 1000);
+                const dx = frac * (util.stackFrame.endX - util.stackFrame.startX);
+                const dy = frac * (util.stackFrame.endY - util.stackFrame.startY);
+                util.target.setXY(
+                    util.stackFrame.startX + dx,
+                    util.stackFrame.startY + dy
+                );
+                util.yield();
+            } else {
+                // Finished: move to final position.
+                util.target.setXY(util.stackFrame.endX, util.stackFrame.endY);
+            }
+        } else {
+            // First time: save data for future use.
+            util.stackFrame.timer = new Timer();
+            util.stackFrame.timer.start();
+            util.stackFrame.duration = Cast.toNumber(args.SECS);
+            util.stackFrame.startX = util.target.x;
+            util.stackFrame.startY = util.target.y;
+            util.stackFrame.endX = Cast.toNumber(args.X);
+            util.stackFrame.endY = Cast.toNumber(args.Y);
+            if (util.stackFrame.duration <= 0) {
+                // Duration too short to glide.
+                util.target.setXY(util.stackFrame.endX, util.stackFrame.endY);
+                return;
+            }
+            util.yield();
+        }
+    }
+
+    glideTo (args, util) {
+        const targetXY = this.getTargetXY(args.TO, util);
+        if (targetXY) {
+            this.glide({SECS: args.SECS, X: targetXY[0], Y: targetXY[1]}, util);
+        }
+    }
+
+    ifOnEdgeBounce (args, util) {
+        const bounds = util.target.getBounds();
+        if (!bounds) {
+            return;
+        }
+        // Measure distance to edges.
+        // Values are positive when the sprite is far away,
+        // and clamped to zero when the sprite is beyond.
+        const stageWidth = this.runtime.constructor.STAGE_WIDTH;
+        const stageHeight = this.runtime.constructor.STAGE_HEIGHT;
+        const distLeft = Math.max(0, (stageWidth / 2) + bounds.left);
+        const distTop = Math.max(0, (stageHeight / 2) - bounds.top);
+        const distRight = Math.max(0, (stageWidth / 2) - bounds.right);
+        const distBottom = Math.max(0, (stageHeight / 2) + bounds.bottom);
+        // Find the nearest edge.
+        let nearestEdge = '';
+        let minDist = Infinity;
+        if (distLeft < minDist) {
+            minDist = distLeft;
+            nearestEdge = 'left';
+        }
+        if (distTop < minDist) {
+            minDist = distTop;
+            nearestEdge = 'top';
+        }
+        if (distRight < minDist) {
+            minDist = distRight;
+            nearestEdge = 'right';
+        }
+        if (distBottom < minDist) {
+            minDist = distBottom;
+            nearestEdge = 'bottom';
+        }
+        if (minDist > 0) {
+            return; // Not touching any edge.
+        }
+        // Point away from the nearest edge.
+        const radians = MathUtil.degToRad(90 - util.target.direction);
+        let dx = Math.cos(radians);
+        let dy = -Math.sin(radians);
+        if (nearestEdge === 'left') {
+            dx = Math.max(0.2, Math.abs(dx));
+        } else if (nearestEdge === 'top') {
+            dy = Math.max(0.2, Math.abs(dy));
+        } else if (nearestEdge === 'right') {
+            dx = 0 - Math.max(0.2, Math.abs(dx));
+        } else if (nearestEdge === 'bottom') {
+            dy = 0 - Math.max(0.2, Math.abs(dy));
+        }
+        const newDirection = MathUtil.radToDeg(Math.atan2(dy, dx)) + 90;
+        util.target.setDirection(newDirection);
+        // Keep within the stage.
+        const fencedPosition = util.target.keepInFence(util.target.x, util.target.y);
+        util.target.setXY(fencedPosition[0], fencedPosition[1]);
+    }
+
+    setRotationStyle (args, util) {
+        util.target.setRotationStyle(args.STYLE);
+    }
+
+    changeX (args, util) {
+        const dx = Cast.toNumber(args.DX);
+        util.target.setXY(util.target.x + dx, util.target.y);
+    }
+
+    setX (args, util) {
+        const x = Cast.toNumber(args.X);
+        util.target.setXY(x, util.target.y);
+    }
+
+    changeY (args, util) {
+        const dy = Cast.toNumber(args.DY);
+        util.target.setXY(util.target.x, util.target.y + dy);
+    }
+
+    setY (args, util) {
+        const y = Cast.toNumber(args.Y);
+        util.target.setXY(util.target.x, y);
+    }
+
+    getX (args, util) {
+        return this.limitPrecision(util.target.x);
+    }
+
+    getY (args, util) {
+        return this.limitPrecision(util.target.y);
+    }
+
+    getDirection (args, util) {
+        return util.target.direction;
+    }
+
+    // This corresponds to snapToInteger in Scratch 2
+    limitPrecision (coordinate) {
+        const rounded = Math.round(coordinate);
+        const delta = coordinate - rounded;
+        const limitedCoord = (Math.abs(delta) < 1e-9) ? rounded : coordinate;
+
+        return limitedCoord;
+    }
+}
+
+module.exports = Scratch3MotionBlocks;

package/src/blocks/scratch3_operators.js

@@ -0,0 +1,154 @@
+const Cast = require('../util/cast.js');
+const MathUtil = require('../util/math-util.js');
+
+class Scratch3OperatorsBlocks {
+    constructor (runtime) {
+        /**
+         * The runtime instantiating this block package.
+         * @type {Runtime}
+         */
+        this.runtime = runtime;
+    }
+
+    /**
+     * Retrieve the block primitives implemented by this package.
+     * @return {object.<string, Function>} Mapping of opcode to Function.
+     */
+    getPrimitives () {
+        return {
+            operator_add: this.add,
+            operator_subtract: this.subtract,
+            operator_multiply: this.multiply,
+            operator_divide: this.divide,
+            operator_lt: this.lt,
+            operator_equals: this.equals,
+            operator_gt: this.gt,
+            operator_and: this.and,
+            operator_or: this.or,
+            operator_not: this.not,
+            operator_random: this.random,
+            operator_join: this.join,
+            operator_letter_of: this.letterOf,
+            operator_length: this.length,
+            operator_contains: this.contains,
+            operator_mod: this.mod,
+            operator_round: this.round,
+            operator_mathop: this.mathop
+        };
+    }
+
+    add (args) {
+        return Cast.toNumber(args.NUM1) + Cast.toNumber(args.NUM2);
+    }
+
+    subtract (args) {
+        return Cast.toNumber(args.NUM1) - Cast.toNumber(args.NUM2);
+    }
+
+    multiply (args) {
+        return Cast.toNumber(args.NUM1) * Cast.toNumber(args.NUM2);
+    }
+
+    divide (args) {
+        return Cast.toNumber(args.NUM1) / Cast.toNumber(args.NUM2);
+    }
+
+    lt (args) {
+        return Cast.compare(args.OPERAND1, args.OPERAND2) < 0;
+    }
+
+    equals (args) {
+        return Cast.compare(args.OPERAND1, args.OPERAND2) === 0;
+    }
+
+    gt (args) {
+        return Cast.compare(args.OPERAND1, args.OPERAND2) > 0;
+    }
+
+    and (args) {
+        return Cast.toBoolean(args.OPERAND1) && Cast.toBoolean(args.OPERAND2);
+    }
+
+    or (args) {
+        return Cast.toBoolean(args.OPERAND1) || Cast.toBoolean(args.OPERAND2);
+    }
+
+    not (args) {
+        return !Cast.toBoolean(args.OPERAND);
+    }
+
+    random (args) {
+        const nFrom = Cast.toNumber(args.FROM);
+        const nTo = Cast.toNumber(args.TO);
+        const low = nFrom <= nTo ? nFrom : nTo;
+        const high = nFrom <= nTo ? nTo : nFrom;
+        if (low === high) return low;
+        // If both arguments are ints, truncate the result to an int.
+        if (Cast.isInt(args.FROM) && Cast.isInt(args.TO)) {
+            return low + Math.floor(Math.random() * ((high + 1) - low));
+        }
+        return (Math.random() * (high - low)) + low;
+    }
+
+    join (args) {
+        return Cast.toString(args.STRING1) + Cast.toString(args.STRING2);
+    }
+
+    letterOf (args) {
+        const index = Cast.toNumber(args.LETTER) - 1;
+        const str = Cast.toString(args.STRING);
+        // Out of bounds?
+        if (index < 0 || index >= str.length) {
+            return '';
+        }
+        return str.charAt(index);
+    }
+
+    length (args) {
+        return Cast.toString(args.STRING).length;
+    }
+
+    contains (args) {
+        const format = function (string) {
+            return Cast.toString(string).toLowerCase();
+        };
+        return format(args.STRING1).includes(format(args.STRING2));
+    }
+
+    mod (args) {
+        const n = Cast.toNumber(args.NUM1);
+        const modulus = Cast.toNumber(args.NUM2);
+        let result = n % modulus;
+        // Scratch mod uses floored division instead of truncated division.
+        if (result / modulus < 0) result += modulus;
+        return result;
+    }
+
+    round (args) {
+        return Math.round(Cast.toNumber(args.NUM));
+    }
+
+    mathop (args) {
+        const operator = Cast.toString(args.OPERATOR).toLowerCase();
+        const n = Cast.toNumber(args.NUM);
+        switch (operator) {
+        case 'abs': return Math.abs(n);
+        case 'floor': return Math.floor(n);
+        case 'ceiling': return Math.ceil(n);
+        case 'sqrt': return Math.sqrt(n);
+        case 'sin': return parseFloat(Math.sin((Math.PI * n) / 180).toFixed(10));
+        case 'cos': return parseFloat(Math.cos((Math.PI * n) / 180).toFixed(10));
+        case 'tan': return MathUtil.tan(n);
+        case 'asin': return (Math.asin(n) * 180) / Math.PI;
+        case 'acos': return (Math.acos(n) * 180) / Math.PI;
+        case 'atan': return (Math.atan(n) * 180) / Math.PI;
+        case 'ln': return Math.log(n);
+        case 'log': return Math.log(n) / Math.LN10;
+        case 'e ^': return Math.exp(n);
+        case '10 ^': return Math.pow(10, n);
+        }
+        return 0;
+    }
+}
+
+module.exports = Scratch3OperatorsBlocks;

package/src/blocks/scratch3_procedures.js

@@ -0,0 +1,79 @@
+class Scratch3ProcedureBlocks {
+    constructor (runtime) {
+        /**
+         * The runtime instantiating this block package.
+         * @type {Runtime}
+         */
+        this.runtime = runtime;
+    }
+
+    /**
+     * Retrieve the block primitives implemented by this package.
+     * @return {object.<string, Function>} Mapping of opcode to Function.
+     */
+    getPrimitives () {
+        return {
+            procedures_definition: this.definition,
+            procedures_call: this.call,
+            argument_reporter_string_number: this.argumentReporterStringNumber,
+            argument_reporter_boolean: this.argumentReporterBoolean
+        };
+    }
+
+    definition () {
+        // No-op: execute the blocks.
+    }
+
+    call (args, util) {
+        if (!util.stackFrame.executed) {
+            const procedureCode = args.mutation.proccode;
+            const paramNamesIdsAndDefaults = util.getProcedureParamNamesIdsAndDefaults(procedureCode);
+
+            // If null, procedure could not be found, which can happen if custom
+            // block is dragged between sprites without the definition.
+            // Match Scratch 2.0 behavior and noop.
+            if (paramNamesIdsAndDefaults === null) {
+                return;
+            }
+
+            const [paramNames, paramIds, paramDefaults] = paramNamesIdsAndDefaults;
+
+            // Initialize params for the current stackFrame to {}, even if the procedure does
+            // not take any arguments. This is so that `getParam` down the line does not look
+            // at earlier stack frames for the values of a given parameter (#1729)
+            util.initParams();
+            for (let i = 0; i < paramIds.length; i++) {
+                if (Object.prototype.hasOwnProperty.call(args, paramIds[i])) {
+                    util.pushParam(paramNames[i], args[paramIds[i]]);
+                } else {
+                    util.pushParam(paramNames[i], paramDefaults[i]);
+                }
+            }
+
+            util.stackFrame.executed = true;
+            util.startProcedure(procedureCode);
+        }
+    }
+
+    argumentReporterStringNumber (args, util) {
+        const value = util.getParam(args.VALUE);
+        if (value === null) {
+            // When the parameter is not found in the most recent procedure
+            // call, the default is always 0.
+            return 0;
+        }
+        return value;
+    }
+
+    argumentReporterBoolean (args, util) {
+        const value = util.getParam(args.VALUE);
+        if (value === null) {
+            // When the parameter is not found in the most recent procedure
+            // call, the default is always 0.
+            return 0;
+        }
+        return value;
+    }
+}
+
+module.exports = Scratch3ProcedureBlocks;