=0;k--)\n {\n let b = this.beeps[k];\n let volume = b.volume ;\n if (b.time/b.duration>b.span)\n {\n volume = 0 ;\n }\n if (b.waveform == \"square\")\n {\n sig += b.phase>.5? volume : -volume ;\n }\n else if (b.waveform == \"saw\")\n {\n sig += (b.phase*2-1)*volume ;\n }\n else if (b.waveform == \"noise\")\n {\n sig += (Math.random()*2-1)*volume ;\n }\n else\n {\n sig += Math.sin(b.phase*Math.PI*2)*volume ;\n }\n\n b.phase = (b.phase+b.increment)%1 ;\n b.time += 1 ;\n if (b.time>=b.duration)\n {\n b.time = 0 ;\n if (b.loopto != null)\n {\n if (b.repeats != null && b.repeats>0)\n {\n if (b.loopcount == null)\n {\n b.loopcount = 0 ;\n }\n b.loopcount++ ;\n if (b.loopcount>=b.repeats)\n {\n b.loopcount = 0 ;\n if (b.next != null)\n {\n b.next.phase = b.phase ;\n b = b.next ;\n this.beeps[k] = b ;\n }\n else\n {\n this.beeps.splice(k,1) ;\n }\n }\n else\n {\n b.loopto.phase = b.phase ;\n b = b.loopto ;\n this.beeps[k] = b ;\n }\n }\n else\n {\n b.loopto.phase = b.phase ;\n b = b.loopto ;\n this.beeps[k] = b ;\n }\n }\n else if (b.next != null)\n {\n b.next.phase = b.phase ;\n b = b.next ;\n this.beeps[k] = b ;\n }\n else\n {\n this.beeps.splice(k,1) ;\n }\n }\n }\n this.last = this.last*.9+sig*.1 ;\n channel[j] = this.last ;\n }\n }\n }\n return true ;\n }\n}\n\nregisterProcessor('my-worklet-processor', MyWorkletProcessor);";
+
+ return AudioCore;
+
+})();
+
+this.AudioBufferizer = (function() {
+ function AudioBufferizer(node) {
+ var i, j, k, left, ref, right;
+ this.node = node;
+ this.buffer_size = 4096;
+ this.chunk_size = 512;
+ this.chunks = [];
+ this.nb_chunks = this.buffer_size / this.chunk_size;
+ for (i = j = 0, ref = this.nb_chunks - 1; j <= ref; i = j += 1) {
+ left = (function() {
+ var n, ref1, results;
+ results = [];
+ for (k = n = 0, ref1 = this.chunk_size - 1; 0 <= ref1 ? n <= ref1 : n >= ref1; k = 0 <= ref1 ? ++n : --n) {
+ results.push(0);
+ }
+ return results;
+ }).call(this);
+ right = (function() {
+ var n, ref1, results;
+ results = [];
+ for (k = n = 0, ref1 = this.chunk_size - 1; 0 <= ref1 ? n <= ref1 : n >= ref1; k = 0 <= ref1 ? ++n : --n) {
+ results.push(0);
+ }
+ return results;
+ }).call(this);
+ this.chunks[i] = [[left, right]];
+ }
+ this.current = 0;
+ setInterval(((function(_this) {
+ return function() {
+ return _this.step();
+ };
+ })(this)), this.chunk_size / 44100 * 1000);
+ }
+
+ AudioBufferizer.prototype.step = function() {
+ if (this.current >= this.chunks.length) {
+ return;
+ }
+ this.node.process(null, this.chunks[this.current], null);
+ this.current++;
+ };
+
+ AudioBufferizer.prototype.flush = function(outputs) {
+ var chunk, i, index, j, k, l, left, n, r, ref, ref1, right;
+ while (this.current < this.chunks.length) {
+ this.step();
+ }
+ this.current = 0;
+ left = outputs[0][0];
+ right = outputs[0][1];
+ index = 0;
+ chunk = 0;
+ for (i = j = 0, ref = this.chunks.length - 1; 0 <= ref ? j <= ref : j >= ref; i = 0 <= ref ? ++j : --j) {
+ chunk = this.chunks[i];
+ l = chunk[0][0];
+ r = chunk[0][1];
+ for (k = n = 0, ref1 = l.length - 1; 0 <= ref1 ? n <= ref1 : n >= ref1; k = 0 <= ref1 ? ++n : --n) {
+ left[index] = l[k];
+ right[index] = r[k];
+ index += 1;
+ }
+ }
+ };
+
+ return AudioBufferizer;
+
+})();
+
+this.Beeper = (function() {
+ function Beeper(audio) {
+ var i, j, k, l, len, len1, n, oct, ref, ref1, text;
+ this.audio = audio;
+ this.notes = {};
+ this.plain_notes = {};
+ text = [["C", "DO"], ["C#", "DO#", "Db", "REb"], ["D", "RE"], ["D#", "RE#", "Eb", "MIb"], ["E", "MI"], ["F", "FA"], ["F#", "FA#", "Gb", "SOLb"], ["G", "SOL"], ["G#", "SOL#", "Ab", "LAb"], ["A", "LA"], ["A#", "LA#", "Bb", "SIb"], ["B", "SI"]];
+ for (i = j = 0; j <= 127; i = j += 1) {
+ this.notes[i] = i;
+ oct = Math.floor(i / 12) - 1;
+ ref = text[i % 12];
+ for (k = 0, len = ref.length; k < len; k++) {
+ n = ref[k];
+ this.notes[n + oct] = i;
+ }
+ if (oct === -1) {
+ ref1 = text[i % 12];
+ for (l = 0, len1 = ref1.length; l < len1; l++) {
+ n = ref1[l];
+ this.plain_notes[n] = i;
+ }
+ }
+ }
+ this.current_octave = 5;
+ this.current_duration = .5;
+ this.current_volume = .5;
+ this.current_span = 1;
+ this.current_waveform = "square";
+ }
+
+ Beeper.prototype.beep = function(input) {
+ var i, j, k, len, loops, lop, n, note, parsed, ref, ref1, sequence, status, t, test;
+ test = "loop 0 square tempo 120 duration 500 volume 50 span 50 DO2 DO - FA SOL SOL FA -";
+ status = "normal";
+ sequence = [];
+ loops = [];
+ parsed = input.split(" ");
+ for (j = 0, len = parsed.length; j < len; j++) {
+ t = parsed[j];
+ if (t === "") {
+ continue;
+ }
+ switch (status) {
+ case "normal":
+ if (this.notes[t] != null) {
+ note = this.notes[t];
+ this.current_octave = Math.floor(note / 12);
+ sequence.push({
+ frequency: 440 * Math.pow(Math.pow(2, 1 / 12), note - 69),
+ volume: this.current_volume,
+ span: this.current_span,
+ duration: this.current_duration,
+ waveform: this.current_waveform
+ });
+ } else if (this.plain_notes[t] != null) {
+ note = this.plain_notes[t] + this.current_octave * 12;
+ sequence.push({
+ frequency: 440 * Math.pow(Math.pow(2, 1 / 12), note - 69),
+ volume: this.current_volume,
+ span: this.current_span,
+ duration: this.current_duration,
+ waveform: this.current_waveform
+ });
+ } else if (t === "square" || t === "sine" || t === "saw" || t === "noise") {
+ this.current_waveform = t;
+ } else if (t === "tempo" || t === "duration" || t === "volume" || t === "span" || t === "loop" || t === "to") {
+ status = t;
+ } else if (t === "-") {
+ sequence.push({
+ frequency: 440,
+ volume: 0,
+ span: this.current_span,
+ duration: this.current_duration,
+ waveform: this.current_waveform
+ });
+ } else if (t === "end") {
+ if (loops.length > 0 && sequence.length > 0) {
+ sequence.push({
+ frequency: 440,
+ volume: 0,
+ span: this.current_span,
+ duration: 0,
+ waveform: this.current_waveform
+ });
+ lop = loops.splice(loops.length - 1, 1)[0];
+ sequence[sequence.length - 1].loopto = lop.start;
+ sequence[sequence.length - 1].repeats = lop.repeats;
+ }
+ }
+ break;
+ case "tempo":
+ status = "normal";
+ t = Number.parseFloat(t);
+ if (!Number.isNaN(t) && t > 0) {
+ this.current_duration = 60 / t;
+ }
+ break;
+ case "duration":
+ status = "normal";
+ t = Number.parseFloat(t);
+ if (!Number.isNaN(t) && t > 0) {
+ this.current_duration = t / 1000;
+ }
+ break;
+ case "volume":
+ status = "normal";
+ t = Number.parseFloat(t);
+ if (!Number.isNaN(t)) {
+ this.current_volume = t / 100;
+ }
+ break;
+ case "span":
+ status = "normal";
+ t = Number.parseFloat(t);
+ if (!Number.isNaN(t)) {
+ this.current_span = t / 100;
+ }
+ break;
+ case "loop":
+ status = "normal";
+ loops.push({
+ start: sequence.length
+ });
+ t = Number.parseFloat(t);
+ if (!Number.isNaN(t)) {
+ loops[loops.length - 1].repeats = t;
+ }
+ break;
+ case "to":
+ status = "normal";
+ if (note != null) {
+ n = null;
+ if (this.notes[t] != null) {
+ n = this.notes[t];
+ } else if (this.plain_notes[t] != null) {
+ n = this.plain_notes[t] + this.current_octave * 12;
+ }
+ if ((n != null) && n !== note) {
+ for (i = k = ref = note, ref1 = n; ref <= ref1 ? k <= ref1 : k >= ref1; i = ref <= ref1 ? ++k : --k) {
+ if (i !== note) {
+ sequence.push({
+ frequency: 440 * Math.pow(Math.pow(2, 1 / 12), i - 69),
+ volume: this.current_volume,
+ span: this.current_span,
+ duration: this.current_duration,
+ waveform: this.current_waveform
+ });
+ }
+ }
+ note = n;
+ }
+ }
+ }
+ }
+ if (loops.length > 0 && sequence.length > 0) {
+ lop = loops.splice(loops.length - 1, 1)[0];
+ sequence.push({
+ frequency: 440,
+ volume: 0,
+ span: this.current_span,
+ duration: 0,
+ waveform: this.current_waveform
+ });
+ sequence[sequence.length - 1].loopto = lop.start;
+ sequence[sequence.length - 1].repeats = lop.repeats;
+ }
+ return this.audio.addBeeps(sequence);
+ };
+
+ return Beeper;
+
+})();
+
+this.Sound = class Sound {
+ constructor(audio, url) {
+ var request;
+ this.audio = audio;
+ this.url = url;
+ if (typeof MicroSound !== "undefined" && MicroSound !== null) {
+ this.class = MicroSound;
+ }
+ if (this.url instanceof AudioBuffer) {
+ this.buffer = this.url;
+ this.ready = 1;
+ } else {
+ this.ready = 0;
+ request = new XMLHttpRequest();
+ request.open('GET', this.url, true);
+ request.responseType = 'arraybuffer';
+ request.onload = () => {
+ return this.audio.context.decodeAudioData(request.response, (buffer1) => {
+ this.buffer = buffer1;
+ return this.ready = 1;
+ });
+ };
+ request.send();
+ }
+ }
+
+ play(volume = 1, pitch = 1, pan = 0, loopit = false) {
+ var gain, panner, playing, res, source;
+ if (this.buffer == null) {
+ return;
+ }
+ source = this.audio.context.createBufferSource();
+ source.playbackRate.value = pitch;
+ source.buffer = this.buffer;
+ if (loopit) {
+ source.loop = true;
+ }
+ gain = this.audio.context.createGain();
+ gain.gain.value = volume;
+ if (false && (this.audio.context.createStereoPanner != null)) {
+ panner = this.audio.context.createStereoPanner();
+ panner.setPan = function(pan) {
+ return panner.pan.value = pan;
+ };
+ } else {
+ panner = this.audio.context.createPanner();
+ panner.panningModel = "equalpower";
+ panner.setPan = function(pan) {
+ return panner.setPosition(pan, 0, 1 - Math.abs(pan));
+ };
+ }
+ panner.setPan(pan);
+ source.connect(gain);
+ gain.connect(panner);
+ panner.connect(this.audio.context.destination);
+ source.start();
+ playing = null;
+ if (loopit) {
+ playing = {
+ stop: () => {
+ return source.stop();
+ }
+ };
+ this.audio.addPlaying(playing);
+ }
+ res = {
+ stop: () => {
+ source.stop();
+ if (playing) {
+ this.audio.removePlaying(playing);
+ }
+ return 1;
+ },
+ setVolume: function(volume) {
+ return gain.gain.value = Math.max(0, Math.min(1, volume));
+ },
+ setPitch: function(pitch) {
+ return source.playbackRate.value = Math.max(.001, Math.min(1000, pitch));
+ },
+ setPan: function(pan) {
+ return panner.setPan(Math.max(-1, Math.min(1, pan)));
+ },
+ getDuration: function() {
+ return source.buffer.duration;
+ },
+ finished: false
+ };
+ source.onended = function() {
+ return res.finished = true;
+ };
+ return res;
+ }
+
+ static createSoundClass(audiocore) {
+ return window.MicroSound = (function() {
+ var _Class;
+
+ _Class = class {
+ constructor(channels, length, sampleRate = 44100) {
+ var buffer, ch1, ch2, snd;
+ this.class = MicroSound;
+ channels = channels === 1 ? 1 : 2;
+ if (!(length > 1) || !(length < 44100 * 1000)) {
+ length = 44100;
+ }
+ if (!(sampleRate >= 8000) || !(sampleRate <= 96000)) {
+ sampleRate = 44100;
+ }
+ buffer = audiocore.context.createBuffer(channels, length, sampleRate);
+ snd = new Sound(audiocore, buffer);
+ this.channels = channels;
+ this.length = length;
+ this.sampleRate = sampleRate;
+ ch1 = buffer.getChannelData(0);
+ if (channels === 2) {
+ ch2 = buffer.getChannelData(1);
+ }
+ this.play = function(volume, pitch, pan, loopit) {
+ return snd.play(volume, pitch, pan, loopit);
+ };
+ this.write = function(channel, position, value) {
+ if (channel === 0) {
+ ch1 = buffer.getChannelData(0);
+ return ch1[position] = value;
+ } else if (channels === 2) {
+ ch2 = buffer.getChannelData(1);
+ return ch2[position] = value;
+ }
+ };
+ this.read = function(channel, position) {
+ if (channel === 0) {
+ ch1 = buffer.getChannelData(0);
+ return ch1[position];
+ } else if (channels === 2) {
+ ch2 = buffer.getChannelData(1);
+ return ch2[position];
+ } else {
+ return 0;
+ }
+ };
+ }
+
+ };
+
+ _Class.classname = "Sound";
+
+ return _Class;
+
+ }).call(this);
+ }
+
+};
+
+this.Music = (function() {
+ function Music(audio, url) {
+ this.audio = audio;
+ this.url = url;
+ this.tag = new Audio(this.url);
+ this.playing = false;
+ }
+
+ Music.prototype.play = function(volume, loopit) {
+ if (volume == null) {
+ volume = 1;
+ }
+ if (loopit == null) {
+ loopit = false;
+ }
+ this.playing = true;
+ this.tag.loop = loopit ? true : false;
+ this.tag.volume = volume;
+ if (this.audio.isStarted()) {
+ this.tag.play();
+ } else {
+ this.audio.addToWakeUpList(this);
+ }
+ this.audio.addPlaying(this);
+ return {
+ play: (function(_this) {
+ return function() {
+ return _this.tag.play();
+ };
+ })(this),
+ stop: (function(_this) {
+ return function() {
+ _this.playing = false;
+ _this.tag.pause();
+ return _this.audio.removePlaying(_this);
+ };
+ })(this),
+ setVolume: (function(_this) {
+ return function(volume) {
+ return _this.tag.volume = Math.max(0, Math.min(1, volume));
+ };
+ })(this),
+ getPosition: (function(_this) {
+ return function() {
+ return _this.tag.currentTime;
+ };
+ })(this),
+ getDuration: (function(_this) {
+ return function() {
+ return _this.tag.duration;
+ };
+ })(this),
+ setPosition: (function(_this) {
+ return function(pos) {
+ _this.tag.pause();
+ _this.tag.currentTime = Math.max(0, Math.min(_this.tag.duration, pos));
+ if (_this.playing) {
+ return _this.tag.play();
+ }
+ };
+ })(this)
+ };
+ };
+
+ Music.prototype.wakeUp = function() {
+ if (this.playing) {
+ return this.tag.play();
+ }
+ };
+
+ Music.prototype.stop = function() {
+ this.playing = false;
+ return this.tag.pause();
+ };
+
+ return Music;
+
+})();
+
+this.Player = class Player {
+ constructor(listener) {
+ var i, len, ref, source;
+ this.listener = listener;
+ //src = document.getElementById("code").innerText
+ this.source_count = 0;
+ this.sources = {};
+ this.resources = resources;
+ this.request_id = 1;
+ this.pending_requests = {};
+ if (resources.sources != null) {
+ ref = resources.sources;
+ for (i = 0, len = ref.length; i < len; i++) {
+ source = ref[i];
+ this.loadSource(source);
+ }
+ } else {
+ this.sources.main = document.getElementById("code").innerText;
+ this.start();
+ }
+ }
+
+ loadSource(source) {
+ var req;
+ req = new XMLHttpRequest();
+ req.onreadystatechange = (event) => {
+ var name;
+ if (req.readyState === XMLHttpRequest.DONE) {
+ if (req.status === 200) {
+ name = source.file.split(".")[0];
+ this.sources[name] = req.responseText;
+ this.source_count++;
+ if (this.source_count >= resources.sources.length && (this.runtime == null)) {
+ return this.start();
+ }
+ }
+ }
+ };
+ req.open("GET", location.origin + location.pathname + `ms/${source.file}?v=${source.version}`);
+ return req.send();
+ }
+
+ start() {
+ var touchListener, touchStartListener, wrapper;
+ this.runtime = new Runtime((window.exported_project ? "" : location.origin + location.pathname), this.sources, resources, this);
+ this.client = new PlayerClient(this);
+ wrapper = document.getElementById("canvaswrapper");
+ wrapper.appendChild(this.runtime.screen.canvas);
+ window.addEventListener("resize", () => {
+ return this.resize();
+ });
+ this.resize();
+ //@runtime.start()
+ touchStartListener = (event) => {
+ event.preventDefault();
+ //event.stopPropagation()
+ //event.stopImmediatePropagation()
+ this.runtime.screen.canvas.removeEventListener("touchstart", touchStartListener);
+ return true;
+ };
+ touchListener = (event) => {
+ //event.preventDefault()
+ //event.stopPropagation()
+ //event.stopImmediatePropagation()
+ //@runtime.screen.canvas.removeEventListener "touchend",touchListener
+ if ((this.runtime != null) && (this.runtime.vm != null) && this.runtime.vm.context.global.system.disable_autofullscreen) {
+ return true;
+ } else {
+ this.setFullScreen();
+ }
+ return true;
+ };
+ this.runtime.screen.canvas.addEventListener("touchstart", touchStartListener);
+ this.runtime.screen.canvas.addEventListener("touchend", touchListener);
+ this.runtime.start();
+ window.addEventListener("message", (msg) => {
+ return this.messageReceived(msg);
+ });
+ return this.postMessage({
+ name: "focus"
+ });
+ }
+
+ resize() {
+ var file, ref, results, src;
+ this.runtime.screen.resize();
+ if (this.runtime.vm != null) {
+ if (this.runtime.vm.context.global.draw == null) {
+ this.runtime.update_memory = {};
+ ref = this.runtime.sources;
+ results = [];
+ for (file in ref) {
+ src = ref[file];
+ results.push(this.runtime.updateSource(file, src, false));
+ }
+ return results;
+ } else if (this.runtime.stopped) {
+ return this.runtime.drawCall();
+ }
+ }
+ }
+
+ setFullScreen() {
+ var ref;
+ if ((document.documentElement.webkitRequestFullScreen != null) && !document.webkitIsFullScreen) {
+ document.documentElement.webkitRequestFullScreen();
+ } else if ((document.documentElement.requestFullScreen != null) && !document.fullScreen) {
+ document.documentElement.requestFullScreen();
+ } else if ((document.documentElement.mozRequestFullScreen != null) && !document.mozFullScreen) {
+ document.documentElement.mozRequestFullScreen();
+ }
+ if ((window.screen != null) && (window.screen.orientation != null) && ((ref = window.orientation) === "portrait" || ref === "landscape")) {
+ return window.screen.orientation.lock(window.orientation).then(null, function(error) {});
+ }
+ }
+
+ //console.error error
+ reportError(err) {
+ return this.postMessage({
+ name: "error",
+ data: err
+ });
+ }
+
+ log(text) {
+ return this.postMessage({
+ name: "log",
+ data: text
+ });
+ }
+
+ codePaused() {
+ return this.postMessage({
+ name: "code_paused"
+ });
+ }
+
+ exit() {
+ return this.postMessage({
+ name: "exit"
+ });
+ }
+
+ messageReceived(msg) {
+ var code, data, err, file;
+ data = msg.data;
+ try {
+ data = JSON.parse(data);
+ switch (data.name) {
+ case "command":
+ return this.runtime.runCommand(data.line, (res) => {
+ if (!data.line.trim().startsWith("print")) {
+ return this.postMessage({
+ name: "output",
+ data: res,
+ id: data.id
+ });
+ }
+ });
+ case "pause":
+ return this.runtime.stop();
+ case "step_forward":
+ return this.runtime.stepForward();
+ case "resume":
+ return this.runtime.resume();
+ case "code_updated":
+ code = data.code;
+ file = data.file.split(".")[0];
+ if (this.runtime.vm != null) {
+ this.runtime.vm.clearWarnings();
+ }
+ return this.runtime.updateSource(file, code, true);
+ case "sprite_updated":
+ file = data.file;
+ return this.runtime.updateSprite(file, 0, data.data, data.properties);
+ case "map_updated":
+ file = data.file;
+ return this.runtime.updateMap(file, 0, data.data);
+ case "take_picture":
+ this.runtime.screen.takePicture((pic) => {
+ return this.postMessage({
+ name: "picture_taken",
+ data: pic
+ });
+ });
+ if (this.runtime.stopped) {
+ return this.runtime.drawCall();
+ }
+ break;
+ case "time_machine":
+ return this.runtime.time_machine.messageReceived(data);
+ case "watch":
+ return this.runtime.watch(data.list);
+ case "stop_watching":
+ return this.runtime.stopWatching();
+ default:
+ if (data.request_id != null) {
+ if (this.pending_requests[data.request_id] != null) {
+ this.pending_requests[data.request_id](data);
+ return delete this.pending_requests[data.request_id];
+ }
+ }
+ }
+ } catch (error1) {
+ err = error1;
+ return console.error(err);
+ }
+ }
+
+ call(name, args) {
+ if ((this.runtime != null) && (this.runtime.vm != null)) {
+ return this.runtime.vm.call(name, args);
+ }
+ }
+
+ setGlobal(name, value) {
+ if ((this.runtime != null) && (this.runtime.vm != null)) {
+ return this.runtime.vm.context.global[name] = value;
+ }
+ }
+
+ exec(command, callback) {
+ if (this.runtime != null) {
+ return this.runtime.runCommand(command, callback);
+ }
+ }
+
+ postMessage(data) {
+ var err;
+ if (window !== window.parent) {
+ window.parent.postMessage(JSON.stringify(data), "*");
+ }
+ if (this.listener != null) {
+ try {
+ return this.listener(data);
+ } catch (error1) {
+ err = error1;
+ return console.error(err);
+ }
+ }
+ }
+
+ postRequest(data, callback) {
+ data.request_id = this.request_id;
+ this.pending_requests[this.request_id++] = callback;
+ return this.postMessage(data);
+ }
+
+};
+
+if ((navigator.serviceWorker != null) && !window.skip_service_worker) {
+ navigator.serviceWorker.register('sw.js', {
+ scope: location.pathname
+ }).then(function(reg) {
+ return console.log('Registration succeeded. Scope is' + reg.scope);
+ }).catch(function(error) {
+ return console.log('Registration failed with' + error);
+ });
+}
+
+this.PlayerClient = class PlayerClient {
+ constructor(player) {
+ var err;
+ this.player = player;
+ this.pending_requests = {};
+ this.request_id = 0;
+ this.version_checked = false;
+ this.reconnect_delay = 1000;
+ if (location.protocol.startsWith("http") && !window.exported_project) {
+ try {
+ this.connect();
+ } catch (error) {
+ err = error;
+ console.error(err);
+ }
+ setInterval((() => {
+ if (this.socket != null) {
+ return this.sendRequest({
+ name: "ping"
+ });
+ }
+ }), 30000);
+ }
+ }
+
+ connect() {
+ this.socket = new WebSocket(window.location.origin.replace("http", "ws"));
+ this.socket.onmessage = (msg) => {
+ var err;
+ console.info("received: " + msg.data);
+ try {
+ msg = JSON.parse(msg.data);
+ if (msg.request_id != null) {
+ if (this.pending_requests[msg.request_id] != null) {
+ this.pending_requests[msg.request_id](msg);
+ delete this.pending_requests[msg.request_id];
+ }
+ }
+ //if msg.name == "code_updated"
+ // @player.runtime.updateSource(msg.file,msg.code,true)
+
+ //if msg.name == "sprite_updated"
+ // @player.runtime.updateSprite(msg.sprite)
+ if (msg.name === "project_file_updated") {
+ this.player.runtime.projectFileUpdated(msg.type, msg.file, msg.version, msg.data, msg.properties);
+ }
+ if (msg.name === "project_file_deleted") {
+ this.player.runtime.projectFileDeleted(msg.type, msg.file);
+ }
+ if (msg.name === "project_options_updated") {
+ return this.player.runtime.projectOptionsUpdated(msg);
+ }
+ } catch (error) {
+ err = error;
+ return console.error(err);
+ }
+ };
+ this.socket.onopen = () => {
+ var i, j, k, l, len, len1, len2, len3, m, maps, project, ref, ref1, ref2, ref3, s, sources, sprites, user;
+ //console.info "socket opened"
+ this.reconnect_delay = 1000;
+ user = location.pathname.split("/")[1];
+ project = location.pathname.split("/")[2];
+ if (this.buffer != null) {
+ ref = this.buffer;
+ for (i = 0, len = ref.length; i < len; i++) {
+ m = ref[i];
+ this.send(m);
+ }
+ delete this.buffer;
+ }
+ this.send({
+ name: "listen_to_project",
+ user: user,
+ project: project
+ });
+ if (!this.version_checked) {
+ this.version_checked = true;
+ sprites = {};
+ maps = {};
+ sources = {};
+ ref1 = this.player.resources.images;
+ for (j = 0, len1 = ref1.length; j < len1; j++) {
+ s = ref1[j];
+ sprites[s.file.split(".")[0]] = s.version;
+ }
+ ref2 = this.player.resources.maps;
+ for (k = 0, len2 = ref2.length; k < len2; k++) {
+ s = ref2[k];
+ maps[s.file.split(".")[0]] = s.version;
+ }
+ ref3 = this.player.resources.sources;
+ for (l = 0, len3 = ref3.length; l < len3; l++) {
+ s = ref3[l];
+ sources[s.file.split(".")[0]] = s.version;
+ }
+ return this.sendRequest({
+ name: "get_file_versions",
+ user: user,
+ project: project
+ }, (msg) => {
+ var info, name, ref4, ref5, ref6, results, v;
+ ref4 = msg.data.sources;
+ for (name in ref4) {
+ info = ref4[name];
+ v = sources[name];
+ if ((v == null) || v !== info.version) {
+ //console.info "updating #{name} to version #{version}"
+ this.player.runtime.projectFileUpdated("ms", name, info.version, null, info.properties);
+ }
+ }
+ ref5 = msg.data.sprites;
+ for (name in ref5) {
+ info = ref5[name];
+ v = sprites[name];
+ if ((v == null) || v !== info.version) {
+ //console.info "updating #{name} to version #{version}"
+ this.player.runtime.projectFileUpdated("sprites", name, info.version, null, info.properties);
+ }
+ }
+ ref6 = msg.data.maps;
+ results = [];
+ for (name in ref6) {
+ info = ref6[name];
+ v = maps[name];
+ if ((v == null) || v !== info.version) {
+ //console.info "updating #{name} to version #{version}"
+ results.push(this.player.runtime.projectFileUpdated("maps", name, info.version, null, info.properties));
+ } else {
+ results.push(void 0);
+ }
+ }
+ return results;
+ });
+ }
+ };
+ return this.socket.onclose = () => {
+ //console.info "socket closed"
+ setTimeout((() => {
+ return this.connect();
+ }), this.reconnect_delay);
+ return this.reconnect_delay += 1000;
+ };
+ }
+
+ send(data) {
+ if (this.socket.readyState !== 1) {
+ if (this.buffer == null) {
+ this.buffer = [];
+ }
+ return this.buffer.push(data);
+ } else {
+ return this.socket.send(JSON.stringify(data));
+ }
+ }
+
+ sendRequest(msg, callback) {
+ msg.request_id = this.request_id++;
+ this.pending_requests[msg.request_id] = callback;
+ return this.send(msg);
+ }
+
+};
+
diff --git a/cas.zip b/WebGames-master/WebGames-master/games/cap/music/music.mp3
similarity index 72%
rename from cas.zip
rename to WebGames-master/WebGames-master/games/cap/music/music.mp3
index 4cdfb4ab..e1656723 100644
Binary files a/cas.zip and b/WebGames-master/WebGames-master/games/cap/music/music.mp3 differ
diff --git a/WebGames-master/WebGames-master/games/cap/parser.js b/WebGames-master/WebGames-master/games/cap/parser.js
new file mode 100644
index 00000000..c9696477
--- /dev/null
+++ b/WebGames-master/WebGames-master/games/cap/parser.js
@@ -0,0 +1,812 @@
+this.Parser = (function() {
+ class Parser {
+ constructor(input, filename = "") {
+ this.input = input;
+ this.filename = filename;
+ if (/^\s*\/\/\s*javascript\s*\n/.test(this.input)) {
+ this.input = 'system.javascript("""\n\n' + this.input.replace(/\\/g, "\\\\") + '\n\n""")';
+ }
+ this.tokenizer = new Tokenizer(this.input, this.filename);
+ this.program = new Program();
+ this.current_block = [];
+ this.current = {
+ line: 1,
+ column: 1
+ };
+ this.verbose = false;
+ this.nesting = 0;
+ this.object_nesting = 0;
+ this.not_terminated = [];
+ this.api_reserved = {
+ screen: true,
+ audio: true,
+ keyboard: true,
+ gamepad: true,
+ sprites: true,
+ sounds: true,
+ music: true,
+ assets: true,
+ asset_manager: true,
+ maps: true,
+ touch: true,
+ mouse: true,
+ fonts: true,
+ Sound: true,
+ Image: true,
+ Sprite: true,
+ Map: true,
+ system: true,
+ storage: true,
+ print: true,
+ random: true,
+ Function: true,
+ List: true,
+ Object: true,
+ String: true,
+ Number: true
+ };
+ }
+
+ nextToken() {
+ var token;
+ token = this.tokenizer.next();
+ if (token == null) {
+ this.unexpected_eof = true;
+ throw "Unexpected end of file";
+ }
+ return this.current = token;
+ }
+
+ nextTokenOptional() {
+ var token;
+ token = this.tokenizer.next();
+ if (token != null) {
+ this.current = token;
+ }
+ return token;
+ }
+
+ parse() {
+ var err, expression, nt, token;
+ try {
+ this.warnings = [];
+ while (true) {
+ expression = this.parseLine();
+ if ((expression == null) && !this.tokenizer.finished()) {
+ token = this.tokenizer.next();
+ if ((token != null) && token.reserved_keyword) {
+ if (token.value === "end") {
+ this.error("Too many 'end'");
+ } else {
+ this.error(`Misuse of reserved keyword: '${token.value}'`);
+ }
+ } else {
+ this.error("Unexpected data");
+ }
+ }
+ if (expression === null) {
+ break;
+ }
+ this.current_block.push(expression);
+ this.program.add(expression);
+ if (this.verbose) {
+ console.info(expression);
+ }
+ }
+ return this;
+ } catch (error1) {
+ err = error1;
+ //console.info "Error at line: #{@current.line} column: #{@current.column}"
+ if (this.not_terminated.length > 0 && err === "Unexpected end of file") {
+ nt = this.not_terminated[this.not_terminated.length - 1];
+ return this.error_info = {
+ error: `Unterminated '${nt.value}' ; no matching 'end' found`,
+ line: nt.line,
+ column: nt.column
+ };
+ } else {
+ return this.error_info = {
+ error: err,
+ line: this.current.line,
+ column: this.current.column
+ };
+ }
+ }
+ }
+
+ //console.error err
+ parseLine() {
+ var token;
+ token = this.nextTokenOptional();
+ if (token == null) {
+ return null;
+ }
+ switch (token.type) {
+ case Token.TYPE_RETURN:
+ return new Program.Return(token, this.parseExpression());
+ case Token.TYPE_BREAK:
+ return new Program.Break(token);
+ case Token.TYPE_CONTINUE:
+ return new Program.Continue(token);
+ case Token.TYPE_LOCAL:
+ return this.parseLocalAssignment(token);
+ default:
+ this.tokenizer.pushBack(token);
+ return this.parseExpression();
+ }
+ }
+
+ parseExpression(filter, first_function_call = false) {
+ var access, expression;
+ expression = this.parseExpressionStart();
+ if (expression == null) {
+ return null;
+ }
+ while (true) {
+ access = this.parseExpressionSuffix(expression, filter);
+ if (access == null) {
+ return expression;
+ }
+ if (first_function_call && access instanceof Program.FunctionCall) {
+ return access;
+ }
+ expression = access;
+ }
+ }
+
+ assertExpression(filter, first_function_call = false) {
+ var exp;
+ exp = this.parseExpression(filter, first_function_call);
+ if (exp == null) {
+ throw "Expression expected";
+ }
+ return exp;
+ }
+
+ parseExpressionSuffix(expression, filter) {
+ var field, identifier, token;
+ token = this.nextTokenOptional();
+ if (token == null) {
+ return (filter === "self" ? expression : null);
+ }
+ switch (token.type) {
+ case Token.TYPE_DOT:
+ if (expression instanceof Program.Value && expression.type === Program.Value.TYPE_NUMBER) {
+ this.tokenizer.pushBack(token);
+ return null;
+ } else {
+ this.tokenizer.changeNumberToIdentifier();
+ identifier = this.assertBroadIdentifier("Expected identifier");
+ return Program.CreateFieldAccess(token, expression, new Program.Value(identifier, Program.Value.TYPE_STRING, identifier.value));
+ }
+ break;
+ case Token.TYPE_OPEN_BRACKET:
+ field = this.assertExpression();
+ this.assert(Token.TYPE_CLOSED_BRACKET, "Expected ']'");
+ return Program.CreateFieldAccess(token, expression, field);
+ case Token.TYPE_OPEN_BRACE:
+ return this.parseFunctionCall(token, expression);
+ case Token.TYPE_EQUALS:
+ return this.parseAssignment(token, expression);
+ case Token.TYPE_PLUS_EQUALS:
+ return this.parseSelfAssignment(token, expression, token.type);
+ case Token.TYPE_MINUS_EQUALS:
+ return this.parseSelfAssignment(token, expression, token.type);
+ case Token.TYPE_MULTIPLY_EQUALS:
+ return this.parseSelfAssignment(token, expression, token.type);
+ case Token.TYPE_DIVIDE_EQUALS:
+ return this.parseSelfAssignment(token, expression, token.type);
+ case Token.TYPE_MODULO_EQUALS:
+ case Token.TYPE_AND_EQUALS:
+ case Token.TYPE_OR_EQUALS:
+ return this.parseSelfAssignment(token, expression, token.type);
+ default:
+ if (filter === "self") {
+ this.tokenizer.pushBack(token);
+ return expression;
+ } else if (token.is_binary_operator && filter !== "noop") {
+ return this.parseBinaryOperation(token, expression);
+ } else {
+ this.tokenizer.pushBack(token);
+ return null;
+ }
+ }
+ }
+
+ parseExpressionStart() {
+ var next, token;
+ token = this.nextTokenOptional();
+ if (token == null) {
+ return null;
+ }
+ switch (token.type) {
+ case Token.TYPE_IDENTIFIER: // variable name
+ return new Program.Variable(token, token.value);
+ case Token.TYPE_NUMBER:
+ return this.parseNumberExpression(token);
+ case Token.TYPE_PLUS:
+ return this.assertExpression();
+ case Token.TYPE_MINUS:
+ return this.parseExpressionSuffix(new Program.Negate(token, this.assertExpression("noop")), "self");
+ case Token.TYPE_NOT:
+ return this.parseExpressionSuffix(new Program.Not(token, this.assertExpression("noop")), "self");
+ case Token.TYPE_STRING:
+ return this.parseStringExpression(token);
+ case Token.TYPE_IF:
+ return this.parseIf(token);
+ case Token.TYPE_FOR:
+ return this.parseFor(token);
+ case Token.TYPE_WHILE:
+ return this.parseWhile(token);
+ case Token.TYPE_OPEN_BRACE:
+ return this.parseBracedExpression(token);
+ case Token.TYPE_OPEN_BRACKET:
+ return this.parseArray(token);
+ case Token.TYPE_FUNCTION:
+ return this.parseFunction(token);
+ case Token.TYPE_OBJECT:
+ return this.parseObject(token);
+ case Token.TYPE_CLASS:
+ return this.parseClass(token);
+ case Token.TYPE_NEW:
+ return this.parseNew(token);
+ case Token.TYPE_DOT:
+ next = this.assert(Token.TYPE_NUMBER, "malformed number");
+ if (!Number.isInteger(next.value)) {
+ throw "malformed number";
+ }
+ return new Program.Value(token, Program.Value.TYPE_NUMBER, Number.parseFloat(`.${next.string_value}`));
+ case Token.TYPE_AFTER:
+ return this.parseAfter(token);
+ case Token.TYPE_EVERY:
+ return this.parseEvery(token);
+ case Token.TYPE_DO:
+ return this.parseDo(token);
+ case Token.TYPE_SLEEP:
+ return this.parseSleep(token);
+ case Token.TYPE_DELETE:
+ return this.parseDelete(token);
+ default:
+ this.tokenizer.pushBack(token);
+ return null;
+ }
+ }
+
+ parseNumberExpression(number) {
+ return new Program.Value(number, Program.Value.TYPE_NUMBER, number.value);
+ }
+
+ parseStringExpression(string) {
+ var token;
+ token = this.nextTokenOptional();
+ if (token == null) {
+ return new Program.Value(string, Program.Value.TYPE_STRING, string.value);
+ } else {
+ this.tokenizer.pushBack(token);
+ return new Program.Value(string, Program.Value.TYPE_STRING, string.value);
+ }
+ }
+
+ parseArray(bracket) {
+ var res, token;
+ res = [];
+ while (true) {
+ token = this.nextToken();
+ if (token.type === Token.TYPE_CLOSED_BRACKET) {
+ return new Program.Value(bracket, Program.Value.TYPE_ARRAY, res);
+ } else if (token.type === Token.TYPE_COMMA) {
+ continue;
+ } else {
+ this.tokenizer.pushBack(token);
+ res.push(this.assertExpression());
+ }
+ }
+ }
+
+ parseBinaryOperation(operation, term1) {
+ var ops, terms, token;
+ ops = [new Program.Operation(operation, operation.value)];
+ terms = [term1];
+ terms.push(this.assertExpression("noop"));
+ while (true) {
+ token = this.nextTokenOptional();
+ if (token == null) {
+ break;
+ }
+ if (!token.is_binary_operator) {
+ this.tokenizer.pushBack(token);
+ break;
+ }
+ ops.push(new Program.Operation(token, token.value));
+ terms.push(this.assertExpression("noop"));
+ }
+ return Program.BuildOperations(ops, terms);
+ }
+
+ parseAssignment(token, expression) {
+ var res;
+ if (!(expression instanceof Program.Variable) && !(expression instanceof Program.Field)) {
+ throw "Expected variable identifier or property";
+ }
+ if (this.object_nesting === 0 && expression instanceof Program.Variable && this.api_reserved[expression.identifier]) {
+ this.warnings.push({
+ type: "assigning_api_variable",
+ identifier: expression.identifier,
+ line: token.line,
+ column: token.column
+ });
+ }
+ if (expression instanceof Program.Field) {
+ this.object_nesting += 1;
+ res = new Program.Assignment(token, expression, this.assertExpression());
+ this.object_nesting -= 1;
+ } else {
+ res = new Program.Assignment(token, expression, this.assertExpression());
+ }
+ return res;
+ }
+
+ parseSelfAssignment(token, expression, operation) {
+ if (!(expression instanceof Program.Variable) && !(expression instanceof Program.Field)) {
+ throw "Expected variable identifier or property";
+ }
+ return new Program.SelfAssignment(token, expression, operation, this.assertExpression());
+ }
+
+ parseLocalAssignment(local) {
+ var identifier;
+ identifier = this.assert(Token.TYPE_IDENTIFIER, "Expected identifier");
+ this.assert(Token.TYPE_EQUALS, "Expected '='");
+ return new Program.Assignment(local, new Program.Variable(identifier, identifier.value), this.assertExpression(), true);
+ }
+
+ parseBracedExpression(open) {
+ var expression, token;
+ expression = this.assertExpression();
+ token = this.nextToken();
+ if (token.type === Token.TYPE_CLOSED_BRACE) {
+ return new Program.Braced(open, expression);
+ } else {
+ return this.error("missing closing parenthese");
+ }
+ }
+
+ parseFunctionCall(brace_token, expression) {
+ var args, start, token;
+ args = [];
+ this.last_function_call = new Program.FunctionCall(brace_token, expression, args);
+ this.last_function_call.argslimits = [];
+ while (true) {
+ token = this.nextTokenOptional();
+ if (token == null) {
+ return this.error("missing closing parenthese");
+ } else if (token.type === Token.TYPE_CLOSED_BRACE) {
+ return new Program.FunctionCall(token, expression, args);
+ } else if (token.type === Token.TYPE_COMMA) {
+ continue;
+ } else {
+ this.tokenizer.pushBack(token);
+ start = token.start;
+ args.push(this.assertExpression());
+ this.last_function_call.argslimits.push({
+ start: start,
+ end: this.tokenizer.index - 1
+ });
+ }
+ }
+ }
+
+ addTerminable(token) {
+ return this.not_terminated.push(token);
+ }
+
+ endTerminable() {
+ if (this.not_terminated.length > 0) {
+ this.not_terminated.splice(this.not_terminated.length - 1, 1);
+ }
+ }
+
+ parseFunction(funk) {
+ var args, line, sequence, token;
+ this.nesting += 1;
+ this.addTerminable(funk);
+ args = this.parseFunctionArgs();
+ sequence = [];
+ while (true) {
+ token = this.nextToken();
+ if (token.type === Token.TYPE_END) {
+ this.nesting -= 1;
+ this.endTerminable();
+ return new Program.Function(funk, args, sequence, token);
+ } else {
+ this.tokenizer.pushBack(token);
+ line = this.parseLine();
+ if (line != null) {
+ sequence.push(line);
+ } else {
+ this.error("Unexpected data while parsing function");
+ }
+ }
+ }
+ }
+
+ parseFunctionArgs() {
+ var args, exp, last, token;
+ token = this.nextToken();
+ args = [];
+ last = null;
+ if (token.type !== Token.TYPE_OPEN_BRACE) {
+ return this.error("Expected opening parenthese");
+ }
+ while (true) {
+ token = this.nextToken();
+ if (token.type === Token.TYPE_CLOSED_BRACE) {
+ return args;
+ } else if (token.type === Token.TYPE_COMMA) {
+ last = null;
+ continue;
+ } else if (token.type === Token.TYPE_EQUALS && last === "argument") {
+ exp = this.assertExpression();
+ args[args.length - 1].default = exp;
+ } else if (token.type === Token.TYPE_IDENTIFIER) {
+ last = "argument";
+ args.push({
+ name: token.value
+ });
+ } else {
+ return this.error("Unexpected token");
+ }
+ }
+ }
+
+ warningAssignmentCondition(expression) {
+ if (expression instanceof Program.Assignment) {
+ return this.warnings.push({
+ type: "assignment_as_condition",
+ line: expression.token.line,
+ column: expression.token.column
+ });
+ }
+ }
+
+ parseIf(iftoken) {
+ var chain, current, line, token;
+ this.addTerminable(iftoken);
+ current = {
+ condition: this.assertExpression(),
+ sequence: []
+ };
+ this.warningAssignmentCondition(current.condition);
+ chain = [];
+ token = this.nextToken();
+ if (token.type !== Token.TYPE_THEN) {
+ return this.error("Expected 'then'");
+ }
+ while (true) {
+ token = this.nextToken();
+ if (token.type === Token.TYPE_ELSIF) {
+ chain.push(current);
+ current = {
+ condition: this.assertExpression(),
+ sequence: []
+ };
+ this.warningAssignmentCondition(current.condition);
+ this.assert(Token.TYPE_THEN, "Expected 'then'");
+ } else if (token.type === Token.TYPE_ELSE) {
+ current.else = [];
+ } else if (token.type === Token.TYPE_END) {
+ chain.push(current);
+ this.endTerminable();
+ return new Program.Condition(iftoken, chain);
+ } else {
+ this.tokenizer.pushBack(token);
+ line = this.parseLine();
+ if (line == null) {
+ throw Error("Unexpected data while parsing if");
+ }
+ if (current.else != null) {
+ current.else.push(line);
+ } else {
+ current.sequence.push(line);
+ }
+ }
+ }
+ }
+
+ assert(type, error) {
+ var token;
+ token = this.nextToken();
+ if (token.type !== type) {
+ throw error;
+ }
+ return token;
+ }
+
+ assertBroadIdentifier(error) {
+ var token;
+ token = this.nextToken();
+ if (token.type !== Token.TYPE_IDENTIFIER && token.reserved_keyword) {
+ token.type = Token.TYPE_IDENTIFIER;
+ }
+ if (token.type !== Token.TYPE_IDENTIFIER) {
+ throw error;
+ }
+ return token;
+ }
+
+ error(text) {
+ throw text;
+ }
+
+ parseFor(fortoken) {
+ var iterator, list, range_by, range_from, range_to, token;
+ iterator = this.assertExpression();
+ if (iterator instanceof Program.Assignment) {
+ range_from = iterator.expression;
+ iterator = iterator.field;
+ token = this.nextToken();
+ if (token.type !== Token.TYPE_TO) {
+ return this.error("Expected 'to'");
+ }
+ range_to = this.assertExpression();
+ token = this.nextToken();
+ if (token.type === Token.TYPE_BY) {
+ range_by = this.assertExpression();
+ } else {
+ range_by = 0;
+ this.tokenizer.pushBack(token);
+ }
+ return new Program.For(fortoken, iterator.identifier, range_from, range_to, range_by, this.parseSequence(fortoken));
+ } else if (iterator instanceof Program.Variable) {
+ this.assert(Token.TYPE_IN, "Error expected keyword 'in'");
+ list = this.assertExpression();
+ return new Program.ForIn(fortoken, iterator.identifier, list, this.parseSequence(fortoken));
+ } else {
+ return this.error("Malformed for loop");
+ }
+ }
+
+ parseWhile(whiletoken) {
+ var condition;
+ condition = this.assertExpression();
+ return new Program.While(whiletoken, condition, this.parseSequence(whiletoken));
+ }
+
+ parseSequence(start_token) {
+ var line, sequence, token;
+ if (start_token != null) {
+ this.addTerminable(start_token);
+ }
+ this.nesting += 1;
+ sequence = [];
+ while (true) {
+ token = this.nextToken();
+ if (token.type === Token.TYPE_END) {
+ if (start_token != null) {
+ this.endTerminable();
+ }
+ this.nesting -= 1;
+ return sequence;
+ } else {
+ this.tokenizer.pushBack(token);
+ line = this.parseLine();
+ if (line == null) {
+ this.error("Unexpected data");
+ }
+ sequence.push(line);
+ }
+ }
+ return sequence;
+ }
+
+ parseObject(object) {
+ var exp, fields, token;
+ this.nesting += 1;
+ this.object_nesting += 1;
+ this.addTerminable(object);
+ fields = [];
+ while (true) {
+ token = this.nextToken();
+ if (token.type === Token.TYPE_END) {
+ this.nesting -= 1;
+ this.object_nesting -= 1;
+ this.endTerminable();
+ return new Program.CreateObject(object, fields);
+ } else {
+ if (token.type !== Token.TYPE_IDENTIFIER && token.reserved_keyword) {
+ token.type = Token.TYPE_IDENTIFIER;
+ }
+ if (token.type === Token.TYPE_STRING) {
+ token.type = Token.TYPE_IDENTIFIER;
+ }
+ if (token.type === Token.TYPE_IDENTIFIER) {
+ this.assert(Token.TYPE_EQUALS, "Expected '='");
+ exp = this.assertExpression();
+ fields.push({
+ field: token.value,
+ value: exp
+ });
+ } else {
+ return this.error("Malformed object");
+ }
+ }
+ }
+ }
+
+ parseClass(object) {
+ var exp, ext, fields, token;
+ this.nesting += 1;
+ this.object_nesting += 1;
+ this.addTerminable(object);
+ fields = [];
+ token = this.nextToken();
+ if (token.type === Token.TYPE_EXTENDS) {
+ ext = this.assertExpression();
+ token = this.nextToken();
+ }
+ while (true) {
+ if (token.type === Token.TYPE_END) {
+ this.nesting -= 1;
+ this.object_nesting -= 1;
+ this.endTerminable();
+ return new Program.CreateClass(object, ext, fields);
+ } else {
+ if (token.type !== Token.TYPE_IDENTIFIER && token.reserved_keyword) {
+ token.type = Token.TYPE_IDENTIFIER;
+ }
+ if (token.type === Token.TYPE_STRING) {
+ token.type = Token.TYPE_IDENTIFIER;
+ }
+ if (token.type === Token.TYPE_IDENTIFIER) {
+ this.assert(Token.TYPE_EQUALS, "Expected '='");
+ exp = this.assertExpression();
+ fields.push({
+ field: token.value,
+ value: exp
+ });
+ } else {
+ return this.error("Malformed object");
+ }
+ }
+ token = this.nextToken();
+ }
+ }
+
+ parseNew(token) {
+ var exp;
+ exp = this.assertExpression(null, true);
+ return new Program.NewCall(token, exp);
+ }
+
+ parseAfter(after) {
+ var delay, line, multiplier, sequence, token;
+ this.nesting += 1;
+ this.addTerminable(after);
+ delay = this.assertExpression();
+ token = this.nextToken();
+ multiplier = null;
+ if (token.type === Token.TYPE_IDENTIFIER && this.multipliers[token.value]) {
+ multiplier = this.multipliers[token.value];
+ token = this.nextToken();
+ }
+ if ((token == null) || token.type !== Token.TYPE_DO) {
+ this.error("Expected keyword 'do'");
+ }
+ sequence = [];
+ while (true) {
+ token = this.nextToken();
+ if (token.type === Token.TYPE_END) {
+ this.nesting -= 1;
+ this.endTerminable();
+ return new Program.After(after, delay, sequence, token, multiplier);
+ } else {
+ this.tokenizer.pushBack(token);
+ line = this.parseLine();
+ if (line != null) {
+ sequence.push(line);
+ } else {
+ this.error("Unexpected data while parsing after");
+ }
+ }
+ }
+ }
+
+ parseEvery(every) {
+ var delay, line, multiplier, sequence, token;
+ this.nesting += 1;
+ this.addTerminable(every);
+ delay = this.assertExpression();
+ token = this.nextToken();
+ multiplier = null;
+ if (token.type === Token.TYPE_IDENTIFIER && this.multipliers[token.value]) {
+ multiplier = this.multipliers[token.value];
+ token = this.nextToken();
+ }
+ if ((token == null) || token.type !== Token.TYPE_DO) {
+ this.error("Expected keyword 'do'");
+ }
+ sequence = [];
+ while (true) {
+ token = this.nextToken();
+ if (token.type === Token.TYPE_END) {
+ this.nesting -= 1;
+ this.endTerminable();
+ return new Program.Every(every, delay, sequence, token, multiplier);
+ } else {
+ this.tokenizer.pushBack(token);
+ line = this.parseLine();
+ if (line != null) {
+ sequence.push(line);
+ } else {
+ this.error("Unexpected data while parsing after");
+ }
+ }
+ }
+ }
+
+ parseDo(do_token) {
+ var line, sequence, token;
+ this.nesting += 1;
+ this.addTerminable(do_token);
+ sequence = [];
+ while (true) {
+ token = this.nextToken();
+ if (token.type === Token.TYPE_END) {
+ this.nesting -= 1;
+ this.endTerminable();
+ return new Program.Do(do_token, sequence, token);
+ } else {
+ this.tokenizer.pushBack(token);
+ line = this.parseLine();
+ if (line != null) {
+ sequence.push(line);
+ } else {
+ this.error("Unexpected data while parsing after");
+ }
+ }
+ }
+ }
+
+ parseSleep(sleep) {
+ var delay, multiplier, token;
+ delay = this.assertExpression();
+ token = this.nextToken();
+ multiplier = null;
+ if (token != null) {
+ if (token.type === Token.TYPE_IDENTIFIER && this.multipliers[token.value]) {
+ multiplier = this.multipliers[token.value];
+ } else {
+ this.tokenizer.pushBack(token);
+ }
+ }
+ return new Program.Sleep(sleep, delay, multiplier);
+ }
+
+ parseDelete(del) {
+ var v;
+ v = this.parseExpression();
+ if ((v == null) || (!(v instanceof Program.Variable) && !(v instanceof Program.Field))) {
+ return this.error("expecting variable name or property access after keyword `delete`");
+ } else {
+ return new Program.Delete(del, v);
+ }
+ }
+
+ };
+
+ Parser.prototype.multipliers = {
+ millisecond: 1,
+ milliseconds: 1,
+ second: 1000,
+ seconds: 1000,
+ minute: 60000,
+ minutes: 60000,
+ hour: 60000 * 60,
+ hours: 60000 * 60,
+ day: 60000 * 60 * 24,
+ days: 60000 * 60 * 24
+ };
+
+ return Parser;
+
+}).call(this);
diff --git a/WebGames-master/WebGames-master/games/cap/processor.js b/WebGames-master/WebGames-master/games/cap/processor.js
new file mode 100644
index 00000000..60ed44c6
--- /dev/null
+++ b/WebGames-master/WebGames-master/games/cap/processor.js
@@ -0,0 +1,1542 @@
+this.Processor = class Processor {
+ constructor(runner) {
+ this.runner = runner;
+ this.locals = [];
+ this.stack = [];
+ this.call_stack = [];
+ this.log = false;
+ this.time_limit = 2e308;
+ this.done = true;
+ }
+
+ load(routine1) {
+ this.routine = routine1;
+ return this.resetState();
+ }
+
+ resetState() {
+ this.local_index = 0;
+ this.stack_index = -1;
+ this.op_index = 0;
+ this.call_stack_index = 0;
+ this.global = null;
+ this.object = this.routine.object || null;
+ this.locals_offset = 0;
+ this.call_super = null;
+ this.call_supername = "";
+ return this.done = false;
+ }
+
+ resolveParentClass(obj, global) {
+ if ((obj.class != null) && typeof obj.class === "string") {
+ if (global[obj.class] != null) {
+ obj.class = global[obj.class];
+ return this.resolveParentClass(obj.class, global);
+ }
+ } else if (obj.class != null) {
+ return this.resolveParentClass(obj.class, global);
+ }
+ }
+
+ applyFunction(args) {}
+
+ routineAsFunction(routine, context) {
+ var f, proc;
+ proc = new Processor(this.runner);
+ f = function() {
+ var a, count, i, j, k, ref, ref1;
+ count = Math.min(routine.num_args, arguments.length);
+ proc.load(routine);
+ for (i = j = 0, ref = count - 1; j <= ref; i = j += 1) {
+ proc.stack[++proc.stack_index] = arguments[i] || 0;
+ }
+ proc.stack[++proc.stack_index] = arguments.length;
+ if (routine.uses_arguments) {
+ a = [...arguments];
+ for (i = k = 0, ref1 = a.length - 1; k <= ref1; i = k += 1) {
+ if (a[i] == null) {
+ a[i] = 0;
+ }
+ }
+ proc.stack[++proc.stack_index] = a;
+ }
+ return proc.run(context);
+ };
+ //res = proc.stack[0]
+ return f;
+ }
+
+ routineAsApplicableFunction(routine, context) {
+ var f, proc;
+ proc = new Processor(this.runner);
+ f = function() {
+ var a, count, i, j, k, ref, ref1, res;
+ count = routine.num_args;
+ proc.load(routine);
+ proc.object = this;
+ for (i = j = 0, ref = count - 1; j <= ref; i = j += 1) {
+ proc.stack[++proc.stack_index] = arguments[i] || 0;
+ }
+ proc.stack[++proc.stack_index] = arguments.length;
+ if (routine.uses_arguments) {
+ a = [...arguments];
+ for (i = k = 0, ref1 = a.length - 1; k <= ref1; i = k += 1) {
+ if (a[i] == null) {
+ a[i] = 0;
+ }
+ }
+ proc.stack[++proc.stack_index] = a;
+ }
+ proc.run(context);
+ return res = proc.stack[0];
+ };
+ return f;
+ }
+
+ argToNative(arg, context) {
+ if (arg instanceof Routine) {
+ return this.routineAsFunction(arg, context);
+ } else {
+ if (arg != null) {
+ return arg;
+ } else {
+ return 0;
+ }
+ }
+ }
+
+ modulo(context, a, b) {
+ var f, obj;
+ if (Array.isArray(a)) {
+ obj = context.global.List;
+ } else if (typeof a === "string") {
+ if (isFinite(a)) {
+ a %= b;
+ if (isFinite(a)) {
+ return a;
+ } else {
+ return 0;
+ }
+ } else {
+ obj = context.global.String;
+ }
+ } else {
+ obj = a;
+ }
+ f = obj["%"];
+ while ((f == null) && (obj.class != null)) {
+ obj = obj.class;
+ f = obj["%"];
+ }
+ if (f == null) {
+ f = context.global.Object["%"];
+ }
+ if ((f != null) && f instanceof Routine) {
+ if (f.as_function == null) {
+ f.as_function = this.routineAsApplicableFunction(f, context);
+ }
+ f = f.as_function;
+ return f.call(context.global, a, b);
+ } else {
+ return 0;
+ }
+ }
+
+ add(context, a, b, self) {
+ var f, obj;
+ if (Array.isArray(a)) {
+ obj = context.global.List;
+ } else if (typeof a === "string") {
+ obj = context.global.String;
+ } else {
+ obj = a;
+ }
+ f = obj["+"];
+ while ((f == null) && (obj.class != null)) {
+ obj = obj.class;
+ f = obj["+"];
+ }
+ if (f == null) {
+ f = context.global.Object["+"];
+ }
+ if (f != null) {
+ if (f instanceof Routine) {
+ if (f.as_function == null) {
+ f.as_function = this.routineAsApplicableFunction(f, context);
+ }
+ f = f.as_function;
+ return f.call(context.global, a, b, self);
+ } else if (typeof f === "function") {
+ return f.call(context.global, a, b, self);
+ }
+ } else {
+ return 0;
+ }
+ }
+
+ sub(context, a, b, self) {
+ var f, obj;
+ if (Array.isArray(a)) {
+ obj = context.global.List;
+ } else if (typeof a === "string") {
+ if (isFinite(a)) {
+ a -= b;
+ if (isFinite(a)) {
+ return a;
+ } else {
+ return 0;
+ }
+ } else {
+ obj = context.global.String;
+ }
+ } else {
+ obj = a;
+ }
+ f = obj["-"];
+ while ((f == null) && (obj.class != null)) {
+ obj = obj.class;
+ f = obj["-"];
+ }
+ if (f == null) {
+ f = context.global.Object["-"];
+ }
+ if (f != null) {
+ if (f instanceof Routine) {
+ if (f.as_function == null) {
+ f.as_function = this.routineAsApplicableFunction(f, context);
+ }
+ f = f.as_function;
+ return f.call(context.global, a, b, self);
+ } else if (typeof f === "function") {
+ return f.call(context.global, a, b, self);
+ }
+ } else {
+ return 0;
+ }
+ }
+
+ negate(context, a) {
+ var f, obj;
+ if (Array.isArray(a)) {
+ obj = context.global.List;
+ } else if (typeof a === "string") {
+ if (isFinite(a)) {
+ return -a;
+ } else {
+ obj = context.global.String;
+ }
+ } else {
+ obj = a;
+ }
+ f = obj["-"];
+ while ((f == null) && (obj.class != null)) {
+ obj = obj.class;
+ f = obj["-"];
+ }
+ if (f == null) {
+ f = context.global.Object["-"];
+ }
+ if (f != null) {
+ if (f instanceof Routine) {
+ if (f.as_function == null) {
+ f.as_function = this.routineAsApplicableFunction(f, context);
+ }
+ f = f.as_function;
+ return f.call(context.global, 0, a);
+ } else if (typeof f === "function") {
+ return f.call(context.global, 0, a);
+ }
+ } else {
+ return 0;
+ }
+ }
+
+ mul(context, a, b, self) {
+ var f, obj;
+ if (Array.isArray(a)) {
+ obj = context.global.List;
+ } else if (typeof a === "string") {
+ if (isFinite(a)) {
+ a *= b;
+ if (isFinite(a)) {
+ return a;
+ } else {
+ return 0;
+ }
+ } else {
+ obj = context.global.String;
+ }
+ } else {
+ obj = a;
+ }
+ f = obj["*"];
+ while ((f == null) && (obj.class != null)) {
+ obj = obj.class;
+ f = obj["*"];
+ }
+ if (f == null) {
+ f = context.global.Object["*"];
+ }
+ if (f != null) {
+ if (f instanceof Routine) {
+ if (f.as_function == null) {
+ f.as_function = this.routineAsApplicableFunction(f, context);
+ }
+ f = f.as_function;
+ return f.call(context.global, a, b, self);
+ } else if (typeof f === "function") {
+ return f.call(context.global, a, b, self);
+ }
+ } else {
+ return 0;
+ }
+ }
+
+ div(context, a, b, self) {
+ var f, obj;
+ if (Array.isArray(a)) {
+ obj = context.global.List;
+ } else if (typeof a === "string") {
+ if (isFinite(a)) {
+ a /= b;
+ if (isFinite(a)) {
+ return a;
+ } else {
+ return 0;
+ }
+ } else {
+ obj = context.global.String;
+ }
+ } else {
+ obj = a;
+ }
+ f = obj["/"];
+ while ((f == null) && (obj.class != null)) {
+ obj = obj.class;
+ f = obj["/"];
+ }
+ if (f == null) {
+ f = context.global.Object["/"];
+ }
+ if (f != null) {
+ if (f instanceof Routine) {
+ if (f.as_function == null) {
+ f.as_function = this.routineAsApplicableFunction(f, context);
+ }
+ f = f.as_function;
+ return f.call(context.global, a, b, self);
+ } else if (typeof f === "function") {
+ return f.call(context.global, a, b, self);
+ }
+ } else {
+ return 0;
+ }
+ }
+
+ band(context, a, b, self) {
+ var f, obj;
+ if (Array.isArray(a)) {
+ obj = context.global.List;
+ } else if (typeof a === "string") {
+ if (isFinite(a)) {
+ a &= b;
+ if (isFinite(a)) {
+ return a;
+ } else {
+ return 0;
+ }
+ } else {
+ obj = context.global.String;
+ }
+ } else {
+ obj = a;
+ }
+ f = obj["&"];
+ while ((f == null) && (obj.class != null)) {
+ obj = obj.class;
+ f = obj["&"];
+ }
+ if (f == null) {
+ f = context.global.Object["&"];
+ }
+ if (f != null) {
+ if (f instanceof Routine) {
+ if (f.as_function == null) {
+ f.as_function = this.routineAsApplicableFunction(f, context);
+ }
+ f = f.as_function;
+ return f.call(context.global, a, b, self);
+ } else if (typeof f === "function") {
+ return f.call(context.global, a, b, self);
+ }
+ } else {
+ return 0;
+ }
+ }
+
+ bor(context, a, b, self) {
+ var f, obj;
+ if (Array.isArray(a)) {
+ obj = context.global.List;
+ } else if (typeof a === "string") {
+ if (isFinite(a)) {
+ a |= b;
+ if (isFinite(a)) {
+ return a;
+ } else {
+ return 0;
+ }
+ } else {
+ obj = context.global.String;
+ }
+ } else {
+ obj = a;
+ }
+ f = obj["|"];
+ while ((f == null) && (obj.class != null)) {
+ obj = obj.class;
+ f = obj["|"];
+ }
+ if (f == null) {
+ f = context.global.Object["|"];
+ }
+ if (f != null) {
+ if (f instanceof Routine) {
+ if (f.as_function == null) {
+ f.as_function = this.routineAsApplicableFunction(f, context);
+ }
+ f = f.as_function;
+ return f.call(context.global, a, b, self);
+ } else if (typeof f === "function") {
+ return f.call(context.global, a, b, self);
+ }
+ } else {
+ return 0;
+ }
+ }
+
+ run(context) {
+ var a, arg1, args, argv, b, c, call_stack, call_stack_index, call_super, call_supername, con, cs, err, f, fc, field, global, i, i1, i2, id, index, ir, iter, iterator, j, k, key, l, len, length, local_index, locals, locals_offset, loop_by, loop_to, m, n, name, o, obj, object, op_count, op_index, opcodes, p, parent, q, r, rc, ref, ref1, ref10, ref11, ref12, ref13, ref14, ref2, ref3, ref4, ref5, ref6, ref7, ref8, ref9, res, restore_op_index, routine, s, sleep_time, src, stack, stack_index, sup, t, token, u, v, value, w;
+ routine = this.routine;
+ opcodes = this.routine.opcodes;
+ arg1 = this.routine.arg1;
+ length = opcodes.length;
+ op_index = this.op_index;
+ stack = this.stack;
+ stack_index = this.stack_index;
+ locals = this.locals;
+ local_index = this.local_index;
+ global = this.global || context.global;
+ object = this.object || global;
+ call_stack = this.call_stack;
+ call_stack_index = this.call_stack_index;
+ call_super = this.call_super || global;
+ call_supername = this.call_supername || "";
+ locals_offset = this.locals_offset;
+ op_count = 0;
+ restore_op_index = -1;
+ while (op_index < length) {
+ switch (opcodes[op_index]) {
+ case 1: // OPCODE_TYPE
+ v = stack[stack_index];
+ switch (typeof v) {
+ case "number":
+ stack[stack_index] = "number";
+ break;
+ case "string":
+ stack[stack_index] = "string";
+ break;
+ case "function":
+ stack[stack_index] = "function";
+ break;
+ case "object":
+ if (Array.isArray(v)) {
+ stack[stack_index] = "list";
+ } else if (v instanceof Routine) {
+ stack[stack_index] = "function";
+ } else {
+ stack[stack_index] = "object";
+ }
+ }
+ op_index++;
+ break;
+ case 2: // OPCODE_TYPE_VARIABLE
+ v = object[arg1[op_index]];
+ if (v == null) {
+ v = global[arg1[op_index]];
+ }
+ if (v == null) {
+ stack[++stack_index] = 0;
+ } else {
+ switch (typeof v) {
+ case "number":
+ stack[++stack_index] = "number";
+ break;
+ case "string":
+ stack[++stack_index] = "string";
+ break;
+ case "function":
+ stack[++stack_index] = "function";
+ break;
+ default:
+ if (Array.isArray(v)) {
+ stack[++stack_index] = "list";
+ } else if (v instanceof Routine) {
+ stack[++stack_index] = "function";
+ } else {
+ stack[++stack_index] = "object";
+ }
+ }
+ }
+ op_index++;
+ break;
+ case 3: // OPCODE_TYPE_PROPERTY
+ v = stack[stack_index - 1][stack[stack_index]];
+ if (v == null) {
+ stack[--stack_index] = 0;
+ } else {
+ switch (typeof v) {
+ case "number":
+ stack[--stack_index] = "number";
+ break;
+ case "string":
+ stack[--stack_index] = "string";
+ break;
+ case "function":
+ stack[--stack_index] = "function";
+ break;
+ default:
+ if (Array.isArray(v)) {
+ stack[--stack_index] = "list";
+ } else if (v instanceof Routine) {
+ stack[--stack_index] = "function";
+ } else {
+ stack[--stack_index] = "object";
+ }
+ }
+ }
+ op_index++;
+ break;
+ case 4: // OPCODE_LOAD_IMPORT
+ stack[++stack_index] = routine.import_values[arg1[op_index++]];
+ break;
+ case 5: // OPCODE_LOAD_THIS
+ stack[++stack_index] = object;
+ op_index++;
+ break;
+ case 6: // OPCODE_LOAD_GLOBAL
+ stack[++stack_index] = global;
+ op_index++;
+ break;
+ case 10: // CODE_LOAD_VALUE
+ stack[++stack_index] = arg1[op_index++];
+ break;
+ case 11: // OPCODE_LOAD_LOCAL
+ stack[++stack_index] = locals[locals_offset + arg1[op_index++]];
+ break;
+ case 12: // OPCODE_LOAD_VARIABLE
+ name = arg1[op_index];
+ v = object[name];
+ if ((v == null) && (object.class != null)) {
+ obj = object;
+ while ((v == null) && (obj.class != null)) {
+ obj = obj.class;
+ v = obj[name];
+ }
+ }
+ if (v == null) {
+ v = global[name];
+ }
+ if ((v == null) && !routine.ref[op_index].nowarning) {
+ token = routine.ref[op_index].token;
+ id = token.tokenizer.filename + "-" + token.line + "-" + token.column;
+ if (!context.warnings.using_undefined_variable[id]) {
+ context.warnings.using_undefined_variable[id] = {
+ file: token.tokenizer.filename,
+ line: token.line,
+ column: token.column,
+ expression: name
+ };
+ }
+ }
+ stack[++stack_index] = v != null ? v : 0;
+ op_index++;
+ break;
+ case 13: // OPCODE_LOAD_LOCAL_OBJECT
+ o = locals[locals_offset + arg1[op_index]];
+ if (typeof o !== "object") {
+ o = locals[locals_offset + arg1[op_index]] = {};
+ token = routine.ref[op_index].token;
+ id = token.tokenizer.filename + "-" + token.line + "-" + token.column;
+ if (!context.warnings.assigning_field_to_undefined[id]) {
+ context.warnings.assigning_field_to_undefined[id] = {
+ file: token.tokenizer.filename,
+ line: token.line,
+ column: token.column,
+ expression: token.value
+ };
+ }
+ }
+ stack[++stack_index] = o;
+ op_index++;
+ break;
+ case 14: // OPCODE_LOAD_VARIABLE_OBJECT
+ name = arg1[op_index];
+ obj = object;
+ v = obj[name];
+ while ((v == null) && (obj.class != null)) {
+ obj = obj.class;
+ v = obj[name];
+ }
+ if ((v == null) && (global[name] != null)) {
+ obj = global;
+ v = global[name];
+ }
+ if ((v == null) || typeof v !== "object") {
+ v = obj[name] = {};
+ token = routine.ref[op_index].token;
+ id = token.tokenizer.filename + "-" + token.line + "-" + token.column;
+ if (!context.warnings.assigning_field_to_undefined[id]) {
+ context.warnings.assigning_field_to_undefined[id] = {
+ file: token.tokenizer.filename,
+ line: token.line,
+ column: token.column,
+ expression: arg1[op_index]
+ };
+ }
+ }
+ stack[++stack_index] = v;
+ op_index++;
+ break;
+ case 15: // OPCODE_POP
+ stack_index--;
+ op_index++;
+ break;
+ case 16: // OPCODE_LOAD_PROPERTY
+ obj = stack[stack_index - 1];
+ name = stack[stack_index];
+ v = obj[name];
+ while ((v == null) && (obj.class != null)) {
+ obj = obj.class;
+ v = obj[name];
+ }
+ if (v == null) {
+ v = 0;
+ if (!routine.ref[op_index].nowarning) {
+ routine.ref[op_index].nowarning = true;
+ if (!Array.isArray(obj)) {
+ token = routine.ref[op_index].token;
+ id = token.tokenizer.filename + "-" + token.line + "-" + token.column;
+ context.warnings.using_undefined_variable[id] = {
+ file: token.tokenizer.filename,
+ line: token.line,
+ column: token.column,
+ expression: name
+ };
+ }
+ }
+ }
+ stack[--stack_index] = v;
+ op_index++;
+ break;
+ case 17: // OPCODE_LOAD_PROPERTY_OBJECT
+ v = stack[stack_index - 1][stack[stack_index]];
+ if (typeof v !== "object") {
+ v = stack[stack_index - 1][stack[stack_index]] = {};
+ token = routine.ref[op_index].token;
+ id = token.tokenizer.filename + "-" + token.line + "-" + token.column;
+ if (!context.warnings.assigning_field_to_undefined[id]) {
+ context.warnings.assigning_field_to_undefined[id] = {
+ file: token.tokenizer.filename,
+ line: token.line,
+ column: token.column,
+ expression: stack[stack_index]
+ };
+ }
+ }
+ stack[--stack_index] = v;
+ op_index++;
+ break;
+ case 18: // OPCODE_CREATE_OBJECT
+ stack[++stack_index] = {};
+ op_index++;
+ break;
+ case 19: // OPCODE_MAKE_OBJECT
+ if (typeof stack[stack_index] !== "object") {
+ stack[stack_index] = {};
+ }
+ op_index++;
+ break;
+ case 20: // OPCODE_CREATE_ARRAY
+ stack[++stack_index] = [];
+ op_index++;
+ break;
+ case 21: // OPCODE_STORE_LOCAL
+ locals[locals_offset + arg1[op_index]] = stack[stack_index];
+ op_index++;
+ break;
+ case 22: // OPCODE_STORE_LOCAL_POP
+ locals[locals_offset + arg1[op_index]] = stack[stack_index--];
+ op_index++;
+ break;
+ case 23: // OPCODE_STORE_VARIABLE
+ object[arg1[op_index++]] = stack[stack_index];
+ break;
+ case 24: // OPCODE_CREATE_PROPERTY
+ obj = stack[stack_index - 2];
+ field = stack[stack_index - 1];
+ obj[field] = stack[stack_index];
+ stack_index -= 2;
+ op_index++;
+ break;
+ case 25: // OPCODE_STORE_PROPERTY
+ obj = stack[stack_index - 2];
+ field = stack[stack_index - 1];
+ stack[stack_index - 2] = obj[field] = stack[stack_index];
+ stack_index -= 2;
+ op_index++;
+ break;
+ case 26: // OPCODE_DELETE
+ obj = stack[stack_index - 1];
+ field = stack[stack_index];
+ delete obj[field];
+ stack[stack_index -= 1] = 0;
+ op_index++;
+ break;
+ case 27: // OPCODE_UPDATE_CLASS
+ name = arg1[op_index];
+ // TODO: set classname to variable name
+ if ((object[name] != null) && typeof object[name] === "object") {
+ obj = object[name];
+ src = stack[stack_index];
+ for (key in src) {
+ value = src[key];
+ obj[key] = value;
+ }
+ } else {
+ object[name] = stack[stack_index];
+ }
+ op_index++;
+ break;
+ case 28: // OPCODE_CREATE_CLASS
+ res = {};
+ parent = stack[stack_index];
+ if (parent) {
+ res.class = parent;
+ } else if (arg1[op_index]) {
+ res.class = arg1[op_index];
+ }
+ stack[stack_index] = res;
+ op_index++;
+ break;
+ case 29: // OPCODE_NEW_CALL
+ c = stack[stack_index];
+ args = arg1[op_index];
+ if (typeof c === "function") {
+ a = [];
+ for (i = j = 0, ref = args - 1; j <= ref; i = j += 1) {
+ a.push(stack[stack_index - args + i]);
+ }
+ stack_index -= args;
+ // NEW CALL is followed by a POP (to get rid of constructor return value)
+ stack[stack_index - 1] = new c(...a);
+ op_index++;
+ } else {
+ this.resolveParentClass(c, global);
+ res = {
+ class: c
+ };
+ con = c.constructor;
+ while (!con && (c.class != null)) {
+ c = c.class;
+ con = c.constructor;
+ }
+ if ((con != null) && con instanceof Routine) {
+ stack[stack_index - args - 1] = res;
+ stack_index--;
+ cs = call_stack[call_stack_index] || (call_stack[call_stack_index] = {});
+ call_stack_index++;
+ cs.routine = routine;
+ cs.object = object;
+ cs.super = call_super;
+ cs.supername = call_supername;
+ cs.op_index = op_index + 1;
+ locals_offset += routine.locals_size;
+ routine = con;
+ opcodes = con.opcodes;
+ arg1 = con.arg1;
+ op_index = 0;
+ length = opcodes.length;
+ object = res;
+ call_super = c;
+ call_supername = "constructor";
+ if (routine.uses_arguments) {
+ argv = stack.slice(stack_index - args + 1, stack_index + 1);
+ }
+ if (args < con.num_args) {
+ for (i = k = ref1 = args + 1, ref2 = con.num_args; k <= ref2; i = k += 1) {
+ stack[++stack_index] = 0;
+ }
+ } else if (args > con.num_args) {
+ stack_index -= args - con.num_args;
+ }
+ stack[++stack_index] = args;
+ if (routine.uses_arguments) {
+ stack[++stack_index] = argv;
+ }
+ } else {
+ stack_index -= args;
+ stack[stack_index - 1] = res;
+ op_index++;
+ }
+ }
+ break;
+ case 30: // OPCODE_ADD
+ b = stack[stack_index--];
+ a = stack[stack_index];
+ if (typeof a === "number") {
+ a += b;
+ stack[stack_index] = isFinite(a) || typeof b === "string" ? a : 0;
+ } else {
+ stack[stack_index] = this.add(context, a, b, arg1[op_index]);
+ }
+ op_index++;
+ break;
+ case 31: // OPCODE_SUB
+ b = stack[stack_index--];
+ a = stack[stack_index];
+ if (typeof a === "number") {
+ a -= b;
+ stack[stack_index] = isFinite(a) ? a : 0;
+ } else {
+ stack[stack_index] = this.sub(context, a, b, arg1[op_index]);
+ }
+ op_index++;
+ break;
+ case 32: // OPCODE_MUL
+ b = stack[stack_index--];
+ a = stack[stack_index];
+ if (typeof a === "number") {
+ a *= b;
+ stack[stack_index] = isFinite(a) ? a : 0;
+ } else {
+ stack[stack_index] = this.mul(context, a, b);
+ }
+ op_index++;
+ break;
+ case 33: // OPCODE_DIV
+ b = stack[stack_index--];
+ a = stack[stack_index];
+ if (typeof a === "number") {
+ a /= b;
+ stack[stack_index] = isFinite(a) ? a : 0;
+ } else {
+ stack[stack_index] = this.div(context, a, b);
+ }
+ op_index++;
+ break;
+ case 34: // OPCODE_MODULO
+ b = stack[stack_index--];
+ a = stack[stack_index];
+ if (typeof a === "number" && typeof b === "number") {
+ a %= b;
+ stack[stack_index] = isFinite(a) ? a : 0;
+ } else {
+ stack[stack_index] = this.modulo(context, a, b);
+ }
+ op_index++;
+ break;
+ case 35: // OPCODE_BINARY_AND
+ b = stack[stack_index--];
+ a = stack[stack_index];
+ if (typeof a === "number") {
+ a &= b;
+ stack[stack_index] = isFinite(a) ? a : 0;
+ } else {
+ stack[stack_index] = this.band(context, a, b);
+ }
+ op_index++;
+ break;
+ case 36: // OPCODE_BINARY_OR
+ b = stack[stack_index--];
+ a = stack[stack_index];
+ if (typeof a === "number") {
+ a |= b;
+ stack[stack_index] = isFinite(a) ? a : 0;
+ } else {
+ stack[stack_index] = this.bor(context, a, b);
+ }
+ op_index++;
+ break;
+ case 37: // OPCODE_SHIFT_LEFT
+ v = stack[stack_index - 1] << stack[stack_index];
+ stack[--stack_index] = isFinite(v) ? v : 0;
+ op_index++;
+ break;
+ case 38: // OPCODE_SHIFT_RIGHT
+ v = stack[stack_index - 1] >> stack[stack_index];
+ stack[--stack_index] = isFinite(v) ? v : 0;
+ op_index++;
+ break;
+ case 39: // OPCODE_NEGATE
+ a = stack[stack_index];
+ if (typeof a === "number") {
+ stack[stack_index] = -a;
+ } else {
+ stack[stack_index] = this.negate(context, a);
+ }
+ op_index++;
+ break;
+ case 50: // OPCODE_NOT
+ stack[stack_index] = stack[stack_index] ? 0 : 1;
+ op_index++;
+ break;
+ case 68: // OPCODE_LOAD_PROPERTY_ATOP
+ obj = stack[stack_index - 1];
+ name = stack[stack_index];
+ v = obj[name];
+ while ((v == null) && (obj.class != null)) {
+ obj = obj.class;
+ v = obj[name];
+ }
+ if (v == null) {
+ v = 0;
+ if (!routine.ref[op_index].nowarning) {
+ routine.ref[op_index].nowarning = true;
+ if (!Array.isArray(obj)) {
+ token = routine.ref[op_index].token;
+ id = token.tokenizer.filename + "-" + token.line + "-" + token.column;
+ context.warnings.using_undefined_variable[id] = {
+ file: token.tokenizer.filename,
+ line: token.line,
+ column: token.column,
+ expression: name
+ };
+ }
+ }
+ }
+ stack[++stack_index] = v;
+ op_index++;
+ break;
+ case 40: // OPCODE_EQ
+ stack[stack_index - 1] = stack[stack_index] === stack[stack_index - 1] ? 1 : 0;
+ stack_index--;
+ op_index++;
+ break;
+ case 41: // OPCODE_NEQ
+ stack[stack_index - 1] = stack[stack_index] !== stack[stack_index - 1] ? 1 : 0;
+ stack_index--;
+ op_index++;
+ break;
+ case 42: // OPCODE_LT
+ stack[stack_index - 1] = stack[stack_index - 1] < stack[stack_index] ? 1 : 0;
+ stack_index--;
+ op_index++;
+ break;
+ case 43: // OPCODE_GT
+ stack[stack_index - 1] = stack[stack_index - 1] > stack[stack_index] ? 1 : 0;
+ stack_index--;
+ op_index++;
+ break;
+ case 44: // OPCODE_LTE
+ stack[stack_index - 1] = stack[stack_index - 1] <= stack[stack_index] ? 1 : 0;
+ stack_index--;
+ op_index++;
+ break;
+ case 45: // OPCODE_GTE
+ stack[stack_index - 1] = stack[stack_index - 1] >= stack[stack_index] ? 1 : 0;
+ stack_index--;
+ op_index++;
+ break;
+ case 95: // FORLOOP_INIT
+ // fix loop_by if not set
+ iter = arg1[op_index][0];
+ loop_to = locals[locals_offset + iter + 1] = stack[stack_index - 1];
+ loop_by = stack[stack_index];
+ iterator = locals[locals_offset + iter];
+ stack[--stack_index] = 0; // unload 2 values and load default value
+ if (loop_by === 0) {
+ locals[locals_offset + iter + 2] = loop_to > iterator ? 1 : -1;
+ op_index++;
+ } else {
+ locals[locals_offset + iter + 2] = loop_by;
+ if ((loop_by > 0 && iterator > loop_to) || (loop_by < 0 && iterator < loop_to)) {
+ op_index = arg1[op_index][1];
+ } else {
+ op_index++;
+ }
+ }
+ break;
+ case 96: // FORLOOP_CONTROL
+ iter = arg1[op_index][0];
+ loop_by = locals[locals_offset + iter + 2];
+ loop_to = locals[locals_offset + iter + 1];
+ iterator = locals[locals_offset + iter];
+ iterator += loop_by;
+ if ((loop_by > 0 && iterator > loop_to) || (loop_by < 0 && iterator < loop_to)) {
+ op_index++;
+ } else {
+ locals[locals_offset + iter] = iterator;
+ op_index = arg1[op_index][1];
+ }
+ if (op_count++ > 100) {
+ op_count = 0;
+ if (Date.now() > this.time_limit) {
+ restore_op_index = op_index;
+ op_index = length; // stop the loop without adding a condition statement
+ }
+ }
+ break;
+ case 97: // FORIN_INIT
+ v = stack[stack_index];
+ stack[stack_index] = 0; // default result
+ iterator = arg1[op_index][0];
+ if (typeof v === "object") {
+ if (Array.isArray(v)) {
+ locals[locals_offset + iterator + 1] = v;
+ } else {
+ v = locals[locals_offset + iterator + 1] = Object.keys(v);
+ }
+ } else if (typeof v === "string") {
+ v = locals[locals_offset + iterator + 1] = v.split("");
+ } else {
+ v = locals[locals_offset + iterator + 1] = [];
+ }
+ if (v.length === 0) {
+ op_index = arg1[op_index][1];
+ } else {
+ value = v[0];
+ // value could be undefined if the array is sparse
+ locals[locals_offset + arg1[op_index][0]] = value != null ? value : 0;
+ locals[locals_offset + iterator + 2] = 0;
+ op_index++;
+ }
+ break;
+ case 98: // FORIN_CONTROL
+ iterator = arg1[op_index][0];
+ index = locals[locals_offset + iterator + 2] += 1;
+ v = locals[locals_offset + iterator + 1];
+ if (index < v.length) {
+ value = v[index];
+ // value could be undefined if the array is sparse
+ locals[locals_offset + iterator] = value != null ? value : 0;
+ op_index = arg1[op_index][1];
+ } else {
+ op_index++;
+ }
+ if (op_count++ > 100) {
+ op_count = 0;
+ if (Date.now() > this.time_limit) {
+ restore_op_index = op_index;
+ op_index = length; // stop the loop without adding a condition statement
+ }
+ }
+ break;
+ case 80: // OPCODE_JUMP
+ op_index = arg1[op_index];
+ if (op_count++ > 100) {
+ op_count = 0;
+ if (Date.now() > this.time_limit) {
+ restore_op_index = op_index;
+ op_index = length; // stop the loop without adding a condition statement
+ }
+ }
+ break;
+ case 81: // OPCODE_JUMPY
+ if (stack[stack_index--]) {
+ op_index = arg1[op_index];
+ } else {
+ op_index++;
+ }
+ break;
+ case 82: // OPCODE_JUMPN
+ if (!stack[stack_index--]) {
+ op_index = arg1[op_index];
+ } else {
+ op_index++;
+ }
+ break;
+ case 83: // OPCODE_JUMPY_NOPOP
+ if (stack[stack_index]) {
+ op_index = arg1[op_index];
+ } else {
+ op_index++;
+ }
+ break;
+ case 84: // OPCODE_JUMPN_NOPOP
+ if (!stack[stack_index]) {
+ op_index = arg1[op_index];
+ } else {
+ op_index++;
+ }
+ break;
+ case 89: // OPCODE_LOAD_ROUTINE
+ r = arg1[op_index++];
+ rc = r.clone();
+ ref3 = r.import_refs;
+ for (l = 0, len = ref3.length; l < len; l++) {
+ ir = ref3[l];
+ if (ir === r.import_self) {
+ rc.import_values.push(rc);
+ } else {
+ rc.import_values.push(locals[locals_offset + ir]);
+ }
+ }
+ rc.object = object;
+ stack[++stack_index] = rc;
+ break;
+ case 90: // OPCODE_FUNCTION_CALL
+ args = arg1[op_index];
+ f = stack[stack_index];
+ if (f instanceof Routine) {
+ stack_index--;
+ cs = call_stack[call_stack_index] || (call_stack[call_stack_index] = {});
+ call_stack_index++;
+ cs.routine = routine;
+ cs.object = object;
+ cs.super = call_super;
+ cs.supername = call_supername;
+ cs.op_index = op_index + 1;
+ locals_offset += routine.locals_size;
+ routine = f;
+ opcodes = f.opcodes;
+ arg1 = f.arg1;
+ op_index = 0;
+ length = opcodes.length;
+ object = routine.object != null ? routine.object : global;
+ call_super = global;
+ call_supername = "";
+ if (routine.uses_arguments) {
+ argv = stack.slice(stack_index - args + 1, stack_index + 1);
+ }
+ if (args < f.num_args) {
+ for (i = m = ref4 = args + 1, ref5 = f.num_args; m <= ref5; i = m += 1) {
+ stack[++stack_index] = 0;
+ }
+ } else if (args > f.num_args) {
+ stack_index -= args - f.num_args;
+ }
+ stack[++stack_index] = args;
+ if (routine.uses_arguments) {
+ stack[++stack_index] = argv;
+ }
+ } else if (typeof f === "function") {
+ switch (args) {
+ case 0:
+ try {
+ v = f();
+ } catch (error) {
+ err = error;
+ console.error(err);
+ v = 0;
+ }
+ stack[stack_index] = v != null ? v : 0;
+ break;
+ case 1:
+ try {
+ v = f(this.argToNative(stack[stack_index - 1], context));
+ } catch (error) {
+ err = error;
+ console.error(err);
+ v = 0;
+ }
+ stack[stack_index - 1] = v != null ? v : 0;
+ stack_index -= 1;
+ break;
+ default:
+ argv = [];
+ stack_index -= args;
+ for (i = n = 0, ref6 = args - 1; n <= ref6; i = n += 1) {
+ argv[i] = this.argToNative(stack[stack_index + i], context);
+ }
+ try {
+ v = f.apply(null, argv);
+ } catch (error) {
+ err = error;
+ console.error(err);
+ v = 0;
+ }
+ stack[stack_index] = v != null ? v : 0;
+ }
+ op_index++;
+ } else {
+ stack_index -= args;
+ stack[stack_index] = f != null ? f : 0;
+ token = routine.ref[op_index].token;
+ id = token.tokenizer.filename + "-" + token.line + "-" + token.column;
+ if (!context.warnings.invoking_non_function[id]) {
+ fc = routine.ref[op_index];
+ i1 = fc.expression.token.start;
+ i2 = fc.token.start + fc.token.length;
+ context.warnings.invoking_non_function[id] = {
+ file: token.tokenizer.filename,
+ line: token.line,
+ column: token.column,
+ expression: fc.token.tokenizer.input.substring(i1, i2)
+ };
+ }
+ op_index++;
+ }
+ break;
+ case 91: // OPCODE_FUNCTION_APPLY_VARIABLE
+ name = stack[stack_index];
+ sup = obj = object;
+ f = obj[name];
+ if (f == null) {
+ while ((f == null) && (sup.class != null)) {
+ sup = sup.class;
+ f = sup[name];
+ }
+ if (f == null) {
+ f = global.Object[name];
+ }
+ if (f == null) {
+ f = global[name];
+ sup = global;
+ obj = global;
+ }
+ }
+ args = arg1[op_index];
+ if (f instanceof Routine) {
+ stack_index -= 1;
+ cs = call_stack[call_stack_index] || (call_stack[call_stack_index] = {});
+ call_stack_index++;
+ cs.routine = routine;
+ cs.object = object;
+ cs.super = call_super;
+ cs.supername = call_supername;
+ cs.op_index = op_index + 1;
+ locals_offset += routine.locals_size;
+ routine = f;
+ opcodes = f.opcodes;
+ arg1 = f.arg1;
+ op_index = 0;
+ length = opcodes.length;
+ object = obj;
+ call_super = sup;
+ call_supername = name;
+ if (routine.uses_arguments) {
+ argv = stack.slice(stack_index - args + 1, stack_index + 1);
+ }
+ if (args < f.num_args) {
+ for (i = p = ref7 = args + 1, ref8 = f.num_args; p <= ref8; i = p += 1) {
+ stack[++stack_index] = 0;
+ }
+ } else if (args > f.num_args) {
+ stack_index -= args - f.num_args;
+ }
+ stack[++stack_index] = args;
+ if (routine.uses_arguments) {
+ stack[++stack_index] = argv;
+ }
+ } else if (typeof f === "function") {
+ switch (args) {
+ case 0:
+ try {
+ v = f.call(obj);
+ } catch (error) {
+ err = error;
+ console.error(err);
+ v = 0;
+ }
+ stack[stack_index] = v != null ? v : 0;
+ break;
+ case 1:
+ try {
+ v = f.call(obj, this.argToNative(stack[stack_index - 1], context));
+ } catch (error) {
+ err = error;
+ console.error(err);
+ v = 0;
+ }
+ stack[--stack_index] = v != null ? v : 0;
+ break;
+ default:
+ argv = [];
+ stack_index -= args;
+ for (i = q = 0, ref9 = args - 1; q <= ref9; i = q += 1) {
+ argv[i] = this.argToNative(stack[stack_index + i], context);
+ }
+ try {
+ v = f.apply(obj, argv);
+ } catch (error) {
+ err = error;
+ console.error(err);
+ v = 0;
+ }
+ stack[stack_index] = v != null ? v : 0;
+ }
+ op_index++;
+ } else {
+ stack_index -= args;
+ stack[stack_index] = f != null ? f : 0;
+ token = routine.ref[op_index].token;
+ id = token.tokenizer.filename + "-" + token.line + "-" + token.column;
+ if (!context.warnings.invoking_non_function[id]) {
+ fc = routine.ref[op_index];
+ i1 = fc.expression.token.start;
+ i2 = fc.token.start + fc.token.length;
+ context.warnings.invoking_non_function[id] = {
+ file: token.tokenizer.filename,
+ line: token.line,
+ column: token.column,
+ expression: fc.token.tokenizer.input.substring(i1, i2)
+ };
+ }
+ op_index++;
+ }
+ break;
+ case 92: // OPCODE_FUNCTION_APPLY_PROPERTY
+ obj = stack[stack_index - 1];
+ sup = obj;
+ name = stack[stack_index];
+ f = obj[name];
+ while ((f == null) && (sup.class != null)) {
+ sup = sup.class;
+ f = sup[name];
+ }
+ args = arg1[op_index];
+ if (f == null) {
+ if (obj instanceof Routine) {
+ f = global.Function[name];
+ } else if (typeof obj === "string") {
+ f = global.String[name];
+ } else if (typeof obj === "number") {
+ f = global.Number[name];
+ } else if (Array.isArray(obj)) {
+ f = global.List[name];
+ } else if (typeof obj === "object") {
+ f = global.Object[name];
+ }
+ }
+ if (f instanceof Routine) {
+ stack_index -= 2;
+ cs = call_stack[call_stack_index] || (call_stack[call_stack_index] = {});
+ call_stack_index++;
+ cs.object = object;
+ cs.super = call_super;
+ cs.supername = call_supername;
+ cs.routine = routine;
+ cs.op_index = op_index + 1;
+ locals_offset += routine.locals_size;
+ routine = f;
+ opcodes = f.opcodes;
+ arg1 = f.arg1;
+ op_index = 0;
+ length = opcodes.length;
+ object = obj;
+ call_super = sup;
+ call_supername = name;
+ if (routine.uses_arguments) {
+ argv = stack.slice(stack_index - args + 1, stack_index + 1);
+ }
+ if (args < f.num_args) {
+ for (i = s = ref10 = args + 1, ref11 = f.num_args; s <= ref11; i = s += 1) {
+ stack[++stack_index] = 0;
+ }
+ } else if (args > f.num_args) {
+ stack_index -= args - f.num_args;
+ }
+ stack[++stack_index] = args;
+ if (routine.uses_arguments) {
+ stack[++stack_index] = argv;
+ }
+ } else if (typeof f === "function") {
+ switch (args) {
+ case 0:
+ try {
+ v = f.call(obj);
+ } catch (error) {
+ err = error;
+ console.error(err);
+ v = 0;
+ }
+ stack[--stack_index] = v != null ? v : 0;
+ break;
+ case 1:
+ try {
+ v = f.call(obj, this.argToNative(stack[stack_index - 2], context));
+ } catch (error) {
+ err = error;
+ console.error(err);
+ v = 0;
+ }
+ stack[stack_index - 2] = v != null ? v : 0;
+ stack_index -= 2;
+ break;
+ default:
+ argv = [];
+ stack_index -= args + 1;
+ for (i = u = 0, ref12 = args - 1; u <= ref12; i = u += 1) {
+ argv[i] = this.argToNative(stack[stack_index + i], context);
+ }
+ try {
+ v = f.apply(obj, argv);
+ } catch (error) {
+ err = error;
+ console.error(err);
+ v = 0;
+ }
+ stack[stack_index] = v != null ? v : 0;
+ }
+ op_index++;
+ } else {
+ stack_index -= args + 1;
+ stack[stack_index] = f != null ? f : 0;
+ token = routine.ref[op_index].token;
+ id = token.tokenizer.filename + "-" + token.line + "-" + token.column;
+ if (!context.warnings.invoking_non_function[id]) {
+ fc = routine.ref[op_index];
+ i1 = fc.expression.token.start;
+ i2 = fc.token.start + fc.token.length;
+ context.warnings.invoking_non_function[id] = {
+ file: token.tokenizer.filename,
+ line: token.line,
+ column: token.column,
+ expression: fc.token.tokenizer.input.substring(i1, i2)
+ };
+ }
+ op_index++;
+ }
+ break;
+ case 93: // OPCODE_SUPER_CALL
+ if ((call_super != null) && (call_supername != null)) {
+ sup = call_super;
+ f = null;
+ while ((f == null) && (sup.class != null)) {
+ sup = sup.class;
+ f = sup[call_supername];
+ }
+ if ((f != null) && f instanceof Routine) {
+ args = arg1[op_index];
+ cs = call_stack[call_stack_index] || (call_stack[call_stack_index] = {});
+ call_stack_index++;
+ cs.object = object;
+ cs.super = call_super;
+ cs.supername = call_supername;
+ cs.routine = routine;
+ cs.op_index = op_index + 1;
+ locals_offset += routine.locals_size;
+ routine = f;
+ opcodes = f.opcodes;
+ arg1 = f.arg1;
+ op_index = 0;
+ length = opcodes.length;
+ call_super = sup;
+ if (routine.uses_arguments) {
+ argv = stack.slice(stack_index - args + 1, stack_index + 1);
+ }
+ if (args < f.num_args) {
+ for (i = w = ref13 = args + 1, ref14 = f.num_args; w <= ref14; i = w += 1) {
+ stack[++stack_index] = 0;
+ }
+ } else if (args > f.num_args) {
+ stack_index -= args - f.num_args;
+ }
+ stack[++stack_index] = args;
+ if (routine.uses_arguments) {
+ stack[++stack_index] = argv;
+ }
+ } else {
+ args = arg1[op_index];
+ stack_index -= args;
+ stack[++stack_index] = 0;
+ op_index++;
+ }
+ } else {
+ args = arg1[op_index];
+ stack_index -= args;
+ stack[++stack_index] = 0;
+ op_index++;
+ }
+ break;
+ case 94: // OPCODE_RETURN
+ local_index -= arg1[op_index];
+ if (call_stack_index <= 0) {
+ op_index = length;
+ } else {
+ cs = call_stack[--call_stack_index];
+ object = cs.object;
+ call_super = cs.super;
+ call_supername = cs.supername;
+ routine = cs.routine;
+ op_index = cs.op_index;
+ opcodes = routine.opcodes;
+ arg1 = routine.arg1;
+ locals_offset -= routine.locals_size;
+ length = opcodes.length;
+ }
+ break;
+ case 100: // OPCODE_UNARY_FUNC
+ v = arg1[op_index](stack[stack_index]);
+ stack[stack_index] = isFinite(v) ? v : 0;
+ op_index++;
+ break;
+ case 101: // OPCODE_BINARY_FUNC
+ v = arg1[op_index](stack[stack_index - 1], stack[stack_index]);
+ stack[--stack_index] = isFinite(v) ? v : 0;
+ op_index++;
+ break;
+ case 110: // OPCODE_AFTER
+ t = this.runner.createThread(stack[stack_index - 1], stack[stack_index], false);
+ stack[--stack_index] = t;
+ op_index += 1;
+ break;
+ // add thread to the runner thread list
+ case 111: // OPCODE_EVERY
+ t = this.runner.createThread(stack[stack_index - 1], stack[stack_index], true);
+ stack[--stack_index] = t;
+ op_index += 1;
+ break;
+ // add thread to the runner thread list
+ case 112: // OPCODE_DO
+ t = this.runner.createThread(stack[stack_index], 0, false);
+ stack[stack_index] = t;
+ op_index += 1;
+ break;
+ // add thread to the runner thread list
+ case 113: // OPCODE_SLEEP
+ sleep_time = isFinite(stack[stack_index]) ? stack[stack_index] : 0;
+ this.runner.sleep(sleep_time);
+ op_index += 1;
+ restore_op_index = op_index;
+ op_index = length; // stop the thread
+ break;
+ case 200: // COMPILED
+ stack_index = arg1[op_index](stack, stack_index, locals, locals_offset, object, global);
+ op_index++;
+ break;
+ default:
+ throw `Unsupported operation: ${opcodes[op_index]}`;
+ }
+ }
+ if (restore_op_index >= 0) {
+ this.op_index = restore_op_index;
+ this.routine = routine;
+ this.stack_index = stack_index;
+ this.local_index = local_index;
+ this.object = object;
+ this.call_stack_index = call_stack_index;
+ this.call_super = call_super;
+ this.call_supername = call_supername;
+ this.locals_offset = locals_offset;
+ this.done = false;
+ } else {
+ this.op_index = 0;
+ this.done = true;
+ if (this.routine.callback != null) {
+ this.routine.callback(stack[stack_index]);
+ this.routine.callback = null;
+ }
+ }
+ // console.info """stack_index: #{stack_index}"""
+ // console.info stack
+ if (this.log) {
+ console.info("total operations: " + op_count);
+ console.info(`stack_index: ${stack_index}`);
+ console.info(`result: ${stack[stack_index]}`);
+ }
+ return stack[stack_index];
+ }
+
+};
diff --git a/WebGames-master/WebGames-master/games/cap/program.js b/WebGames-master/WebGames-master/games/cap/program.js
new file mode 100644
index 00000000..784c1d66
--- /dev/null
+++ b/WebGames-master/WebGames-master/games/cap/program.js
@@ -0,0 +1,371 @@
+this.Program = class Program {
+ constructor() {
+ this.statements = [];
+ }
+
+ add(statement) {
+ return this.statements.push(statement);
+ }
+
+ isAssignment() {
+ return this.statements.length > 0 && this.statements[this.statements.length - 1] instanceof Program.Assignment;
+ }
+
+};
+
+this.Program.Expression = class Expression {
+ constructor() {}
+
+};
+
+this.Program.Assignment = class Assignment {
+ constructor(token1, field1, expression1, local) {
+ this.token = token1;
+ this.field = field1;
+ this.expression = expression1;
+ this.local = local;
+ }
+
+};
+
+this.Program.SelfAssignment = class SelfAssignment {
+ constructor(token1, field1, operation, expression1) {
+ this.token = token1;
+ this.field = field1;
+ this.operation = operation;
+ this.expression = expression1;
+ }
+
+};
+
+this.Program.Value = (function() {
+ class Value {
+ constructor(token1, type, value1) {
+ this.token = token1;
+ this.type = type;
+ this.value = value1;
+ }
+
+ };
+
+ Value.TYPE_NUMBER = 1;
+
+ Value.TYPE_STRING = 2;
+
+ Value.TYPE_ARRAY = 3;
+
+ Value.TYPE_OBJECT = 4;
+
+ Value.TYPE_FUNCTION = 5;
+
+ Value.TYPE_CLASS = 6;
+
+ return Value;
+
+}).call(this);
+
+this.Program.CreateFieldAccess = function(token, expression, field) {
+ if (expression instanceof Program.Field) {
+ expression.appendField(field);
+ return expression;
+ } else {
+ return new Program.Field(token, expression, [field]);
+ }
+};
+
+this.Program.Variable = class Variable {
+ constructor(token1, identifier) {
+ this.token = token1;
+ this.identifier = identifier;
+ }
+
+};
+
+this.Program.Field = class Field {
+ constructor(token1, expression1, chain) {
+ this.token = token1;
+ this.expression = expression1;
+ this.chain = chain;
+ this.token = this.expression.token;
+ }
+
+ appendField(field) {
+ return this.chain.push(field);
+ }
+
+};
+
+this.Program.BuildOperations = function(ops, terms) {
+ var i, o, o1, o2, prec, t1, t2;
+ while (ops.length > 1) {
+ i = 0;
+ prec = 0;
+ while (i < ops.length - 1) {
+ o1 = ops[i];
+ o2 = ops[i + 1];
+ if (Program.Precedence[o2.operation] <= Program.Precedence[o1.operation]) {
+ break;
+ }
+ i++;
+ }
+ t1 = terms[i];
+ t2 = terms[i + 1];
+ o = new Program.Operation(ops[i].token, ops[i].operation, t1, t2);
+ terms.splice(i, 2, o);
+ ops.splice(i, 1);
+ }
+ return new Program.Operation(ops[0].token, ops[0].operation, terms[0], terms[1]);
+};
+
+this.Program.Operation = class Operation {
+ constructor(token1, operation, term1, term2) {
+ this.token = token1;
+ this.operation = operation;
+ this.term1 = term1;
+ this.term2 = term2;
+ }
+
+};
+
+this.Program.Negate = class Negate {
+ constructor(token1, expression1) {
+ this.token = token1;
+ this.expression = expression1;
+ }
+
+};
+
+this.Program.Not = class Not {
+ constructor(token1, expression1) {
+ this.token = token1;
+ this.expression = expression1;
+ }
+
+};
+
+this.Program.Braced = class Braced {
+ constructor(token1, expression1) {
+ this.token = token1;
+ this.expression = expression1;
+ }
+
+};
+
+this.Program.Return = class Return {
+ constructor(token1, expression1) {
+ this.token = token1;
+ this.expression = expression1;
+ }
+
+};
+
+this.Program.Condition = class Condition {
+ constructor(token1, chain) {
+ this.token = token1;
+ this.chain = chain;
+ }
+
+};
+
+this.Program.For = class For {
+ constructor(token1, iterator, range_from, range_to, range_by, sequence) {
+ this.token = token1;
+ this.iterator = iterator;
+ this.range_from = range_from;
+ this.range_to = range_to;
+ this.range_by = range_by;
+ this.sequence = sequence;
+ }
+
+};
+
+this.Program.ForIn = class ForIn {
+ constructor(token1, iterator, list, sequence) {
+ this.token = token1;
+ this.iterator = iterator;
+ this.list = list;
+ this.sequence = sequence;
+ }
+
+};
+
+this.Program.toString = function(value, nesting = 0) {
+ var i, j, k, key, len, pref, ref, s, v;
+ if (value instanceof Routine) {
+ if (nesting === 0) {
+ return value.source || "[function]";
+ } else {
+ return "[function]";
+ }
+ } else if (typeof value === "function") {
+ return "[native function]";
+ } else if (typeof value === "string") {
+ return `"${value}"`;
+ } else if (Array.isArray(value)) {
+ if (nesting >= 1) {
+ return "[list]";
+ }
+ s = "[";
+ for (i = j = 0, len = value.length; j < len; i = ++j) {
+ v = value[i];
+ s += Program.toString(v, nesting + 1) + (i < value.length - 1 ? "," : "");
+ }
+ return s + "]";
+ } else if (typeof value === "object") {
+ if (nesting >= 1) {
+ return "[object]";
+ }
+ s = "object\n";
+ pref = "";
+ for (i = k = 1, ref = nesting; k <= ref; i = k += 1) {
+ pref += " ";
+ }
+ for (key in value) {
+ v = value[key];
+ s += pref + ` ${key} = ${Program.toString(v, nesting + 1)}\n`;
+ }
+ return s + pref + "end";
+ }
+ return value || 0;
+};
+
+this.Program.While = class While {
+ constructor(token1, condition, sequence) {
+ this.token = token1;
+ this.condition = condition;
+ this.sequence = sequence;
+ }
+
+};
+
+this.Program.Break = class Break {
+ constructor(token1) {
+ this.token = token1;
+ this.nopop = true;
+ }
+
+};
+
+this.Program.Continue = class Continue {
+ constructor(token1) {
+ this.token = token1;
+ this.nopop = true;
+ }
+
+};
+
+this.Program.Function = class Function {
+ constructor(token1, args, sequence, end) {
+ this.token = token1;
+ this.args = args;
+ this.sequence = sequence;
+ this.source = "function" + this.token.tokenizer.input.substring(this.token.index, end.index + 2);
+ }
+
+};
+
+this.Program.FunctionCall = class FunctionCall {
+ constructor(token1, expression1, args) {
+ this.token = token1;
+ this.expression = expression1;
+ this.args = args;
+ }
+
+};
+
+this.Program.CreateObject = class CreateObject {
+ constructor(token1, fields) {
+ this.token = token1;
+ this.fields = fields;
+ }
+
+};
+
+this.Program.CreateClass = class CreateClass {
+ constructor(token1, ext, fields) {
+ this.token = token1;
+ this.ext = ext;
+ this.fields = fields;
+ }
+
+};
+
+this.Program.NewCall = class NewCall {
+ constructor(token1, expression1) {
+ this.token = token1;
+ this.expression = expression1;
+ if (!(this.expression instanceof Program.FunctionCall)) {
+ this.expression = new Program.FunctionCall(this.token, this.expression, []);
+ }
+ }
+
+};
+
+this.Program.After = class After {
+ constructor(token1, delay, sequence, end, multiplier) {
+ this.token = token1;
+ this.delay = delay;
+ this.sequence = sequence;
+ this.multiplier = multiplier;
+ this.source = "after " + this.token.tokenizer.input.substring(this.token.index, end.index + 2);
+ }
+
+};
+
+this.Program.Every = class Every {
+ constructor(token1, delay, sequence, end, multiplier) {
+ this.token = token1;
+ this.delay = delay;
+ this.sequence = sequence;
+ this.multiplier = multiplier;
+ this.source = "every " + this.token.tokenizer.input.substring(this.token.index, end.index + 2);
+ }
+
+};
+
+this.Program.Do = class Do {
+ constructor(token1, sequence, end) {
+ this.token = token1;
+ this.sequence = sequence;
+ this.source = "do " + this.token.tokenizer.input.substring(this.token.index, end.index + 2);
+ }
+
+};
+
+this.Program.Sleep = class Sleep {
+ constructor(token1, delay, multiplier) {
+ this.token = token1;
+ this.delay = delay;
+ this.multiplier = multiplier;
+ }
+
+};
+
+this.Program.Delete = class Delete {
+ constructor(token1, field1) {
+ this.token = token1;
+ this.field = field1;
+ }
+
+};
+
+this.Program.Precedence = {
+ "^": 21,
+ "/": 20,
+ "*": 19,
+ "%": 18,
+ "+": 17,
+ "-": 17,
+ "<": 16,
+ "<=": 15,
+ ">": 14,
+ ">=": 13,
+ "==": 12,
+ "!=": 11,
+ "<<": 10,
+ ">>": 9,
+ "&": 8,
+ "|": 7,
+ "and": 6,
+ "or": 5
+};
diff --git a/WebGames-master/WebGames-master/games/cap/routine.js b/WebGames-master/WebGames-master/games/cap/routine.js
new file mode 100644
index 00000000..9d0b5540
--- /dev/null
+++ b/WebGames-master/WebGames-master/games/cap/routine.js
@@ -0,0 +1,530 @@
+this.Routine = class Routine {
+ constructor(num_args) {
+ this.num_args = num_args;
+ this.ops = [];
+ this.opcodes = [];
+ this.arg1 = [];
+ this.ref = [];
+ this.label_count = 0;
+ this.labels = {};
+ this.transpile = false;
+ this.import_refs = [];
+ this.import_values = [];
+ this.import_self = -1;
+ }
+
+ clone() {
+ var r;
+ r = new Routine(this.num_args);
+ r.opcodes = this.opcodes;
+ r.arg1 = this.arg1;
+ r.ref = this.ref;
+ r.locals_size = this.locals_size;
+ r.uses_arguments = this.uses_arguments;
+ return r;
+ }
+
+ createLabel(str = "label") {
+ var name;
+ return name = ":" + str + "_" + this.label_count++;
+ }
+
+ setLabel(name) {
+ return this.labels[name] = this.opcodes.length;
+ }
+
+ optimize() {
+ if (this.transpile) {
+ new Transpiler().transpile(this);
+ }
+ }
+
+ removeable(index) {
+ var label, ref1, value;
+ ref1 = this.labels;
+ for (label in ref1) {
+ value = ref1[label];
+ if (value === index) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ remove(index) {
+ var label, ref1, value;
+ ref1 = this.labels;
+ for (label in ref1) {
+ value = ref1[label];
+ if (value === index) {
+ return false;
+ } else if (value > index) {
+ this.labels[label] -= 1;
+ }
+ }
+ this.opcodes.splice(index, 1);
+ this.arg1.splice(index, 1);
+ this.ref.splice(index, 1);
+ return true;
+ }
+
+ resolveLabels() {
+ var i, j, ref1, ref2, ref3, results;
+ results = [];
+ for (i = j = 0, ref1 = this.opcodes.length - 1; (0 <= ref1 ? j <= ref1 : j >= ref1); i = 0 <= ref1 ? ++j : --j) {
+ if ((ref2 = this.opcodes[i]) === OPCODES.JUMP || ref2 === OPCODES.JUMPY || ref2 === OPCODES.JUMPN || ref2 === OPCODES.JUMPY_NOPOP || ref2 === OPCODES.JUMPN_NOPOP) {
+ if (this.labels[this.arg1[i]]) {
+ results.push(this.arg1[i] = this.labels[this.arg1[i]]);
+ } else {
+ results.push(void 0);
+ }
+ } else if ((ref3 = this.opcodes[i]) === OPCODES.FORLOOP_CONTROL || ref3 === OPCODES.FORLOOP_INIT || ref3 === OPCODES.FORIN_CONTROL || ref3 === OPCODES.FORIN_INIT) {
+ if (this.labels[this.arg1[i][1]]) {
+ results.push(this.arg1[i][1] = this.labels[this.arg1[i][1]]);
+ } else {
+ results.push(void 0);
+ }
+ } else {
+ results.push(void 0);
+ }
+ }
+ return results;
+ }
+
+ OP(code, ref, v1 = 0) {
+ this.opcodes.push(code);
+ this.arg1.push(v1);
+ return this.ref.push(ref);
+ }
+
+ OP_INSERT(code, ref, v1 = 0, index) {
+ var label, ref1, value;
+ this.opcodes.splice(index, 0, code);
+ this.arg1.splice(index, 0, v1);
+ this.ref.splice(index, 0, ref);
+ ref1 = this.labels;
+ for (label in ref1) {
+ value = ref1[label];
+ if (value >= index) {
+ this.labels[label] += 1;
+ }
+ }
+ }
+
+ TYPE(ref) {
+ return this.OP(OPCODES.TYPE, ref);
+ }
+
+ VARIABLE_TYPE(variable, ref) {
+ return this.OP(OPCODES.VARIABLE_TYPE, ref, variable);
+ }
+
+ PROPERTY_TYPE(ref) {
+ return this.OP(OPCODES.PROPERTY_TYPE, ref);
+ }
+
+ LOAD_THIS(ref) {
+ return this.OP(OPCODES.LOAD_THIS, ref);
+ }
+
+ LOAD_GLOBAL(ref) {
+ return this.OP(OPCODES.LOAD_GLOBAL, ref);
+ }
+
+ LOAD_VALUE(value, ref) {
+ return this.OP(OPCODES.LOAD_VALUE, ref, value);
+ }
+
+ LOAD_LOCAL(index, ref) {
+ return this.OP(OPCODES.LOAD_LOCAL, ref, index);
+ }
+
+ LOAD_VARIABLE(variable, ref) {
+ return this.OP(OPCODES.LOAD_VARIABLE, ref, variable);
+ }
+
+ LOAD_LOCAL_OBJECT(index, ref) {
+ return this.OP(OPCODES.LOAD_LOCAL_OBJECT, ref, index);
+ }
+
+ LOAD_VARIABLE_OBJECT(variable, ref) {
+ return this.OP(OPCODES.LOAD_VARIABLE_OBJECT, ref, variable);
+ }
+
+ POP(ref) {
+ return this.OP(OPCODES.POP, ref);
+ }
+
+ LOAD_PROPERTY(ref) {
+ return this.OP(OPCODES.LOAD_PROPERTY, ref);
+ }
+
+ LOAD_PROPERTY_OBJECT(ref) {
+ return this.OP(OPCODES.LOAD_PROPERTY_OBJECT, ref);
+ }
+
+ CREATE_OBJECT(ref) {
+ return this.OP(OPCODES.CREATE_OBJECT, ref);
+ }
+
+ MAKE_OBJECT(ref) {
+ return this.OP(OPCODES.MAKE_OBJECT, ref);
+ }
+
+ CREATE_ARRAY(ref) {
+ return this.OP(OPCODES.CREATE_ARRAY, ref);
+ }
+
+ CREATE_CLASS(parent_var, ref) {
+ return this.OP(OPCODES.CREATE_CLASS, ref, parent_var);
+ }
+
+ UPDATE_CLASS(variable, ref) {
+ return this.OP(OPCODES.UPDATE_CLASS, ref, variable);
+ }
+
+ NEW_CALL(args, ref) {
+ return this.OP(OPCODES.NEW_CALL, ref, args);
+ }
+
+ ADD(ref, self = 0) {
+ return this.OP(OPCODES.ADD, ref, self);
+ }
+
+ SUB(ref, self = 0) {
+ return this.OP(OPCODES.SUB, ref, self);
+ }
+
+ MUL(ref) {
+ return this.OP(OPCODES.MUL, ref);
+ }
+
+ DIV(ref) {
+ return this.OP(OPCODES.DIV, ref);
+ }
+
+ MODULO(ref) {
+ return this.OP(OPCODES.MODULO, ref);
+ }
+
+ BINARY_AND(ref) {
+ return this.OP(OPCODES.BINARY_AND, ref);
+ }
+
+ BINARY_OR(ref) {
+ return this.OP(OPCODES.BINARY_OR, ref);
+ }
+
+ SHIFT_LEFT(ref) {
+ return this.OP(OPCODES.SHIFT_LEFT, ref);
+ }
+
+ SHIFT_RIGHT(ref) {
+ return this.OP(OPCODES.SHIFT_RIGHT, ref);
+ }
+
+ NEGATE(ref) {
+ return this.OP(OPCODES.NEGATE, ref);
+ }
+
+ LOAD_PROPERTY_ATOP(ref) {
+ return this.OP(OPCODES.LOAD_PROPERTY_ATOP, ref);
+ }
+
+ EQ(ref) {
+ return this.OP(OPCODES.EQ, ref);
+ }
+
+ NEQ(ref) {
+ return this.OP(OPCODES.NEQ, ref);
+ }
+
+ LT(ref) {
+ return this.OP(OPCODES.LT, ref);
+ }
+
+ GT(ref) {
+ return this.OP(OPCODES.GT, ref);
+ }
+
+ LTE(ref) {
+ return this.OP(OPCODES.LTE, ref);
+ }
+
+ GTE(ref) {
+ return this.OP(OPCODES.GTE, ref);
+ }
+
+ NOT(ref) {
+ return this.OP(OPCODES.NOT, ref);
+ }
+
+ FORLOOP_INIT(iterator, ref) {
+ return this.OP(OPCODES.FORLOOP_INIT, ref, iterator);
+ }
+
+ FORLOOP_CONTROL(args, ref) {
+ return this.OP(OPCODES.FORLOOP_CONTROL, ref, args);
+ }
+
+ FORIN_INIT(args, ref) {
+ return this.OP(OPCODES.FORIN_INIT, ref, args);
+ }
+
+ FORIN_CONTROL(args, ref) {
+ return this.OP(OPCODES.FORIN_CONTROL, ref, args);
+ }
+
+ JUMP(index, ref) {
+ return this.OP(OPCODES.JUMP, ref, index);
+ }
+
+ JUMPY(index, ref) {
+ return this.OP(OPCODES.JUMPY, ref, index);
+ }
+
+ JUMPN(index, ref) {
+ return this.OP(OPCODES.JUMPN, ref, index);
+ }
+
+ JUMPY_NOPOP(index, ref) {
+ return this.OP(OPCODES.JUMPY_NOPOP, ref, index);
+ }
+
+ JUMPN_NOPOP(index, ref) {
+ return this.OP(OPCODES.JUMPN_NOPOP, ref, index);
+ }
+
+ STORE_LOCAL(index, ref) {
+ return this.OP(OPCODES.STORE_LOCAL, ref, index);
+ }
+
+ STORE_VARIABLE(field, ref) {
+ return this.OP(OPCODES.STORE_VARIABLE, ref, field);
+ }
+
+ CREATE_PROPERTY(ref) {
+ return this.OP(OPCODES.CREATE_PROPERTY, ref);
+ }
+
+ STORE_PROPERTY(ref) {
+ return this.OP(OPCODES.STORE_PROPERTY, ref);
+ }
+
+ LOAD_ROUTINE(value, ref) {
+ return this.OP(OPCODES.LOAD_ROUTINE, ref, value);
+ }
+
+ FUNCTION_CALL(args, ref) {
+ return this.OP(OPCODES.FUNCTION_CALL, ref, args);
+ }
+
+ FUNCTION_APPLY_VARIABLE(args, ref) {
+ return this.OP(OPCODES.FUNCTION_APPLY_VARIABLE, ref, args);
+ }
+
+ FUNCTION_APPLY_PROPERTY(args, ref) {
+ return this.OP(OPCODES.FUNCTION_APPLY_PROPERTY, ref, args);
+ }
+
+ SUPER_CALL(args, ref) {
+ return this.OP(OPCODES.SUPER_CALL, ref, args);
+ }
+
+ RETURN(ref) {
+ return this.OP(OPCODES.RETURN, ref);
+ }
+
+ AFTER(ref) {
+ return this.OP(OPCODES.AFTER, ref);
+ }
+
+ EVERY(ref) {
+ return this.OP(OPCODES.EVERY, ref);
+ }
+
+ DO(ref) {
+ return this.OP(OPCODES.DO, ref);
+ }
+
+ SLEEP(ref) {
+ return this.OP(OPCODES.SLEEP, ref);
+ }
+
+ DELETE(ref) {
+ return this.OP(OPCODES.DELETE, ref);
+ }
+
+ UNARY_OP(f, ref) {
+ return this.OP(OPCODES.UNARY_OP, ref, f);
+ }
+
+ BINARY_OP(f, ref) {
+ return this.OP(OPCODES.BINARY_OP, ref, f);
+ }
+
+ toString() {
+ var i, j, len, op, ref1, s;
+ s = "";
+ ref1 = this.opcodes;
+ for (i = j = 0, len = ref1.length; j < len; i = ++j) {
+ op = ref1[i];
+ s += OPCODES[op];
+ if (this.arg1[i] != null) {
+ //if typeof @arg1[i] != "function"
+ s += ` ${this.arg1[i]}`;
+ }
+ s += "\n";
+ }
+ return s;
+ }
+
+ exportArg(arg) {
+ if (arg == null) {
+ return 0;
+ } else if (arg instanceof Routine) {
+ return arg.export();
+ } else if (typeof arg === "function") {
+ return arg.name;
+ } else {
+ return arg;
+ }
+ }
+
+ export() {
+ var args, i, j, ref1, res;
+ args = [];
+ for (i = j = 0, ref1 = this.arg1.length - 1; j <= ref1; i = j += 1) {
+ args[i] = this.exportArg(this.arg1[i]);
+ }
+ res = {
+ num_args: this.num_args,
+ ops: this.opcodes,
+ args: args,
+ import_refs: this.import_refs,
+ import_values: this.import_values,
+ import_self: this.import_self,
+ locals_size: this.locals_size
+ };
+ return res;
+ }
+
+ import(src) {
+ var i, j, ref, ref1, token;
+ this.num_args = src.num_args;
+ this.opcodes = src.ops;
+ this.arg1 = src.args;
+ this.import_refs = src.import_refs;
+ this.import_values = src.import_values;
+ this.import_self = src.import_self;
+ this.locals_size = src.locals_size;
+ token = {
+ line: 0,
+ column: 0,
+ start: 0,
+ length: 0,
+ index: 0,
+ tokenizer: {
+ filename: "filename",
+ input: ""
+ }
+ };
+ ref = {
+ expression: {
+ token: token
+ },
+ token: token
+ };
+ for (i = j = 0, ref1 = this.opcodes.length - 1; j <= ref1; i = j += 1) {
+ if (this.opcodes[i] === 100) {
+ this.arg1[i] = Compiler.predefined_unary_functions[this.arg1[i]];
+ } else if (this.opcodes[i] === 101) {
+ this.arg1[i] = Compiler.predefined_binary_functions[this.arg1[i]];
+ } else if (typeof this.arg1[i] === "object" && !Array.isArray(this.arg1[i])) {
+ this.arg1[i] = new Routine(0).import(this.arg1[i]);
+ }
+ this.ref[i] = ref;
+ }
+ return this;
+ }
+
+};
+
+this.OPCODES_CLASS = class OPCODES_CLASS {
+ constructor() {
+ this.table = {};
+ this.set("TYPE", 1);
+ this.set("VARIABLE_TYPE", 2);
+ this.set("PROPERTY_TYPE", 3);
+ this.set("LOAD_IMPORT", 4);
+ this.set("LOAD_THIS", 5);
+ this.set("LOAD_GLOBAL", 6);
+ this.set("LOAD_VALUE", 10);
+ this.set("LOAD_LOCAL", 11);
+ this.set("LOAD_VARIABLE", 12);
+ this.set("LOAD_LOCAL_OBJECT", 13);
+ this.set("LOAD_VARIABLE_OBJECT", 14);
+ this.set("POP", 15);
+ this.set("LOAD_PROPERTY", 16);
+ this.set("LOAD_PROPERTY_OBJECT", 17);
+ this.set("CREATE_OBJECT", 18);
+ this.set("MAKE_OBJECT", 19);
+ this.set("CREATE_ARRAY", 20);
+ this.set("STORE_LOCAL", 21);
+ this.set("STORE_VARIABLE", 23);
+ this.set("CREATE_PROPERTY", 24);
+ this.set("STORE_PROPERTY", 25);
+ this.set("DELETE", 26);
+ this.set("UPDATE_CLASS", 27);
+ this.set("CREATE_CLASS", 28);
+ this.set("NEW_CALL", 29);
+ this.set("ADD", 30);
+ this.set("SUB", 31);
+ this.set("MUL", 32);
+ this.set("DIV", 33);
+ this.set("MODULO", 34);
+ this.set("BINARY_AND", 35);
+ this.set("BINARY_OR", 36);
+ this.set("SHIFT_LEFT", 37);
+ this.set("SHIFT_RIGHT", 38);
+ this.set("NEGATE", 39);
+ this.set("EQ", 40);
+ this.set("NEQ", 41);
+ this.set("LT", 42);
+ this.set("GT", 43);
+ this.set("LTE", 44);
+ this.set("GTE", 45);
+ this.set("NOT", 50);
+ this.set("LOAD_PROPERTY_ATOP", 68);
+ this.set("JUMP", 80);
+ this.set("JUMPY", 81);
+ this.set("JUMPN", 82);
+ this.set("JUMPY_NOPOP", 83);
+ this.set("JUMPN_NOPOP", 84);
+ this.set("LOAD_ROUTINE", 89);
+ this.set("FUNCTION_CALL", 90);
+ this.set("FUNCTION_APPLY_VARIABLE", 91);
+ this.set("FUNCTION_APPLY_PROPERTY", 92);
+ this.set("SUPER_CALL", 93);
+ this.set("RETURN", 94);
+ this.set("FORLOOP_INIT", 95);
+ this.set("FORLOOP_CONTROL", 96);
+ this.set("FORIN_INIT", 97);
+ this.set("FORIN_CONTROL", 98);
+ this.set("UNARY_OP", 100);
+ this.set("BINARY_OP", 101);
+ this.set("COMPILED", 200);
+ this.set("AFTER", 110);
+ this.set("EVERY", 111);
+ this.set("DO", 112);
+ this.set("SLEEP", 113);
+ }
+
+ set(op, code) {
+ this[op] = code;
+ return this[code] = op;
+ }
+
+};
+
+this.OPCODES = new this.OPCODES_CLASS;
diff --git a/WebGames-master/WebGames-master/games/cap/runner.js b/WebGames-master/WebGames-master/games/cap/runner.js
new file mode 100644
index 00000000..a4cde560
--- /dev/null
+++ b/WebGames-master/WebGames-master/games/cap/runner.js
@@ -0,0 +1,385 @@
+this.Runner = class Runner {
+ constructor(microvm) {
+ this.microvm = microvm;
+ }
+
+ init() {
+ this.initialized = true;
+ this.system = this.microvm.context.global.system;
+ this.system.preemptive = 1;
+ this.system.threads = [];
+ this.main_thread = new Thread(this);
+ this.threads = [this.main_thread];
+ this.current_thread = this.main_thread;
+ this.thread_index = 0;
+ this.microvm.context.global.print = this.microvm.context.meta.print;
+ this.microvm.context.global.random = new Random(0);
+ this.microvm.context.global.Function = {
+ bind: function(obj) {
+ var rc;
+ if (this instanceof Routine) {
+ rc = this.clone();
+ rc.object = obj;
+ return rc;
+ } else {
+ return this;
+ }
+ }
+ };
+ this.microvm.context.global.List = {
+ sortList: (f) => {
+ var funk;
+ if ((f != null) && f instanceof Program.Function) {
+ funk = function(a, b) {
+ return f.call(this.microvm.context.global, [a, b], true);
+ };
+ } else if ((f != null) && typeof f === "function") {
+ funk = f;
+ }
+ return this.sort(funk);
+ },
+ "+": function(a, b, self) {
+ if (!self) { // not +=, clone array a
+ a = [...a];
+ }
+ if (Array.isArray(b)) {
+ return a.concat(b);
+ } else {
+ a.push(b);
+ return a;
+ }
+ },
+ "-": function(a, b, self) {
+ var index;
+ if (!self) { // not -=, clone array a
+ a = [...a];
+ }
+ index = a.indexOf(b);
+ if (index >= 0) {
+ a.splice(index, 1);
+ }
+ return a;
+ }
+ };
+ this.microvm.context.global.Object = {};
+ this.microvm.context.global.String = {
+ fromCharCode: function(...args) { return String.fromCharCode(...args) },
+ "+": function(a, b) {
+ return a + b;
+ }
+ };
+ this.microvm.context.global.Number = {
+ parse: function(s) {
+ var res;
+ res = Number.parseFloat(s);
+ if (isFinite(res)) {
+ return res;
+ } else {
+ return 0;
+ }
+ },
+ toString: function() {
+ return this.toString();
+ }
+ };
+ this.fps = 60;
+ this.fps_max = 60;
+ this.cpu_load = 0;
+ this.microvm.context.meta.print("microScript 2.0");
+ return this.triggers_controls_update = true;
+ }
+
+ run(src, filename, callback) {
+ var compiler, err, id, j, len, parser, program, ref, result, w;
+ if (!this.initialized) {
+ this.init();
+ }
+ parser = new Parser(src, filename);
+ parser.parse();
+ if (parser.error_info != null) {
+ err = parser.error_info;
+ err.type = "compile";
+ throw err;
+ }
+ if (parser.warnings.length > 0) {
+ ref = parser.warnings;
+ for (j = 0, len = ref.length; j < len; j++) {
+ w = ref[j];
+ id = filename + "-" + w.line + "-" + w.column;
+ switch (w.type) {
+ case "assigning_api_variable":
+ if (this.microvm.context.warnings.assigning_api_variable[id] == null) {
+ this.microvm.context.warnings.assigning_api_variable[id] = {
+ file: filename,
+ line: w.line,
+ column: w.column,
+ expression: w.identifier
+ };
+ }
+ break;
+ case "assignment_as_condition":
+ if (this.microvm.context.warnings.assignment_as_condition[id] == null) {
+ this.microvm.context.warnings.assignment_as_condition[id] = {
+ file: filename,
+ line: w.line,
+ column: w.column
+ };
+ }
+ }
+ }
+ }
+ program = parser.program;
+ compiler = new Compiler(program);
+ result = null;
+ compiler.routine.callback = function(res) {
+ if (callback != null) {
+ return callback(Program.toString(res));
+ } else {
+ return result = res;
+ }
+ };
+ this.main_thread.addCall(compiler.routine);
+ this.tick();
+ return result;
+ }
+
+ call(name, args) {
+ var f, routine;
+ if (name === "draw" || name === "update" || name === "serverUpdate") {
+ if (this.microvm.context.global[name] != null) {
+ this.main_thread.addCall(`${name}()`);
+ }
+ return;
+ }
+ if (this.microvm.context.global[name] != null) {
+ if ((args == null) || !args.length) {
+ return this.main_thread.addCall(`${name}()`);
+ } else {
+ routine = this.microvm.context.global[name];
+ if (routine instanceof Routine) {
+ f = this.main_thread.processor.routineAsFunction(routine, this.microvm.context);
+ return f(...args);
+ } else if (typeof routine === "function") {
+ return routine(...args);
+ }
+ }
+ } else {
+ return 0;
+ }
+ }
+
+ toString(obj) {
+ return Program.toString(obj);
+ }
+
+ process(thread, time_limit) {
+ var processor;
+ processor = thread.processor;
+ processor.time_limit = time_limit;
+ this.current_thread = thread;
+ return processor.run(this.microvm.context);
+ }
+
+ tick() {
+ var dt, frame_time, i, index, j, k, len, load, margin, processing, processor, ref, ref1, t, time, time_limit, time_out;
+ if (this.system.fps != null) {
+ this.fps = this.fps * .9 + this.system.fps * .1;
+ }
+ this.fps_max = Math.max(this.fps, this.fps_max);
+ frame_time = Math.min(16, Math.floor(1000 / this.fps_max));
+ if (this.fps < 59) {
+ margin = 10;
+ } else {
+ margin = Math.floor(1000 / this.fps * .8);
+ }
+ time = Date.now();
+ time_limit = time + 100; // allow more time to prevent interrupting main_thread in the middle of a draw()
+ time_out = this.system.preemptive ? time_limit : 2e308;
+ processor = this.main_thread.processor;
+ if (!processor.done) {
+ if (this.main_thread.sleep_until != null) {
+ if (Date.now() >= this.main_thread.sleep_until) {
+ delete this.main_thread.sleep_until;
+ this.process(this.main_thread, time_out);
+ }
+ } else {
+ this.process(this.main_thread, time_out);
+ }
+ }
+ while (processor.done && Date.now() < time_out && this.main_thread.loadNext()) {
+ this.process(this.main_thread, time_out);
+ }
+ time_limit = time + margin; // secondary threads get remaining time
+ time_out = this.system.preemptive ? time_limit : 2e308;
+ processing = true;
+ while (processing) {
+ processing = false;
+ ref = this.threads;
+ for (j = 0, len = ref.length; j < len; j++) {
+ t = ref[j];
+ if (t !== this.main_thread) {
+ if (t.paused || t.terminated) {
+ continue;
+ }
+ processor = t.processor;
+ if (!processor.done) {
+ if (t.sleep_until != null) {
+ if (Date.now() >= t.sleep_until) {
+ delete t.sleep_until;
+ this.process(t, time_out);
+ processing = true;
+ }
+ } else {
+ this.process(t, time_out);
+ processing = true;
+ }
+ } else if (t.start_time != null) {
+ if (t.repeat) {
+ while (time >= t.start_time && !(t.paused || t.terminated)) {
+ if (time >= t.start_time + 150) {
+ t.start_time = time + t.delay;
+ } else {
+ t.start_time += t.delay;
+ }
+ processor.load(t.routine);
+ this.process(t, time_out);
+ processing = true;
+ }
+ } else {
+ if (time >= t.start_time) {
+ delete t.start_time;
+ processor.load(t.routine);
+ this.process(t, time_out);
+ processing = true;
+ }
+ }
+ } else {
+ t.terminated = true;
+ }
+ }
+ }
+ if (Date.now() > time_limit) {
+ break;
+ }
+ }
+ for (i = k = ref1 = this.threads.length - 1; k >= 1; i = k += -1) {
+ t = this.threads[i];
+ if (t.terminated) {
+ this.threads.splice(i, 1);
+ index = this.system.threads.indexOf(t.interface);
+ if (index >= 0) {
+ this.system.threads.splice(index, 1);
+ }
+ }
+ }
+ t = Date.now() - time;
+ dt = time_limit - time;
+ load = t / dt * 100;
+ this.cpu_load = this.cpu_load * .9 + load * .1;
+ this.system.cpu_load = Math.min(100, Math.round(this.cpu_load));
+ }
+
+ createThread(routine, delay, repeat) {
+ var i, j, ref, t;
+ t = new Thread(this);
+ t.routine = routine;
+ this.threads.push(t);
+ t.start_time = Date.now() + delay - 1000 / this.fps;
+ if (repeat) {
+ t.repeat = repeat;
+ t.delay = delay;
+ }
+ this.system.threads.push(t.interface);
+ for (i = j = 0, ref = routine.import_values.length - 1; j <= ref; i = j += 1) {
+ if (routine.import_values[i] === routine) {
+ routine.import_values[i] = t.interface;
+ }
+ }
+ return t.interface;
+ }
+
+ sleep(value) {
+ if (this.current_thread != null) {
+ return this.current_thread.sleep_until = Date.now() + Math.max(0, value);
+ }
+ }
+
+};
+
+this.Thread = class Thread {
+ constructor(runner) {
+ this.runner = runner;
+ this.loop = false;
+ this.processor = new Processor(this.runner);
+ this.paused = false;
+ this.terminated = false;
+ this.next_calls = [];
+ this.interface = {
+ pause: () => {
+ return this.pause();
+ },
+ resume: () => {
+ return this.resume();
+ },
+ stop: () => {
+ return this.stop();
+ },
+ status: "running"
+ };
+ }
+
+ addCall(call) {
+ if (this.next_calls.indexOf(call) < 0) {
+ return this.next_calls.push(call);
+ }
+ }
+
+ loadNext() {
+ var compiler, f, parser, program;
+ if (this.next_calls.length > 0) {
+ f = this.next_calls.splice(0, 1)[0];
+ if (f instanceof Routine) {
+ this.processor.load(f);
+ } else {
+ parser = new Parser(f, "");
+ parser.parse();
+ program = parser.program;
+ compiler = new Compiler(program);
+ this.processor.load(compiler.routine);
+ if ((f === "update()" || f === "serverUpdate()") && (this.runner.updateControls != null)) {
+ this.runner.updateControls();
+ }
+ }
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ pause() {
+ if (this.interface.status === "running") {
+ this.interface.status = "paused";
+ this.paused = true;
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+
+ resume() {
+ if (this.interface.status === "paused") {
+ this.interface.status = "running";
+ this.paused = false;
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+
+ stop() {
+ this.interface.status = "stopped";
+ this.terminated = true;
+ return 1;
+ }
+
+};
diff --git a/WebGames-master/WebGames-master/games/cap/sounds/death.wav b/WebGames-master/WebGames-master/games/cap/sounds/death.wav
new file mode 100644
index 00000000..65c7153e
Binary files /dev/null and b/WebGames-master/WebGames-master/games/cap/sounds/death.wav differ
diff --git a/WebGames-master/WebGames-master/games/cap/sounds/jump.wav b/WebGames-master/WebGames-master/games/cap/sounds/jump.wav
new file mode 100644
index 00000000..ac5d6cf6
Binary files /dev/null and b/WebGames-master/WebGames-master/games/cap/sounds/jump.wav differ
diff --git a/WebGames-master/WebGames-master/games/cap/sprites/bas.png b/WebGames-master/WebGames-master/games/cap/sprites/bas.png
new file mode 100644
index 00000000..b30f9235
Binary files /dev/null and b/WebGames-master/WebGames-master/games/cap/sprites/bas.png differ
diff --git a/WebGames-master/WebGames-master/games/cap/sprites/blade.png b/WebGames-master/WebGames-master/games/cap/sprites/blade.png
new file mode 100644
index 00000000..8919ba4e
Binary files /dev/null and b/WebGames-master/WebGames-master/games/cap/sprites/blade.png differ
diff --git a/WebGames-master/WebGames-master/games/cap/sprites/cage.png b/WebGames-master/WebGames-master/games/cap/sprites/cage.png
new file mode 100644
index 00000000..1ac51134
Binary files /dev/null and b/WebGames-master/WebGames-master/games/cap/sprites/cage.png differ
diff --git a/WebGames-master/WebGames-master/games/cap/sprites/chick.png b/WebGames-master/WebGames-master/games/cap/sprites/chick.png
new file mode 100644
index 00000000..88eb3627
Binary files /dev/null and b/WebGames-master/WebGames-master/games/cap/sprites/chick.png differ
diff --git a/WebGames-master/WebGames-master/games/cap/sprites/columnblade.png b/WebGames-master/WebGames-master/games/cap/sprites/columnblade.png
new file mode 100644
index 00000000..b6d38cf1
Binary files /dev/null and b/WebGames-master/WebGames-master/games/cap/sprites/columnblade.png differ
diff --git a/WebGames-master/WebGames-master/games/cap/sprites/columnempty.png b/WebGames-master/WebGames-master/games/cap/sprites/columnempty.png
new file mode 100644
index 00000000..9f6ec623
Binary files /dev/null and b/WebGames-master/WebGames-master/games/cap/sprites/columnempty.png differ
diff --git a/WebGames-master/WebGames-master/games/cap/sprites/cube.png b/WebGames-master/WebGames-master/games/cap/sprites/cube.png
new file mode 100644
index 00000000..d4bd7765
Binary files /dev/null and b/WebGames-master/WebGames-master/games/cap/sprites/cube.png differ
diff --git a/WebGames-master/WebGames-master/games/cap/sprites/cube_ghost.png b/WebGames-master/WebGames-master/games/cap/sprites/cube_ghost.png
new file mode 100644
index 00000000..58ee9ed3
Binary files /dev/null and b/WebGames-master/WebGames-master/games/cap/sprites/cube_ghost.png differ
diff --git a/WebGames-master/WebGames-master/games/cap/sprites/icon.png b/WebGames-master/WebGames-master/games/cap/sprites/icon.png
new file mode 100644
index 00000000..7c9f14e2
Binary files /dev/null and b/WebGames-master/WebGames-master/games/cap/sprites/icon.png differ
diff --git a/WebGames-master/WebGames-master/games/cap/sprites/mockup_bas.png b/WebGames-master/WebGames-master/games/cap/sprites/mockup_bas.png
new file mode 100644
index 00000000..63b95f45
Binary files /dev/null and b/WebGames-master/WebGames-master/games/cap/sprites/mockup_bas.png differ
diff --git a/WebGames-master/WebGames-master/games/cap/sprites/piece.png b/WebGames-master/WebGames-master/games/cap/sprites/piece.png
new file mode 100644
index 00000000..9d9277c4
Binary files /dev/null and b/WebGames-master/WebGames-master/games/cap/sprites/piece.png differ
diff --git a/WebGames-master/WebGames-master/games/cap/sprites/poster.png b/WebGames-master/WebGames-master/games/cap/sprites/poster.png
new file mode 100644
index 00000000..bfa655c4
Binary files /dev/null and b/WebGames-master/WebGames-master/games/cap/sprites/poster.png differ
diff --git a/WebGames-master/WebGames-master/games/cap/sprites/spike.png b/WebGames-master/WebGames-master/games/cap/sprites/spike.png
new file mode 100644
index 00000000..eeefd869
Binary files /dev/null and b/WebGames-master/WebGames-master/games/cap/sprites/spike.png differ
diff --git a/WebGames-master/WebGames-master/games/cap/sprites/tower.png b/WebGames-master/WebGames-master/games/cap/sprites/tower.png
new file mode 100644
index 00000000..4e2d1c8f
Binary files /dev/null and b/WebGames-master/WebGames-master/games/cap/sprites/tower.png differ
diff --git a/WebGames-master/WebGames-master/games/cap/sprites/tower1.png b/WebGames-master/WebGames-master/games/cap/sprites/tower1.png
new file mode 100644
index 00000000..95f717dc
Binary files /dev/null and b/WebGames-master/WebGames-master/games/cap/sprites/tower1.png differ
diff --git a/WebGames-master/WebGames-master/games/cap/sprites/tower2.png b/WebGames-master/WebGames-master/games/cap/sprites/tower2.png
new file mode 100644
index 00000000..0e4262db
Binary files /dev/null and b/WebGames-master/WebGames-master/games/cap/sprites/tower2.png differ
diff --git a/WebGames-master/WebGames-master/games/cap/token.js b/WebGames-master/WebGames-master/games/cap/token.js
new file mode 100644
index 00000000..e9d14b85
--- /dev/null
+++ b/WebGames-master/WebGames-master/games/cap/token.js
@@ -0,0 +1,201 @@
+this.Token = class Token {
+ constructor(tokenizer, type, value, string_value) {
+ this.tokenizer = tokenizer;
+ this.type = type;
+ this.value = value;
+ this.string_value = string_value;
+ this.line = this.tokenizer.line;
+ this.column = this.tokenizer.column;
+ this.start = this.tokenizer.token_start;
+ this.length = this.tokenizer.index - this.start;
+ this.index = this.tokenizer.index;
+ if (this.type === Token.TYPE_IDENTIFIER && Token.predefined.hasOwnProperty(this.value)) {
+ this.type = Token.predefined[this.value];
+ this.reserved_keyword = true;
+ }
+ this.is_binary_operator = (this.type >= 30 && this.type <= 39) || (this.type >= 200 && this.type <= 201) || (this.type >= 2 && this.type <= 7);
+ }
+
+ toString() {
+ return this.value + " : " + this.type;
+ }
+
+};
+
+this.Token.TYPE_EQUALS = 1;
+
+this.Token.TYPE_DOUBLE_EQUALS = 2;
+
+this.Token.TYPE_GREATER = 3;
+
+this.Token.TYPE_GREATER_OR_EQUALS = 4;
+
+this.Token.TYPE_LOWER = 5;
+
+this.Token.TYPE_LOWER_OR_EQUALS = 6;
+
+this.Token.TYPE_UNEQUALS = 7;
+
+this.Token.TYPE_IDENTIFIER = 10;
+
+this.Token.TYPE_NUMBER = 11;
+
+this.Token.TYPE_STRING = 12;
+
+this.Token.TYPE_OPEN_BRACE = 20;
+
+this.Token.TYPE_CLOSED_BRACE = 21;
+
+// @Token.TYPE_OPEN_CURLY_BRACE = 22
+// @Token.TYPE_CLOSED_CURLY_BRACE = 23
+this.Token.TYPE_OPEN_BRACKET = 24;
+
+this.Token.TYPE_CLOSED_BRACKET = 25;
+
+this.Token.TYPE_COMMA = 26;
+
+this.Token.TYPE_DOT = 27;
+
+this.Token.TYPE_PLUS = 30;
+
+this.Token.TYPE_MINUS = 31;
+
+this.Token.TYPE_MULTIPLY = 32;
+
+this.Token.TYPE_DIVIDE = 33;
+
+this.Token.TYPE_POWER = 34;
+
+this.Token.TYPE_MODULO = 35;
+
+this.Token.TYPE_BINARY_AND = 36;
+
+this.Token.TYPE_BINARY_OR = 37;
+
+this.Token.TYPE_SHIFT_LEFT = 38;
+
+this.Token.TYPE_SHIFT_RIGHT = 39;
+
+this.Token.TYPE_PLUS_EQUALS = 40;
+
+this.Token.TYPE_MINUS_EQUALS = 41;
+
+this.Token.TYPE_MULTIPLY_EQUALS = 42;
+
+this.Token.TYPE_DIVIDE_EQUALS = 43;
+
+this.Token.TYPE_MODULO_EQUALS = 44;
+
+this.Token.TYPE_AND_EQUALS = 45;
+
+this.Token.TYPE_OR_EQUALS = 46;
+
+this.Token.TYPE_RETURN = 50;
+
+this.Token.TYPE_BREAK = 51;
+
+this.Token.TYPE_CONTINUE = 52;
+
+this.Token.TYPE_FUNCTION = 60;
+
+this.Token.TYPE_AFTER = 61;
+
+this.Token.TYPE_EVERY = 62;
+
+this.Token.TYPE_DO = 63;
+
+this.Token.TYPE_SLEEP = 64;
+
+this.Token.TYPE_LOCAL = 70;
+
+this.Token.TYPE_OBJECT = 80;
+
+this.Token.TYPE_CLASS = 90;
+
+this.Token.TYPE_EXTENDS = 91;
+
+this.Token.TYPE_NEW = 92;
+
+this.Token.TYPE_FOR = 100;
+
+this.Token.TYPE_TO = 101;
+
+this.Token.TYPE_BY = 102;
+
+this.Token.TYPE_IN = 103;
+
+this.Token.TYPE_WHILE = 104;
+
+this.Token.TYPE_IF = 105;
+
+this.Token.TYPE_THEN = 106;
+
+this.Token.TYPE_ELSE = 107;
+
+this.Token.TYPE_ELSIF = 108;
+
+this.Token.TYPE_END = 120;
+
+this.Token.TYPE_AND = 200;
+
+this.Token.TYPE_OR = 201;
+
+this.Token.TYPE_NOT = 202;
+
+this.Token.TYPE_ERROR = 404;
+
+this.Token.predefined = {};
+
+this.Token.predefined["return"] = this.Token.TYPE_RETURN;
+
+this.Token.predefined["break"] = this.Token.TYPE_BREAK;
+
+this.Token.predefined["continue"] = this.Token.TYPE_CONTINUE;
+
+this.Token.predefined["function"] = this.Token.TYPE_FUNCTION;
+
+this.Token.predefined["for"] = this.Token.TYPE_FOR;
+
+this.Token.predefined["to"] = this.Token.TYPE_TO;
+
+this.Token.predefined["by"] = this.Token.TYPE_BY;
+
+this.Token.predefined["in"] = this.Token.TYPE_IN;
+
+this.Token.predefined["while"] = this.Token.TYPE_WHILE;
+
+this.Token.predefined["if"] = this.Token.TYPE_IF;
+
+this.Token.predefined["then"] = this.Token.TYPE_THEN;
+
+this.Token.predefined["else"] = this.Token.TYPE_ELSE;
+
+this.Token.predefined["elsif"] = this.Token.TYPE_ELSIF;
+
+this.Token.predefined["end"] = this.Token.TYPE_END;
+
+this.Token.predefined["object"] = this.Token.TYPE_OBJECT;
+
+this.Token.predefined["class"] = this.Token.TYPE_CLASS;
+
+this.Token.predefined["extends"] = this.Token.TYPE_EXTENDS;
+
+this.Token.predefined["new"] = this.Token.TYPE_NEW;
+
+this.Token.predefined["and"] = this.Token.TYPE_AND;
+
+this.Token.predefined["or"] = this.Token.TYPE_OR;
+
+this.Token.predefined["not"] = this.Token.TYPE_NOT;
+
+this.Token.predefined["after"] = this.Token.TYPE_AFTER;
+
+this.Token.predefined["every"] = this.Token.TYPE_EVERY;
+
+this.Token.predefined["do"] = this.Token.TYPE_DO;
+
+this.Token.predefined["sleep"] = this.Token.TYPE_SLEEP;
+
+this.Token.predefined["delete"] = this.Token.TYPE_DELETE;
+
+this.Token.predefined["local"] = this.Token.TYPE_LOCAL;
diff --git a/WebGames-master/WebGames-master/games/cap/tokenizer.js b/WebGames-master/WebGames-master/games/cap/tokenizer.js
new file mode 100644
index 00000000..37b7ffe4
--- /dev/null
+++ b/WebGames-master/WebGames-master/games/cap/tokenizer.js
@@ -0,0 +1,343 @@
+this.Tokenizer = (function() {
+ function Tokenizer(input, filename) {
+ this.input = input;
+ this.filename = filename;
+ this.index = 0;
+ this.line = 1;
+ this.column = 0;
+ this.last_column = 0;
+ this.buffer = [];
+ this.chars = {};
+ this.chars["("] = Token.TYPE_OPEN_BRACE;
+ this.chars[")"] = Token.TYPE_CLOSED_BRACE;
+ this.chars["["] = Token.TYPE_OPEN_BRACKET;
+ this.chars["]"] = Token.TYPE_CLOSED_BRACKET;
+ this.chars["{"] = Token.TYPE_OPEN_CURLY_BRACE;
+ this.chars["}"] = Token.TYPE_CLOSED_CURLY_BRACE;
+ this.chars["^"] = Token.TYPE_POWER;
+ this.chars[","] = Token.TYPE_COMMA;
+ this.chars["."] = Token.TYPE_DOT;
+ this.doubles = {};
+ this.doubles[">"] = [Token.TYPE_GREATER, Token.TYPE_GREATER_OR_EQUALS];
+ this.doubles["<"] = [Token.TYPE_LOWER, Token.TYPE_LOWER_OR_EQUALS];
+ this.doubles["="] = [Token.TYPE_EQUALS, Token.TYPE_DOUBLE_EQUALS];
+ this.doubles["+"] = [Token.TYPE_PLUS, Token.TYPE_PLUS_EQUALS];
+ this.doubles["-"] = [Token.TYPE_MINUS, Token.TYPE_MINUS_EQUALS];
+ this.doubles["*"] = [Token.TYPE_MULTIPLY, Token.TYPE_MULTIPLY_EQUALS];
+ this.doubles["/"] = [Token.TYPE_DIVIDE, Token.TYPE_DIVIDE_EQUALS];
+ this.doubles["%"] = [Token.TYPE_MODULO, Token.TYPE_MODULO_EQUALS];
+ this.doubles["&"] = [Token.TYPE_BINARY_AND, Token.TYPE_AND_EQUALS];
+ this.doubles["|"] = [Token.TYPE_BINARY_OR, Token.TYPE_OR_EQUALS];
+ this.shifts = {
+ "<": Token.TYPE_SHIFT_LEFT,
+ ">": Token.TYPE_SHIFT_RIGHT
+ };
+ this.letter_regex = RegExp(/^\p{L}/, 'u');
+ }
+
+ Tokenizer.prototype.pushBack = function(token) {
+ return this.buffer.splice(0, 0, token);
+ };
+
+ Tokenizer.prototype.finished = function() {
+ return this.index >= this.input.length && this.buffer.length === 0;
+ };
+
+ Tokenizer.prototype.nextChar = function(ignore_comments) {
+ var c, endseq;
+ if (ignore_comments == null) {
+ ignore_comments = false;
+ }
+ c = this.input.charAt(this.index++);
+ if (c === "\n") {
+ this.line += 1;
+ this.last_column = this.column;
+ this.column = 0;
+ } else if (c === "/" && !ignore_comments) {
+ if (this.input.charAt(this.index) === "/") {
+ while (true) {
+ c = this.input.charAt(this.index++);
+ if (c === "\n" || this.index >= this.input.length) {
+ break;
+ }
+ }
+ this.line += 1;
+ this.last_column = this.column;
+ this.column = 0;
+ return this.nextChar();
+ } else if (this.input.charAt(this.index) === "*") {
+ endseq = 0;
+ while (true) {
+ c = this.input.charAt(this.index++);
+ if (c === "\n") {
+ this.line += 1;
+ this.last_column = this.column;
+ this.column = 0;
+ endseq = 0;
+ } else if (c === "*") {
+ endseq = 1;
+ } else if (c === "/" && endseq === 1) {
+ break;
+ } else {
+ endseq = 0;
+ }
+ if (this.index >= this.input.length) {
+ break;
+ }
+ }
+ return this.nextChar();
+ }
+ } else {
+ this.column += 1;
+ }
+ return c;
+ };
+
+ Tokenizer.prototype.rewind = function() {
+ this.index -= 1;
+ this.column -= 1;
+ if (this.input.charAt(this.index) === "\n") {
+ this.line -= 1;
+ return this.column = this.last_column;
+ }
+ };
+
+ Tokenizer.prototype.next = function() {
+ var c, code;
+ if (this.buffer.length > 0) {
+ return this.buffer.splice(0, 1)[0];
+ }
+ while (true) {
+ if (this.index >= this.input.length) {
+ return null;
+ }
+ c = this.nextChar();
+ code = c.charCodeAt(0);
+ if (code > 32 && code !== 160) {
+ break;
+ }
+ }
+ this.token_start = this.index - 1;
+ if (this.doubles[c] != null) {
+ return this.parseDouble(c, this.doubles[c]);
+ }
+ if (this.chars[c] != null) {
+ return new Token(this, this.chars[c], c);
+ }
+ if (c === "!") {
+ return this.parseUnequals(c);
+ } else if (code >= 48 && code <= 57) {
+ return this.parseNumber(c);
+ } else if ((code >= 65 && code <= 90) || (code >= 97 && code <= 122) || code === 95 || this.letter_regex.test(c)) {
+ return this.parseIdentifier(c);
+ } else if (c === '"') {
+ return this.parseString(c, '"');
+ } else if (c === "'") {
+ return this.parseString(c, "'");
+ } else {
+ return this.error("Syntax Error");
+ }
+ };
+
+ Tokenizer.prototype.changeNumberToIdentifier = function() {
+ var i, j, ref, results, token, v;
+ token = this.next();
+ if ((token != null) && token.type === Token.TYPE_NUMBER) {
+ v = token.string_value.split(".");
+ results = [];
+ for (i = j = ref = v.length - 1; j >= 0; i = j += -1) {
+ if (v[i].length > 0) {
+ this.pushBack(new Token(this, Token.TYPE_IDENTIFIER, v[i]));
+ }
+ if (i > 0) {
+ results.push(this.pushBack(new Token(this, Token.TYPE_DOT, ".")));
+ } else {
+ results.push(void 0);
+ }
+ }
+ return results;
+ } else if ((token != null) && token.type === Token.TYPE_STRING) {
+ return this.pushBack(new Token(this, Token.TYPE_IDENTIFIER, token.value));
+ } else {
+ return this.pushBack(token);
+ }
+ };
+
+ Tokenizer.prototype.parseDouble = function(c, d) {
+ if ((this.shifts[c] != null) && this.index < this.input.length && this.input.charAt(this.index) === c) {
+ this.nextChar();
+ return new Token(this, this.shifts[c], c + c);
+ } else if (this.index < this.input.length && this.input.charAt(this.index) === "=") {
+ this.nextChar();
+ return new Token(this, d[1], c + "=");
+ } else {
+ return new Token(this, d[0], c);
+ }
+ };
+
+ Tokenizer.prototype.parseEquals = function(c) {
+ if (this.index < this.input.length && this.input.charAt(this.index) === "=") {
+ this.nextChar();
+ return new Token(this, Token.TYPE_DOUBLE_EQUALS, "==");
+ } else {
+ return new Token(this, Token.TYPE_EQUALS, "=");
+ }
+ };
+
+ Tokenizer.prototype.parseGreater = function(c) {
+ if (this.index < this.input.length && this.input.charAt(this.index) === "=") {
+ this.nextChar();
+ return new Token(this, Token.TYPE_GREATER_OR_EQUALS, ">=");
+ } else {
+ return new Token(this, Token.TYPE_GREATER_OR_EQUALS, ">");
+ }
+ };
+
+ Tokenizer.prototype.parseLower = function(c) {
+ if (this.index < this.input.length && this.input.charAt(this.index) === "=") {
+ this.nextChar();
+ return new Token(this, Token.TYPE_LOWER_OR_EQUALS, "<=");
+ } else {
+ return new Token(this, Token.TYPE_LOWER, "<");
+ }
+ };
+
+ Tokenizer.prototype.parseUnequals = function(c) {
+ if (this.index < this.input.length && this.input.charAt(this.index) === "=") {
+ this.nextChar();
+ return new Token(this, Token.TYPE_UNEQUALS, "!=");
+ } else {
+ return this.error("Expected inequality !=");
+ }
+ };
+
+ Tokenizer.prototype.parseIdentifier = function(s) {
+ var c, code;
+ while (true) {
+ if (this.index >= this.input.length) {
+ return new Token(this, Token.TYPE_IDENTIFIER, s);
+ }
+ c = this.nextChar();
+ code = c.charCodeAt(0);
+ if ((code >= 65 && code <= 90) || (code >= 97 && code <= 122) || code === 95 || (code >= 48 && code <= 57) || this.letter_regex.test(c)) {
+ s += c;
+ } else {
+ this.rewind();
+ return new Token(this, Token.TYPE_IDENTIFIER, s);
+ }
+ }
+ };
+
+ Tokenizer.prototype.parseNumber = function(s) {
+ var c, code, exp, pointed;
+ pointed = false;
+ exp = false;
+ while (true) {
+ if (this.index >= this.input.length) {
+ return new Token(this, Token.TYPE_NUMBER, Number.parseFloat(s), s);
+ }
+ c = this.nextChar();
+ code = c.charCodeAt(0);
+ if (c === "." && !pointed && !exp) {
+ pointed = true;
+ s += c;
+ } else if (code >= 48 && code <= 57) {
+ s += c;
+ } else if ((c === "e" || c === "E") && !exp && this.index < this.input.length) {
+ exp = true;
+ s += c;
+ c = this.nextChar();
+ if (c === "+" || c === "-") {
+ s += c;
+ } else {
+ this.rewind();
+ }
+ } else if ((c === "x" || c === "X") && s === "0") {
+ return this.parseHexNumber("0x");
+ } else {
+ this.rewind();
+ return new Token(this, Token.TYPE_NUMBER, Number.parseFloat(s), s);
+ }
+ }
+ };
+
+ Tokenizer.prototype.parseHexNumber = function(s) {
+ var c;
+ while (true) {
+ if (this.index >= this.input.length) {
+ return new Token(this, Token.TYPE_NUMBER, Number.parseInt(s), s);
+ }
+ c = this.nextChar();
+ if (/[a-fA-F0-9]/.test(c)) {
+ s += c;
+ } else {
+ this.rewind();
+ return new Token(this, Token.TYPE_NUMBER, Number.parseInt(s), s);
+ }
+ }
+ };
+
+ Tokenizer.prototype.parseString = function(s, close) {
+ var c, code, count_close, n;
+ if (close == null) {
+ close = '"';
+ }
+ if (close === '"') {
+ if (this.input.charAt(this.index) === '"' && this.input.charAt(this.index + 1) === '"' && this.input.charAt(this.index + 2) !== '"') {
+ close = '"""';
+ this.nextChar(true);
+ this.nextChar(true);
+ }
+ }
+ count_close = 0;
+ while (true) {
+ if (this.index >= this.input.length) {
+ return this.error("Unclosed string value");
+ }
+ c = this.nextChar(true);
+ code = c.charCodeAt(0);
+ if (c === "\\") {
+ n = this.nextChar(true);
+ switch (n) {
+ case "n":
+ s += "\n";
+ break;
+ case "\\":
+ s += "\\";
+ break;
+ case close:
+ s += close;
+ break;
+ default:
+ s += "\\" + n;
+ }
+ } else if (c === close) {
+ n = this.nextChar(true);
+ if (n === close) {
+ s += c;
+ } else {
+ this.rewind();
+ s += c;
+ return new Token(this, Token.TYPE_STRING, s.substring(1, s.length - 1));
+ }
+ } else {
+ if (close === '"""' && c === '"') {
+ count_close += 1;
+ if (count_close === 3) {
+ return new Token(this, Token.TYPE_STRING, s.substring(1, s.length - 2));
+ }
+ } else {
+ count_close = 0;
+ }
+ s += c;
+ }
+ }
+ };
+
+ Tokenizer.prototype.error = function(s) {
+ throw s;
+ };
+
+ return Tokenizer;
+
+})();
diff --git a/WebGames-master/WebGames-master/games/cap/transpiler.js b/WebGames-master/WebGames-master/games/cap/transpiler.js
new file mode 100644
index 00000000..8395cfc1
--- /dev/null
+++ b/WebGames-master/WebGames-master/games/cap/transpiler.js
@@ -0,0 +1,244 @@
+var Transpiler;
+
+Transpiler = (function() {
+ function Transpiler() {}
+
+ Transpiler.prototype.transpile = function(r) {
+ var i, j, l, op, ref, results;
+ results = [];
+ for (i = l = 0, ref = r.opcodes.length - 1; l <= ref; i = l += 1) {
+ op = OPCODES[r.opcodes[i]];
+ if (this.transpilable(op, r.arg1[i])) {
+ j = i + 1;
+ while (j < r.opcodes.length && r.removeable(j) && this.transpilable(OPCODES[r.opcodes[j]], r.arg1[j])) {
+ j += 1;
+ }
+ j -= 1;
+ if (j - i >= 2) {
+ results.push(this.transpileSegment(r, i, j));
+ } else {
+ results.push(void 0);
+ }
+ } else {
+ results.push(void 0);
+ }
+ }
+ return results;
+ };
+
+ Transpiler.prototype.transpileSegment = function(r, i, j) {
+ var comp, err, index, k, l, m, ref, ref1, ref2, ref3, s;
+ this.vcount = 0;
+ this.stack = new Stack();
+ this.locals = {};
+ this.variables = {};
+ s = "f = function(stack,stack_index,locals,locals_offset,object,global) {\n";
+ for (k = l = ref = i, ref1 = j; l <= ref1; k = l += 1) {
+ console.info(OPCODES[r.opcodes[k]] + " " + r.arg1[k]);
+ comp = this[OPCODES[r.opcodes[k]]](r.arg1[k]);
+ if (comp) {
+ s += comp + "\n";
+ }
+ }
+ for (index in this.stack.touched) {
+ if (this.stack.touched[index]) {
+ if (index < 0) {
+ s += "stack[stack_index-" + (Math.abs(index)) + "] = " + this.stack.stack[index] + " ;\n";
+ } else if (index > 0) {
+ s += "stack[stack_index+" + index + "] = " + this.stack.stack[index] + " ;\n";
+ } else {
+ s += "stack[stack_index] = " + this.stack.stack[index] + " ;\n";
+ }
+ }
+ }
+ if (this.stack.index < 0) {
+ s += "stack_index -= " + (Math.abs(this.stack.index)) + " ;\n";
+ } else if (this.stack.index > 0) {
+ s += "stack_index += " + this.stack.index + " ;\n";
+ }
+ s += "return stack_index ;\n}";
+ console.info(s);
+ try {
+ eval(s);
+ } catch (error) {
+ err = error;
+ console.error(s);
+ console.error(err);
+ }
+ r.opcodes[i] = 200;
+ r.arg1[i] = f;
+ for (k = m = ref2 = i + 1, ref3 = j; m <= ref3; k = m += 1) {
+ r.remove(i + 1);
+ }
+ };
+
+ Transpiler.prototype.createVariable = function() {
+ return "v" + (this.vcount++);
+ };
+
+ Transpiler.prototype.transpilable = function(op, arg) {
+ var ref;
+ if (op === "LOAD_VALUE") {
+ return (ref = typeof arg) === "string" || ref === "number";
+ } else {
+ return this[op] != null;
+ }
+ };
+
+ Transpiler.prototype.LOAD_VALUE = function(arg) {
+ if (typeof arg === "string") {
+ this.stack.push(" \"" + (arg.replace(/"/g, "\\\"")) + "\" ");
+ } else if (typeof arg === "number") {
+ this.stack.push(arg + "");
+ }
+ return "";
+ };
+
+ Transpiler.prototype.LOAD_LOCAL = function(arg) {
+ var v;
+ v = this.createVariable();
+ this.stack.push(v);
+ return "let " + v + " = locals[locals_offset+" + arg + "] ; // LOAD_LOCAL";
+ };
+
+ Transpiler.prototype.LOAD_LOCAL_OBJECT = function(arg) {
+ var res, v;
+ if (this.locals[arg] != null) {
+ v = this.locals[arg];
+ this.stack.push(v);
+ return "if (typeof " + v + " != \"object\") { " + v + " = locals[locals_offset+" + arg + "] = {} } ;";
+ } else {
+ v = this.createVariable();
+ res = "let " + v + " = locals[locals_offset+" + arg + "] ;\nif (typeof " + v + " != \"object\") { " + v + " = locals[locals_offset+" + arg + "] = {} } ;";
+ this.stack.push(v);
+ this.locals[arg] = v;
+ return res;
+ }
+ };
+
+ Transpiler.prototype.STORE_LOCAL = function(arg) {
+ var v;
+ v = this.stack.get();
+ return "locals[locals_offset+" + arg + "] = " + v + " ; // STORE_LOCAL";
+ };
+
+ Transpiler.prototype.POP = function() {
+ this.stack.pop();
+ return "";
+ };
+
+ Transpiler.prototype.CREATE_PROPERTY = function(arg) {
+ var res;
+ res = (this.stack.get(-2)) + "[" + (this.stack.get(-1)) + "] = " + (this.stack.get()) + " ;";
+ this.stack.pop();
+ this.stack.pop();
+ return res;
+ };
+
+ Transpiler.prototype.LOAD_PROPERTY = function(arg) {
+ var res, v;
+ v = this.createVariable();
+ res = "let " + v + " = " + (this.stack.get(-1)) + "[" + (this.stack.get()) + "] ; // LOAD_PROPERTY\nif (" + v + " == null) { " + v + " = 0 ; }";
+ this.stack.pop();
+ this.stack.pop();
+ this.stack.push(v);
+ return res;
+ };
+
+ Transpiler.prototype.LOAD_PROPERTY_ATOP = function(arg) {
+ var res, v;
+ v = this.createVariable();
+ res = "let " + v + " = " + (this.stack.get(-1)) + "[" + (this.stack.get()) + "] ; // LOAD_PROPERTY_ATOP\nif (" + v + " == null) { " + v + " = 0 ; }";
+ this.stack.push(v);
+ return res;
+ };
+
+ Transpiler.prototype.NEW_OBJECT = function() {
+ var v;
+ v = this.createVariable();
+ this.stack.push(v);
+ return "let " + v + " = {} ;";
+ };
+
+ Transpiler.prototype.NEW_ARRAY = function() {
+ var v;
+ v = this.createVariable();
+ this.stack.push(v);
+ return "let " + v + " = [] ;";
+ };
+
+ Transpiler.prototype.MAKE_OBJECT = function() {
+ var res, v;
+ v = this.createVariable();
+ res = "let " + v + " = " + (this.stack.get()) + " ;\nif (typeof " + v + " != \"object\") " + v + " = {} ; ";
+ this.stack.pop();
+ this.stack.push(v);
+ return res;
+ };
+
+ Transpiler.prototype.STORE_VARIABLE = function(arg) {
+ if (this.variables[arg] != null) {
+ return this.variables[arg] + " = object[\"" + arg + "\"] = " + (this.stack.get()) + " ; // STORE_VARIABLE";
+ } else {
+ return "object[\"" + arg + "\"] = " + (this.stack.get()) + " ; // STORE_VARIABLE";
+ }
+ };
+
+ Transpiler.prototype.STORE_PROPERTY = function(arg) {
+ var res, v;
+ v = this.createVariable();
+ res = "let " + v + " = " + (this.stack.get(-2)) + "[" + (this.stack.get(-1)) + "] = " + (this.stack.get(0)) + " ; // STORE_PROPERTY";
+ this.stack.pop();
+ this.stack.pop();
+ this.stack.pop();
+ this.stack.push(v);
+ return res;
+ };
+
+ return Transpiler;
+
+})();
+
+this.Stack = (function() {
+ function Stack() {
+ this.stack = ["stack[stack_index]"];
+ this.index = 0;
+ this.touched = {};
+ }
+
+ Stack.prototype.push = function(value) {
+ this.stack[++this.index] = value;
+ return this.touched[this.index] = true;
+ };
+
+ Stack.prototype.pop = function() {
+ var res;
+ if (this.index >= 0) {
+ res = this.stack.splice(this.index, 1)[0];
+ } else if (this.stack[this.index] != null) {
+ res = this.stack[this.index];
+ } else {
+ res = "stack[stack_index-" + this.index + "]";
+ }
+ this.index -= 1;
+ return res;
+ };
+
+ Stack.prototype.get = function(index) {
+ var i;
+ if (index == null) {
+ index = 0;
+ }
+ i = this.index + index;
+ if (i >= 0) {
+ return this.stack[i];
+ } else if (this.stack[i] != null) {
+ return this.stack[i];
+ } else {
+ return "stack[stack_index-" + (-i) + "]";
+ }
+ };
+
+ return Stack;
+
+})();
diff --git a/ba.html b/ba.html
index afa97f15..70416680 100644
--- a/ba.html
+++ b/ba.html
@@ -8,6 +8,10 @@
else { window.location="https://fun-miles-4jub.onrender.com/404";
}
-this is for the bata testers
+
+ new test
+ Gladihoppers-gh
+
this wont look good because its beta testers eyes only
+