Spaces:
Build error
Build error
| const Cast = require('../util/cast'); | |
| const SandboxRunner = require('../util/sandboxed-javascript-runner.js'); | |
| class Scratch3ControlBlocks { | |
| constructor (runtime) { | |
| /** | |
| * The runtime instantiating this block package. | |
| * @type {Runtime} | |
| */ | |
| this.runtime = runtime; | |
| /** | |
| * The "counter" block value. For compatibility with 2.0. | |
| * @type {number} | |
| */ | |
| this._counter = 0; // used by compiler | |
| /** | |
| * The "error" block value. | |
| * @type {string} | |
| */ | |
| this._error = ''; // used by compiler | |
| this.runtime.on('RUNTIME_DISPOSED', this.clearCounter.bind(this)); | |
| } | |
| /** | |
| * Retrieve the block primitives implemented by this package. | |
| * @return {object.<string, Function>} Mapping of opcode to Function. | |
| */ | |
| getPrimitives () { | |
| return { | |
| control_repeat: this.repeat, | |
| control_repeat_until: this.repeatUntil, | |
| control_while: this.repeatWhile, | |
| control_for_each: this.forEach, | |
| control_forever: this.forever, | |
| control_wait: this.wait, | |
| control_repeatForSeconds: this.repeatForSeconds, | |
| control_waittick: this.waitTick, | |
| control_waitsecondsoruntil: this.waitOrUntil, | |
| control_wait_until: this.waitUntil, | |
| control_if: this.if, | |
| control_if_else: this.ifElse, | |
| control_stop: this.stop, | |
| control_stop_sprite: this.stopSprite, | |
| control_create_clone_of: this.createClone, | |
| control_delete_this_clone: this.deleteClone, | |
| control_delete_clones_of: this.deleteClonesOf, | |
| control_get_counter: this.getCounter, | |
| control_incr_counter: this.incrCounter, | |
| control_decr_counter: this.decrCounter, | |
| control_set_counter: this.setCounter, | |
| control_clear_counter: this.clearCounter, | |
| control_all_at_once: this.allAtOnce, | |
| control_backToGreenFlag: this.backToGreenFlag, | |
| control_if_return_else_return: this.if_return_else_return, | |
| control_javascript_command: this.runJavascript | |
| }; | |
| } | |
| getMonitored () { | |
| return { | |
| control_get_counter: { | |
| getId: () => 'get_counter' | |
| } | |
| }; | |
| } | |
| backToGreenFlag(_, util) { | |
| const thisThread = util.thread.topBlock; | |
| this.runtime.emit("PROJECT_START_BEFORE_RESET"); | |
| this.runtime.threads | |
| .filter(thread => thread.topBlock !== thisThread) | |
| .forEach(thread => thread.stopThisScript()); | |
| // green flag behaviour | |
| this.runtime.emit("PROJECT_START"); | |
| this.runtime.updateCurrentMSecs(); | |
| this.runtime.ioDevices.clock.resetProjectTimer(); | |
| this.runtime.targets.forEach(target => target.clearEdgeActivatedValues()); | |
| for (let i = this.runtime.targets.length - 1; i >= 0; i--) { | |
| const thisTarget = this.runtime.targets[i]; | |
| thisTarget.onGreenFlag(); | |
| if (!thisTarget.isOriginal) { | |
| this.runtime.disposeTarget(thisTarget); | |
| this.runtime.stopForTarget(thisTarget); | |
| } | |
| } | |
| this.runtime.startHats("event_whenflagclicked"); | |
| } | |
| if_return_else_return (args) { | |
| return Cast.toBoolean(args.boolean) ? args.TEXT1 : args.TEXT2; | |
| } | |
| getHats () { | |
| return { | |
| control_start_as_clone: { | |
| restartExistingThreads: false | |
| } | |
| }; | |
| } | |
| runJavascript(args) { | |
| return new Promise((resolve) => { | |
| const js = Cast.toString(args.JS); | |
| SandboxRunner.execute(js).then(result => { | |
| resolve(result.value); | |
| }); | |
| }); | |
| } | |
| repeat (args, util) { | |
| const times = Math.round(Cast.toNumber(args.TIMES)); | |
| // Initialize loop | |
| if (typeof util.stackFrame.loopCounter === 'undefined') { | |
| util.stackFrame.loopCounter = times; | |
| } | |
| // Only execute once per frame. | |
| // When the branch finishes, `repeat` will be executed again and | |
| // the second branch will be taken, yielding for the rest of the frame. | |
| // Decrease counter | |
| util.stackFrame.loopCounter--; | |
| // If we still have some left, start the branch. | |
| if (util.stackFrame.loopCounter >= 0) { | |
| util.startBranch(1, true); | |
| } | |
| } | |
| repeatUntil (args, util) { | |
| const condition = Cast.toBoolean(args.CONDITION); | |
| // If the condition is false (repeat UNTIL), start the branch. | |
| if (!condition) { | |
| util.startBranch(1, true); | |
| } | |
| } | |
| repeatWhile (args, util) { | |
| const condition = Cast.toBoolean(args.CONDITION); | |
| // If the condition is true (repeat WHILE), start the branch. | |
| if (condition) { | |
| util.startBranch(1, true); | |
| } | |
| } | |
| forEach (args, util) { | |
| const variable = util.target.lookupOrCreateVariable( | |
| args.VARIABLE.id, args.VARIABLE.name); | |
| if (typeof util.stackFrame.index === 'undefined') { | |
| util.stackFrame.index = 0; | |
| } | |
| if (util.stackFrame.index < Number(args.VALUE)) { | |
| util.stackFrame.index++; | |
| variable.value = util.stackFrame.index; | |
| util.startBranch(1, true); | |
| } | |
| } | |
| waitUntil (args, util) { | |
| const condition = Cast.toBoolean(args.CONDITION); | |
| if (!condition) { | |
| util.yield(); | |
| } | |
| } | |
| forever (args, util) { | |
| util.startBranch(1, true); | |
| } | |
| wait (args, util) { | |
| if (util.stackTimerNeedsInit()) { | |
| const duration = Math.max(0, 1000 * Cast.toNumber(args.DURATION)); | |
| util.startStackTimer(duration); | |
| this.runtime.requestRedraw(); | |
| util.yield(); | |
| } else if (!util.stackTimerFinished()) { | |
| util.yield(); | |
| } | |
| } | |
| repeatForSeconds (args, util) { | |
| if (util.stackTimerNeedsInit()) { | |
| const duration = Math.max(0, 1000 * Cast.toNumber(args.TIMES)); | |
| util.startStackTimer(duration); | |
| this.runtime.requestRedraw(); | |
| util.startBranch(1, true); | |
| util.yield(); | |
| } else if (!util.stackTimerFinished()) { | |
| util.startBranch(1, true); | |
| util.yield(); | |
| } | |
| } | |
| waitTick (_, util) { | |
| util.yieldTick(); | |
| } | |
| waitOrUntil (args, util) { | |
| const condition = Cast.toBoolean(args.CONDITION); | |
| if (!condition) { | |
| if (util.stackTimerNeedsInit()) { | |
| const duration = Math.max(0, 1000 * Cast.toNumber(args.DURATION)); | |
| util.startStackTimer(duration); | |
| this.runtime.requestRedraw(); | |
| util.yield(); | |
| return; | |
| } | |
| if (!util.stackTimerFinished()) { | |
| util.yield(); | |
| } | |
| } | |
| } | |
| if (args, util) { | |
| const condition = Cast.toBoolean(args.CONDITION); | |
| if (condition) { | |
| util.startBranch(1, false); | |
| } | |
| } | |
| ifElse (args, util) { | |
| const condition = Cast.toBoolean(args.CONDITION); | |
| if (condition) { | |
| util.startBranch(1, false); | |
| } else { | |
| util.startBranch(2, false); | |
| } | |
| } | |
| stop (args, util) { | |
| const option = args.STOP_OPTION; | |
| if (option === 'all') { | |
| util.stopAll(); | |
| } else if (option === 'other scripts in sprite' || | |
| option === 'other scripts in stage') { | |
| util.stopOtherTargetThreads(); | |
| } else if (option === 'this script') { | |
| util.stopThisScript(); | |
| } | |
| } | |
| stopSprite (args, util) { | |
| const option = args.STOP_OPTION; | |
| // Set target | |
| let target; | |
| if (option === '_myself_') { | |
| target = util.target; | |
| } else if (option === '_stage_') { | |
| target = this.runtime.getTargetForStage(); | |
| } else { | |
| target = this.runtime.getSpriteTargetByName(option); | |
| } | |
| if (!target) return; | |
| this.runtime.stopForTarget(target); | |
| } | |
| createClone (args, util) { | |
| this._createClone(Cast.toString(args.CLONE_OPTION), util.target); | |
| } | |
| _createClone (cloneOption, target) { // used by compiler | |
| // Set clone target | |
| let cloneTarget; | |
| if (cloneOption === '_myself_') { | |
| cloneTarget = target; | |
| } else { | |
| cloneTarget = this.runtime.getSpriteTargetByName(cloneOption); | |
| } | |
| // If clone target is not found, return | |
| if (!cloneTarget) return; | |
| // Create clone | |
| const newClone = cloneTarget.makeClone(); | |
| if (newClone) { | |
| this.runtime.addTarget(newClone); | |
| // Place behind the original target. | |
| newClone.goBehindOther(cloneTarget); | |
| } | |
| } | |
| deleteClone (args, util) { | |
| if (util.target.isOriginal) return; | |
| this.runtime.disposeTarget(util.target); | |
| this.runtime.stopForTarget(util.target); | |
| } | |
| deleteClonesOf (args, util) { | |
| const cloneOption = Cast.toString(args.CLONE_OPTION); | |
| // Set clone target | |
| let cloneTarget; | |
| if (cloneOption === '_myself_') { | |
| cloneTarget = util.target; | |
| } else { | |
| cloneTarget = this.runtime.getSpriteTargetByName(cloneOption); | |
| } | |
| // If clone target is not found, return | |
| if (!cloneTarget) return; | |
| const sprite = cloneTarget.sprite; | |
| if (!sprite) return; | |
| if (!sprite.clones) return; | |
| const cloneList = [].concat(sprite.clones); | |
| cloneList.forEach(clone => { | |
| if (clone.isOriginal) return; | |
| if (clone.isStage) return; | |
| this.runtime.disposeTarget(clone); | |
| this.runtime.stopForTarget(clone); | |
| }) | |
| } | |
| getCounter () { | |
| return this._counter; | |
| } | |
| setCounter (args) { | |
| const num = Cast.toNumber(args.VALUE); | |
| this._counter = num; | |
| } | |
| clearCounter () { | |
| this._counter = 0; | |
| } | |
| incrCounter () { | |
| this._counter++; | |
| } | |
| decrCounter () { | |
| this._counter--; | |
| } | |
| allAtOnce (util) { | |
| util.thread.peekStackFrame().warpMode = false; | |
| util.startBranch(1, false); | |
| util.thread.peekStackFrame().warpMode = true; | |
| } | |
| } | |
| module.exports = Scratch3ControlBlocks; | |