view/trunk/jgame.js

///<reference path="all.ts"/>
///<reference path="all.ts"/>
var jg;
(function (jg) {
    (function (Angle) {
        Angle[Angle["Unknown"] = 0] = "Unknown";
        Angle[Angle["Left"] = 1] = "Left";
        Angle[Angle["Right"] = 2] = "Right";
        Angle[Angle["Up"] = 3] = "Up";
        Angle[Angle["Down"] = 4] = "Down";
    })(jg.Angle || (jg.Angle = {}));
    var Angle = jg.Angle;
    (function (RenderTransferMode) {
        RenderTransferMode[RenderTransferMode["Unknown"] = 0] = "Unknown";
        RenderTransferMode[RenderTransferMode["Transfer"] = 1] = "Transfer";
        RenderTransferMode[RenderTransferMode["Flip"] = 2] = "Flip";
        RenderTransferMode[RenderTransferMode["Direct"] = 3] = "Direct";
    })(jg.RenderTransferMode || (jg.RenderTransferMode = {}));
    var RenderTransferMode = jg.RenderTransferMode;
    (function (InputEventType) {
        InputEventType[InputEventType["Unknown"] = 0] = "Unknown";
        InputEventType[InputEventType["Keyboard"] = 1] = "Keyboard";
        InputEventType[InputEventType["Point"] = 2] = "Point";
    })(jg.InputEventType || (jg.InputEventType = {}));
    var InputEventType = jg.InputEventType;
    (function (InputEventAction) {
        InputEventAction[InputEventAction["Unknown"] = 0] = "Unknown";
        InputEventAction[InputEventAction["Down"] = 1] = "Down";
        InputEventAction[InputEventAction["Move"] = 2] = "Move";
        InputEventAction[InputEventAction["Up"] = 3] = "Up";
    })(jg.InputEventAction || (jg.InputEventAction = {}));
    var InputEventAction = jg.InputEventAction;
    (function (Keytype) {
        Keytype[Keytype["Unknown"] = 0] = "Unknown";
        Keytype[Keytype["Left"] = 1] = "Left";
        Keytype[Keytype["Right"] = 2] = "Right";
        Keytype[Keytype["Up"] = 3] = "Up";
        Keytype[Keytype["Down"] = 4] = "Down";
        Keytype[Keytype["Enter"] = 5] = "Enter";
        Keytype[Keytype["Esc"] = 6] = "Esc";
    })(jg.Keytype || (jg.Keytype = {}));
    var Keytype = jg.Keytype;
    (function (ShapeStyle) {
        ShapeStyle[ShapeStyle["Unknown"] = 0] = "Unknown";
        ShapeStyle[ShapeStyle["Stroke"] = 1] = "Stroke";
        ShapeStyle[ShapeStyle["Fill"] = 2] = "Fill";
    })(jg.ShapeStyle || (jg.ShapeStyle = {}));
    var ShapeStyle = jg.ShapeStyle;
    (function (ShapeType) {
        ShapeType[ShapeType["Unknown"] = 0] = "Unknown";
        ShapeType[ShapeType["Rect"] = 1] = "Rect";
        ShapeType[ShapeType["Arc"] = 2] = "Arc";
    })(jg.ShapeType || (jg.ShapeType = {}));
    var ShapeType = jg.ShapeType;
    (function (EffectType) {
        EffectType[EffectType["None"] = 0] = "None";
        EffectType[EffectType["Fade"] = 1] = "Fade";
        EffectType[EffectType["Mosaic"] = 2] = "Mosaic";
        EffectType[EffectType["Blur"] = 3] = "Blur";
        EffectType[EffectType["SlideUp"] = 4] = "SlideUp";
        EffectType[EffectType["SlideDown"] = 5] = "SlideDown";
        EffectType[EffectType["SlideLeft"] = 6] = "SlideLeft";
        EffectType[EffectType["SlideRight"] = 7] = "SlideRight";
        EffectType[EffectType["WipeUp"] = 8] = "WipeUp";
        EffectType[EffectType["WipeDown"] = 9] = "WipeDown";
        EffectType[EffectType["WipeLeft"] = 10] = "WipeLeft";
        EffectType[EffectType["WipeRight"] = 11] = "WipeRight";
        EffectType[EffectType["WipeFadeUp"] = 12] = "WipeFadeUp";
        EffectType[EffectType["WipeFadeDown"] = 13] = "WipeFadeDown";
        EffectType[EffectType["WipeFadeLeft"] = 14] = "WipeFadeLeft";
        EffectType[EffectType["WipeFadeRight"] = 15] = "WipeFadeRight";
        EffectType[EffectType["BoxOut"] = 16] = "BoxOut";
        EffectType[EffectType["BoxOut45"] = 17] = "BoxOut45";
        EffectType[EffectType["BoxIn"] = 18] = "BoxIn";
        EffectType[EffectType["BoxIn45"] = 19] = "BoxIn45";
        EffectType[EffectType["ArcOut"] = 20] = "ArcOut";
        EffectType[EffectType["ArcIn"] = 21] = "ArcIn";
    })(jg.EffectType || (jg.EffectType = {}));
    var EffectType = jg.EffectType;
})(jg || (jg = {}));
///<reference path="all.ts"/>
if (!window.requestAnimationFrame) {
    window.requestAnimationFrame =
        window["mozRequestAnimationFrame"] ||
            window["webkitRequestAnimationFrame"] ||
            window["msRequestAnimationFrame"] ||
            (function () {
                var lastTime = Date.now ? Date.now() : new Date().getTime();
                var frame = 1000 / 60;
                return function (func) {
                    var currentTime = Date.now ? Date.now() : new Date().getTime();
                    var _id = setTimeout(function () {
                        func(Date.now ? Date.now() : new Date().getTime());
                    }, Math.max(0, lastTime + frame - currentTime));
                    lastTime = currentTime;
                    return _id;
                };
            }());
}
window.createCanvas = function (width, height) {
    var canvas = document.createElement("canvas");
    canvas.width = width;
    canvas.height = height;
    if ("imageSmoothingEnabled" in window) {
        var browser = jg.JGUtil.getBrowser();
        if (browser.opera) {
            canvas.style["imageRendering"] = "-o-crisp-edges";
        }
        else if (browser.msie) {
            canvas.style["msInterpolationMode"] = "nearest-neighbor";
        }
        else if (browser.safari) {
            canvas.style["imageRendering"] = "-webkit-optimize-contrast";
        }
        var context = canvas.getContext("2d");
        if (context["imageSmoothingEnabled"])
            context["imageSmoothingEnabled"] = false;
        if (context["webkitImageSmoothingEnabled"])
            context["webkitImageSmoothingEnabled"] = false;
        if (context["mozImageSmoothingEnabled"])
            context["mozImageSmoothingEnabled"] = false;
    }
    return canvas;
};
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var Rectangle = (function () {
        function Rectangle(left, top, right, bottom) {
            this.left = left;
            this.top = top;
            this.right = right;
            this.bottom = bottom;
        }
        Rectangle.prototype.hitTest = function (point) {
            return (this.left <= point.x && this.right >= point.x && this.top <= point.y && this.bottom >= point.y);
        };
        Rectangle.prototype.fit = function (point) {
            if (point.y < this.top)
                point.y = this.top;
            else if (point.y > this.bottom)
                point.y = this.bottom;
            if (point.x < this.left)
                point.x = this.left;
            else if (point.x > this.right)
                point.x = this.right;
        };
        Rectangle.prototype.width = function () {
            return Math.abs(this.right - this.left);
        };
        Rectangle.prototype.height = function () {
            return Math.abs(this.bottom - this.top);
        };
        return Rectangle;
    })();
    jg.Rectangle = Rectangle;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var Easing = (function () {
        function Easing() {
        }
        Easing.LINEAR = function (t, b, c, d) {
            return c * t / d + b;
        };
        Easing.SWING = function (t, b, c, d) {
            return c * (0.5 - Math.cos(((t / d) * Math.PI)) / 2) + b;
        };
        Easing.QUAD_EASEIN = function (t, b, c, d) {
            return c * (t /= d) * t + b;
        };
        Easing.QUAD_EASEOUT = function (t, b, c, d) {
            return -c * (t /= d) * (t - 2) + b;
        };
        Easing.QUAD_EASEINOUT = function (t, b, c, d) {
            if ((t /= d / 2) < 1) {
                return c / 2 * t * t + b;
            }
            return -c / 2 * ((--t) * (t - 2) - 1) + b;
        };
        Easing.CUBIC_EASEIN = function (t, b, c, d) {
            return c * (t /= d) * t * t + b;
        };
        Easing.CUBIC_EASEOUT = function (t, b, c, d) {
            return c * ((t = t / d - 1) * t * t + 1) + b;
        };
        Easing.CUBIC_EASEINOUT = function (t, b, c, d) {
            if ((t /= d / 2) < 1) {
                return c / 2 * t * t * t + b;
            }
            return c / 2 * ((t -= 2) * t * t + 2) + b;
        };
        Easing.QUART_EASEIN = function (t, b, c, d) {
            return c * (t /= d) * t * t * t + b;
        };
        Easing.QUART_EASEOUT = function (t, b, c, d) {
            return -c * ((t = t / d - 1) * t * t * t - 1) + b;
        };
        Easing.QUART_EASEINOUT = function (t, b, c, d) {
            if ((t /= d / 2) < 1) {
                return c / 2 * t * t * t * t + b;
            }
            return -c / 2 * ((t -= 2) * t * t * t - 2) + b;
        };
        Easing.QUINT_EASEIN = function (t, b, c, d) {
            return c * (t /= d) * t * t * t * t + b;
        };
        Easing.QUINT_EASEOUT = function (t, b, c, d) {
            return c * ((t = t / d - 1) * t * t * t * t + 1) + b;
        };
        Easing.QUINT_EASEINOUT = function (t, b, c, d) {
            if ((t /= d / 2) < 1) {
                return c / 2 * t * t * t * t * t + b;
            }
            return c / 2 * ((t -= 2) * t * t * t * t + 2) + b;
        };
        Easing.SIN_EASEIN = function (t, b, c, d) {
            return -c * Math.cos(t / d * (Math.PI / 2)) + c + b;
        };
        Easing.SIN_EASEOUT = function (t, b, c, d) {
            return c * Math.sin(t / d * (Math.PI / 2)) + b;
        };
        Easing.SIN_EASEINOUT = function (t, b, c, d) {
            return -c / 2 * (Math.cos(Math.PI * t / d) - 1) + b;
        };
        Easing.CIRC_EASEIN = function (t, b, c, d) {
            return -c * (Math.sqrt(1 - (t /= d) * t) - 1) + b;
        };
        Easing.CIRC_EASEOUT = function (t, b, c, d) {
            return c * Math.sqrt(1 - (t = t / d - 1) * t) + b;
        };
        Easing.CIRC_EASEINOUT = function (t, b, c, d) {
            if ((t /= d / 2) < 1) {
                return -c / 2 * (Math.sqrt(1 - t * t) - 1) + b;
            }
            return c / 2 * (Math.sqrt(1 - (t -= 2) * t) + 1) + b;
        };
        Easing.ELASTIC_EASEIN = function (t, b, c, d, a, p) {
            if (t === 0) {
                return b;
            }
            if ((t /= d) === 1) {
                return b + c;
            }
            if (!p) {
                p = d * 0.3;
            }
            var s;
            if (!a || a < Math.abs(c)) {
                a = c;
                s = p / 4;
            }
            else {
                s = p / (2 * Math.PI) * Math.asin(c / a);
            }
            return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;
        };
        Easing.ELASTIC_EASEOUT = function (t, b, c, d, a, p) {
            if (t === 0) {
                return b;
            }
            if ((t /= d) === 1) {
                return b + c;
            }
            if (!p) {
                p = d * 0.3;
            }
            var s;
            if (!a || a < Math.abs(c)) {
                a = c;
                s = p / 4;
            }
            else {
                s = p / (2 * Math.PI) * Math.asin(c / a);
            }
            return (a * Math.pow(2, -10 * t) * Math.sin((t * d - s) * (2 * Math.PI) / p) + c + b);
        };
        Easing.ELASTIC_EASEINOUT = function (t, b, c, d, a, p) {
            if (t === 0) {
                return b;
            }
            if ((t /= d / 2) === 2) {
                return b + c;
            }
            if (!p) {
                p = d * (0.3 * 1.5);
            }
            var s;
            if (!a || a < Math.abs(c)) {
                a = c;
                s = p / 4;
            }
            else {
                s = p / (2 * Math.PI) * Math.asin(c / a);
            }
            if (t < 1) {
                return -0.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;
            }
            return a * Math.pow(2, -10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p) * 0.5 + c + b;
        };
        Easing.BOUNCE_EASEOUT = function (t, b, c, d) {
            if ((t /= d) < (1 / 2.75)) {
                return c * (7.5625 * t * t) + b;
            }
            else if (t < (2 / 2.75)) {
                return c * (7.5625 * (t -= (1.5 / 2.75)) * t + 0.75) + b;
            }
            else if (t < (2.5 / 2.75)) {
                return c * (7.5625 * (t -= (2.25 / 2.75)) * t + 0.9375) + b;
            }
            else {
                return c * (7.5625 * (t -= (2.625 / 2.75)) * t + 0.984375) + b;
            }
        };
        Easing.BOUNCE_EASEIN = function (t, b, c, d) {
            return c - Easing.BOUNCE_EASEOUT(d - t, 0, c, d) + b;
        };
        Easing.BOUNCE_EASEINOUT = function (t, b, c, d) {
            if (t < d / 2) {
                return Easing.BOUNCE_EASEIN(t * 2, 0, c, d) * 0.5 + b;
            }
            else {
                return Easing.BOUNCE_EASEOUT(t * 2 - d, 0, c, d) * 0.5 + c * 0.5 + b;
            }
        };
        Easing.BACK_EASEIN = function (t, b, c, d, s) {
            if (s === undefined) {
                s = 1.70158;
            }
            return c * (t /= d) * t * ((s + 1) * t - s) + b;
        };
        Easing.BACK_EASEOUT = function (t, b, c, d, s) {
            if (s === undefined) {
                s = 1.70158;
            }
            return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;
        };
        Easing.BACK_EASEINOUT = function (t, b, c, d, s) {
            if (s === undefined) {
                s = 1.70158;
            }
            if ((t /= d / 2) < 1) {
                return c / 2 * (t * t * (((s *= (1.525)) + 1) * t - s)) + b;
            }
            return c / 2 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2) + b;
        };
        Easing.EXPO_EASEIN = function (t, b, c, d) {
            return (t === 0) ? b : c * Math.pow(2, 10 * (t / d - 1)) + b;
        };
        Easing.EXPO_EASEOUT = function (t, b, c, d) {
            return (t === d) ? b + c : c * (-Math.pow(2, -10 * t / d) + 1) + b;
        };
        Easing.EXPO_EASEINOUT = function (t, b, c, d) {
            if (t === 0) {
                return b;
            }
            if (t === d) {
                return b + c;
            }
            if ((t /= d / 2) < 1) {
                return c / 2 * Math.pow(2, 10 * (t - 1)) + b;
            }
            return c / 2 * (-Math.pow(2, -10 * --t) + 2) + b;
        };
        return Easing;
    })();
    jg.Easing = Easing;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    jg.ENTITY_OPTIONS_DEFAULT_VALUES = {
        rotate: 0,
        translate: { x: 0, y: 0 },
        transform: { m11: 1, m12: 0, m21: 0, m22: 1, dx: 0, dy: 0 },
        scale: { x: 1, y: 1 },
        purescale: { x: 1, y: 1 },
        globalAlpha: undefined,
        font: undefined,
        fillStyle: undefined,
        strokeStyle: undefined,
        lineCap: undefined,
        lineJoin: undefined,
        lineWidth: undefined,
        miterLimit: undefined,
        shadowBlur: undefined,
        shadowColor: undefined,
        shadowOffsetX: undefined,
        shadowOffsetY: undefined,
        textAlign: undefined,
        textBaseline: undefined,
        globalCompositeOperation: undefined
    };
    var E = (function () {
        function E() {
            this.opacity = 1;
            this.x = 0;
            this.y = 0;
        }
        E.prototype.enablePointingEvent = function () {
            this.pointCapture = true;
            if (!this.pointDown)
                this.pointDown = new jg.Trigger();
            if (!this.pointUp)
                this.pointUp = new jg.Trigger();
            if (!this.pointMove)
                this.pointMove = new jg.Trigger();
        };
        E.prototype.disablePointingEvent = function () {
            delete this.pointCapture;
        };
        E.prototype.removeDrawOption = function (name) {
            if (!this.options)
                return;
            if (this.options[name] !== undefined)
                delete this.options[name];
            var cnt = 0;
            for (var i in this.options) {
                cnt++;
                break;
            }
            if (!cnt)
                delete this.options;
            this.updated();
        };
        E.prototype.setDrawOption = function (name, value) {
            if (!this.options)
                this.options = {};
            this.options[name] = value;
            this.updated();
        };
        E.prototype.getDrawOption = function (name) {
            if (!this.options || this.options[name] == undefined)
                return jg.ENTITY_OPTIONS_DEFAULT_VALUES[name];
            return this.options[name];
        };
        E.prototype.moveTo = function (x, y) {
            this.x = x;
            this.y = y;
            this.updated();
        };
        E.prototype.moveBy = function (x, y) {
            this.x += x;
            this.y += y;
            this.updated();
        };
        E.prototype.scrollTo = function (x, y) {
            this.scroll = {
                x: x,
                y: y
            };
            this.updated();
        };
        E.prototype.scrollBy = function (x, y) {
            if (!this.scroll)
                this.scroll = { x: 0, y: 0 };
            this.scroll.x += x;
            this.scroll.y += y;
            this.updated();
        };
        E.prototype.activate = function () {
            if (this.active_queue) {
                var f;
                while (f = this.active_queue.shift())
                    f.call(this);
                delete this.active_queue;
            }
            if (this.entities) {
                for (var i = 0; i < this.entities.length; i++) {
                    if (!this.entities[i].scene) {
                        this.entities[i].scene = this.scene;
                        this.entities[i].activate();
                    }
                }
            }
        };
        E.prototype.addActiveQueue = function (f) {
            if (this.scene) {
                f.call(this);
                return;
            }
            if (!this.active_queue)
                this.active_queue = [];
            this.active_queue.push(f);
        };
        E.prototype.appendTo = function (scene, layerName) {
            scene.append(this, layerName);
        };
        E.prototype.remove = function () {
            if (this.parent)
                this.parent.removeChild(this);
            else
                throw "Can not remove layer. (use scene.deleteLayer)";
        };
        E.prototype.insert = function (entity, index) {
            if (!this.entities)
                throw "Can not call append of non-container entity";
            entity.scene = this.scene;
            entity.parent = this;
            if (typeof index != "number") {
                for (var i = 0; i < this.entities.length; i++) {
                    if (this.entities[i] == index) {
                        index = i;
                        break;
                    }
                }
            }
            this.entities.splice(index, 0, entity);
            entity.activate();
            this.updated();
        };
        E.prototype.append = function (entity) {
            if (!this.entities)
                throw "Can not call append of non-container entity";
            entity.scene = this.scene;
            entity.parent = this;
            this.entities.push(entity);
            if (this.scene)
                entity.activate();
            this.updated();
        };
        E.prototype.removeChild = function (entity) {
            if (!this.entities)
                throw "Can not call removeChild of non-container entity";
            for (var i = 0; i < this.entities.length; i++) {
                if (this.entities[i] == entity) {
                    if (entity.entities) {
                        var childEntity;
                        while (childEntity = entity.entities.pop())
                            entity.removeChild(childEntity);
                    }
                    this.entities.splice(i, 1);
                    entity.destroy();
                    this.updated();
                    return true;
                }
            }
            return false;
        };
        E.prototype.start = function () {
            if (this.started)
                return;
            this.started = true;
            if (this.scene)
                this.scene.game.update.handle(this, this.update);
            else
                this.addActiveQueue(function () { this.scene.game.update.handle(this, this.update); });
        };
        E.prototype.stop = function () {
            if (!this.started)
                return;
            this.started = false;
            if (this.scene)
                this.scene.game.update.remove(this, this.update);
            else
                this.addActiveQueue(function () { this.scene.game.update.remove(this, this.update); });
        };
        E.prototype.startTimer = function (wait, method) {
            if (this.scene)
                this.scene.game.addTimer(wait, this, method ? method : this.interval);
            else
                this.addActiveQueue(function () { this.scene.game.addTimer(wait, this, method ? method : this.interval); });
        };
        E.prototype.stopTimer = function (wait, method) {
            if (this.scene)
                this.scene.game.removeTimer(wait, this, method ? method : this.interval);
            else
                this.addActiveQueue(function () { this.scene.game.removeTimer(wait, this, method ? method : this.interval); });
        };
        E.prototype.updated = function () {
            var p = this;
            while (p.parent)
                p = p.parent;
            p.isUpdated = true;
        };
        E.prototype.tl = function () {
            if (!this._tl)
                this._tl = new jg.Timeline(this);
            return this._tl;
        };
        E.prototype.destroy = function () {
            if (this._tl) {
                this._tl.clear();
                delete this._tl;
            }
            this.stop();
            if (this.scene) {
                this.scene.game.removeTimerAll(this);
                this.scene = null;
            }
            delete this.parent;
            if (this.entities) {
                var childEntity;
                while (childEntity = this.entities.pop())
                    childEntity.destroy();
            }
            if (this.pointDown) {
                this.pointDown.destroy();
                delete this.pointDown;
            }
            if (this.pointUp) {
                this.pointUp.destroy();
                delete this.pointUp;
            }
            if (this.pointMove) {
                this.pointMove.destroy();
                delete this.pointMove;
            }
        };
        E.prototype.offset = function () {
            var parent_offset = this.parent ? this.parent.offset() : { x: this.scroll ? this.scroll.x : 0, y: this.scroll ? this.scroll.y : 0 };
            return {
                x: this.x + parent_offset.x,
                y: this.y + parent_offset.y
            };
        };
        E.prototype.rect = function () {
            var offset = this.offset();
            return new jg.Rectangle(offset.x, offset.y, offset.x + this.width, offset.y + this.height);
        };
        E.prototype.hitTest = function (point) {
            return this.rect().hitTest(point);
        };
        E.prototype.getDistance = function (point) {
            var area = point;
            if (area.width && area.height) {
                return {
                    x: Math.abs((area.x + area.width / 2) - (this.x + this.width / 2)),
                    y: Math.abs((area.y + area.height / 2) - (this.y + this.height / 2))
                };
            }
            else {
                return {
                    x: Math.abs(point.x - (this.x + this.width / 2)),
                    y: Math.abs(point.y - (this.y + this.height / 2))
                };
            }
        };
        E.prototype.getEntityByPoint = function (point, force) {
            if (this.entities) {
                for (var i = this.entities.length - 1; i >= 0; i--) {
                    if (force || this.entities[i].pointCapture) {
                        var p = this.entities[i].getEntityByPoint(point);
                        if (p)
                            return p;
                    }
                }
            }
            if ((force || this.pointCapture) && this.hitTest(point))
                return this;
            return null;
        };
        E.prototype.createSprite = function () {
            var buffer = new jg.BufferedRenderer({ width: this.width, height: this.height });
            var x = this.x;
            var y = this.y;
            this.x = 0;
            this.y = 0;
            buffer.renderUnit(this);
            this.x = x;
            this.y = y;
            return buffer.createSprite();
        };
        E.prototype.update = function (t) { };
        E.prototype.interval = function () { };
        E.prototype.draw = function (context) { };
        E.prototype.show = function () {
            this.opacity = 1;
            this.updated();
        };
        E.prototype.hide = function () {
            this.opacity = 0;
            this.updated();
        };
        return E;
    })();
    jg.E = E;
})(jg || (jg = {}));
(function () {
    var canvas = document.createElement("canvas");
    var context = canvas.getContext("2d");
    for (var p in jg.ENTITY_OPTIONS_DEFAULT_VALUES)
        if (jg.ENTITY_OPTIONS_DEFAULT_VALUES[p] === undefined)
            jg.ENTITY_OPTIONS_DEFAULT_VALUES[p] = context[p];
})();
var __extends = this.__extends || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    __.prototype = b.prototype;
    d.prototype = new __();
};
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var Shape = (function (_super) {
        __extends(Shape, _super);
        function Shape(width, height, style, color, type) {
            _super.call(this);
            this.x = 0;
            this.y = 0;
            this.width = width;
            this.height = height;
            this.style = style ? style : jg.ShapeStyle.Stroke;
            if (color)
                this.setColor(color);
            this.type = type ? type : jg.ShapeType.Rect;
        }
        Shape.prototype.setClip = function (value) {
            this.clip = value;
            if (this.clip)
                this.disableTransform = true;
            else
                delete this.disableTransform;
        };
        Shape.prototype.setStyle = function (style) {
            this.style = style;
            this.setColor(this.getColor());
        };
        Shape.prototype.setLineWidth = function (width) {
            this.setDrawOption("lineWidth", width);
        };
        Shape.prototype.getLineWidth = function () {
            return this.getDrawOption("lineWidth");
        };
        Shape.prototype.setColor = function (color) {
            if (this.style == jg.ShapeStyle.Stroke)
                this.setDrawOption("strokeStyle", color);
            else
                this.setDrawOption("fillStyle", color);
        };
        Shape.prototype.getColor = function () {
            if (this.style == jg.ShapeStyle.Stroke)
                return this.getDrawOption("strokeStyle");
            else
                return this.getDrawOption("filltyle");
        };
        Shape.prototype.synchronize = function (syncObj, syncFunc) {
            this.syncObj = syncObj;
            this.syncFunc = syncFunc;
        };
        Shape.prototype.draw = function (context) {
            if (this.syncObj)
                this.syncFunc.call(this.syncObj, this);
            if (this.clip) {
                context.save();
                context.translate(this.x, this.y);
                if (this.options)
                    this.scene.game.renderer.useDrawOption(this, context);
            }
            context.beginPath();
            switch (this.type) {
                case jg.ShapeType.Rect:
                    context.rect(0, 0, this.width, this.height);
                    break;
                case jg.ShapeType.Arc:
                    var w2 = this.width / 2;
                    context.arc(w2, w2, w2, 0, Shape.PI_200_PER, false);
                    break;
            }
            if (this.clip) {
                context.restore();
                context.clip();
            }
            else if (this.style == jg.ShapeStyle.Fill)
                context.fill();
            else
                context.stroke();
        };
        Shape.PI_200_PER = Math.PI * 2;
        return Shape;
    })(jg.E);
    jg.Shape = Shape;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var Trigger = (function () {
        function Trigger() {
            this.handlers = [];
        }
        Trigger.prototype.handleInsert = function (index, owner, handler) {
            if (!handler)
                this.handlers.splice(index, 0, { owner: window, handler: owner });
            else
                this.handlers.splice(index, 0, { owner: owner, handler: handler });
        };
        Trigger.prototype.handle = function (owner, handler) {
            if (!handler)
                this.handlers.push({ owner: window, handler: owner });
            else
                this.handlers.push({ owner: owner, handler: handler });
        };
        Trigger.prototype.destroy = function () {
            this.handlers = [];
        };
        Trigger.prototype.removeAll = function (owner) {
            var ret = [];
            var tmp;
            while (tmp = this.handlers.shift())
                if (tmp.owner != owner)
                    ret.push(tmp);
            this.handlers = ret;
        };
        Trigger.prototype.removeAllByHandler = function (handler) {
            var ret = [];
            var tmp;
            while (tmp = this.handlers.shift())
                if (tmp.handler != handler)
                    ret.push(tmp);
            this.handlers = ret;
        };
        Trigger.prototype.remove = function (owner, handler) {
            var ret = [];
            var tmp;
            if (!handler) {
                handler = owner;
                owner = window;
            }
            while (tmp = this.handlers.shift())
                if (tmp.handler != handler || tmp.owner != owner)
                    ret.push(tmp);
            this.handlers = ret;
        };
        Trigger.prototype.fire = function (param) {
            if (this.handlers.length == 0)
                return;
            var handlers = this.handlers.concat();
            for (var i = 0; i < handlers.length; i++)
                handlers[i].handler.call(handlers[i].owner, param);
        };
        Trigger.prototype.fastFire = function (param) {
            for (var i = 0; i < this.handlers.length; i++)
                this.handlers[i].handler.call(this.handlers[i].owner, param);
        };
        return Trigger;
    })();
    jg.Trigger = Trigger;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var SimpleSound = (function () {
        function SimpleSound() {
        }
        SimpleSound.play = function (sound, loop) {
            var _sound = new Audio(null);
            _sound.src = sound.src;
            _sound.loop = loop ? loop : false;
            ;
            _sound.play();
            return _sound;
        };
        SimpleSound.hasBgm = function () {
            return SimpleSound.bgm !== undefined;
        };
        SimpleSound.playBgm = function (sound, loop) {
            if (SimpleSound.bgm)
                SimpleSound.stopBgm();
            sound.load();
            sound.loop = loop ? loop : false;
            sound.play();
            SimpleSound.bgm = sound;
            return SimpleSound.bgm;
        };
        SimpleSound.stop = function (source) {
            if (!source)
                return;
            source.pause();
        };
        SimpleSound.stopBgm = function () {
            SimpleSound.stop(SimpleSound.bgm);
            delete SimpleSound.bgm;
        };
        return SimpleSound;
    })();
    jg.SimpleSound = SimpleSound;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var ResourceStructure = (function () {
        function ResourceStructure(img, sound) {
            this.img = img;
            this.sound = sound;
        }
        ResourceStructure.prototype.isAbsolute = function (url) {
            var white = [".", "/"];
            if (white.indexOf(url.charAt(0)) >= 0 || url.match(/^(http:|https:|data:)/))
                return url;
        };
        ResourceStructure.prototype.imageUrl = function (url) {
            if (this.isAbsolute(url))
                return url;
            return this.img + url;
        };
        ResourceStructure.prototype.soundUrl = function (url) {
            if (this.isAbsolute(url))
                return url;
            return this.sound + url;
        };
        ResourceStructure.Default = new ResourceStructure("img/", "sound/");
        ResourceStructure.Plain = new ResourceStructure("", "");
        return ResourceStructure;
    })();
    jg.ResourceStructure = ResourceStructure;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var ResourceLoader = (function () {
        function ResourceLoader(resource) {
            this.resource = resource;
        }
        ResourceLoader.prototype.load = function (url, identifier) {
        };
        return ResourceLoader;
    })();
    jg.ResourceLoader = ResourceLoader;
    var ImageResourceLoader = (function (_super) {
        __extends(ImageResourceLoader, _super);
        function ImageResourceLoader() {
            _super.apply(this, arguments);
        }
        ImageResourceLoader.prototype.load = function (url, identifier) {
            var image = new Image();
            image.src = this.resource.structure.imageUrl(url);
            var caller = this;
            var callback = this.completed;
            image.onerror = function () {
                callback.call(caller, identifier, image, false);
            };
            image.onload = function () {
                callback.call(caller, identifier, image, true);
            };
        };
        ImageResourceLoader.prototype.completed = function (name, image, is_success) {
            if (!is_success)
                console.log("error: " + name);
            else
                this.resource.images[name] = image;
            this.resource.requestCompleted(name);
        };
        return ImageResourceLoader;
    })(ResourceLoader);
    jg.ImageResourceLoader = ImageResourceLoader;
    var ScriptResourceLoader = (function (_super) {
        __extends(ScriptResourceLoader, _super);
        function ScriptResourceLoader() {
            _super.apply(this, arguments);
        }
        ScriptResourceLoader.prototype.load = function (url, identifier) {
            var _this = this;
            var callback = this.completed;
            var waitLoader = function () {
                if (ScriptResourceLoader.loading) {
                    window.setTimeout(waitLoader, 100);
                    return;
                }
                ScriptResourceLoader.loading = true;
                var script = document.createElement("script");
                var heads = document.getElementsByTagName("head");
                if (heads.length == 0)
                    throw "can not find head tag";
                script.src = url + "?" + (new Date()).getTime();
                script.onload = function () {
                    callback.call(_this, identifier, script, true);
                    ScriptResourceLoader.loading = false;
                };
                script.onerror = function () {
                    callback.call(_this, identifier, script, false);
                    ScriptResourceLoader.loading = false;
                };
                heads[0].appendChild(script);
            };
            waitLoader();
        };
        ScriptResourceLoader.prototype.completed = function (name, script, is_success) {
            if (!is_success)
                console.log("error: " + name);
            else
                this.resource.scripts[name] = script;
            this.resource.requestCompleted(name);
        };
        return ScriptResourceLoader;
    })(ResourceLoader);
    jg.ScriptResourceLoader = ScriptResourceLoader;
    var SoundResourceLoader = (function (_super) {
        __extends(SoundResourceLoader, _super);
        function SoundResourceLoader() {
            _super.apply(this, arguments);
        }
        SoundResourceLoader.prototype.load = function (url, identifier) {
            var _this = this;
            var audio = new Audio(null);
            audio.autoplay = false;
            audio.preload = "auto";
            audio.src = this.resource.structure.soundUrl(url);
            audio.load();
            audio.addEventListener("canplaythrough", function () {
                _this.completed(identifier, audio, true);
            }, true);
            audio.addEventListener("error", function () {
                _this.completed(identifier, audio, false);
            }, true);
        };
        SoundResourceLoader.prototype.completed = function (name, audio, is_success) {
            if (!is_success)
                console.log("error: " + name);
            else
                this.resource.sounds[name] = audio;
            this.resource.requestCompleted(name);
        };
        return SoundResourceLoader;
    })(ResourceLoader);
    jg.SoundResourceLoader = SoundResourceLoader;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var Resource = (function () {
        function Resource() {
            this.requests = [];
            this.loaded = new jg.Trigger();
            this.added = new jg.Trigger();
            this.clear();
            this.loaders = {};
            this.loaders["js"] = new jg.ScriptResourceLoader(this);
            this.loaders["default"] = new jg.ImageResourceLoader(this);
            this.loaders["mp3"] = new jg.SoundResourceLoader(this);
            this.loaders["ogg"] = this.loaders["mp3"];
            this.loaders["wav"] = this.loaders["mp3"];
            this.loaders["mid"] = this.loaders["mp3"];
            this.structure = jg.ResourceStructure.Default;
        }
        Resource.getInstance = function () {
            if (!Resource.instance)
                Resource.instance = new Resource();
            return Resource.instance;
        };
        Resource.prototype.clear = function () {
            this.images = {};
            this.scripts = {};
            this.sounds = {};
        };
        Resource.prototype.get = function (name) {
            return this.images[name];
        };
        Resource.prototype.sound = function (name) {
            return this.sounds[name];
        };
        Resource.prototype.requestCompleted = function (name) {
            for (var i = 0; i < this.requests.length; i++) {
                if (this.requests[i] == name) {
                    this.requests.splice(i, 1);
                    break;
                }
            }
            this.loaded.fire(this.requests.length);
        };
        Resource.prototype.load = function (name, url) {
            if (!url)
                url = name;
            this.requests.push(name);
            var dot = url.split(/\./g);
            var ext;
            if (dot.length == 0)
                ext = "";
            else
                ext = dot[dot.length - 1];
            ext = ext.toLowerCase();
            var loader = this.loaders[ext] ? this.loaders[ext] : this.loaders["default"];
            loader.load(url, name);
            this.added.fire({
                name: name,
                url: url,
                loader: loader
            });
        };
        Resource.prototype.loadManual = function (name) {
            this.requests.push(name);
            this.added.fire({
                name: name,
                url: null,
                loader: null
            });
        };
        Resource.prototype.completeManual = function (name) {
            this.requestCompleted(name);
        };
        return Resource;
    })();
    jg.Resource = Resource;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var Scene = (function () {
        function Scene(game) {
            this.game = game;
            this.layers = {};
            this.root = new jg.Layer(this);
            this.layers["root"] = this.root;
            this.layerCount = 1;
            this.mode = [];
            this.started = new jg.Trigger();
            this.ended = new jg.Trigger();
            this.showed = new jg.Trigger();
            this.hid = new jg.Trigger();
        }
        Scene.prototype.currentMode = function () {
            return this.mode.length == 0 ? null : this.mode[this.mode.length - 1];
        };
        Scene.prototype.getLayerArray = function () {
            var ret = [];
            for (var i in this.layers)
                ret.push(this.layers[i]);
            return ret;
        };
        Scene.prototype.enablePointingEvent = function () {
            this.root.enablePointingEvent();
            if (!this.pointDown)
                this.pointDown = new jg.Trigger();
            if (!this.pointMove)
                this.pointMove = new jg.Trigger();
            if (!this.pointUp)
                this.pointUp = new jg.Trigger();
        };
        Scene.prototype.disablePointingEvent = function () {
            this.root.disablePointingEvent();
        };
        Scene.prototype.changeMode = function (mode) {
            var linkMode = this.currentMode();
            if (linkMode && this[linkMode + "Hide"])
                this[linkMode + "Hide"]();
            this.mode.push(mode);
            if (mode) {
                if (this[mode + "Start"])
                    this[mode + "Start"]();
                if (this[mode + "Show"])
                    this[mode + "Show"]();
            }
        };
        Scene.prototype.endCurrentMode = function (newMode) {
            if (this.mode.length == 0) {
                this.end();
                return;
            }
            var mode = this.mode.pop();
            if (mode)
                if (this[mode + "End"])
                    this[mode + "End"]();
            var linkMode = this.currentMode();
            if (newMode !== undefined)
                this.changeMode(newMode);
            else if (linkMode && this[linkMode + "Show"])
                this[linkMode + "Show"]();
        };
        Scene.prototype.createLayer = function (name, size) {
            for (var i in this.layers)
                if (!this.layers[i].hasBuffer())
                    this.layers[i].createBuffer();
            if (size && size instanceof jg.Layer) {
                this.layers[name] = size;
                this.layers[name].scene = this;
            }
            else {
                this.layers[name] = new jg.Layer(this);
                if (size) {
                    this.layers[name].width = size.width;
                    this.layers[name].height = size.height;
                }
            }
            this.layers[name].createBuffer();
            this.layerCount++;
            return this.layers[name];
        };
        Scene.prototype.deleteLayer = function (name) {
            if (name == "root")
                throw "can not delete root layer";
            this.layers[name].destroy();
            delete this.layers[name];
            this.layerCount--;
            if (this.layerCount == 1)
                this.root.deleteBuffer();
        };
        Scene.prototype.destroy = function () {
            for (var i in this.layers)
                this.layers[i].destroy();
            if (this.keyDown)
                this.keyDown.destroy();
            if (this.keyUp)
                this.keyUp.destroy();
            if (this.pointDown)
                this.pointDown.destroy();
            if (this.pointUp)
                this.pointUp.destroy();
            if (this.pointMove)
                this.pointMove.destroy();
        };
        Scene.prototype.end = function () {
            this.game.endScene();
        };
        Scene.prototype.refresh = function () {
            for (var i in this.layers) {
                this.layers[i].refresh();
                this.layers[i].updated();
            }
        };
        Scene.prototype.scrollTo = function (x, y, layerName) {
            if (!layerName)
                layerName = "root";
            this.layers[layerName].scrollTo(x, y);
        };
        Scene.prototype.scrollBy = function (x, y, layerName) {
            if (x == 0 && y == 0)
                return;
            if (!layerName)
                layerName = "root";
            this.layers[layerName].scrollBy(x, y);
        };
        Scene.prototype.append = function (entity, layerName) {
            if (!layerName)
                this.root.append(entity);
            else
                this.layers[layerName].append(entity);
        };
        Scene.prototype.removeEntity = function (entity) {
            for (var i in this.layers)
                this.layers[i].removeChild(entity);
        };
        return Scene;
    })();
    jg.Scene = Scene;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var Sprite = (function (_super) {
        __extends(Sprite, _super);
        function Sprite(image, srcWidth, srcHeight) {
            _super.call(this);
            this.x = 0;
            this.y = 0;
            this.width = srcWidth ? srcWidth : image.width;
            this.height = srcHeight ? srcHeight : image.height;
            this.srcWidth = this.width;
            this.srcHeight = this.height;
            this.srcX = 0;
            this.srcY = 0;
            this.image = image;
        }
        Sprite.prototype.draw = function (context) {
            context.drawImage(this.image, this.srcX, this.srcY, this.srcWidth, this.srcHeight, 0, 0, this.width, this.height);
        };
        return Sprite;
    })(jg.E);
    jg.Sprite = Sprite;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var FrameSprite = (function (_super) {
        __extends(FrameSprite, _super);
        function FrameSprite(image, srcWidth, srcHeight, wait) {
            _super.call(this, image, srcWidth, srcHeight);
            this.sep = Math.floor(this.image.width / this.width);
            var frameCnt = Math.ceil(image.width * image.height) / (srcWidth * srcHeight);
            this.frame = [];
            for (var i = 0; i < frameCnt; i++)
                this.frame.push(i);
            this.fno = 0;
            this.animation = false;
            this.wait = wait === undefined ? 200 : wait;
            this.loop = true;
        }
        FrameSprite.prototype.changeFrame = function () {
            this.srcX = (this.frame[this.fno] % this.sep) * this.srcWidth;
            this.srcY = Math.floor(this.frame[this.fno] / this.sep) * this.srcHeight;
            this.updated();
        };
        FrameSprite.prototype.animate = function (noClear) {
            if (this.animation)
                return true;
            if (!noClear)
                this.fno = 0;
            this.animation = true;
            this.startTimer(this.wait);
        };
        FrameSprite.prototype.inanimate = function () {
            if (!this.animation)
                return;
            this.stopTimer(this.wait);
            this.animation = false;
        };
        FrameSprite.prototype.interval = function () {
            this.fno++;
            if (this.fno >= this.frame.length) {
                if (this.loop) {
                    this.fno = 0;
                }
                else {
                    if (this.frameEnded) {
                        this.inanimate();
                        this.frameEnded.fire();
                        return;
                    }
                }
            }
            this.changeFrame();
        };
        return FrameSprite;
    })(jg.Sprite);
    jg.FrameSprite = FrameSprite;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var Character = (function (_super) {
        __extends(Character, _super);
        function Character(image, width, height, wait) {
            _super.call(this, image, width, height, wait);
            this.moving = false;
            if (!wait)
                wait = 200;
            this.animeCnt = 2;
            this.charaSeq = 0;
            this.charaCol = 1;
            this.movePixel = 64;
            this.moveTime = 300;
            this.animate();
        }
        Character.prototype.moveLeft = function (stackNext) {
            if (this.move(-this.movePixel, 0, this.moveTime)) {
                this.angle(jg.Angle.Left);
                return true;
            }
            if (stackNext && this.moveInfo.t * 2 >= this.moveInfo.f)
                this.nextMove = "Left";
            return false;
        };
        Character.prototype.moveRight = function (stackNext) {
            if (this.move(this.movePixel, 0, this.moveTime)) {
                this.angle(jg.Angle.Right);
                return true;
            }
            if (stackNext && this.moveInfo.t * 2 >= this.moveInfo.f)
                this.nextMove = "Right";
            return false;
        };
        Character.prototype.moveUp = function (stackNext) {
            if (this.move(0, -this.movePixel, this.moveTime)) {
                this.angle(jg.Angle.Up);
                return true;
            }
            if (stackNext && this.moveInfo.t * 2 >= this.moveInfo.f)
                this.nextMove = "Up";
            return false;
        };
        Character.prototype.moveDown = function (stackNext) {
            if (this.move(0, this.movePixel, this.moveTime)) {
                this.angle(jg.Angle.Down);
                return true;
            }
            if (stackNext && this.moveInfo.t * 2 >= this.moveInfo.f)
                this.nextMove = "Down";
            return false;
        };
        Character.prototype.move = function (x, y, f) {
            if (this.moving)
                return false;
            this.moving = true;
            this.moveInfo = {
                x: this.x,
                y: this.y,
                dx: this.x + x,
                dy: this.y + y,
                f: f,
                t: 0
            };
            if (this.beginMove)
                this.beginMove.fire(this.moveInfo);
            if (this.moving)
                this.start();
            return true;
        };
        Character.prototype.update = function (t) {
            if (this.moving) {
                this.moveInfo.t += t;
                if (this.moveInfo.t < this.moveInfo.f) {
                    this.moveTo(this.moveInfo.x + Math.round((this.moveInfo.dx - this.moveInfo.x) / this.moveInfo.f * this.moveInfo.t), this.moveInfo.y + Math.round((this.moveInfo.dy - this.moveInfo.y) / this.moveInfo.f * this.moveInfo.t));
                }
                else {
                    this.moveTo(this.moveInfo.dx, this.moveInfo.dy);
                    this.endMove();
                }
            }
        };
        Character.prototype.endMove = function () {
            this.moving = false;
            this.stop();
            var e = {};
            if (this.nextMove) {
                e.nextMove = this.nextMove;
                delete this.nextMove;
            }
            if (this.moved)
                this.moved.fire(e);
            if (e.nextMove)
                this["move" + e.nextMove]();
        };
        Character.prototype.angle = function (angle) {
            this.currentAngle = angle;
            var rowP = Math.floor(this.charaSeq / this.charaCol) * 4;
            switch (angle) {
                case jg.Angle.Up:
                    rowP += (this.angleSeq ? this.angleSeq[jg.Angle.Up] : 3);
                    break;
                case jg.Angle.Down:
                    rowP += (this.angleSeq ? this.angleSeq[jg.Angle.Down] : 0);
                    break;
                case jg.Angle.Left:
                    rowP += (this.angleSeq ? this.angleSeq[jg.Angle.Left] : 1);
                    break;
                case jg.Angle.Right:
                    rowP += (this.angleSeq ? this.angleSeq[jg.Angle.Right] : 2);
                    break;
            }
            var f = this.animeCnt * (this.charaSeq % this.charaCol) + this.charaCol * this.animeCnt * rowP;
            this.frame = [];
            if (this.animeCnt % 2 == 1) {
                for (var i = 0; i < this.animeCnt; i++)
                    this.frame.push(i + f);
                for (var i = this.animeCnt - 2; i > 0; i--)
                    this.frame.push(i + f);
            }
            else {
                for (var i = 0; i < this.animeCnt; i++)
                    this.frame.push(i + f);
            }
            this.changeFrame();
        };
        return Character;
    })(jg.FrameSprite);
    jg.Character = Character;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var CharacterFactory = (function () {
        function CharacterFactory(image, width, height) {
            this.width = width;
            this.height = height;
            this.image = image;
            this.wait = 200;
            this.charaCol = 1;
            this.animeCnt = 2;
            this.moveTime = 300;
            this.movePixel = 64;
            this.angle = jg.Angle.Down;
            this.createClass = jg.Character;
        }
        CharacterFactory.prototype.create = function (charaSeq, offset, angle) {
            var c = new this.createClass(this.image, this.width, this.height, this.wait);
            var black = ["width", "height", "image", "wait", "angle"];
            for (var i in this) {
                if (typeof this[i] == "function")
                    continue;
                if (black.indexOf(i) >= 0)
                    continue;
                c[i] = this[i];
            }
            c.charaSeq = charaSeq;
            c.angle(angle == undefined ? this.angle : angle);
            if (offset)
                c.moveTo(offset.x, offset.y);
            return c;
        };
        return CharacterFactory;
    })();
    jg.CharacterFactory = CharacterFactory;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var Label = (function (_super) {
        __extends(Label, _super);
        function Label(text, fontSize, fontColor, baseline) {
            _super.call(this);
            this.x = 0;
            this.y = 0;
            if (text) {
                this.setText(text);
            }
            else {
                this.setText("");
                this.width = 0;
                this.height = 0;
            }
            this.setTextBaseline(baseline ? baseline : "top");
            this.setFontSize(fontSize ? fontSize : 14);
            this.setColor(fontColor ? fontColor : "black");
        }
        Label.prototype.setMaxWidth = function (maxWidth) {
            this.maxWidth = maxWidth;
            this.updateSize();
        };
        Label.prototype.updateSize = function () {
            var canvas = window.createCanvas(10, 10);
            var ctx = canvas.getContext("2d");
            ctx.font = this.getFont();
            var metrix = ctx.measureText(this.text);
            this.width = metrix.width;
            this.height = this.getFontSize();
        };
        Label.prototype.addShadow = function (color) {
            this.setDrawOption("shadowBlur", 1);
            this.setDrawOption("shadowColor", color ? color : "rgba(0,0,0,0.8)");
            this.setDrawOption("shadowOffsetX", 1);
            this.setDrawOption("shadowOffsetY", 1);
        };
        Label.prototype.removeShadow = function () {
            this.removeDrawOption("shadowBlur");
            this.removeDrawOption("shadowColor");
        };
        Label.prototype.setText = function (text) {
            this.text = text;
            this.updateSize();
            this.updated();
        };
        Label.prototype.setFont = function (fontString) {
            this.setDrawOption("font", fontString);
            this.updateSize();
        };
        Label.prototype.getFont = function () {
            return this.getDrawOption("font");
        };
        Label.prototype.setFontSize = function (size) {
            var dom = document.createElement("div");
            dom.style.font = this.getFont();
            dom.style.fontSize = size + "px";
            this.setFont(dom.style.font);
        };
        Label.prototype.getFontSize = function () {
            var dom = document.createElement("div");
            dom.style.font = this.getFont();
            return Number(dom.style.fontSize.substr(0, dom.style.fontSize.length - 2));
        };
        Label.prototype.getFontFamily = function () {
            var dom = document.createElement("div");
            dom.style.font = this.getFont();
            return dom.style.fontFamily;
        };
        Label.prototype.setFontFamily = function (family) {
            var dom = document.createElement("div");
            dom.style.font = this.getFont();
            dom.style.fontFamily = family;
            this.setFont(dom.style.font);
        };
        Label.prototype.setTextAlign = function (align) {
            this.setDrawOption("textAlign", align);
        };
        Label.prototype.getTextAlign = function () {
            return this.getDrawOption("textAlign");
        };
        Label.prototype.setTextBaseline = function (baseline) {
            this.setDrawOption("textBaseline", baseline);
        };
        Label.prototype.getTextBaseline = function () {
            return this.getDrawOption("textBaseline");
        };
        Label.prototype.setColor = function (color) {
            this.setDrawOption("fillStyle", color);
        };
        Label.prototype.getColor = function () {
            return this.getDrawOption("fillStyle");
        };
        Label.prototype.synchronize = function (obj, prop, round) {
            this.syncObj = obj;
            this.syncProp = prop;
            this.syncRound = round;
        };
        Label.prototype.draw = function (context) {
            if (this.syncObj) {
                var val;
                if (typeof this.syncObj[this.syncProp] == "function")
                    val = this.syncObj[this.syncProp](this);
                else
                    val = this.syncObj[this.syncProp];
                this.text = this.syncRound ? Math.round(val) : val;
            }
            if (this.maxWidth) {
                context.fillText(this.text, 0, 0, this.maxWidth);
            }
            else {
                context.fillText(this.text, 0, 0);
            }
        };
        return Label;
    })(jg.E);
    jg.Label = Label;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var TextLineInfo = (function () {
        function TextLineInfo(offsetY) {
            this.width = 0;
            this.height = 0;
            this.offsetY = offsetY;
        }
        return TextLineInfo;
    })();
    jg.TextLineInfo = TextLineInfo;
    var MultilineScriptAnalyzer = (function () {
        function MultilineScriptAnalyzer() {
        }
        MultilineScriptAnalyzer.prototype.init = function (owner, context, pos) {
            this.mode = 0;
            this.owner = owner;
            this.context = context;
            this.pos = pos;
        };
        MultilineScriptAnalyzer.prototype.next = function (c) {
            if (this.mode) {
                if (c == " ") {
                    this.mode = 0;
                    if (this.buf == "page")
                        return -1;
                }
                else
                    this.buf += c;
                return 1;
            }
            if (c == "#") {
                this.mode = 1;
                this.buf = "";
                return 1;
            }
            return 0;
        };
        return MultilineScriptAnalyzer;
    })();
    jg.MultilineScriptAnalyzer = MultilineScriptAnalyzer;
    var MultilineText = (function (_super) {
        __extends(MultilineText, _super);
        function MultilineText(size, offset) {
            _super.call(this);
            this.scriptAnalyzer = new MultilineScriptAnalyzer();
            this.width = size.width;
            this.height = size.height;
            if (offset)
                this.moveTo(offset.x, offset.y);
            else
                this.moveTo(0, 0);
            this.defaultStyle = "#fff";
            this.defaultFont = "18px sans-serif";
            this.defaultBlur = 1;
            this.defaultShadowColor = "rgba(0,0,0,0.8)";
            this.defaultShadowOffsetX = 1;
            this.defaultShadowOffsetY = 1;
            this.clip = new jg.Line({ x: 0, y: 0 });
            this.clip.addLine(this.width, 0);
            this.clip.addLine(this.width, this.height);
            this.clip.addLine(0, this.height);
            this.clip.addLine(0, this.height);
            this.clip.addLine(0, this.height);
            this.clip.closePath = true;
            this.clip.setClip(true);
            this.entities = [];
            this.entities.push(this.clip);
            this.animeSpeed = 400;
            this.animated = new jg.Trigger();
        }
        MultilineText.prototype.setText = function (text, offset) {
            var plainScript = text;
            return this.setScript(plainScript, offset);
        };
        MultilineText.prototype.setScript = function (script, offset) {
            this.script = script.replace(/\r\n?/g, "\n");
            this.updated();
            return this.createBuffer(offset);
        };
        MultilineText.prototype.getLineHeight = function (c) {
            var font = c.font;
            var firstPos = font.indexOf("px");
            var lastPos = font.lastIndexOf(" ", firstPos);
            if (lastPos < 0)
                lastPos = 0;
            if (firstPos < 0)
                return 16;
            var fontSize = parseInt(font.substring(lastPos, firstPos));
            var line_height = Math.round(fontSize * MultilineText.LINE_HEIGHT_NORMAL);
            return line_height;
        };
        MultilineText.prototype.createBuffer = function (offset) {
            var _this = this;
            if (!this.buffer)
                this.buffer = window.createCanvas(this.width, this.height);
            if (offset === undefined)
                offset = 0;
            var script = this.script;
            var len = script.length;
            var pos = { x: 0, y: 0 };
            var c = this.buffer.getContext("2d");
            var s;
            var m = MultilineText.BROWSER_BASELINE_MARGIN;
            this.lines = [];
            if (this.bufferBg)
                c.putImageData(this.bufferBg, 0, 0);
            else
                c.clearRect(0, 0, this.width, this.height);
            c.fillStyle = this.defaultStyle;
            c.font = this.defaultFont;
            c.textBaseline = "top";
            if (!this.disableShadow) {
                c.shadowBlur = this.defaultBlur;
                c.shadowColor = this.defaultShadowColor;
                c.shadowOffsetX = this.defaultShadowOffsetX;
                c.shadowOffsetY = this.defaultShadowOffsetY;
            }
            var lineHeight = this.getLineHeight(c);
            var lineInfo = new TextLineInfo(0);
            lineInfo.height = lineHeight;
            this.lines.push(lineInfo);
            var _newLine = function () {
                pos.x = 0;
                pos.y += lineInfo.height;
                if ((pos.y + lineInfo.height) > _this.height)
                    return false;
                lineInfo = new TextLineInfo(pos.y);
                lineInfo.height = lineHeight;
                _this.lines.push(lineInfo);
                return true;
            };
            this.scriptAnalyzer.init(this, c, pos);
            while (offset < len) {
                s = script.substr(offset, 1);
                var script_ret = this.scriptAnalyzer.next(s);
                if (script_ret) {
                    lineHeight = lineInfo.height;
                    if (script_ret < 0) {
                        offset -= script_ret;
                        break;
                    }
                    offset += script_ret;
                    continue;
                }
                if (s == "\n") {
                    offset++;
                    if (!_newLine())
                        break;
                    continue;
                }
                var metric = c.measureText(s);
                if ((pos.x + metric.width) > this.width) {
                    if (!_newLine())
                        break;
                }
                c.fillText(s, pos.x, pos.y + m);
                pos.x += metric.width;
                lineInfo.width += metric.width;
                offset++;
            }
            this.sprite = new jg.Sprite(this.buffer);
            this.sprite.moveTo(0, 0);
            if (this.entities.length == 1)
                this.entities.push(this.sprite);
            else
                this.entities[1] = this.sprite;
            return offset == len ? -1 : offset;
        };
        MultilineText.prototype.refresh = function () {
            delete this.buffer;
            this.createBuffer();
        };
        MultilineText.prototype.startAnimation = function (animeSpeed) {
            this.start();
            this.animeLine = 0;
            this.animePos = { x: 0, y: this.lines[this.animeLine].height };
            if (animeSpeed !== undefined)
                this.animeSpeed = animeSpeed;
            this.hideAll();
            this.clip.p[4].y = this.animePos.y;
            this.clip.p[5].y = this.animePos.y;
        };
        MultilineText.prototype.update = function (t) {
            this.animePos.x += this.animeSpeed / 1000 * t;
            if (this.animePos.x >= this.lines[this.animeLine].width) {
                this.animePos.x = 0;
                this.animePos.y += this.lines[this.animeLine].height;
                this.animeLine++;
                if (this.animeLine < this.lines.length) {
                    this.clip.p[2].y = this.lines[this.animeLine].offsetY;
                    this.clip.p[3].y = this.clip.p[2].y;
                    this.clip.p[4].y = this.animePos.y;
                    this.clip.p[5].y = this.animePos.y;
                }
            }
            if (this.animeLine >= this.lines.length) {
                this.showAll();
            }
            else {
                this.clip.p[3].x = this.animePos.x;
                this.clip.p[4].x = this.clip.p[3].x;
            }
            this.updated();
        };
        MultilineText.prototype.hideAll = function () {
            this.clip.p[0] = { x: 0, y: 0 };
            this.clip.p[1] = { x: this.width, y: 0 };
            this.clip.p[2] = { x: this.width, y: 0 };
            this.clip.p[3] = { x: 0, y: 0 };
            this.clip.p[4] = { x: 0, y: 0 };
            this.clip.p[5] = { x: 0, y: 0 };
        };
        MultilineText.prototype.showAll = function () {
            this.clip.p[0] = { x: 0, y: 0 };
            this.clip.p[1] = { x: this.width, y: 0 };
            this.clip.p[2] = { x: this.width, y: this.height };
            this.clip.p[3] = { x: 0, y: this.height };
            this.clip.p[4] = { x: 0, y: this.height };
            this.clip.p[5] = { x: 0, y: this.height };
            this.stop();
            this.animated.fire();
        };
        MultilineText.LINE_HEIGHT_NORMAL = 1.2;
        MultilineText.BROWSER_BASELINE_MARGIN = 0;
        return MultilineText;
    })(jg.E);
    jg.MultilineText = MultilineText;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var ChipSet = (function () {
        function ChipSet(image) {
            this.image = image;
        }
        ChipSet.prototype.count = function (tile) {
            return Math.round((this.image.width * this.image.height) / (tile.tileWidth * tile.tileHeight));
        };
        ChipSet.prototype.draw = function (tile, c, x, y, chip) {
            var tw = tile.tileWidth;
            var th = tile.tileHeight;
            var sep = Math.floor(this.image.width / tile.tileWidth);
            c.drawImage(this.image, (chip % sep) * tw, Math.floor(chip / sep) * th, tw, th, x * tw, y * th, tw, th);
        };
        ChipSet.prototype.getChips = function (tile) {
            var len = this.count(tile);
            var sprite = new jg.Sprite(this.image);
            var buf = new jg.BufferedRenderer(sprite);
            var ret = [];
            var w = tile.tileWidth;
            var h = tile.tileHeight;
            var area = {
                x: 0,
                y: 0,
                width: w,
                height: h
            };
            buf.renderUnit(sprite);
            var sep = Math.floor(this.image.width / tile.tileWidth);
            for (var i = 0; i < len; i++) {
                ret.push(buf.createSprite({
                    x: (i % sep) * w,
                    y: Math.floor(i / sep) * h,
                    width: w,
                    height: h
                }, area, area));
            }
            return ret;
        };
        return ChipSet;
    })();
    jg.ChipSet = ChipSet;
    var AutoTileChipSet = (function (_super) {
        __extends(AutoTileChipSet, _super);
        function AutoTileChipSet() {
            _super.apply(this, arguments);
        }
        AutoTileChipSet.prototype.map = function (tile, x, y, out_value) {
            if (x < 0 || y < 0 || x >= tile.size.width || y >= tile.size.height)
                return out_value !== undefined ? out_value : -1;
            return tile.data[x][y];
        };
        AutoTileChipSet.prototype.count = function (tile) {
            return 1;
        };
        AutoTileChipSet.prototype.draw = function (tile, c, x, y, chip) {
            var tw = tile.tileWidth;
            var th = tile.tileHeight;
            var tw2 = Math.floor(tw / 2);
            var th2 = Math.floor(th / 2);
            var sep = Math.floor(this.image.width / tile.tileWidth);
            chip += this.chipOffset;
            for (var i = 0; i < 2; i++) {
                for (var j = 0; j < 2; j++) {
                    var tx = x + (i == 0 ? -1 : 1);
                    var ty = y + (j == 0 ? -1 : 1);
                    var v = this.map(tile, tx, y, chip);
                    var h = this.map(tile, x, ty, chip);
                    var vh = this.map(tile, tx, ty, chip);
                    var sel = 0;
                    if (h == chip)
                        sel++;
                    if (v == chip)
                        sel += 2;
                    if (sel == 3 && vh == chip)
                        sel++;
                    c.drawImage(this.image, (sel % sep) * tw + tw2 * i, Math.floor(sel / sep) * th + th2 * j, tw2, th2, x * tw + tw2 * i, y * th + th2 * j, tw2, th2);
                }
            }
        };
        AutoTileChipSet.prototype.getChips = function (tile) {
            var len = this.count(tile);
            var sprite = new jg.Sprite(this.image, tile.tileWidth, tile.tileHeight);
            return [sprite.createSprite()];
        };
        return AutoTileChipSet;
    })(ChipSet);
    jg.AutoTileChipSet = AutoTileChipSet;
    var Tile = (function (_super) {
        __extends(Tile, _super);
        function Tile(image, tileWidth, tileHeight) {
            _super.call(this);
            this.tileWidth = tileWidth;
            this.tileHeight = tileHeight;
            this.chips = [];
            this.chipMap = [];
            this.chipCount = 0;
            if (image)
                this.addChipSet(image);
            this.x = 0;
            this.y = 0;
            this.disableTransform = true;
        }
        Tile.prototype.addChipSet = function (image, opt) {
            var chipset;
            if (opt) {
                if (opt.autoTile) {
                    chipset = new AutoTileChipSet(image);
                }
            }
            if (!chipset)
                chipset = new ChipSet(image);
            chipset.chipOffset = this.chipCount;
            this.chips.push(chipset);
            var cnt = chipset.count(this);
            var cnt2 = this.chipCount + cnt;
            for (var i = this.chipCount; i < cnt2; i++)
                this.chipMap[i] = chipset;
            this.chipCount = cnt2;
        };
        Tile.prototype.copyChips = function (tile) {
            tile.chips = this.chips;
            tile.chipCount = this.chipCount;
            tile.chipMap = this.chipMap;
        };
        Tile.prototype._clear = function (width, height) {
            this.size = {
                width: width,
                height: height
            };
            this.width = this.tileWidth * width;
            this.height = this.tileHeight * height;
        };
        Tile.prototype.clear = function (width, height, value) {
            if (!width)
                width = this.size.width;
            if (!height)
                height = this.size.height;
            if (value === undefined)
                value = -1;
            this._clear(width, height);
            this.data = [];
            for (var x = 0; x < width; x++) {
                this.data[x] = [];
                for (var y = 0; y < height; y++)
                    this.data[x][y] = value;
            }
            this.refresh();
        };
        Tile.prototype.generate = function (data, width, height, transpose) {
            if (width === true) {
                transpose = true;
                width = data.length;
                height = data[0].length;
            }
            if (!width)
                width = data.length;
            if (!height)
                height = data[0].length;
            this.data = transpose ? jg.JGUtil.transpose(data) : data;
            this._clear(width, height);
            this.refresh();
        };
        Tile.prototype.refresh = function () {
            this.canvas = window.createCanvas(this.width, this.height);
            var c = this.canvas.getContext("2d");
            var chipset;
            var w = this.size.width;
            var h = this.size.height;
            var d = this.data;
            var cm = this.chipMap;
            for (var x = 0; x < w; x++)
                for (var y = 0; y < h; y++)
                    this.drawChip(x, y, false, c);
            this.updated();
        };
        Tile.prototype.drawChip = function (x, y, clear, context) {
            if (context === undefined)
                context = this.canvas.getContext("2d");
            if (clear)
                context.clearRect(x * this.tileWidth, y * this.tileHeight, this.tileWidth, this.tileHeight);
            if (this.data[x][y] < 0)
                return;
            var cs = this.chipMap[this.data[x][y]];
            cs.draw(this, context, x, y, this.data[x][y] - cs.chipOffset);
        };
        Tile.prototype.draw = function (context) {
            if (!this.canvas)
                return;
            var parent = this.parent ? this.parent : this;
            var scroll = parent.scroll ? parent.scroll : { x: 0, y: 0 };
            var src = {
                x: -scroll.x,
                y: -scroll.y,
                width: parent.width,
                height: parent.height
            };
            var dist = {
                x: -scroll.x,
                y: -scroll.y,
                width: parent.width,
                height: parent.height
            };
            if (src.x < 0) {
                src.width += src.x;
                if (src.width <= 0)
                    return;
                dist.x -= src.x;
                dist.width += src.x;
                src.x = 0;
            }
            else if ((src.x + src.width) > this.width) {
                var p = ((src.x + src.width) - this.width);
                src.width -= p;
                if (src.width <= 0)
                    return;
                dist.width -= p;
            }
            if (src.y < 0) {
                src.height += src.y;
                if (src.height <= 0)
                    return;
                dist.y -= src.y;
                dist.height += src.y;
                src.y = 0;
            }
            else if ((src.y + src.height) > this.height) {
                var p = ((src.y + src.height) - this.height);
                src.height -= p;
                if (src.height <= 0)
                    return;
                dist.height -= p;
            }
            context.drawImage(this.canvas, src.x, src.y, src.width, src.height, dist.x, dist.y, dist.width, dist.height);
        };
        Tile.prototype.getChips = function () {
            var ret = [];
            var len = this.chips.length;
            for (var i = 0; i < len; i++)
                ret = ret.concat(this.chips[i].getChips(this));
            return ret;
        };
        return Tile;
    })(jg.E);
    jg.Tile = Tile;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var Layer = (function (_super) {
        __extends(Layer, _super);
        function Layer(scene) {
            _super.call(this);
            this.entities = [];
            this.x = 0;
            this.y = 0;
            this.scene = scene;
            if (this.scene) {
                this.width = this.scene.game.width;
                this.height = this.scene.game.height;
            }
            this.isUpdated = true;
        }
        Layer.prototype.hasBuffer = function () {
            if (this.canvas)
                return true;
            return false;
        };
        Layer.prototype.createBuffer = function () {
            this.refresh(true);
        };
        Layer.prototype.refresh = function (must) {
            if (must || this.hasBuffer()) {
                this.canvas = window.createCanvas(this.width, this.height);
                this.context = this.canvas.getContext("2d");
                this.updated();
            }
            if (this.entities) {
                for (var i = 0; i < this.entities.length; i++) {
                    if (this.entities[i]["refresh"])
                        this.entities[i]["refresh"]();
                }
            }
        };
        Layer.prototype.deleteBuffer = function () {
            delete this.context;
            delete this.canvas;
        };
        Layer.prototype.destroy = function () {
            _super.prototype.destroy.call(this);
            if (this.hasBuffer())
                this.deleteBuffer();
        };
        return Layer;
    })(jg.E);
    jg.Layer = Layer;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var LoadingScene = (function (_super) {
        __extends(LoadingScene, _super);
        function LoadingScene(game, resource) {
            _super.call(this, game);
            this.resource = resource;
            this.resource.loaded.handle(this, this.complete);
            this.resource.added.handle(this, this.added);
            this.requestCount = this.resource.requests.length;
            this.finished = new jg.Trigger();
            this.init();
        }
        LoadingScene.prototype.init = function () {
            this.shape = new jg.Shape(this.game.width, 32);
            this.shape.moveTo(0, this.game.height / 2 - 16);
            this.shapeP = new jg.Shape(1, 32, jg.ShapeStyle.Fill);
            this.shapeP.moveTo(0, this.game.height / 2 - 16);
            this.append(this.shape);
            this.append(this.shapeP);
        };
        LoadingScene.prototype.animate = function (per) {
            this.shapeP.width = this.game.width * per;
            this.shapeP.updated();
        };
        LoadingScene.prototype.complete = function (cnt) {
            var per = (this.requestCount - cnt) / this.requestCount;
            this.animate(per);
            if (per == 1) {
                this.resource.loaded.remove(this, this.complete);
                this.resource.added.remove(this, this.added);
                this.end();
                this.finished.fire();
            }
        };
        LoadingScene.prototype.added = function (e) {
            this.requestCount++;
        };
        return LoadingScene;
    })(jg.Scene);
    jg.LoadingScene = LoadingScene;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var InputEvent = (function () {
        function InputEvent(type, action, param) {
            this.type = type;
            this.action = action;
            this.param = param;
        }
        return InputEvent;
    })();
    jg.InputEvent = InputEvent;
    var InputKeyboardEvent = (function (_super) {
        __extends(InputKeyboardEvent, _super);
        function InputKeyboardEvent(action, key, e) {
            _super.call(this, jg.InputEventType.Keyboard, action, e);
            this.key = key;
        }
        return InputKeyboardEvent;
    })(InputEvent);
    jg.InputKeyboardEvent = InputKeyboardEvent;
    var InputPointEvent = (function (_super) {
        __extends(InputPointEvent, _super);
        function InputPointEvent(action, e, point) {
            _super.call(this, jg.InputEventType.Point, action, e);
            this.point = point;
        }
        InputPointEvent.prototype.set = function (entity) {
            var entityOffset = entity.offset();
            this.entity = entity;
            this.x = this.point.x - entityOffset.x;
            this.y = this.point.y - entityOffset.y;
        };
        return InputPointEvent;
    })(InputEvent);
    jg.InputPointEvent = InputPointEvent;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var Renderer = (function () {
        function Renderer() {
            var _this = this;
            this.radian = Math.PI / 180;
            this.drawOptionFunctions = {
                transform: function (c, entity, params) {
                    c.transform(params.m11, params.m12, params.m21, params.m22, params.dx, params.dy);
                },
                translate: function (c, entity, params) {
                    c.translate(params.x, params.y);
                },
                scale: function (c, entity, params) {
                    c.transform.apply(c, _this.getMatrix(entity.width, entity.height, params.x, params.y, 0));
                },
                purescale: function (c, entity, params) {
                    c.scale(params.x, params.y);
                },
                rotate: function (c, entity, params) {
                    c.transform.apply(c, _this.getMatrix(entity.width, entity.height, 1, 1, params));
                }
            };
        }
        Renderer.prototype.getMatrix = function (width, height, scaleX, scaleY, angle) {
            var r = angle * this.radian;
            var _cos = Math.cos(r);
            var _sin = Math.sin(r);
            var a = _cos * scaleX;
            var b = _sin * scaleX;
            var c = _sin * scaleY;
            var d = _cos * scaleY;
            var w = width / 2;
            var h = height / 2;
            return [
                a,
                b,
                -c,
                d,
                (-a * w + c * h + w),
                (-b * w - d * h + h)
            ];
        };
        Renderer.prototype.renderParent = function (parent, c) {
            if (parent.orderDraw)
                parent.orderDraw(parent);
            c.save();
            if (parent.opacity != 1)
                c.globalAlpha = parent.opacity;
            if (parent.options) {
                if (this.useDrawOption(parent, c)) {
                    c.restore();
                    return;
                }
            }
            if (parent.scroll)
                c.translate(parent.scroll.x, parent.scroll.y);
            for (var i = 0; i < parent.entities.length; i++)
                this.renderEntity(parent.entities[i], c);
            c.restore();
        };
        Renderer.prototype.renderEntity = function (entity, c) {
            if (!entity.opacity)
                return;
            if (entity.disableTransform) {
                entity.draw(c);
            }
            else {
                c.save();
                c.translate(entity.x, entity.y);
                if (entity.opacity != 1)
                    c.globalAlpha *= entity.opacity;
                if (entity.options) {
                    if (this.useDrawOption(entity, c)) {
                        c.restore();
                        return;
                    }
                }
                if (entity.filter) {
                    this.filterDraw(entity, c);
                }
                else {
                    entity.draw(c);
                    if (entity.entities) {
                        if (entity.scroll)
                            c.translate(entity.scroll.x, entity.scroll.y);
                        for (var i = 0; i < entity.entities.length; i++)
                            this.renderEntity(entity.entities[i], c);
                    }
                }
                c.restore();
            }
        };
        Renderer.prototype.renderPure = function (entity, c) {
            entity.draw(c);
            if (entity.entities) {
                for (var i = 0; i < entity.entities.length; i++)
                    this.renderEntity(entity.entities[i], c);
            }
        };
        Renderer.prototype.filterDraw = function (entity, c) {
            var buffer = new jg.BufferedRenderer(entity);
            buffer.filter = entity.filter;
            buffer.renderPure(entity, buffer.c);
            buffer.applyFilter(buffer.c, entity);
            buffer.draw(c);
        };
        Renderer.prototype.useDrawOption = function (entity, c) {
            for (var p in entity.options) {
                if (this.drawOptionFunctions[p])
                    this.drawOptionFunctions[p].call(this, c, entity, entity.options[p]);
                else {
                    c[p] = entity.options[p];
                }
            }
        };
        return Renderer;
    })();
    jg.Renderer = Renderer;
})(jg || (jg = {}));
///<reference path="all.ts"/>
var jg;
(function (jg) {
    var GameRenderer = (function (_super) {
        __extends(GameRenderer, _super);
        function GameRenderer(game, container, transferMode, disableBg) {
            _super.call(this);
            this.game = game;
            this.container = container ? container : document.getElementById("jgame");
            if (!this.container) {
                var div = document.createElement("div");
                div.id = "jgame";
                var bodies = document.getElementsByTagName("body");
                if (bodies.length == 0)
                    throw "can not initialize game engine";
                bodies[0].appendChild(div);
                this.container = div;
            }
            this.handler = document.createElement("div");
            this.handler.style.display = "inline-block";
            this.handler.setAttribute("tabindex", "1");
            this.handler.className = "input-handler";
            this.handler.style.outline = 'none';
            this.container.appendChild(this.handler);
            this.handler.focus();
            this.changeTransferMode(transferMode ? transferMode : jg.RenderTransferMode.Transfer);
            if (!disableBg) {
                this.bg = this.fc.getImageData(0, 0, this.game.width, this.game.height);
                for (var i = 0; i < this.bg.data.length; i++)
                    this.bg.data[i] = 255;
            }
        }
        GameRenderer.prototype.changeFrontCanvasSize = function (size, offset) {
            this.frontCanvasSize = size;
            this.frontCanvasOffset = offset;
            this.refresh();
        };
        GameRenderer.prototype.changeTransferMode = function (mode) {
            this.transferMode = mode;
            if (this.transferMode == jg.RenderTransferMode.Flip) {
                this.handler.style.position = "relative";
                this.handler.style.width = this.game.width + "px";
                this.handler.style.height = this.game.height + "px";
            }
            this.refresh();
        };
        GameRenderer.prototype.changeScene = function (scene) {
            this.scene = scene;
        };
        GameRenderer.prototype.flip = function () {
            var c = this.fc;
            this.fc = this.bc;
            this.bc = this.fc;
            this.flipNo = this.flipNo ? 0 : 1;
            this.buffer[this.flipNo].style.zIndex = "1";
            this.buffer[this.flipNo ? 0 : 1].style.zIndex = "0";
        };
        GameRenderer.prototype.render = function () {
            var hasUpdate = false;
            if (this.scene.layerCount == 1) {
                var layer = this.scene.root;
                if (!layer.isUpdated) {
                }
                else {
                    hasUpdate = true;
                    if (!this.disableClear)
                        this.bc.putImageData(this.bg, 0, 0);
                    this.renderParent(layer, this.bc);
                    layer.isUpdated = false;
                }
            }
            else {
                for (var i in this.scene.layers) {
                    if (this.scene.layers[i].isUpdated) {
                        hasUpdate = true;
                        break;
                    }
                }
                if (hasUpdate) {
                    if (!this.disableClear)
                        this.bc.putImageData(this.bg, 0, 0);
                    for (var i in this.scene.layers) {
                        var layer = this.scene.layers[i];
                        if (layer.isUpdated) {
                            layer.context.clearRect(0, 0, layer.width, layer.height);
                            this.renderParent(layer, layer.context);
                        }
                        this.bc.drawImage(layer.canvas, layer.x, layer.y);
                        layer.isUpdated = false;
                    }
                }
            }
            if (hasUpdate) {
                if (this.filter) {
                    var imageData = this.bc.getImageData(0, 0, this.game.width, this.game.height);
                    this.filter.filter(imageData);
                    this.fc.putImageData(imageData, 0, 0);
                }
                else {
                    if (this.bc != this.fc) {
                        this.fc.drawImage(this.buffer[1], 0, 0);
                    }
                    else if (this.transferMode == jg.RenderTransferMode.Flip) {
                        this.flip();
                    }
                }
            }
        };
        GameRenderer.prototype.refresh = function () {
            delete this.buffer;
            this.buffer = [];
            if (this.transferMode == jg.RenderTransferMode.Flip) {
                this.handler.innerHTML = "";
                for (var i = 0; i < 2; i++) {
                    this.buffer[i] = window.createCanvas(this.game.width, this.game.height);
                    ;
                    this.buffer[i].style.position = "absolute";
                    this.buffer[i].style.zIndex = i.toString();
                    this.handler.appendChild(this.buffer[i]);
                }
                this.fc = this.buffer[1].getContext("2d");
                this.bc = this.buffer[0].getContext("2d");
                this.flipNo = 1;
                if (this.frontCanvasSize) {
                    jg.JGUtil.scaleCanvas(this.buffer[1], this.frontCanvasSize);
                }
            }
            else if (this.transferMode == jg.RenderTransferMode.Transfer) {
                this.handler.innerHTML = "";
                for (var i = 0; i < 2; i++) {
                    this.buffer[i] = window.createCanvas(this.game.width, this.game.height);
                    ;
                }
                this.handler.appendChild(this.buffer[0]);
                this.fc = this.buffer[0].getContext("2d");
                this.bc = this.buffer[1].getContext("2d");
            }
            else {
                this.handler.innerHTML = "";
                this.buffer[0] = window.createCanvas(this.game.width, this.game.height);
                ;
                this.handler.appendChild(this.buffer[0]);
                this.fc = this.buffer[0].getContext("2d");
                this.bc = this.fc;
            }
            if (this.frontCanvasSize) {
                jg.JGUtil.scaleCanvas(this.buffer[0], this.frontCanvasSize);
                if (this.frontCanvasOffset) {
                    this.handler.style.position = "relative";
                    this.handler.style.left = this.frontCanvasOffset.x + "px";
                    this.handler.style.top = this.frontCanvasOffset.y + "px";
                }
            }
            var bounding = this.handler.getBoundingClientRect();
            this._pageX = Math.round(window["scrollX"] || window.pageXOffset + bounding.left);