Added Scripting Stuff for Host

Author: jabbany

src/scripting/Host.js

@@ -230,7 +230,9 @@ var CCLScripting = function(workerUrl){
 		this.resetWorker = function(){
 			try{
 				worker.terminate();
-			}catch(e){}
+			} catch(e) {
+
+      }
 			worker = scripter.getWorker();
 			if(!worker){
 				throw new Error("SANDBOX: Worker pool exhausted.");

src/scripting/api/Display/Bitmap.ts

@@ -3,6 +3,42 @@
 
 module Display {
 
+  class DirtyArea {
+    private _xBegin:number = null;
+    private _yBegin:number = null;
+    private _xEnd:number = null;
+    private _yEnd:number = null;
+
+    public expand(x:number, y:number) {
+      this._xBegin = this._xBegin === null ? x : Math.min(this._xBegin, x);
+      this._xEnd = this._xEnd === null ? x : Math.max(this._xEnd, x);
+      this._yBegin = this._yBegin === null ? y :Math.min(this._yBegin, y);
+      this._yEnd = this._xEnd === null ? y :Math.max(this._yEnd, y);
+    }
+
+    public asRect():Rectangle {
+      if (this.isEmpty()) {
+        return new Rectangle(0, 0, 0, 0);
+      }
+      return new Rectangle(this._xBegin,
+        this._yBegin,
+        this._xEnd - this._xBegin,
+        this._yEnd - this._yBegin);
+    }
+
+    public isEmpty():boolean {
+      return this._xBegin === null || this._yBegin === null ||
+        this._xEnd === null || this._yEnd === null;
+    }
+
+    public reset():void {
+      this._xBegin = null;
+      this._xEnd = null;
+      this._yBegin = null;
+      this._yEnd = null;
+    }
+  }
+
   /**
    * Bitmap AS3 Polyfill class
    * Note: This is NOT equivalent to the Bitmap library class of the same name!
@@ -71,16 +107,21 @@ module Display {
    * @author Jim Chen
    */
   export class BitmapData {
+    private _id:string;
     private _rect:Rectangle;
+    private _locked:boolean = false;
+    private _dirtyArea:DirtyArea;
     private _transparent:boolean;
     private _fillColor:number;
     private _byteArray:Array<number>;
 
     constructor(width:number,
       height:number,
       transparent:boolean = true,
-      fillColor:number = 0xffffffff) {
+      fillColor:number = 0xffffffff,
+      id:string = Runtime.generateId()) {
 
+      this._id = id;
       this._rect = new Rectangle(0, 0, width, height);
       this._transparent = transparent;
       this._fillColor = fillColor;
@@ -94,6 +135,50 @@ module Display {
       }
     }
 
+    private _updateBox(changeRect:Rectangle = null):void {
+      if (this._dirtyArea.isEmpty()) {
+        // Don't update anything if nothing was changed
+        return;
+      }
+      if (this._locked) {
+        // Don't send updates if this is locked
+        return;
+      }
+      var change:Rectangle = changeRect === null ? this._dirtyArea.asRect() :
+        changeRect;
+
+      // Make sure we're not out-of-bounds
+      if (!this._rect.containsRect(change)) {
+        __trace('', 'err');
+        throw new Error('Rectangle provided was not within image bounds.');
+      }
+      // Extract the values
+      var region:Array<number> = [];
+      for (var i = 0; i < change.height; i++) {
+        for (var j = 0; j < change.width; j++) {
+          region.push(this._byteArray[(change.y + i) * this._rect.width +
+              change.x + j]);
+        }
+      }
+
+      __pchannel('Runtime:CallMethod', {
+        'id': this.getId(),
+        'name': 'updateBox',
+        'value': {
+          'box': change.serialize(),
+          'values': values
+        },
+      });
+    }
+
+    private _call(method:string, arguments:any):void {
+      __pchannel('Runtime:CallMethod', {
+        'id': this.getId(),
+        'name': name,
+        'value': arguments,
+      });
+    }
+
     get height():number {
       return this._rect.height;
     }
@@ -162,6 +247,7 @@ module Display {
         color = color & 0xffffffff;
       }
       this._byteArray[y * this._rect.width + x] = color;
+      this._dirtyArea.expand(x, y);
     }
 
     public setPixels(rect:Rectangle, input:Array<number>):void {
@@ -177,10 +263,28 @@ module Display {
         for (var j = 0; j < rect.height; j++) {
           this._byteArray[(rect.y + j) * this.width + (rect.x + i)] =
             input[j * rect.width + i];
+            this._dirtyArea.expand(i, j);
         }
       }
     }
 
+    public lock():void {
+      this._locked = true;
+    }
+
+    public unlock(changeRect:Rectangle = null):void {
+      this._locked = false;
+      if (changeRect == null) {
+        this._updateBox();
+      } else {
+        this._updateBox(changeRect);
+      }
+    }
+
+    public getId():string {
+      return this._id;
+    }
+
     public serialize():Object {
       return {
         'class':'BitmapData'

src/scripting/api/Player/Player.ts

@@ -156,7 +156,12 @@ module Player{
   }
 
   export function keyTrigger(callback:Function, timeout:number):void{
-
+    if (!Runtime.hasObject('__player')) {
+      __trace('Your environment does not support key triggers.', 'warn');
+      return;
+    }
+    var player:Runtime.Listenable = <Runtime.Listenable>
+      Runtime.getObject('__player');
   }
 
   export function setMask(mask:any):void{

src/scripting/api/Runtime.d.ts

@@ -54,6 +54,19 @@ declare module Runtime {
   function privilegedCode(): void;
 }
 declare module Runtime {
+  interface Listenable {
+    addEventListener(
+      event:string,
+      listener:Function,
+      useCapture:boolean,
+      priority:number):void;
+    removeEventListener(
+      event:string,
+      listener:Function,
+      useCapture:boolean
+    ):void;
+    hasEventListener(event:string):boolean;
+  }
   interface RegisterableObject {
     getId():string;
     dispatchEvent(event:string, data?:any):void;
@@ -70,9 +83,9 @@ declare module Runtime {
   /**
   * Gets the object registered by id
   * @param objectId - objectid of object
-  * @returns {any} - object or undefined if not found
+  * @returns {RegisterableObject} - object or undefined if not found
   */
-  function getObject(objectId: string): any;
+  function getObject(objectId: string): RegisterableObject;
   /**
   * Registers an object to allow two way communication between the API
   * and the host.

src/scripting/api/Runtime/NotCrypto.ts

@@ -0,0 +1,66 @@
+/**
+ * Crypto-like wrappers that have no actual guarantees of safety.
+ * These are just around to provide common interfaces since the sandbox may be
+ * running in different environments.
+ *
+ * If safety is required, please use something else.
+ */
+module Runtime.NotCrypto {
+  class Rc4 {
+    private _s:number[] = [];
+    constructor (key:number[]) {
+      for (var i = 0; i < 256; i++) {
+        this._s[i] = i;
+      }
+      var j = 0;
+      for (var i = 0; i < 256; i++) {
+        j = j + this._s[i] + key[i % key.length] % 256;
+        var m = this._s[i];
+        this._s[i] = this._s[j];
+        this._s[j] = m;
+      }
+    }
+  }
+
+  /**
+   * (UNSAFE) Random value generator.
+   * @param {number} bits - number of bits of randomness requested
+   * @returns {number} a number within requested number of bits
+   */
+  export function random(bits:number = 16):number {
+    // Use Math.random for this if it exists
+    if (Math && Math.random) {
+      var value:number = 0;
+      for (var i = 0; i < bits; i++) {
+        value = (value << 1) + (Math.random() < 0.5 ? 0 : 1);
+      }
+      return value;
+    } else {
+      return Runtime.NotCrypto.fallbackRandom([Date.now() % 1024]);
+    }
+  }
+
+  /**
+   * Generates a some randomness
+   */
+  export function fallbackRandom(seed:number[], bits:number = 16):number {
+    return ;
+  }
+
+  /**
+   * Transforms an integer to a hex value.
+   * @param {number} value - value to transform
+   * @param {number} length - how many hex digits to use. 0 means no prefixed 0s
+   * @return {string} hex value
+   */
+  export function toHex(value:number, length:number = 0):string {
+    if (length <= 0) {
+      return value.toString(16);
+    }
+    var base:string = value.toString(16);
+    while (base.length < length) {
+      base = '0' + base;
+    }
+    return base;
+  }
+}

src/scripting/api/Runtime/Runtime.ts

@@ -47,6 +47,9 @@ module Runtime {
     private _listeners:{[name:string]: Array<Function>} = {};
 
     constructor(name:string) {
+      if (name.slice(0, 2) !== '__') {
+        throw new Error('MetaObject names must start with two underscores.');
+      }
       this._name = name;
     }
 
@@ -103,6 +106,7 @@ module Runtime {
   }
 
   /** Variables **/
+  // objCount is uniformly increasing to make object names unique
   var objCount:number = 0;
   var _registeredObjects:ObjectRegistry = {
     '__self': new MetaObject('__self'),
@@ -149,9 +153,9 @@ module Runtime {
   /**
    * Gets the object registered by id
    * @param {string} objectId - objectid of object
-   * @returns {any} - object or undefined if not found
+   * @returns {RegisterableObject} - object or undefined if not found
    */
-  export function getObject(objectId:string):any{
+  export function getObject(objectId:string):RegisterableObject{
     return _registeredObjects[objectId];
   }
 
@@ -162,25 +166,26 @@ module Runtime {
    */
   export function registerObject(object:RegisterableObject):void{
     if (!object.getId) {
-      __trace("Attempted to register unnamed object", "warn");
+      __trace('Cannot register object without getId method.','warn');
       return;
     }
     if (!Runtime.hasObject(object.getId())) {
       _registeredObjects[object.getId()] = object;
-      __pchannel("Runtime:RegisterObject", {
-        "id": object.getId(),
-        "data": object.serialize()
+      __pchannel('Runtime:RegisterObject', {
+        'id': object.getId(),
+        'data': object.serialize()
       });
       __schannel("object::(" + object.getId() + ")",  (payload:any) => {
-        if (payload.hasOwnProperty("type") &&
-          payload.type === "event") {
+        if (payload.hasOwnProperty('type') &&
+          payload.type === 'event') {
           _dispatchEvent(object.getId(), payload.event, payload.data);
         }
       });
       objCount++;
       return;
     } else {
-      __trace('Attempted to re-register object or id collision', 'warn');
+      __trace('Attempted to re-register object or id collision @ ' +
+        object.getId(), 'warn');
       return;
     }
   }
@@ -194,33 +199,39 @@ module Runtime {
    */
   export function deregisterObject(objectId:string):void {
     if (Runtime.hasObject(objectId)) {
-      if (objectId.substr(0,2) === "__") {
-        __trace("Runtime.deregisterObject cannot de-register a MetaObject","warn");
+      if (objectId.substr(0,2) === '__') {
+        __trace('Runtime.deregisterObject cannot de-register a MetaObject',
+          'warn');
         return;
       }
-      __pchannel("Runtime:DeregisterObject", {
-        "id": objectId
+      __pchannel('Runtime:DeregisterObject', {
+        'id': objectId
       });
       if (typeof _registeredObjects[objectId].unload === "function") {
         // Gracefully unload first
         _registeredObjects[objectId].unload();
       }
       _registeredObjects[objectId] = null;
       delete _registeredObjects[objectId];
-      objCount--;
     }
   }
 
+  function _getId(type:string = 'obj', container:string = 'rt'):string {
+    var randomSeed:number = Math.random()
+    var randomSegment:string = '';
+    return;
+  }
+
   /**
    * Generates an objectid that isn't registered
    * @param {string} type - object type
    * @returns {string} - objectid that has not been registered
    */
   export function generateId(type:string = "obj"):string {
-    var id:string = type + ":" + (new Date()).getTime() + "|" +
-      Math.round(Math.random() * 4096) + ":" + objCount;
+    var id:string = [type, ':', Date.now(), '|',
+      Math.round(Math.random() * 4096), ':', objCount].join();
     while (Runtime.hasObject(id)) {
-      id = type + ":" + (new Date()).getTime() + "|" +
+      id = type + ":" + Date.now() + "|" +
         Math.round(Math.random() * 4096) + ":" + objCount;
     }
     return id;
@@ -254,7 +265,7 @@ module Runtime {
   }
 
   /**
-   * Invoke termination of script
+   * Invoke termination of script from outside the sandbox
    */
   export function crash():void {
     __trace("Runtime.crash() : Manual crash", "fatal");